diff --git a/CMakeLists.txt b/CMakeLists.txt
index 133d9f7e6..5b9f5ad78 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -65,6 +65,7 @@ option(OPENMW_UNITY_BUILD "Use fewer compilation units to speed up compile time"
 
 # Apps and tools
 option(BUILD_OPENMW "build OpenMW" ON)
+option(BUILD_OPENMW_MP "build OpenMW-MP" ON)
 option(BUILD_BSATOOL "build BSA extractor" ON)
 option(BUILD_ESMTOOL "build ESM inspector" ON)
 option(BUILD_LAUNCHER "build Launcher" ON)
@@ -116,6 +117,9 @@ if (WIN32)
     option(USE_DEBUG_CONSOLE "whether a debug console should be enabled for debug builds, if false debug output is redirected to Visual Studio output" ON)
 endif()
 
+find_package(RakNet REQUIRED)
+include_directories(${RakNet_INCLUDES})
+
 if (NOT BUILD_LAUNCHER AND NOT BUILD_OPENCS AND NOT BUILD_WIZARD)
    set(USE_QT FALSE)
 else()
@@ -328,6 +332,12 @@ endif (APPLE)
 
 # Other files
 
+configure_file(${OpenMW_SOURCE_DIR}/files/tes3mp/tes3mp-client-default.cfg
+        "${OpenMW_BINARY_DIR}/tes3mp-client-default.cfg")
+
+configure_file(${OpenMW_SOURCE_DIR}/files/tes3mp/tes3mp-server-default.cfg
+        "${OpenMW_BINARY_DIR}/tes3mp-server-default.cfg")
+
 configure_file(${OpenMW_SOURCE_DIR}/files/settings-default.cfg
     "${OpenMW_BINARY_DIR}/settings-default.cfg")
 
@@ -433,6 +443,11 @@ IF(NOT WIN32 AND NOT APPLE)
     INSTALL(FILES "${OpenMW_BINARY_DIR}/resources/version" DESTINATION "${SYSCONFDIR}" COMPONENT "openmw")
     INSTALL(FILES "${OpenMW_BINARY_DIR}/gamecontrollerdb.txt" DESTINATION "${SYSCONFDIR}" COMPONENT "openmw")
 
+    INSTALL(FILES "${OpenMW_BINARY_DIR}/tes3mp-client-default" DESTINATION "${SYSCONFDIR}" COMPONENT "openmw")
+    INSTALL(FILES "${OpenMW_BINARY_DIR}/tes3mp-client.install" DESTINATION "${SYSCONFDIR}" RENAME "tes3mp-client.cfg" COMPONENT "openmw")
+    INSTALL(FILES "${OpenMW_BINARY_DIR}/tes3mp-server-default" DESTINATION "${SYSCONFDIR}" COMPONENT "openmw-mp")
+    INSTALL(FILES "${OpenMW_BINARY_DIR}/tes3mp-server.install" DESTINATION "${SYSCONFDIR}" RENAME "tes3mp-server.cfg" COMPONENT "openmw-mp")
+
     IF(BUILD_OPENCS)
         INSTALL(FILES "${OpenMW_BINARY_DIR}/openmw-cs.cfg" DESTINATION "${SYSCONFDIR}" COMPONENT "opencs")
     ENDIF(BUILD_OPENCS)
@@ -452,6 +467,7 @@ if(WIN32)
         "${OpenMW_SOURCE_DIR}/Docs/license/GPL3.txt"
         "${OpenMW_SOURCE_DIR}/Docs/license/DejaVu Font License.txt"
         "${OpenMW_BINARY_DIR}/settings-default.cfg"
+        "${OpenMW_BINARY_DIR}/tes3mp-client-default.cfg"
         "${OpenMW_BINARY_DIR}/gamecontrollerdb.txt"
         "${OpenMW_BINARY_DIR}/Release/openmw.exe"
         DESTINATION ".")
@@ -555,6 +571,10 @@ add_subdirectory (components)
 #endif()
 
 # Apps and tools
+if (BUILD_OPENMW_MP)
+    add_subdirectory( apps/openmw-mp )
+endif()
+
 if (BUILD_OPENMW)
     add_subdirectory( apps/openmw )
 endif()
diff --git a/OpenMW-mp changelog b/OpenMW-mp changelog
new file mode 100644
index 000000000..53753cc05
--- /dev/null
+++ b/OpenMW-mp changelog	
@@ -0,0 +1,51 @@
+0.0.1b
+    Fixed NPC attack segfault
+    Movement interpolation
+    Lua-scripting
+    Chat
+
+0.0.1a
+    Combat animation
+    Synchronization of melee and ranged (bow, crossbow, throwable weapons) combat
+    Synchronization of health, mana, stamina (sic) and death
+    Synchronization of attributes and skills
+
+0.0.1
+    Synchronization of racial features
+    Synchronization of position
+    Synchronization of the state (nothing/weapon/spell)
+    Synchronization of movement and jump animations
+
+To do:
+
+0.0.1b
+    Finish combat package (knockout, knockdown, spells and enchantments)
+    Improve position synchronization while being knocked out, knocked down or dying
+    Partial (unbreakable) items synchronization
+    Spells synchronization
+
+0.0.2
+    Vampirism
+    Lycanthropy
+    Items synchronization
+    Locks synchronization
+    Opening doors
+    Opening locks
+    Activators interaction (hook?)
+
+0.0.2b
+    Code cleanup
+
+0.0.3
+    Containers synchronization
+    Loot
+    Stealing from other players
+    Dropping/picking up items
+
+Future
+    Disableable console (~)
+    Client-side script functions for synchronization
+    Weather sync
+    Time sync
+    NPC sync
+    Trading
diff --git a/TES3MPTeam.md b/TES3MPTeam.md
new file mode 100644
index 000000000..2e06e3870
--- /dev/null
+++ b/TES3MPTeam.md
@@ -0,0 +1,25 @@
+Tes3mp Team
+============
+
+Programmers
+-----------
+
+    Stanislav (Koncord) Zhukov - The main loafer and part-time Project Leader
+
+
+Testers:
+--------
+
+    Volk Milit aka Ja'Virr-Dar - Team Manager, Debian Linux
+    Shnatsel - Debian Linux
+    Goodevil - Mint and Xubuntu Linux
+
+
+Public Relations and Translations
+---------------------------------
+
+    Volk Milit aka Ja'Virr-Dar - Public relations & News Writer
+    Shnatsel - Translator & News Writer
+
+
+Thanks to developers of OpenMW. They do amazing things.
diff --git a/apps/opencs/Networking.cpp b/apps/opencs/Networking.cpp
new file mode 100644
index 000000000..c6fe34835
--- /dev/null
+++ b/apps/opencs/Networking.cpp
@@ -0,0 +1,90 @@
+#include "editor.hpp"
+
+#include <exception>
+#include <iostream>
+#include <string>
+
+#include <QApplication>
+#include <QIcon>
+#include <QMetaType>
+
+#include "model/doc/messages.hpp"
+
+#include "model/world/universalid.hpp"
+
+#ifdef Q_OS_MAC
+#include <QDir>
+#endif
+
+Q_DECLARE_METATYPE (std::string)
+
+class Application : public QApplication
+{
+    private:
+
+        bool notify (QObject *receiver, QEvent *event)
+        {
+            try
+            {
+                return QApplication::notify (receiver, event);
+            }
+            catch (const std::exception& exception)
+            {
+                std::cerr << "An exception has been caught: " << exception.what() << std::endl;
+            }
+
+            return false;
+        }
+
+    public:
+
+        Application (int& argc, char *argv[]) : QApplication (argc, argv) {}
+};
+
+int main(int argc, char *argv[])
+{
+    #ifdef Q_OS_MAC
+        setenv("OSG_GL_TEXTURE_STORAGE", "OFF", 0);
+    #endif
+
+    try
+    {
+        // To allow background thread drawing in OSG
+        QApplication::setAttribute(Qt::AA_X11InitThreads, true);
+
+        Q_INIT_RESOURCE (resources);
+
+        qRegisterMetaType<std::string> ("std::string");
+        qRegisterMetaType<CSMWorld::UniversalId> ("CSMWorld::UniversalId");
+        qRegisterMetaType<CSMDoc::Message> ("CSMDoc::Message");
+
+        Application application (argc, argv);
+
+    #ifdef Q_OS_MAC
+        QDir dir(QCoreApplication::applicationDirPath());
+        if (dir.dirName() == "MacOS") {
+            dir.cdUp();
+            dir.cdUp();
+            dir.cdUp();
+        }
+        QDir::setCurrent(dir.absolutePath());
+    #endif
+
+        application.setWindowIcon (QIcon (":./openmw-cs.png"));
+
+        CS::Editor editor;
+
+        if(!editor.makeIPCServer())
+        {
+            editor.connectToIPCServer();
+            return 0;
+        }
+        return editor.run();
+    }
+    catch (std::exception& e)
+    {
+        std::cerr << "ERROR: " << e.what() << std::endl;
+        return 0;
+    }
+
+}
diff --git a/apps/openmw-mp/CMakeLists.txt b/apps/openmw-mp/CMakeLists.txt
new file mode 100644
index 000000000..2219de99b
--- /dev/null
+++ b/apps/openmw-mp/CMakeLists.txt
@@ -0,0 +1,124 @@
+project(openmw-mp)
+
+add_subdirectory(amx)
+
+option(BUILD_WITH_PAWN "Enable Pawn language" OFF)
+if(BUILD_WITH_PAWN)
+    #set(Pawn_ROOT ${CMAKE_SOURCE_DIR}/external/pawn/)
+    set(Pawn_INCLUDES ${Pawn_ROOT}/include)
+    set(Pawn_LIBRARY ${Pawn_ROOT}/lib/libamx.a)
+    set(PawnScript_Sources
+            Script/LangPawn/LangPAWN.cpp
+            Script/LangPawn/PawnFunc.cpp)
+    set(PawnScript_Headers ${Pawn_INCLUDES}
+            Script/LangPawn/LangPAWN.hpp
+            )
+
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DENABLE_PAWN -DPAWN_CELL_SIZE=64")
+    #include_directories(${Pawn_INCLUDES})
+    include_directories("./amx/linux")
+endif(BUILD_WITH_PAWN)
+
+option(BUILD_WITH_LUA "Enable Terra/Lua language" ON)
+if(BUILD_WITH_LUA)
+    #set(Terra_ROOT ${CMAKE_SOURCE_DIR}/external/terra/)
+    find_package(Terra REQUIRED)
+    set(LuaScript_Sources
+            Script/LangLua/LangLua.cpp
+            Script/LangLua/LuaFunc.cpp)
+    set(LuaScript_Headers ${Terra_INCLUDES} ${CMAKE_SOURCE_DIR}/extern/LuaBridge ${CMAKE_SOURCE_DIR}/extern/LuaBridge/detail
+            Script/LangLua/LangLua.hpp)
+
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DENABLE_LUA")
+    include_directories(${Terra_INCLUDES} ${CMAKE_SOURCE_DIR}/extern/LuaBridge)
+endif(BUILD_WITH_LUA)
+
+set(NativeScript_Sources
+        Script/LangNative/LangNative.cpp
+        )
+set(NativeScript_Headers
+        Script/LangNative/LangNative.hpp
+        )
+
+# local files
+set(SERVER
+    main.cpp
+    Player.cpp
+    Networking.cpp
+    Utils.cpp
+    Script/Script.cpp Script/ScriptFunction.cpp
+    Script/ScriptFunctions.cpp
+    Script/Functions/Translocations.cpp Script/Functions/Stats.cpp Script/Functions/Items.cpp
+    Script/Functions/Timer.cpp Script/Functions/Chat.cpp
+    Script/API/TimerAPI.cpp Script/API/PublicFnAPI.cpp
+        ${PawnScript_Sources}
+        ${LuaScript_Sources}
+        ${NativeScript_Sources}
+
+)
+
+set(SERVER_HEADER
+        Script/Types.hpp Script/Script.hpp Script/SystemInterface.hpp
+        Script/ScriptFunction.hpp Script/Platform.hpp
+        Script/ScriptFunctions.hpp Script/API/TimerAPI.hpp Script/API/PublicFnAPI.hpp
+        ${PawnScript_Headers}
+        ${LuaScript_Headers}
+        ${NativeScript_Headers}
+)
+source_group(openmw-mp FILES ${SERVER} ${SERVER_HEADER})
+
+include_directories("./")
+
+# Main executable
+
+add_executable(openmw-mp
+${SERVER_FILES}
+${SERVER} ${SERVER_HEADER}
+${APPLE_BUNDLE_RESOURCES}
+)
+add_definitions(-std=gnu++11)
+
+target_link_libraries(openmw-mp
+    ${OSG_LIBRARIES}
+    ${OPENTHREADS_LIBRARIES}
+    ${OSGPARTICLE_LIBRARIES}
+    ${OSGUTIL_LIBRARIES}
+    ${OSGDB_LIBRARIES}
+    ${OSGVIEWER_LIBRARIES}
+    ${OSGGA_LIBRARIES}
+    ${Boost_SYSTEM_LIBRARY}
+    ${Boost_THREAD_LIBRARY}
+    ${Boost_FILESYSTEM_LIBRARY}
+    ${Boost_PROGRAM_OPTIONS_LIBRARY}
+    ${BULLET_LIBRARIES}
+    ${RakNet_LIBRARY}
+    components
+    amx
+    ${Terra_LIBRARY}
+    ${Pawn_LIBRARY}
+)
+
+if (USE_SYSTEM_TINYXML)
+    target_link_libraries(openmw-mp ${TINYXML_LIBRARIES})
+endif()
+
+if (UNIX)
+    target_link_libraries(openmw-mp dl)
+    # Fix for not visible pthreads functions for linker with glibc 2.15
+    if(NOT APPLE)
+        target_link_libraries(openmw-mp ${CMAKE_THREAD_LIBS_INIT})
+    endif(NOT APPLE)
+endif(UNIX)
+
+if (BUILD_WITH_CODE_COVERAGE)
+  add_definitions (--coverage)
+  target_link_libraries(openmw-mp gcov)
+endif()
+
+if (MSVC)
+    # Debug version needs increased number of sections beyond 2^16
+    if (CMAKE_CL_64)
+        set (CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /bigobj")
+    endif (CMAKE_CL_64)
+    add_definitions("-D_USE_MATH_DEFINES")
+endif (MSVC)
diff --git a/apps/openmw-mp/Networking.cpp b/apps/openmw-mp/Networking.cpp
new file mode 100644
index 000000000..340f15084
--- /dev/null
+++ b/apps/openmw-mp/Networking.cpp
@@ -0,0 +1,394 @@
+//
+// Created by koncord on 12.01.16.
+//
+
+#include "Player.hpp"
+#include <RakPeer.h>
+#include <Kbhit.h>
+#include <components/openmw-mp/NetworkMessages.hpp>
+#include <iostream>
+#include <Script/Script.hpp>
+#include <Script/API/TimerAPI.hpp>
+
+#include "Networking.hpp"
+
+using namespace mwmp;
+using namespace std;
+
+Networking *Networking::sThis = 0;
+
+Networking::Networking(RakNet::RakPeerInterface *peer)
+{
+    sThis = this;
+    this->peer = peer;
+    players = Players::GetPlayers();
+
+    controller = new PacketsController(peer);
+
+    controller->SetStream(0, &bsOut); // set send stream
+
+    Script::Call<Script::CallbackIdentity("OnServerInit")>();
+
+    running = true;
+    exitCode = 0;
+}
+
+Networking::~Networking()
+{
+    Script::Call<Script::CallbackIdentity("OnServerExit")>(false);
+
+    sThis = 0;
+    delete controller;
+}
+
+void Networking::Update(RakNet::Packet *packet)
+{
+
+    Player *player = Players::GetPlayer(packet->guid);
+
+    if(player == 0)
+    {
+        controller->GetPacket(ID_HANDSHAKE)->RequestData(packet->guid);
+
+        NewPlayer(packet->guid);
+        player = Players::GetPlayer(packet->guid);
+
+        return;
+    }
+
+    RakNet::BitStream bsIn(&packet->data[2], packet->length, false);
+
+    {
+        RakNet::RakNetGUID ignoredGUID;
+        bsIn.Read(ignoredGUID);
+        (void)ignoredGUID;
+    }
+
+    controller->SetStream(&bsIn, 0);
+
+    BasePacket *myPacket = controller->GetPacket(packet->data[1]);
+
+    if(packet->data[1] == ID_HANDSHAKE)
+    {
+        DEBUG_PRINTF("ID_HANDSHAKE\n");
+        string passw = "SuperPassword";
+
+        myPacket->Read(player);
+
+        if(player->isHandshaked())
+        {
+            DEBUG_PRINTF("Wrong handshake with player %d, name: %s\n", player->GetID(), player->Npc()->mName.c_str());
+            KickPlayer(player->guid);
+            return;
+        }
+
+        if(*player->GetPassw() != passw)
+        {
+            DEBUG_PRINTF("Wrong server password (player %d, name: %s) pass: %s\n", player->GetID(), player->Npc()->mName.c_str(), player->GetPassw()->c_str());
+            KickPlayer(player->guid);
+            return;
+        }
+        player->Handshake();
+
+        static constexpr unsigned int ident = Script::CallbackIdentity("OnPlayerConnect");
+        Script::CallBackReturn<ident> result = true;
+        Script::Call<ident>(result, Players::GetPlayer(packet->guid)->GetID());
+
+        if(!result)
+        {
+            controller->GetPacket(ID_USER_DISCONNECTED)->Send(Players::GetPlayer(packet->guid), false);
+            Players::DeletePlayer(packet->guid);
+            return;
+        }
+
+        return;
+
+    }
+
+    if(!player->isHandshaked())
+    {
+        DEBUG_PRINTF("Wrong auth player %d, name: %s\n", player->GetID(), player->Npc()->mName.c_str());
+        //KickPlayer(player->guid);
+        return;
+    }
+
+    switch(packet->data[1])
+    {
+        case ID_GAME_BASE_INFO:
+        {
+            DEBUG_PRINTF("ID_GAME_BASE_INFO\n");
+
+            myPacket->Read(player);
+            myPacket->Send(player, true);
+
+            break;
+        }
+        case ID_GAME_UPDATE_POS:
+        {
+            //DEBUG_PRINTF("ID_GAME_UPDATE_POS \n");
+
+            if(!player->CreatureStats()->mDead)
+            {
+                myPacket->Read(player);
+                myPacket->Send(player, true); //send to other clients
+            }
+
+            break;
+        }
+        case ID_GAME_CELL:
+        {
+            DEBUG_PRINTF("ID_GAME_CELL \n");
+
+            if(!player->CreatureStats()->mDead)
+            {
+                myPacket->Read(player);
+                myPacket->Send(player, true); //send to other clients
+                Script::Call<Script::CallbackIdentity("OnPlayerChangeCell")>(player->GetID());
+            }
+
+            break;
+        }
+        case ID_GAME_UPDATE_SKILLS:
+        {
+            DEBUG_PRINTF("ID_GAME_UPDATE_SKILLS\n");
+
+            if(!player->CreatureStats()->mDead)
+            {
+                myPacket->Read(player);
+                myPacket->Send(player, true);
+            }
+
+            break;
+        }
+        case ID_GAME_UPDATE_EQUIPED:
+        {
+            DEBUG_PRINTF("ID_GAME_UPDATE_EQUIPED\n");
+
+            myPacket->Read(player);
+            myPacket->Send(player, true);
+
+            Script::Call<Script::CallbackIdentity("OnPlayerUpdateEquiped")>(player->GetID());
+
+            break;
+        }
+
+        case ID_GAME_ATTACK:
+        {
+            DEBUG_PRINTF("ID_GAME_ATTACK\n");
+
+            if(!player->CreatureStats()->mDead)
+            {
+                myPacket->Read(player);
+
+#if defined(DEBUG)
+                cout << "Player: " << player->Npc()->mName << " atk state: " << (player->GetAttack()->pressed == 1) <<
+                endl;
+                if (player->GetAttack()->pressed == 0)
+                {
+                    cout << "success: " << (player->GetAttack()->success == 1);
+                    if (player->GetAttack()->success == 1)
+                        cout << " damage: " << player->GetAttack()->damage;
+                    cout << endl;
+                }
+#endif
+
+                myPacket->Send(player, true);
+                controller->GetPacket(ID_GAME_UPDATE_BASESTATS)->RequestData(player->GetAttack()->target);
+            }
+            break;
+        }
+
+        case ID_GAME_UPDATE_BASESTATS:
+        {
+            DEBUG_PRINTF("ID_GAME_UPDATE_BASESTATS\n");
+            myPacket->Read(player);
+            myPacket->Send(player, true);
+            break;
+        }
+
+        case ID_GAME_DIE:
+        {
+            DEBUG_PRINTF("ID_GAME_DIE\n");
+            //packetMainStats.Read(player);
+            player->CreatureStats()->mDead = true;
+            myPacket->Send(player, true);
+
+            Script::Call<Script::CallbackIdentity("OnPlayerDeath")>(player->GetID());
+
+            break;
+        }
+
+        case ID_GAME_RESURRECT:
+        {
+            DEBUG_PRINTF("ID_GAME_RESURRECT\n");
+            //packetResurrect.Read(player);
+            player->CreatureStats()->mDead = false;
+            myPacket->Send(player, true);
+            controller->GetPacket(ID_GAME_UPDATE_POS)->RequestData(player->guid);
+            controller->GetPacket(ID_GAME_CELL)->RequestData(player->guid);
+            //packetMainStats.RequestData(player->guid);
+
+            Script::Call<Script::CallbackIdentity("OnPlayerResurrect")>(player->GetID());
+
+            break;
+        }
+
+        case ID_GAME_DRAWSTATE:
+        {
+            DEBUG_PRINTF("ID_GAME_DRAWSTATE\n");
+            myPacket->Read(player);
+            myPacket->Send(player, true);
+            break;
+        }
+
+        case ID_CHAT_MESSAGE:
+        {
+            DEBUG_PRINTF("ID_CHAT_MESSAGE\n");
+            myPacket->Read(player);
+            Script::CallBackReturn<Script::CallbackIdentity("OnPlayerSendMessage")> result = true;
+            Script::Call<Script::CallbackIdentity("OnPlayerSendMessage")>(result, player->GetID(), player->ChatMessage()->c_str());
+
+            if(result)
+            {
+                *player->ChatMessage() = player->Npc()->mName + " (" + std::to_string(player->GetID()) + "): "
+                                         + *player->ChatMessage() + "\n";
+                myPacket->Send(player, false);
+                myPacket->Send(player, true);
+            }
+            break;
+        }
+        case ID_GAME_CHARGEN:
+        {
+            DEBUG_PRINTF("ID_GAME_CHARGEN\n");
+            myPacket->Read(player);
+
+            if (player->CharGenStage()->current == player->CharGenStage()->end && player->CharGenStage()->current != 0)
+            {
+                Script::Call<Script::CallbackIdentity("OnPlayerEndCharGen")>(player->GetID());
+                cout << "RACE: " << player->Npc()->mRace << endl;
+            }
+            break;
+        }
+
+        default:
+            printf("Message with identifier %i has arrived.\n", packet->data[1]);
+            break;
+    }
+}
+
+void Networking::NewPlayer(RakNet::RakNetGUID guid)
+{
+    Players::NewPlayer(guid);
+
+    controller->GetPacket(ID_USER_MYID)->Send(Players::GetPlayer(guid), false);
+
+    controller->GetPacket(ID_GAME_BASE_INFO)->RequestData(guid);
+    //controller->GetPacket(ID_GAME_UPDATE_SKILLS)->RequestData(guid);
+    //controller->GetPacket(ID_GAME_UPDATE_BASESTATS)->RequestData(guid);
+    controller->GetPacket(ID_GAME_UPDATE_POS)->RequestData(guid);
+    controller->GetPacket(ID_GAME_CELL)->RequestData(guid);
+    controller->GetPacket(ID_GAME_UPDATE_EQUIPED)->RequestData(guid);
+
+    for(TPlayers::iterator pl = players->begin(); pl != players->end(); pl++)
+    {
+        if(pl->first == guid) continue;
+
+        controller->GetPacket(ID_GAME_BASE_INFO)->Send(pl->second, guid);
+        //controller->GetPacket(ID_GAME_UPDATE_SKILLS)->Send(pl->second, guid);
+        //controller->GetPacket(ID_GAME_UPDATE_BASESTATS)->Send(pl->second, guid);
+        controller->GetPacket(ID_GAME_UPDATE_POS)->Send(pl->second, guid);
+        controller->GetPacket(ID_GAME_CELL)->Send(pl->second, guid);
+        controller->GetPacket(ID_GAME_UPDATE_EQUIPED)->Send(pl->second, guid);
+    }
+
+}
+
+void Networking::DisconnectPlayer(RakNet::RakNetGUID guid)
+{
+    Script::Call<Script::CallbackIdentity("OnPlayerDisconnect")>(Players::GetPlayer(guid)->GetID());
+    controller->GetPacket(ID_USER_DISCONNECTED)->Send(Players::GetPlayer(guid), true);
+    Players::DeletePlayer(guid);
+}
+
+PacketsController *Networking::GetController() const
+{
+    return controller;
+}
+
+const Networking &Networking::Get()
+{
+    return *sThis;
+}
+
+
+Networking *Networking::GetPtr()
+{
+    return sThis;
+}
+
+void Networking::StopServer(int code)
+{
+    running = false;
+    exitCode = code;
+
+}
+
+int Networking::MainLoop()
+{
+    RakNet::Packet *packet;
+
+    while (running)
+    {
+        if(kbhit() && getch() == '\n')
+            break;
+        for (packet=peer->Receive(); packet; peer->DeallocatePacket(packet), packet=peer->Receive())
+        {
+            switch (packet->data[0])
+            {
+                case ID_REMOTE_DISCONNECTION_NOTIFICATION:
+                    printf("Another client has disconnected.\n");
+                    break;
+                case ID_REMOTE_CONNECTION_LOST:
+                    printf("Another client has lost the connection.\n");
+                    break;
+                case ID_REMOTE_NEW_INCOMING_CONNECTION:
+                    printf("Another client has connected.\n");
+                    break;
+                case ID_CONNECTION_REQUEST_ACCEPTED:    // client to server
+                {
+                    printf("Our connection request has been accepted.\n");
+                    break;
+                }
+                case ID_NEW_INCOMING_CONNECTION:
+                    printf("A connection is incoming.\n");
+                    break;
+                case ID_NO_FREE_INCOMING_CONNECTIONS:
+                    printf("The server is full.\n");
+                    break;
+                case ID_DISCONNECTION_NOTIFICATION:
+                    printf("A client has disconnected.\n");
+                    DisconnectPlayer(packet->guid);
+                    break;
+                case ID_CONNECTION_LOST:
+                    printf("A client lost the connection.\n");
+                    DisconnectPlayer(packet->guid);
+                    break;
+                case ID_CUSTOM_MESSAGE:
+                    Update(packet);
+                    break;
+                default:
+                    printf("Message with identifier %i has arrived.\n", packet->data[0]);
+                    break;
+            }
+        }
+        TimerAPI::Tick();
+    }
+
+    TimerAPI::Terminate();
+    return exitCode;
+}
+
+void Networking::KickPlayer(RakNet::RakNetGUID guid)
+{
+    peer->CloseConnection(guid, true);
+}
diff --git a/apps/openmw-mp/Networking.hpp b/apps/openmw-mp/Networking.hpp
new file mode 100644
index 000000000..200ab2b0f
--- /dev/null
+++ b/apps/openmw-mp/Networking.hpp
@@ -0,0 +1,45 @@
+//
+// Created by koncord on 12.01.16.
+//
+
+#ifndef OPENMW_NETWORKING_HPP
+#define OPENMW_NETWORKING_HPP
+
+#include <components/openmw-mp/PacketsController.hpp>
+
+namespace  mwmp
+{
+    class Networking
+    {
+    public:
+        Networking(RakNet::RakPeerInterface *peer);
+        ~Networking();
+
+        void NewPlayer(RakNet::RakNetGUID guid);
+        void DisconnectPlayer(RakNet::RakNetGUID guid);
+        void KickPlayer(RakNet::RakNetGUID guid);
+        void Update(RakNet::Packet *packet);
+
+        int MainLoop();
+
+        void StopServer(int code);
+
+        PacketsController *GetController() const;
+        static const Networking &Get();
+        static Networking *GetPtr();
+
+    private:
+        static Networking *sThis;
+        RakNet::RakPeerInterface *peer;
+        RakNet::BitStream bsOut;
+        TPlayers *players;
+
+        PacketsController *controller;
+
+        bool running;
+        int exitCode;
+    };
+}
+
+
+#endif //OPENMW_NETWORKING_HPP
diff --git a/apps/openmw-mp/Player.cpp b/apps/openmw-mp/Player.cpp
new file mode 100644
index 000000000..da1c40a8b
--- /dev/null
+++ b/apps/openmw-mp/Player.cpp
@@ -0,0 +1,80 @@
+//
+// Created by koncord on 05.01.16.
+//
+
+#include "Player.hpp"
+
+TPlayers Players::players;
+TSlots Players::slots;
+
+void Players::DeletePlayer(RakNet::RakNetGUID id)
+{
+    if(players[id] != 0)
+    {
+        slots[players[id]->GetID()] = 0;
+        delete players[id];
+        players.erase(id);
+    }
+
+}
+
+void Players::NewPlayer(RakNet::RakNetGUID id)
+{
+    players[id] = new Player(id);
+
+    for(int i = 0; i < 16; i++)
+    {
+        if(slots[i] == 0)
+        {
+            slots[i] = players[id];
+            slots[i]->SetID(i);
+            break;
+        }
+    }
+}
+
+Player *Players::GetPlayer(RakNet::RakNetGUID id)
+{
+    return players[id];
+}
+
+std::map<RakNet::RakNetGUID, Player*> *Players::GetPlayers()
+{
+    return &players;
+}
+
+Player::Player(RakNet::RakNetGUID id) : BasePlayer(id)
+{
+    handshake = false;
+}
+
+Player::~Player()
+{
+
+}
+
+unsigned short Player::GetID()
+{
+    return id;
+}
+
+void Player::SetID(unsigned short id)
+{
+    this->id = id;
+}
+
+void Player::Handshake()
+{
+    handshake = true;
+}
+
+bool Player::isHandshaked()
+{
+    return handshake;
+}
+
+
+Player *Players::GetPlayer(unsigned short id)
+{
+    return slots[id];
+}
diff --git a/apps/openmw-mp/Player.hpp b/apps/openmw-mp/Player.hpp
new file mode 100644
index 000000000..f628e1e79
--- /dev/null
+++ b/apps/openmw-mp/Player.hpp
@@ -0,0 +1,56 @@
+//
+// Created by koncord on 05.01.16.
+//
+
+#ifndef OPENMW_PLAYER_HPP
+#define OPENMW_PLAYER_HPP
+
+#include <map>
+#include <string>
+#include <RakNetTypes.h>
+
+#include <components/esm/npcstats.hpp>
+#include <components/esm/cellid.hpp>
+#include <components/esm/loadnpc.hpp>
+#include <components/esm/loadcell.hpp>
+
+#include <components/openmw-mp/Base/BasePlayer.hpp>
+
+struct Player;
+typedef std::map<RakNet::RakNetGUID, Player*> TPlayers;
+typedef std::map<unsigned short, Player*> TSlots;
+
+class Players
+{
+public:
+    static void NewPlayer(RakNet::RakNetGUID id);
+    static void DeletePlayer(RakNet::RakNetGUID id);
+    static Player *GetPlayer(RakNet::RakNetGUID id);
+    static Player *GetPlayer(unsigned short id);
+    static TPlayers *GetPlayers();
+
+private:
+    static TPlayers players;
+    static TSlots slots;
+};
+
+class Player : public mwmp::BasePlayer
+{
+    unsigned short id;
+public:
+
+    Player(RakNet::RakNetGUID id);
+
+    unsigned short GetID();
+    void SetID(unsigned short id);
+
+    bool isHandshaked();
+
+    void Handshake();
+
+    virtual ~Player();
+private:
+    bool handshake;
+};
+
+#endif //OPENMW_PLAYER_HPP
diff --git a/apps/openmw-mp/Script/API/PublicFnAPI.cpp b/apps/openmw-mp/Script/API/PublicFnAPI.cpp
new file mode 100644
index 000000000..eb09d10d4
--- /dev/null
+++ b/apps/openmw-mp/Script/API/PublicFnAPI.cpp
@@ -0,0 +1,93 @@
+//
+// Created by koncord on 14.05.16.
+//
+
+#include <Script/ScriptFunction.hpp>
+#include "PublicFnAPI.hpp"
+
+using namespace std;
+
+unordered_map<string, Public *> Public::publics;
+
+Public::~Public()
+{
+
+}
+
+Public::Public(ScriptFunc _public, const std::string &name, char ret_type, const std::string &def) : ScriptFunction(_public, ret_type, def)
+{
+    publics.emplace(name, this);
+}
+
+Public::Public(ScriptFuncLua _public, lua_State *lua, const std::string &name, char ret_type, const std::string &def) : ScriptFunction(
+        _public, lua, ret_type, def)
+{
+    publics.emplace(name, this);
+}
+
+#if defined(ENABLE_PAWN)
+Public::Public(ScriptFuncPAWN _public, AMX* amx, const std::string& name, char ret_type, const std::string& def): ScriptFunction(_public, amx, ret_type, def)
+{
+    publics.emplace(name, this);
+}
+#endif
+
+
+boost::any Public::Call(const std::string &name, const std::vector<boost::any> &args)
+{
+    auto it = publics.find(name);
+    if (it == publics.end())
+        throw runtime_error("Public with name \"" + name + "\" does not exist");
+
+    return it->second->ScriptFunction::Call(args);
+}
+
+
+const std::string &Public::GetDefinition(const std::string &name)
+{
+    auto it = publics.find(name);
+
+    if (it == publics.end())
+        throw runtime_error("Public with name \"" + name + "\" does not exist");
+
+    return it->second->def;
+}
+
+
+bool Public::IsLua(const std::string &name)
+{
+#if !defined(ENABLE_LUA)
+    return false;
+#else
+    auto it = publics.find(name);
+    if (it == publics.end())
+        throw runtime_error("Public with name \"" + name + "\" does not exist");
+
+    return it->second->script_type == SCRIPT_LUA;
+#endif
+}
+
+bool Public::IsPAWN(const std::string &name)
+{
+#if !defined(ENABLE_PAWN)
+    return false;
+#else
+    auto it = publics.find(name);
+
+    if (it == publics.end())
+        throw runtime_error("Public with name \"" + name + "\" does not exist");
+
+    return it->second->script_type == SCRIPT_PAWN;
+#endif
+}
+
+
+void Public::DeleteAll()
+{
+    for (auto it = publics.begin(); it != publics.end(); it++)
+    {
+        Public *_public = it->second;
+        delete _public;
+        publics.erase(it);
+    }
+}
\ No newline at end of file
diff --git a/apps/openmw-mp/Script/API/PublicFnAPI.hpp b/apps/openmw-mp/Script/API/PublicFnAPI.hpp
new file mode 100644
index 000000000..cd49185cf
--- /dev/null
+++ b/apps/openmw-mp/Script/API/PublicFnAPI.hpp
@@ -0,0 +1,42 @@
+//
+// Created by koncord on 14.05.16.
+//
+
+#ifndef PLUGINSYSTEM3_PUBLICFNAPI_HPP
+#define PLUGINSYSTEM3_PUBLICFNAPI_HPP
+
+#include <unordered_map>
+#include <Script/ScriptFunction.hpp>
+
+
+class Public : public ScriptFunction
+{
+private:
+    ~Public();
+
+    static std::unordered_map<std::string, Public *> publics;
+
+    Public(ScriptFunc _public, const std::string &name, char ret_type, const std::string &def);
+#if defined(ENABLE_PAWN)
+    Public(ScriptFuncPAWN _public, AMX* amx, const std::string& name, char ret_type, const std::string& def);
+#endif
+#if defined(ENABLE_LUA)
+    Public(ScriptFuncLua _public, lua_State *lua, const std::string &name, char ret_type, const std::string &def);
+#endif
+
+public:
+    template<typename... Args>
+    static void MakePublic(Args &&... args)
+    { new Public(std::forward<Args>(args)...); }
+
+    static boost::any Call(const std::string &name, const std::vector<boost::any> &args);
+
+    static const std::string& GetDefinition(const std::string& name);
+
+    static bool IsPAWN(const std::string &name);
+    static bool IsLua(const std::string &name);
+
+    static void DeleteAll();
+};
+
+#endif //PLUGINSYSTEM3_PUBLICFNAPI_HPP
diff --git a/apps/openmw-mp/Script/API/TimerAPI.cpp b/apps/openmw-mp/Script/API/TimerAPI.cpp
new file mode 100644
index 000000000..fb18122b5
--- /dev/null
+++ b/apps/openmw-mp/Script/API/TimerAPI.cpp
@@ -0,0 +1,238 @@
+//
+// Created by koncord on 15.03.16.
+//
+
+#include "TimerAPI.hpp"
+
+#include <chrono>
+
+#include <iostream>
+using namespace mwmp;
+using namespace std;
+
+Timer::Timer(ScriptFunc callback, long msec, const std::string& def, std::vector<boost::any> args) : ScriptFunction(callback, 'v', def)
+{
+    targetMsec = msec;
+    this->args = args;
+    end = true;
+}
+
+#if defined(ENABLE_PAWN)
+Timer::Timer(AMX *amx, ScriptFuncPAWN callback, long msec, const std::string &def, std::vector<boost::any> args): ScriptFunction(callback, amx, 'v', def)
+{
+    targetMsec = msec;
+    this->args = args;
+    end = true;
+}
+#endif
+#if defined(ENABLE_LUA)
+Timer::Timer(lua_State *lua, ScriptFuncLua callback, long msec, const std::string& def, std::vector<boost::any> args): ScriptFunction(callback, lua, 'v', def)
+{
+    targetMsec = msec;
+    this->args = args;
+    end = true;
+}
+#endif
+
+void Timer::Tick()
+{
+    if(end)
+        return;
+
+    const auto duration = chrono::system_clock::now().time_since_epoch();
+    const auto time = chrono::duration_cast<chrono::milliseconds>(duration).count();
+
+    if (time - startTime >= targetMsec)
+    {
+        Call(args);
+        end = true;
+    }
+}
+
+bool Timer::IsEnd()
+{
+    return end;
+}
+
+void Timer::Stop()
+{
+    end = true;
+}
+
+void Timer::Restart(int msec)
+{
+    targetMsec = msec;
+    Start();
+}
+
+void Timer::Start()
+{
+    end = false;
+
+    const auto duration = chrono::system_clock::now().time_since_epoch();
+    const auto msec = chrono::duration_cast<chrono::milliseconds>(duration).count();
+    startTime = msec;
+}
+
+int TimerAPI::pointer = 0;
+std::unordered_map<int, Timer* > TimerAPI::timers;
+
+#if defined(ENABLE_PAWN)
+int TimerAPI::CreateTimerPAWN(AMX *amx, ScriptFuncPAWN callback, long msec, const string& def, std::vector<boost::any> args)
+{
+    int id = -1;
+
+    for (auto timer : timers)
+    {
+        if (timer.second != nullptr)
+            continue;
+        timer.second = new Timer(amx, callback, msec, def, args);
+        id = timer.first;
+    }
+
+    if (id == -1)
+    {
+        timers[pointer] = new Timer(amx, callback, msec, def, args);
+        id = pointer;
+        pointer++;
+    }
+
+    return id;
+}
+#endif
+
+#if defined(ENABLE_LUA)
+int TimerAPI::CreateTimerLua(lua_State *lua, ScriptFuncLua callback, long msec, const std::string& def, std::vector<boost::any> args)
+{
+    int id = -1;
+
+    for (auto timer : timers)
+    {
+        if (timer.second != nullptr)
+            continue;
+        timer.second = new Timer(lua, callback, msec, def, args);
+        id = timer.first;
+    }
+
+    if (id == -1)
+    {
+        timers[pointer] = new Timer(lua, callback, msec, def, args);
+        id = pointer;
+        pointer++;
+    }
+
+    return id;
+}
+#endif
+
+
+int TimerAPI::CreateTimer(ScriptFunc callback, long msec, const std::string &def, std::vector<boost::any> args)
+{
+    int id = -1;
+
+    for (auto timer : timers)
+    {
+        if (timer.second != nullptr)
+            continue;
+        timer.second = new Timer(callback, msec, def, args);
+        id = timer.first;
+    }
+
+    if (id == -1)
+    {
+        timers[pointer] = new Timer(callback, msec, def, args);
+        id = pointer;
+        pointer++;
+    }
+
+    return id;
+}
+
+void TimerAPI::FreeTimer(int timerid)
+{
+
+    try
+    {
+        if(timers.at(timerid) != nullptr)
+        {
+            delete timers[timerid];
+            timers[timerid] = nullptr;
+        }
+    }
+    catch(...)
+    {
+        std::cerr << "Timer " << timerid << " not found!" << endl;
+    }
+}
+
+void TimerAPI::ResetTimer(int timerid, long msec)
+{
+    try
+    {
+        timers.at(timerid)->Restart(msec);
+    }
+    catch(...)
+    {
+        std::cerr << "Timer " << timerid << " not found!" << endl;
+    }
+}
+
+void TimerAPI::StartTimer(int timerid)
+{
+    try
+    {
+        Timer *timer = timers.at(timerid);
+        if(timer == nullptr)
+            throw 1;
+        timer->Start();
+    }
+    catch(...)
+    {
+        std::cerr << "Timer " << timerid << " not found!" << endl;
+    }
+}
+
+void TimerAPI::StopTimer(int timerid)
+{
+    try
+    {
+        timers.at(timerid)->Stop();
+    }
+    catch(...)
+    {
+        std::cerr << "Timer " << timerid << " not found!" << endl;
+    }
+}
+
+bool TimerAPI::IsEndTimer(int timerid)
+{
+    bool ret = false;
+    try
+    {
+        ret = timers.at(timerid)->IsEnd();
+    }
+    catch(...)
+    {
+        std::cerr << "Timer " << timerid << " not found!" << endl;
+    }
+    return ret;
+}
+
+void TimerAPI::Terminate()
+{
+    for(auto timer : timers)
+    {
+        if(timer.second != nullptr)
+            delete timer.second;
+        timer.second = nullptr;
+    }
+}
+
+void TimerAPI::Tick()
+{
+    for (auto timer : timers)
+    {
+        if(timer.second != nullptr)
+            timer.second->Tick();
+    }
+}
\ No newline at end of file
diff --git a/apps/openmw-mp/Script/API/TimerAPI.hpp b/apps/openmw-mp/Script/API/TimerAPI.hpp
new file mode 100644
index 000000000..153ffdacd
--- /dev/null
+++ b/apps/openmw-mp/Script/API/TimerAPI.hpp
@@ -0,0 +1,70 @@
+//
+// Created by koncord on 15.03.16.
+//
+
+#ifndef OPENMW_TIMERAPI_HPP
+#define OPENMW_TIMERAPI_HPP
+
+#include <string>
+
+#include <Script/Script.hpp>
+#include <Script/ScriptFunction.hpp>
+
+namespace mwmp
+{
+
+    class TimerAPI;
+
+    class Timer: public ScriptFunction
+    {
+        friend class TimerAPI;
+
+    public:
+
+        Timer(ScriptFunc callback, long msec, const std::string& def, std::vector<boost::any> args);
+#if defined(ENABLE_PAWN)
+        Timer(AMX *amx, ScriptFuncPAWN callback, long msec, const std::string& def, std::vector<boost::any> args);
+#endif
+#if defined(ENABLE_LUA)
+        Timer(lua_State *lua, ScriptFuncLua callback, long msec, const std::string& def, std::vector<boost::any> args);
+#endif
+        void Tick();
+
+        bool IsEnd();
+        void Stop();
+        void Start();
+        void Restart(int msec);
+    private:
+        long startTime, targetMsec;
+        std::string publ, arg_types;
+        std::vector<boost::any> args;
+        Script *scr;
+        bool end;
+    };
+
+    class TimerAPI
+    {
+    public:
+#if defined(ENABLE_PAWN)
+        static int CreateTimerPAWN(AMX *amx, ScriptFuncPAWN callback, long msec, const std::string& def, std::vector<boost::any> args);
+#endif
+#if defined(ENABLE_LUA)
+        static int CreateTimerLua(lua_State *lua, ScriptFuncLua callback, long msec, const std::string& def, std::vector<boost::any> args);
+#endif
+        static int CreateTimer(ScriptFunc callback, long msec, const std::string& def, std::vector<boost::any> args);
+        static void FreeTimer(int timerid);
+        static void ResetTimer(int timerid, long msec);
+        static void StartTimer(int timerid);
+        static void StopTimer(int timerid);
+        static bool IsEndTimer(int timerid);
+
+        static void Terminate();
+
+        static void Tick();
+    private:
+        static std::unordered_map<int, Timer* > timers;
+        static int pointer;
+    };
+}
+
+#endif //OPENMW_TIMERAPI_HPP
diff --git a/apps/openmw-mp/Script/Functions/Chat.cpp b/apps/openmw-mp/Script/Functions/Chat.cpp
new file mode 100644
index 000000000..bdd62918c
--- /dev/null
+++ b/apps/openmw-mp/Script/Functions/Chat.cpp
@@ -0,0 +1,31 @@
+//
+// Created by koncord on 29.04.16.
+//
+
+#include <apps/openmw-mp/Script/ScriptFunctions.hpp>
+#include <apps/openmw-mp/Networking.hpp>
+#include <components/openmw-mp/NetworkMessages.hpp>
+
+void ScriptFunctions::SendMessage(unsigned short pid, const char *message, bool broadcast) noexcept
+{
+    Player *player;
+    GET_PLAYER(pid, player,);
+
+    *player->ChatMessage() = message;
+
+    DEBUG_PRINTF("System: %s", message);
+
+    mwmp::Networking::Get().GetController()->GetPacket(ID_CHAT_MESSAGE)->Send(player, false);
+    if(broadcast)
+        mwmp::Networking::Get().GetController()->GetPacket(ID_CHAT_MESSAGE)->Send(player, true);
+}
+
+void ScriptFunctions::CleanChat(unsigned short pid)
+{
+
+}
+
+void ScriptFunctions::CleanChat()
+{
+
+}
diff --git a/apps/openmw-mp/Script/Functions/Items.cpp b/apps/openmw-mp/Script/Functions/Items.cpp
new file mode 100644
index 000000000..981e29649
--- /dev/null
+++ b/apps/openmw-mp/Script/Functions/Items.cpp
@@ -0,0 +1,56 @@
+//
+// Created by koncord on 02.03.16.
+//
+
+#include <apps/openmw-mp/Script/ScriptFunctions.hpp>
+#include <components/openmw-mp/NetworkMessages.hpp>
+#include <apps/openmw-mp/Networking.hpp>
+#include <components/misc/stringops.hpp>
+
+
+/*void ScriptFunctions::AddItem(unsigned short pid, const char* itemName, unsigned short count) noexcept
+{
+    Player *player;
+    GET_PLAYER(pid, player,);
+
+
+
+    mwmp::Networking::Get().GetController()->GetPacket(ID_GAME_UPDATE_BASESTATS)->Send(player, false);
+    mwmp::Networking::Get().GetController()->GetPacket(ID_GAME_UPDATE_BASESTATS)->Send(player, true);
+}*/
+
+void ScriptFunctions::EquipItem(unsigned short pid, unsigned short slot, const char *itemName, unsigned short count) noexcept
+{
+    Player *player;
+    GET_PLAYER(pid, player,);
+
+    player->EquipedItem(slot)->refid = itemName;
+    player->EquipedItem(slot)->count = count;
+
+    mwmp::Networking::Get().GetController()->GetPacket(ID_GAME_UPDATE_EQUIPED)->Send(player, false);
+    mwmp::Networking::Get().GetController()->GetPacket(ID_GAME_UPDATE_EQUIPED)->Send(player, true);
+}
+
+void ScriptFunctions::UnequipItem(unsigned short pid, unsigned short slot) noexcept
+{
+    ScriptFunctions::EquipItem(pid, slot, "", 0);
+}
+
+const char *ScriptFunctions::GetItemSlot(unsigned short pid, unsigned short slot) noexcept
+{
+    Player *player;
+    GET_PLAYER(pid, player, 0);
+
+    return player->EquipedItem(slot)->refid.c_str();
+}
+
+bool ScriptFunctions::HasItemEquipped(unsigned short pid, const char* itemName)
+{
+    Player *player;
+    GET_PLAYER(pid, player, false);
+
+    for(int slot = 0; slot < 27; slot ++)
+        if(Misc::StringUtils::ciEqual(player->EquipedItem(slot)->refid, itemName))
+            return true;
+    return false;
+}
\ No newline at end of file
diff --git a/apps/openmw-mp/Script/Functions/Stats.cpp b/apps/openmw-mp/Script/Functions/Stats.cpp
new file mode 100644
index 000000000..b6ba7ea3e
--- /dev/null
+++ b/apps/openmw-mp/Script/Functions/Stats.cpp
@@ -0,0 +1,415 @@
+//
+// Created by koncord on 29.02.16.
+//
+
+#include <apps/openmw-mp/Script/ScriptFunctions.hpp>
+#include <components/openmw-mp/NetworkMessages.hpp>
+#include <apps/openmw-mp/Networking.hpp>
+#include <components/misc/stringops.hpp>
+#include <iostream>
+
+using namespace std;
+
+void ScriptFunctions::SetName(unsigned short pid, const char *name) noexcept
+{
+    Player *player;
+    GET_PLAYER(pid, player,);
+
+    if (player->GetCell()->mName == name)
+        return;
+
+    player->GetCell()->mName = name;
+
+    mwmp::Networking::Get().GetController()->GetPacket(ID_GAME_BASE_INFO)->Send(player, false);
+    mwmp::Networking::Get().GetController()->GetPacket(ID_GAME_BASE_INFO)->Send(player, true);
+}
+
+const char *ScriptFunctions::GetName(unsigned short pid) noexcept
+{
+
+    Player *player;
+    GET_PLAYER(pid, player, 0);
+
+    cout << "pname: " << player->Npc()->mName.c_str() << endl;
+
+    return player->Npc()->mName.c_str();
+}
+
+void ScriptFunctions::SetBirthsign(unsigned short pid, const char *sign) noexcept
+{
+    Player *player;
+    GET_PLAYER(pid, player,);
+
+    if (player->GetCell()->mName == sign)
+        return;
+
+    *player->BirthSign() = sign;
+
+    mwmp::Networking::Get().GetController()->GetPacket(ID_GAME_BASE_INFO)->Send(player, false);
+    mwmp::Networking::Get().GetController()->GetPacket(ID_GAME_BASE_INFO)->Send(player, true);
+}
+
+const char *ScriptFunctions::GetBirthsign(unsigned short pid) noexcept
+{
+
+    Player *player;
+    GET_PLAYER(pid, player, 0);
+
+
+    return player->BirthSign()->c_str();
+}
+
+void ScriptFunctions::SetRace(unsigned short pid, const char *race) noexcept
+{
+    Player *player;
+    GET_PLAYER(pid, player,);
+
+    if (player->Npc()->mRace == race)
+        return;
+
+    printf("Attempt to set race %s -> %s", player->Npc()->mRace.c_str(), race);
+
+    player->Npc()->mRace = race;
+
+
+    mwmp::Networking::Get().GetController()->GetPacket(ID_GAME_BASE_INFO)->Send(player, false);
+    mwmp::Networking::Get().GetController()->GetPacket(ID_GAME_BASE_INFO)->Send(player, true);
+}
+
+const char *ScriptFunctions::GetRace(unsigned short pid) noexcept
+{
+    Player *player;
+    GET_PLAYER(pid, player, 0);
+
+    return player->Npc()->mRace.c_str();
+}
+
+void ScriptFunctions::SetHead(unsigned short pid, const char *race) noexcept
+{
+    Player *player;
+    GET_PLAYER(pid, player,);
+
+    if (player->Npc()->mHead == race)
+        return;
+
+    player->Npc()->mHead = race;
+
+    mwmp::Networking::Get().GetController()->GetPacket(ID_GAME_BASE_INFO)->Send(player, false);
+    mwmp::Networking::Get().GetController()->GetPacket(ID_GAME_BASE_INFO)->Send(player, true);
+}
+
+const char *ScriptFunctions::GetHead(unsigned short pid) noexcept
+{
+    Player *player;
+    GET_PLAYER(pid, player, 0);
+
+
+    return player->Npc()->mHead.c_str();
+}
+
+void ScriptFunctions::SetHairstyle(unsigned short pid, const char *style) noexcept
+{
+    Player *player;
+    GET_PLAYER(pid, player,);
+
+    if (player->Npc()->mHair == style)
+        return;
+
+    player->Npc()->mHair = style;
+
+    mwmp::Networking::Get().GetController()->GetPacket(ID_GAME_BASE_INFO)->Send(player, false);
+    mwmp::Networking::Get().GetController()->GetPacket(ID_GAME_BASE_INFO)->Send(player, true);
+}
+
+const char *ScriptFunctions::GetHairstyle(unsigned short pid) noexcept
+{
+    Player *player;
+    GET_PLAYER(pid, player, 0);
+
+    return player->Npc()->mHair.c_str();
+}
+
+int ScriptFunctions::GetIsMale(unsigned short pid) noexcept
+{
+    Player *player;
+    GET_PLAYER(pid, player,false);
+
+    return player->Npc()->isMale();
+
+}
+
+void ScriptFunctions::SetIsMale(unsigned short pid, int value) noexcept
+{
+    Player *player;
+    GET_PLAYER(pid, player,);
+
+    player->Npc()->setIsMale(value == true);
+
+    mwmp::Networking::Get().GetController()->GetPacket(ID_GAME_UPDATE_BASESTATS)->Send(player, false);
+    mwmp::Networking::Get().GetController()->GetPacket(ID_GAME_UPDATE_BASESTATS)->Send(player, true);
+}
+
+
+float ScriptFunctions::GetHealth(unsigned short pid) noexcept
+{
+    Player *player;
+    GET_PLAYER(pid, player,0.f);
+
+    return player->CreatureStats()->mDynamic[0].mBase;
+
+}
+
+void ScriptFunctions::SetHealth(unsigned short pid, float value) noexcept
+{
+    Player *player;
+    GET_PLAYER(pid, player,);
+
+    player->CreatureStats()->mDynamic[0].mBase = value;
+
+    mwmp::Networking::Get().GetController()->GetPacket(ID_GAME_UPDATE_BASESTATS)->Send(player, false);
+    mwmp::Networking::Get().GetController()->GetPacket(ID_GAME_UPDATE_BASESTATS)->Send(player, true);
+}
+
+float ScriptFunctions::GetCurrentHealth(unsigned short pid) noexcept
+{
+    Player *player;
+    GET_PLAYER(pid, player, 0.f);
+
+    return player->CreatureStats()->mDynamic[0].mCurrent;
+}
+
+void ScriptFunctions::SetCurrentHealth(unsigned short pid, float value) noexcept
+{
+    Player *player;
+    GET_PLAYER(pid, player,);
+
+    player->CreatureStats()->mDynamic[0].mCurrent = 0;
+
+    mwmp::Networking::Get().GetController()->GetPacket(ID_GAME_UPDATE_BASESTATS)->Send(player, false);
+    mwmp::Networking::Get().GetController()->GetPacket(ID_GAME_UPDATE_BASESTATS)->Send(player, true);
+}
+
+float ScriptFunctions::GetMagicka(unsigned short pid) noexcept
+{
+    Player *player;
+    GET_PLAYER(pid, player,0.f);
+
+    return player->CreatureStats()->mDynamic[1].mBase;
+}
+
+void ScriptFunctions::SetMagicka(unsigned short pid, float value) noexcept
+{
+    Player *player;
+    GET_PLAYER(pid, player,);
+
+    player->CreatureStats()->mDynamic[1].mBase = value;
+
+    mwmp::Networking::Get().GetController()->GetPacket(ID_GAME_UPDATE_BASESTATS)->Send(player, false);
+    mwmp::Networking::Get().GetController()->GetPacket(ID_GAME_UPDATE_BASESTATS)->Send(player, true);
+}
+
+float ScriptFunctions::GetCurrentMagicka(unsigned short pid) noexcept
+{
+    Player *player;
+    GET_PLAYER(pid, player, 0.f);
+
+    return player->CreatureStats()->mDynamic[1].mCurrent;
+}
+
+void ScriptFunctions::SetCurrentMagicka(unsigned short pid, float value) noexcept
+{
+    Player *player;
+    GET_PLAYER(pid, player,);
+
+    player->CreatureStats()->mDynamic[1].mCurrent = 0;
+
+    mwmp::Networking::Get().GetController()->GetPacket(ID_GAME_UPDATE_BASESTATS)->Send(player, false);
+    mwmp::Networking::Get().GetController()->GetPacket(ID_GAME_UPDATE_BASESTATS)->Send(player, true);
+}
+
+float ScriptFunctions::GetFatigue(unsigned short pid) noexcept
+{
+    Player *player;
+    GET_PLAYER(pid, player,0.f);
+
+    return player->CreatureStats()->mDynamic[2].mBase;
+
+}
+
+void ScriptFunctions::SetFatigue(unsigned short pid, float value) noexcept
+{
+    Player *player;
+    GET_PLAYER(pid, player,);
+
+    player->CreatureStats()->mDynamic[2].mBase = value;
+
+    mwmp::Networking::Get().GetController()->GetPacket(ID_GAME_UPDATE_BASESTATS)->Send(player, false);
+    mwmp::Networking::Get().GetController()->GetPacket(ID_GAME_UPDATE_BASESTATS)->Send(player, true);
+}
+
+float ScriptFunctions::GetCurrentFatigue(unsigned short pid) noexcept
+{
+    Player *player;
+    GET_PLAYER(pid, player, 0.f);
+
+    return player->CreatureStats()->mDynamic[2].mCurrent;
+}
+
+void ScriptFunctions::SetCurrentFatigue(unsigned short pid, float value) noexcept
+{
+    Player *player;
+    GET_PLAYER(pid, player,);
+
+    player->CreatureStats()->mDynamic[2].mCurrent = 0;
+
+    mwmp::Networking::Get().GetController()->GetPacket(ID_GAME_UPDATE_BASESTATS)->Send(player, false);
+    mwmp::Networking::Get().GetController()->GetPacket(ID_GAME_UPDATE_BASESTATS)->Send(player, true);
+}
+
+int ScriptFunctions::GetAttribute(unsigned short pid, unsigned short attribute) noexcept
+{
+    Player *player;
+    GET_PLAYER(pid, player, 0);
+
+    if(attribute > 7)
+        return 0;
+
+    return player->CreatureStats()->mAttributes[attribute].mBase;
+}
+
+void ScriptFunctions::SetAttribute(unsigned short pid, unsigned short attribute, int value) noexcept
+{
+    Player *player;
+    GET_PLAYER(pid, player,);
+
+    if(attribute > 7)
+        return;
+
+    DEBUG_PRINTF("SetAttribute(%d, %d, %d)\n", pid, attribute, value);
+
+    player->CreatureStats()->mAttributes[attribute].mBase = value;
+
+    mwmp::Networking::Get().GetController()->GetPacket(ID_GAME_ATTRIBUTE)->Send(player, false);
+    mwmp::Networking::Get().GetController()->GetPacket(ID_GAME_ATTRIBUTE)->Send(player, true);
+}
+
+int ScriptFunctions::GetCurrentAttribute(unsigned short pid, unsigned short attribute) noexcept
+{
+    Player *player;
+    GET_PLAYER(pid, player, 0);
+
+    if(attribute > 7)
+        return 0;
+
+    return player->CreatureStats()->mAttributes[attribute].mCurrent;
+}
+
+void ScriptFunctions::SetCurrentAttribute(unsigned short pid, unsigned short attribute, int value) noexcept
+{
+    Player *player;
+    GET_PLAYER(pid, player,);
+
+    if(attribute > 7)
+        return;
+
+    player->CreatureStats()->mAttributes[attribute].mCurrent = value;
+
+    mwmp::Networking::Get().GetController()->GetPacket(ID_GAME_ATTRIBUTE)->Send(player, false);
+    mwmp::Networking::Get().GetController()->GetPacket(ID_GAME_ATTRIBUTE)->Send(player, true);
+}
+
+int ScriptFunctions::GetSkill(unsigned short pid, unsigned short skill) noexcept
+{
+    Player *player;
+    GET_PLAYER(pid, player, 0);
+
+    if(skill > 27)
+        return 0;
+
+    return player->NpcStats()->mSkills[skill].mBase;
+}
+
+void ScriptFunctions::SetSkill(unsigned short pid, unsigned short skill, int value) noexcept  //TODO: need packet for one value
+{
+    Player *player;
+    GET_PLAYER(pid, player,);
+
+    if(skill > 27)
+        return;
+
+    player->NpcStats()->mSkills[skill].mBase = value;
+
+    DEBUG_PRINTF("SetSkill(%d, %d, %d)\n", pid, skill, value);
+
+    mwmp::Networking::Get().GetController()->GetPacket(ID_GAME_SKILL)->Send(player, false);
+    mwmp::Networking::Get().GetController()->GetPacket(ID_GAME_SKILL)->Send(player, true);
+}
+
+int ScriptFunctions::GetCurrentSkill(unsigned short pid, unsigned short skill) noexcept
+{
+    Player *player;
+    GET_PLAYER(pid, player, 0);
+
+    if(skill > 27)
+        return 0;
+
+    return player->NpcStats()->mSkills[skill].mCurrent;
+}
+
+void ScriptFunctions::SetCurrentSkill(unsigned short pid, unsigned short skill, int value) noexcept //TODO: need packet for one value
+{
+    Player *player;
+    GET_PLAYER(pid, player,);
+
+    if(skill > 27)
+        return;
+
+    player->NpcStats()->mSkills[skill].mCurrent = value;
+
+    mwmp::Networking::Get().GetController()->GetPacket(ID_GAME_SKILL)->Send(player, false);
+    mwmp::Networking::Get().GetController()->GetPacket(ID_GAME_SKILL)->Send(player, true);
+}
+
+
+int ScriptFunctions::GetIncreaseSkill(unsigned short pid, unsigned int pos) noexcept
+{
+    Player *player;
+    GET_PLAYER(pid, player, 0);
+
+    if(pos > 7)
+        return 0;
+
+    return player->NpcStats()->mSkillIncrease[pos];
+}
+
+void ScriptFunctions::SetIncreaseSkill(unsigned short pid, unsigned int pos, int value) noexcept // TODO: need packet for transmit it
+{
+    Player *player;
+    GET_PLAYER(pid, player,);
+
+    if(pos > 7)
+        return;
+
+    player->NpcStats()->mSkillIncrease[pos] = value;
+
+    mwmp::Networking::Get().GetController()->GetPacket(ID_GAME_SKILL)->Send(player, false);
+    mwmp::Networking::Get().GetController()->GetPacket(ID_GAME_SKILL)->Send(player, true);
+}
+
+void ScriptFunctions::SetCharGenStage(unsigned short pid, int start, int end) noexcept
+{
+    Player *player;
+    GET_PLAYER(pid, player,);
+
+    player->CharGenStage()->current = start;
+    player->CharGenStage()->end = end;
+
+    mwmp::Networking::Get().GetController()->GetPacket(ID_GAME_CHARGEN)->Send(player, false);
+}
+
+void ScriptFunctions::Resurrect(unsigned short pid)
+{
+    Player *player;
+    GET_PLAYER(pid, player,);
+    mwmp::Networking::Get().GetController()->GetPacket(ID_GAME_RESURRECT)->RequestData(player->guid);
+}
\ No newline at end of file
diff --git a/apps/openmw-mp/Script/Functions/Timer.cpp b/apps/openmw-mp/Script/Functions/Timer.cpp
new file mode 100644
index 000000000..f2246c2c9
--- /dev/null
+++ b/apps/openmw-mp/Script/Functions/Timer.cpp
@@ -0,0 +1,49 @@
+//
+// Created by koncord on 15.03.16.
+//
+
+#include <apps/openmw-mp/Script/ScriptFunctions.hpp>
+#include <components/openmw-mp/NetworkMessages.hpp>
+#include <Player.hpp>
+#include <Networking.hpp>
+#include <Script/API/TimerAPI.hpp>
+
+using namespace std;
+using namespace mwmp;
+
+int ScriptFunctions::CreateTimer(ScriptFunc callback, int msec) noexcept
+{
+
+}
+
+int ScriptFunctions::CreateTimerEx(ScriptFunc callback, int msec, const char *types, ...) noexcept
+{
+
+}
+
+void ScriptFunctions::StartTimer(int timerId) noexcept
+{
+    TimerAPI::StartTimer(timerId);
+}
+
+void ScriptFunctions::StopTimer(int timerId) noexcept
+{
+    TimerAPI::StopTimer(timerId);
+}
+
+void ScriptFunctions::RestartTimer(int timerId, int msec) noexcept
+{
+    TimerAPI::ResetTimer(timerId, msec);
+}
+
+void ScriptFunctions::FreeTimer(int timerId) noexcept
+{
+    TimerAPI::FreeTimer(timerId);
+}
+
+bool ScriptFunctions::IsTimerElapsed(int timerId) noexcept
+{
+    TimerAPI::IsEndTimer(timerId);
+}
+
+
diff --git a/apps/openmw-mp/Script/Functions/Translocations.cpp b/apps/openmw-mp/Script/Functions/Translocations.cpp
new file mode 100644
index 000000000..7fa33686d
--- /dev/null
+++ b/apps/openmw-mp/Script/Functions/Translocations.cpp
@@ -0,0 +1,154 @@
+//
+// Created by koncord on 29.02.16.
+//
+
+#include <apps/openmw-mp/Script/ScriptFunctions.hpp>
+#include <components/openmw-mp/NetworkMessages.hpp>
+#include <apps/openmw-mp/Player.hpp>
+#include <apps/openmw-mp/Networking.hpp>
+
+#include <iostream>
+using namespace std;
+
+void ScriptFunctions::GetPos(unsigned short pid, float *x, float *y, float *z) noexcept
+{
+    *x = 0.00;
+    *y = 0.00;
+    *z = 0.00;
+
+    Player *player;
+    GET_PLAYER(pid, player,);
+
+    *x = player->Position()->pos[0];
+    *y = player->Position()->pos[1];
+    *z = player->Position()->pos[2];
+}
+
+double ScriptFunctions::GetPosX(unsigned short pid) noexcept
+{
+    Player *player;
+    GET_PLAYER(pid, player, 0.0f);
+
+    return player->Position()->pos[0];
+}
+
+double ScriptFunctions::GetPosY(unsigned short pid) noexcept
+{
+    Player *player;
+    GET_PLAYER(pid, player, 0.0f);
+
+    return player->Position()->pos[1];
+}
+
+double ScriptFunctions::GetPosZ(unsigned short pid) noexcept
+{
+    Player *player;
+    GET_PLAYER(pid, player, 0.0f);
+
+    return player->Position()->pos[2];
+}
+
+void ScriptFunctions::SetPos(unsigned short pid, double x, double y, double z) noexcept
+{
+    Player *player;
+    GET_PLAYER(pid, player,);
+
+    player->Position()->pos[0] = x;
+    player->Position()->pos[1] = y;
+    player->Position()->pos[2] = z;
+
+    mwmp::Networking::Get().GetController()->GetPacket(ID_GAME_UPDATE_POS)->Send(player, false);
+    mwmp::Networking::Get().GetController()->GetPacket(ID_GAME_UPDATE_POS)->Send(player, true);
+}
+
+void ScriptFunctions::SetCell(unsigned short pid, const char *name) noexcept
+{
+    Player *player;
+    GET_PLAYER(pid, player,);
+
+    /*if(player->GetCell()->mName == name)
+        return;*/
+
+    cout << "attempt to move player (pid: " << pid << " name: " << player->Npc()->mName << ") from ";
+    if(!player->GetCell()->isExterior())
+        cout << "\"" << player->GetCell()->mName << "\"";
+    else
+        cout << "exterior";
+
+    player->GetCell()->mName = name;
+
+    cout << " in to cell \"" << player->GetCell()->mName << "\"" << endl;
+
+    player->GetCell()->mData.mFlags |=  1;
+
+    mwmp::Networking::Get().GetController()->GetPacket(ID_GAME_CELL)->Send(player, false);
+    mwmp::Networking::Get().GetController()->GetPacket(ID_GAME_CELL)->Send(player, true);
+}
+
+const char* ScriptFunctions::GetCell(unsigned short pid) noexcept
+{
+    Player *player;
+    GET_PLAYER(pid, player, 0);
+
+
+    return player->GetCell()->mName.c_str();
+}
+
+bool ScriptFunctions::IsInInterior(unsigned short pid) noexcept
+{
+    Player *player;
+    GET_PLAYER(pid, player, false);
+
+    return !player->GetCell()->isExterior();
+}
+
+void ScriptFunctions::GetAngle(unsigned short pid, float *x, float *y, float *z) noexcept
+{
+    *x = 0.00;
+    *y = 0.00;
+    *z = 0.00;
+
+    Player *player;
+    GET_PLAYER(pid, player,);
+
+    *x = player->Position()->rot[0];
+    *y = player->Position()->rot[1];
+    *z = player->Position()->rot[2];
+}
+
+double ScriptFunctions::GetAngleX(unsigned short pid) noexcept
+{
+    Player *player;
+    GET_PLAYER(pid, player, 0.0f);
+
+    return player->Position()->rot[0];
+}
+
+double ScriptFunctions::GetAngleY(unsigned short pid) noexcept
+{
+    Player *player;
+    GET_PLAYER(pid, player, 0.0f);
+
+    return player->Position()->rot[1];
+}
+
+double ScriptFunctions::GetAngleZ(unsigned short pid) noexcept
+{
+    Player *player;
+    GET_PLAYER(pid, player, 0.0f);
+
+    return player->Position()->rot[2];
+}
+
+void ScriptFunctions::SetAngle(unsigned short pid, double x, double y, double z) noexcept
+{
+    Player *player;
+    GET_PLAYER(pid, player,);
+
+    player->Position()->rot[0] = x;
+    player->Position()->rot[1] = y;
+    player->Position()->rot[2] = z;
+
+    mwmp::Networking::Get().GetController()->GetPacket(ID_GAME_UPDATE_POS)->Send(player, false);
+    mwmp::Networking::Get().GetController()->GetPacket(ID_GAME_UPDATE_POS)->Send(player, true);
+}
diff --git a/apps/openmw-mp/Script/LangLua/LangLua.cpp b/apps/openmw-mp/Script/LangLua/LangLua.cpp
new file mode 100644
index 000000000..47c77c265
--- /dev/null
+++ b/apps/openmw-mp/Script/LangLua/LangLua.cpp
@@ -0,0 +1,235 @@
+//
+// Created by koncord on 08.05.16.
+//
+
+#include <iostream>
+#include "LangLua.hpp"
+#include <Script/Script.hpp>
+#include <Script/Types.hpp>
+
+using namespace std;
+
+void *LangLua::GetInterface()
+{
+    return lua;
+}
+
+LangLua::LangLua(lua_State *lua)
+{
+    this->lua = lua;
+}
+
+LangLua::LangLua()
+{
+    lua = luaL_newstate();
+    luaL_openlibs(lua); // load all lua std libs
+    terra_init(lua);
+}
+
+LangLua::~LangLua()
+{
+
+}
+
+template<unsigned int I, unsigned int F>
+struct Lua_dispatch_ {
+    template<typename R, typename... Args>
+    inline static R Lua_dispatch(lua_State*&& lua, Args&&... args) noexcept {
+        constexpr ScriptFunctionData const& F_ = ScriptFunctions::functions[F];
+        auto arg = luabridge::Stack<typename CharType<F_.func.types[I - 1]>::type>::get(lua, I);
+        return Lua_dispatch_<I - 1, F>::template Lua_dispatch<R>(
+                forward<lua_State*>(lua),
+                arg,
+                forward<Args>(args)...);
+    }
+};
+
+template<unsigned int F>
+struct Lua_dispatch_<0, F> {
+    template<typename R, typename... Args>
+    inline static R Lua_dispatch(lua_State*&&, Args&&... args) noexcept {
+        constexpr ScriptFunctionData const& F_ = ScriptFunctions::functions[F];
+        return reinterpret_cast<FunctionEllipsis<R>>(F_.func.addr)(forward<Args>(args)...);
+    }
+};
+
+template<unsigned int I>
+static typename enable_if<ScriptFunctions::functions[I].func.ret == 'v', int>::type wrapper(lua_State* lua) noexcept {
+    Lua_dispatch_<ScriptFunctions::functions[I].func.numargs, I>::template Lua_dispatch<void>(forward<lua_State*>(lua));
+    return 0;
+}
+
+template<unsigned int I>
+static typename enable_if<ScriptFunctions::functions[I].func.ret != 'v', int>::type wrapper(lua_State* lua) noexcept {
+    auto ret = Lua_dispatch_<ScriptFunctions::functions[I].func.numargs, I>::template Lua_dispatch<typename CharType<ScriptFunctions::functions[I].func.ret>::type>(forward<lua_State*>(lua));
+    luabridge::Stack <typename CharType<ScriptFunctions::functions[I].func.ret>::type>::push (lua, ret);
+    return 1;
+}
+
+template<unsigned int I>
+struct F_
+{
+    static constexpr LuaFuctionData F{ScriptFunctions::functions[I].name, wrapper<I>};
+};
+
+
+template<> struct F_<0> { static constexpr LuaFuctionData F{"CreateTimer", LangLua::CreateTimer}; };
+template<> struct F_<1> { static constexpr LuaFuctionData F{"CreateTimerEx", LangLua::CreateTimerEx}; };
+template<> struct F_<2> { static constexpr LuaFuctionData F{"MakePublic", LangLua::MakePublic}; };
+template<> struct F_<3> { static constexpr LuaFuctionData F{"CallPublic", LangLua::CallPublic}; };
+
+template<size_t... Indices>
+inline LuaFuctionData *LangLua::functions(indices<Indices...>)
+{
+
+    static LuaFuctionData functions_[sizeof...(Indices)]{
+            F_<Indices>::F...
+    };
+
+    static_assert(
+            sizeof(functions_) / sizeof(functions_[0]) ==
+            sizeof(ScriptFunctions::functions) / sizeof(ScriptFunctions::functions[0]),
+            "Not all functions have been mapped to Lua");
+
+    return functions_;
+}
+
+void LangLua::LoadProgram(const char *filename)
+{
+    int err = 0;
+
+    if ((err = terra_loadfile(lua, filename)) != 0)
+        throw runtime_error("Lua script " + string(filename) + " error (" + to_string(err) + "): \"" +
+                            string(lua_tostring(lua, -1)) + "\"");
+
+    constexpr auto functions_n = sizeof(ScriptFunctions::functions) / sizeof(ScriptFunctions::functions[0]);
+
+    LuaFuctionData *functions_ = functions(IndicesFor<functions_n>{});
+
+    luabridge::Namespace tes3mp = luabridge::getGlobalNamespace(lua).beginNamespace("tes3mp");
+
+    for(int i = 0; i < functions_n; i++)
+        tes3mp.addCFunction(functions_[i].name, functions_[i].func);
+
+    tes3mp.endNamespace();
+
+    if ((err = lua_pcall(lua, 0, 0, 0)) != 0) // Run once script for load in memory.
+        throw runtime_error("Lua script " + string(filename) + " error (" + to_string(err) + "): \"" +
+                            string(lua_tostring(lua, -1)) + "\"");
+}
+
+int LangLua::FreeProgram()
+{
+    lua_close(lua);
+}
+
+bool LangLua::IsCallbackPresent(const char *name)
+{
+    return luabridge::getGlobal(lua, name).isFunction();
+}
+
+boost::any LangLua::Call(const char *name, const char *argl, int buf, ...)
+{
+    va_list vargs;
+    va_start(vargs, buf);
+    std::vector<boost::any> args;
+    try
+    {
+        unsigned int len = strlen(argl);
+
+        for (unsigned int i = 0; i < len; ++i)
+        {
+            switch (argl[i])
+            {
+                case 'i':
+                    args.emplace_back(va_arg(vargs, unsigned int));
+                    break;
+
+                case 'q':
+                    args.emplace_back(va_arg(vargs, signed int));
+                    break;
+
+                case 'l':
+                    args.emplace_back(va_arg(vargs, unsigned long long));
+                    break;
+
+                case 'w':
+                    args.emplace_back(va_arg(vargs, signed long long));
+                    break;
+
+                case 'f':
+                {
+                    args.emplace_back(va_arg(vargs, double));
+                    break;
+                }
+
+                case 'p':
+                    args.emplace_back(va_arg(vargs, void*));
+                    break;
+
+                case 's':
+                    args.emplace_back(va_arg(vargs, const char*));
+                    break;
+
+                default:
+                    throw runtime_error("PAWN call: Unknown argument identifier " + argl[i]);
+            }
+        }
+
+    }
+    catch(...)
+    {
+        va_end(vargs);
+        throw;
+    }
+    va_end(vargs);
+
+    return Call(name, argl, args);
+}
+
+boost::any LangLua::Call(const char *name, const char *argl, const std::vector<boost::any> &args)
+{
+    int n_args = (int)(strlen(argl)) ;
+
+    lua_getglobal (lua, name);
+
+    for (intptr_t i = 0; i < n_args; i++)
+    {
+        switch (argl[i])
+        {
+            case 'i':
+                luabridge::Stack<unsigned int>::push(lua, boost::any_cast<unsigned int>(args.at(i)));
+                break;
+
+            case 'q':
+                luabridge::Stack<signed int>::push(lua, boost::any_cast<signed int>(args.at(i)));
+                break;
+
+            case 'l':
+                luabridge::Stack<unsigned long long>::push(lua, boost::any_cast<unsigned long long>(args.at(i)));
+                break;
+
+            case 'w':
+                luabridge::Stack<signed long long>::push(lua, boost::any_cast<signed long long>(args.at(i)));
+                break;
+
+            case 'f':
+                luabridge::Stack<double>::push(lua, boost::any_cast<double>(args.at(i)));
+                break;
+
+            case 'p':
+                luabridge::Stack<void *>::push(lua, boost::any_cast<void *>(args.at(i)));
+                break;
+
+            case 's':
+                luabridge::Stack<const char *>::push(lua, boost::any_cast<const char *>(args.at(i)));
+                break;
+
+            default:
+                throw runtime_error("Lua call: Unknown argument identifier " + argl[i]);
+        }
+    }
+
+    luabridge::LuaException::pcall (lua, n_args, 1);
+    return boost::any(luabridge::LuaRef::fromStack(lua, -1));
+}
diff --git a/apps/openmw-mp/Script/LangLua/LangLua.hpp b/apps/openmw-mp/Script/LangLua/LangLua.hpp
new file mode 100644
index 000000000..de390d15a
--- /dev/null
+++ b/apps/openmw-mp/Script/LangLua/LangLua.hpp
@@ -0,0 +1,56 @@
+//
+// Created by koncord on 08.05.16.
+//
+
+#ifndef PLUGINSYSTEM3_LANGLUA_HPP
+#define PLUGINSYSTEM3_LANGLUA_HPP
+
+#include <terra/terra.h>
+#include <LuaBridge.h>
+
+#include <boost/any.hpp>
+#include "../ScriptFunction.hpp"
+#include "../Language.hpp"
+
+struct LuaFuctionData
+{
+    const char* name;
+    lua_CFunction func;
+};
+
+class LangLua: public Language
+{
+private:
+    template<std::size_t... Is>
+    struct indices {};
+    template<std::size_t N, std::size_t... Is>
+    struct build_indices : build_indices<N-1, N-1, Is...> {};
+    template<std::size_t... Is>
+    struct build_indices<0, Is...> : indices<Is...> {};
+    template<std::size_t N>
+    using IndicesFor = build_indices<N>;
+
+public:
+    virtual void *GetInterface() override;
+    template<std::size_t... Indices>
+    static LuaFuctionData* functions(indices<Indices...>);
+    lua_State *lua;
+public:
+    LangLua();
+    LangLua(lua_State *lua);
+    ~LangLua();
+    static int MakePublic(lua_State *lua) noexcept;
+    static int CallPublic(lua_State *lua) noexcept;
+
+    static int CreateTimer(lua_State *lua) noexcept;
+    static int CreateTimerEx(lua_State *lua) noexcept;
+
+    virtual void LoadProgram(const char *filename) override;
+    virtual int FreeProgram() override;
+    virtual bool IsCallbackPresent(const char *name) override;
+    virtual boost::any Call(const char *name, const char *argl, int buf, ...) override;
+    virtual boost::any Call(const char *name, const char *argl, const std::vector<boost::any> &args) override;
+};
+
+
+#endif //PLUGINSYSTEM3_LANGLUA_HPP
diff --git a/apps/openmw-mp/Script/LangLua/LuaFunc.cpp b/apps/openmw-mp/Script/LangLua/LuaFunc.cpp
new file mode 100644
index 000000000..230838376
--- /dev/null
+++ b/apps/openmw-mp/Script/LangLua/LuaFunc.cpp
@@ -0,0 +1,182 @@
+//
+// Created by koncord on 09.05.16.
+//
+
+#include <iostream>
+#include "LangLua.hpp"
+#include <Script/API/TimerAPI.hpp>
+#include <Script/API/PublicFnAPI.hpp>
+
+using namespace std;
+
+inline vector<boost::any> DefToVec(lua_State *lua, string types, int args_begin, int args_n)
+{
+    vector<boost::any> args;
+
+    for(int i = args_begin; i < args_n + args_begin; i++)
+    {
+        switch(types[i - args_begin])
+        {
+            case 'i':
+            {
+                args.emplace_back(luabridge::Stack<unsigned int>::get(lua, i));
+                break;
+            }
+
+            case 'q':
+            {
+                args.emplace_back(luabridge::Stack<signed int>::get(lua, i));
+                break;
+            }
+
+                /*case 'l':
+                {
+                    args.emplace_back(luabridge::Stack<unsigned long long>::get(lua, i));
+                    break;
+                }
+
+                case 'w':
+                {
+                    args.emplace_back(luabridge::Stack<signed long long>::get(lua, i));
+                    break;
+                }*/
+
+            case 'f':
+            {
+                args.emplace_back(luabridge::Stack<double>::get(lua, i));
+                break;
+            }
+
+            case 's':
+            {
+                args.emplace_back(luabridge::Stack<const char*>::get(lua, i));
+                break;
+            }
+
+            default:
+            {
+                stringstream ssErr;
+                ssErr << "Lua: Unknown argument identifier" << "\"" << types[i] << "\"" << endl;
+                throw std::runtime_error(ssErr.str());
+            }
+        }
+    }
+    return args;
+}
+
+int LangLua::MakePublic(lua_State *lua) noexcept
+{
+    const char * callback = luabridge::Stack<const char*>::get(lua, 1);
+    const char * name = luabridge::Stack<const char*>::get(lua, 2);
+    char ret_type = luabridge::Stack<char>::get(lua, 3);
+    const char * def = luabridge::Stack<const char*>::get(lua, 4);
+
+    Public::MakePublic(callback, lua, name, ret_type, def);
+    return 0;
+
+}
+
+int LangLua::CallPublic(lua_State *lua) noexcept
+{
+    const char * name = luabridge::Stack<const char*>::get(lua, 1);
+
+    int args_n = lua_gettop(lua) - 1;
+
+    string types = Public::GetDefinition(name);
+
+    if(args_n  != types.size())
+        throw invalid_argument("Script call: Number of arguments does not match definition");
+
+    vector<boost::any> args = DefToVec(lua, types, 2, args_n);
+
+    boost::any result = Public::Call(&name[0], args);
+    if(result.empty())
+        return 0;
+
+    if(result.type().hash_code() == typeid(signed int).hash_code())
+        luabridge::Stack<signed int>::push(lua, boost::any_cast<signed int>(result));
+    else if(result.type().hash_code() == typeid(unsigned int).hash_code())
+        luabridge::Stack<unsigned int>::push(lua, boost::any_cast<unsigned int>(result));
+    else if(result.type().hash_code() == typeid(double).hash_code())
+        luabridge::Stack<double>::push(lua, boost::any_cast<double>(result));
+    else if(result.type().hash_code() == typeid(const char*).hash_code())
+        luabridge::Stack<const char*>::push(lua, boost::any_cast<const char*>(result));
+    return 1;
+}
+
+int LangLua::CreateTimer(lua_State *lua) noexcept
+{
+
+    const char * callback= luabridge::Stack<const char*>::get(lua, 1);
+    int msec = luabridge::Stack<int>::get(lua, 2);
+
+    int id = mwmp::TimerAPI::CreateTimerLua(lua, callback, msec, "", vector<boost::any>());
+    luabridge::push(lua, id);
+    return 1;
+}
+
+int LangLua::CreateTimerEx(lua_State *lua) noexcept
+{
+    const char * callback = luabridge::Stack<const char*>::get(lua, 1);
+    int msec = luabridge::Stack<int>::get(lua, 2);
+
+    const char * types = luabridge::Stack<const char*>::get(lua, 3);
+
+    int args_n = (int)lua_strlen(lua, 3);
+
+    vector<boost::any> args;
+
+    for(int i = 4; i < args_n + 4; i++)
+    {
+        switch(types[i - 4])
+        {
+            case 'i':
+            {
+                args.emplace_back(luabridge::Stack<unsigned int>::get(lua, i));
+                break;
+            }
+
+            case 'q':
+            {
+                args.emplace_back(luabridge::Stack<signed int>::get(lua, i));
+                break;
+            }
+
+                /*case 'l':
+                {
+                    args.emplace_back(luabridge::Stack<unsigned long long>::get(lua, i));
+                    break;
+                }
+
+                case 'w':
+                {
+                    args.emplace_back(luabridge::Stack<signed long long>::get(lua, i));
+                    break;
+                }*/
+
+            case 'f':
+            {
+                args.emplace_back(luabridge::Stack<double>::get(lua, i));
+                break;
+            }
+
+            case 's':
+            {
+                args.emplace_back(luabridge::Stack<const char*>::get(lua, i));
+                break;
+            }
+
+            default:
+            {
+                stringstream ssErr;
+                ssErr << "Lua: Unknown argument identifier" << "\"" << types[i] << "\"" << endl;
+                throw std::runtime_error(ssErr.str());
+            }
+        }
+    }
+
+
+    int id = mwmp::TimerAPI::CreateTimerLua(lua, callback, msec, types, args);
+    luabridge::push(lua, id);
+    return 1;
+}
\ No newline at end of file
diff --git a/apps/openmw-mp/Script/LangNative/LangNative.cpp b/apps/openmw-mp/Script/LangNative/LangNative.cpp
new file mode 100644
index 000000000..f2ba91c41
--- /dev/null
+++ b/apps/openmw-mp/Script/LangNative/LangNative.cpp
@@ -0,0 +1,99 @@
+//
+// Created by koncord on 09.05.16.
+//
+
+#include <dlfcn.h>
+#include <stdexcept>
+#include "LangNative.hpp"
+#include <Script/SystemInterface.hpp>
+#include <Script/Script.hpp>
+
+using namespace std;
+
+template<typename R>
+bool SetScript(SystemInterface<>::lib_t lib, const char *name, R value)
+{
+    SystemInterface<R *> result(lib, name);
+
+    if (result)
+        *result.result = value;
+
+    return result.operator bool();
+}
+
+void LangNative::LoadProgram(const char *filename)
+{
+    FILE *file = fopen(filename, "rb");
+
+    if (!file)
+        throw runtime_error("Script not found: " + string(filename));
+
+    fclose(file);
+
+#ifdef __WIN32__
+    lib = LoadLibrary(filename);
+#else
+    lib = dlopen(filename, RTLD_LAZY);
+#endif
+
+    if (!lib)
+        throw runtime_error("Was not able to load C++ script: " + string(filename));
+
+    try
+    {
+
+        const char *prefix = SystemInterface<const char *>(lib, "prefix").result;
+        string pf(prefix);
+
+        for (const auto &function : ScriptFunctions::functions)
+            if (!SetScript(lib, string(pf + function.name).c_str(), function.func.addr))
+                printf("Script function pointer not found: %s\n", function.name);
+    }
+    catch (...)
+    {
+        FreeProgram();
+        throw;
+    }
+}
+
+int LangNative::FreeProgram()
+{
+#ifdef __WIN32__
+    FreeLibrary(lib);
+#else
+    dlclose(lib);
+#endif
+    return 0;
+}
+
+bool LangNative::IsCallbackPresent(const char *name)
+{
+    return true;
+}
+
+boost::any LangNative::Call(const char *name, const char *argl, int buf, ...)
+{
+    return nullptr;
+}
+
+boost::any LangNative::Call(const char *name, const char *argl, const std::vector<boost::any> &args)
+{
+    return nullptr;
+}
+
+
+void *LangNative::GetInterface()
+{
+    return lib;
+}
+
+
+LangNative::LangNative()
+{
+
+}
+
+LangNative::~LangNative()
+{
+
+}
\ No newline at end of file
diff --git a/apps/openmw-mp/Script/LangNative/LangNative.hpp b/apps/openmw-mp/Script/LangNative/LangNative.hpp
new file mode 100644
index 000000000..1eac6b680
--- /dev/null
+++ b/apps/openmw-mp/Script/LangNative/LangNative.hpp
@@ -0,0 +1,28 @@
+//
+// Created by koncord on 09.05.16.
+//
+
+#ifndef PLUGINSYSTEM3_LANGNATIVE_HPP
+#define PLUGINSYSTEM3_LANGNATIVE_HPP
+
+
+#include <Script/Language.hpp>
+#include <Script/SystemInterface.hpp>
+
+class LangNative : public Language
+{
+    SystemInterface<>::lib_t lib;
+public:
+    virtual void *GetInterface() override;
+    LangNative();
+    ~LangNative();
+    virtual void LoadProgram(const char *filename) override;
+    virtual int FreeProgram() override;
+    virtual bool IsCallbackPresent(const char *name) override;
+    virtual boost::any Call(const char *name, const char *argl, int buf, ...) override;
+    virtual boost::any Call(const char *name, const char *argl, const std::vector<boost::any> &args) override;
+
+};
+
+
+#endif //PLUGINSYSTEM3_LANGNATIVE_HPP
diff --git a/apps/openmw-mp/Script/LangPawn/LangPAWN.cpp b/apps/openmw-mp/Script/LangPawn/LangPAWN.cpp
new file mode 100644
index 000000000..0de562fd8
--- /dev/null
+++ b/apps/openmw-mp/Script/LangPawn/LangPAWN.cpp
@@ -0,0 +1,458 @@
+//
+// Created by koncord on 08.05.16.
+//
+
+#include "LangPAWN.hpp"
+
+
+#include <amxmodules.h>
+#include <amxaux.h>
+#include "Script.hpp"
+
+using namespace std;
+
+typedef long NetworkID;
+
+static vector<vector<char>> strings;
+static vector<pair<cell*, double>> floats;
+static pair<cell*, NetworkID*> data = {nullptr, nullptr};
+
+void free_strings() noexcept {
+    strings.clear();
+}
+
+void free_floats() noexcept {
+    for (const auto& value : floats)
+        *value.first = amx_ftoc(value.second);
+
+    floats.clear();
+}
+
+void free_data(unsigned int size) noexcept {
+    if (data.first && data.second)
+        for (unsigned int i = 0; i < size; ++i)
+            data.first[i] = data.second[i];
+
+    data.first = nullptr;
+    data.second = nullptr;
+}
+
+void after_call() noexcept {
+    free_strings();
+    free_floats();
+}
+
+template<typename R>
+void after_call(const R&) noexcept {
+    free_strings();
+    free_floats();
+}
+
+template<>
+void after_call(const unsigned int& result) noexcept {
+    free_strings();
+    free_floats();
+    free_data(result);
+}
+
+template<typename R, unsigned int I, unsigned int F>
+struct PAWN_extract_ {
+    inline static R PAWN_extract(AMX*&&, const cell*&& params) noexcept {
+        return static_cast<R>(forward<const cell*>(params)[I]);
+    }
+};
+
+template<unsigned int I, unsigned int F>
+struct PAWN_extract_<void*, I, F>
+{
+    inline static void* PAWN_extract(AMX *&&amx, const cell *&&params) noexcept
+    {
+        return amx_Address(amx, forward<const cell *>(params)[I]); // fixme: I'm not sure in this fix
+    }
+};
+
+template<unsigned int I, unsigned int F>
+struct PAWN_extract_<double, I, F> {
+    inline static double PAWN_extract(AMX*&&, const cell*&& params) noexcept {
+        return amx_ctof(forward<const cell*>(params)[I]);
+    }
+};
+
+template<unsigned int I, unsigned int F>
+struct PAWN_extract_<const char*, I, F> {
+    inline static const char* PAWN_extract(AMX*&& amx, const cell*&& params) noexcept {
+        int len;
+        cell* source;
+
+        source = amx_Address(amx, params[I]);
+        amx_StrLen(source, &len);
+
+        strings.emplace_back(len + 1);
+        char* value = &strings.back()[0];
+        amx_GetString(value, source, 0, UNLIMITED);
+
+        return value;
+    }
+};
+
+template<unsigned int I, unsigned int F>
+struct PAWN_extract_<double*, I, F> {
+    inline static double* PAWN_extract(AMX*&& amx, const cell*&& params) noexcept {
+        floats.emplace_back(amx_Address(amx, params[I]), 0.00);
+        return &floats.back().second;
+    }
+};
+
+template<unsigned int I, unsigned int F>
+struct PAWN_extract_<NetworkID**, I, F> {
+    inline static NetworkID** PAWN_extract(AMX*&& amx, const cell*&& params) noexcept {
+        constexpr ScriptFunctionData const& F_ = ScriptFunctions::functions[F];
+        static_assert(F_.func.numargs == I, "NetworkID** must be the last parameter");
+        data.first = amx_Address(amx, params[I]);
+        return &data.second;
+    }
+};
+
+template<unsigned int I, unsigned int F>
+struct PAWN_dispatch_ {
+    template<typename R, typename... Args>
+    inline static R PAWN_dispatch(AMX*&& amx, const cell*&& params, Args&&... args) noexcept {
+        constexpr ScriptFunctionData const& F_ = ScriptFunctions::functions[F];
+        auto arg = PAWN_extract_<typename CharType<F_.func.types[I - 1]>::type, I, F>::PAWN_extract(forward<AMX*>(amx), forward<const cell*>(params));
+        return PAWN_dispatch_<I - 1, F>::template PAWN_dispatch<R>(
+                forward<AMX*>(amx),
+                forward<const cell*>(params),
+                arg,
+                forward<Args>(args)...);
+    }
+};
+
+template<unsigned int F>
+struct PAWN_dispatch_<0, F> {
+    template<typename R, typename... Args>
+    inline static R PAWN_dispatch(AMX*&&, const cell*&&, Args&&... args) noexcept {
+        constexpr ScriptFunctionData const& F_ = ScriptFunctions::functions[F];
+        return reinterpret_cast<FunctionEllipsis<R>>(F_.func.addr)(forward<Args>(args)...);
+    }
+};
+
+template<unsigned int I>
+static typename enable_if<ScriptFunctions::functions[I].func.ret == 'v', cell>::type wrapper(AMX* amx, const cell* params) noexcept {
+    PAWN_dispatch_<ScriptFunctions::functions[I].func.numargs, I>::template PAWN_dispatch<void>(forward<AMX*>(amx), forward<const cell*>(params));
+    after_call();
+    return 1;
+}
+
+template<unsigned int I>
+static typename enable_if<ScriptFunctions::functions[I].func.ret == 'f', cell>::type wrapper(AMX* amx, const cell* params) noexcept {
+    double value = PAWN_dispatch_<ScriptFunctions::functions[I].func.numargs, I>::template PAWN_dispatch<double>(forward<AMX*>(amx), forward<const cell*>(params));
+    after_call();
+    return amx_ftoc(value);
+}
+
+template<unsigned int I>
+static typename enable_if<ScriptFunctions::functions[I].func.ret == 's', cell>::type wrapper(AMX* amx, const cell* params) noexcept {
+    const char* value = PAWN_dispatch_<ScriptFunctions::functions[I].func.numargs, I>::template PAWN_dispatch<const char*>(forward<AMX*>(amx), forward<const cell*>(params));
+    after_call();
+
+    if (value) {
+        cell* dest = amx_Address(amx, params[ScriptFunctions::functions[I].func.numargs + 1]);
+        amx_SetString(dest, value, 1, 0, strlen(value) + 1);
+        return 1;
+    }
+
+    return 0;
+}
+
+template<unsigned int I>
+static typename enable_if<ScriptFunctions::functions[I].func.ret != 'v' && ScriptFunctions::functions[I].func.ret != 'f' && ScriptFunctions::functions[I].func.ret != 's', cell>::type wrapper(AMX* amx, const cell* params) noexcept {
+    auto result = PAWN_dispatch_<ScriptFunctions::functions[I].func.numargs, I>::template PAWN_dispatch<typename CharType<ScriptFunctions::functions[I].func.ret>::type>(forward<AMX*>(amx), forward<const cell*>(params));
+    after_call(result);
+    return result;
+}
+
+template<unsigned int I> struct F_ { static constexpr AMX_NATIVE_INFO F{ScriptFunctions::functions[I].name, wrapper<I>}; };
+template<> struct F_<0> { static constexpr AMX_NATIVE_INFO F{"CreateTimer", LangPAWN::CreateTimer}; };
+template<> struct F_<1> { static constexpr AMX_NATIVE_INFO F{"CreateTimerEx", LangPAWN::CreateTimerEx}; };
+template<> struct F_<2> { static constexpr AMX_NATIVE_INFO F{"MakePublic", LangPAWN::MakePublic}; };
+template<> struct F_<3> { static constexpr AMX_NATIVE_INFO F{"CallPublic", LangPAWN::CallPublic}; };
+
+void LangPAWN::LoadProgram(const char *filename)
+{
+    int err = aux_LoadProgram(amx, filename, 0);
+    if (err != AMX_ERR_NONE)
+        throw runtime_error("PAWN script " + string(filename) + " error (" + to_string(err) + "): \"" + string(aux_StrError(err)) + "\"");
+
+    amx_CoreInit(amx);
+    amx_ConsoleInit(amx);
+    amx_FloatInit(amx);
+    amx_TimeInit(amx);
+    amx_StringInit(amx);
+    amx_FileInit(amx);
+
+    constexpr auto functions_n = sizeof(ScriptFunctions::functions) / sizeof(ScriptFunctions::functions[0]);
+
+    amx_Register(amx, functions(IndicesFor<functions_n>{}), functions_n); // TODO: throw if error
+
+}
+
+int LangPAWN::FreeProgram()
+{
+    int err = aux_FreeProgram(amx);
+    delete amx;
+    return err;
+}
+
+bool LangPAWN::IsCallbackPresent(const char *name)
+{
+    int idx;
+    return (amx_FindPublic(amx, name, &idx) == AMX_ERR_NONE);
+}
+
+boost::any LangPAWN::Call(const char *name, const char *argl, int buf, ...)
+{
+    va_list args;
+    va_start(args, buf);
+    cell ret = 0;
+    vector<pair<cell *, char *>> strings;
+
+    try
+    {
+        int idx = 0;
+        int err = 0;
+
+        err = amx_FindPublic(amx, name, &idx);
+
+        if (err != AMX_ERR_NONE)
+            throw runtime_error("PAWN runtime error (" + to_string(err) + "): \"" + string(aux_StrError(err)) + "\".");
+
+        unsigned int len = strlen(argl);
+        vector<cell> args_amx;
+
+        for (unsigned int i = 0; i < len; ++i)
+        {
+            switch (argl[i])
+            {
+                case 'i':
+                    args_amx.emplace_back(va_arg(args, unsigned
+                            int));
+                    break;
+
+                case 'q':
+                    args_amx.emplace_back(va_arg(args, signed
+                            int));
+                    break;
+
+                case 'l':
+                    args_amx.emplace_back(va_arg(args, unsigned
+                    long
+                            long));
+                    break;
+
+                case 'w':
+                    args_amx.emplace_back(va_arg(args, signed
+                    long
+                            long));
+                    break;
+
+                case 'f':
+                {
+                    double value = va_arg(args, double);
+                    args_amx.emplace_back(amx_ftoc(value));
+                    break;
+                }
+
+                case 'p':
+                    args_amx.emplace_back(reinterpret_cast<uintptr_t>(va_arg(args, void*)));
+                    break;
+
+                case 's':
+                    args_amx.emplace_back(reinterpret_cast<uintptr_t>(va_arg(args, char*)));
+                    break;
+
+                default:
+                    throw runtime_error("PAWN call: Unknown argument identifier " + argl[i]);
+            }
+        }
+
+        for (unsigned int i = len; i; --i)
+        {
+            switch (argl[i - 1])
+            {
+                case 's':
+                {
+                    char *string = reinterpret_cast<char *>(static_cast<unsigned int>(args_amx[i - 1]));
+                    cell *store;
+                    amx_PushString(amx, &store, string, 1, 0);
+                    strings.emplace_back(store, string);
+                    break;
+                }
+
+                default:
+                    amx_Push(amx, args_amx[i - 1]);
+                    break;
+            }
+        }
+
+        err = amx_Exec(amx, &ret, idx);
+
+        if (err != AMX_ERR_NONE)
+            throw runtime_error("PAWN runtime error (" + to_string(err) + "): \"" + string(aux_StrError(err)) + "\".");
+
+        if (buf != 0)
+            for (const auto &str : strings)
+                amx_GetString(str.second, str.first, 0, strlen(str.second) + 1);
+
+        if (!strings.empty())
+            amx_Release(amx, strings[0].first);
+    }
+
+    catch (...)
+    {
+        va_end(args);
+
+        if (!strings.empty())
+            amx_Release(amx, strings[0].first);
+
+        throw;
+    }
+
+    return boost::any(ret);
+}
+
+boost::any LangPAWN::Call(const char *name, const char *argl, const std::vector<boost::any> &args)
+{
+    cell ret = 0;
+    cell *str = nullptr;
+
+    try
+    {
+        int idx = 0;
+        int err = 0;
+
+        err = amx_FindPublic(amx, name, &idx);
+
+        if (err != AMX_ERR_NONE)
+            throw runtime_error("PAWN runtime error (" + to_string(err) + "): \"" + string(aux_StrError(err)) + "\".");
+
+        for (intptr_t i = strlen(argl) - 1; i >= 0; i--)
+        {
+            switch (argl[i])
+            {
+                case 'i':
+                {
+                    cell value = (cell) boost::any_cast<unsigned int>(args.at(i));
+                    amx_Push(amx, value);
+                    break;
+                }
+
+                case 'q':
+                {
+                    cell value = (cell) boost::any_cast<signed int>(args.at(i));
+                    amx_Push(amx, value);
+                    break;
+                }
+
+                case 'l':
+                {
+                    cell value = (cell) boost::any_cast<unsigned long long>(args.at(i));
+                    amx_Push(amx, value);
+                    break;
+                }
+
+                case 'w':
+                {
+                    cell value = (cell) boost::any_cast<signed long long>(args.at(i));
+                    amx_Push(amx, value);
+                    break;
+                }
+
+                case 'f':
+                {
+                    double value = boost::any_cast<double>(args.at(i));
+                    amx_Push(amx, amx_ftoc(value));
+                    break;
+                }
+
+                case 'p':
+                {
+                    cell value = (cell) boost::any_cast<void *>(args.at(i));
+                    amx_Push(amx, value);
+                    break;
+                }
+
+                case 's':
+                {
+                    string string_ = boost::any_cast<string>(args.at(i));
+                    cell *store;
+                    amx_PushString(amx, &store, string_.c_str(), 1, 0);
+
+                    if (!str)
+                        str = store;
+
+                    break;
+                }
+
+                default:
+                    throw runtime_error("PAWN call: Unknown argument identifier " + argl[i]);
+            }
+        }
+
+        err = amx_Exec(amx, &ret, idx);
+
+        if (err != AMX_ERR_NONE)
+            throw runtime_error("PAWN runtime error (" + to_string(err) + "): \"" + string(aux_StrError(err)) + "\".");
+
+        if (str)
+            amx_Release(amx, str);
+    }
+
+    catch (...)
+    {
+        if (str)
+            amx_Release(amx, str);
+
+        throw;
+    }
+
+    return ret;
+}
+
+template<size_t... Indices>
+inline AMX_NATIVE_INFO *LangPAWN::functions(indices<Indices...>)
+{
+
+    static AMX_NATIVE_INFO functions_[sizeof...(Indices)]{
+            F_<Indices>::F...
+    };
+
+    static_assert(
+            sizeof(functions_) / sizeof(functions_[0]) == sizeof(ScriptFunctions::functions) / sizeof(ScriptFunctions::functions[0]),
+            "Not all functions have been mapped to PAWN");
+
+    return functions_;
+}
+
+
+void *LangPAWN::GetInterface()
+{
+    return amx;
+}
+
+LangPAWN::LangPAWN()
+{
+    //throw std::runtime_error("Pawn is no longer supported, use Terra/Lua!");
+    amx = new AMX();
+}
+
+
+LangPAWN::LangPAWN(AMX *amx)
+{
+    this->amx = amx;
+}
+
+
+LangPAWN::~LangPAWN()
+{
+
+}
diff --git a/apps/openmw-mp/Script/LangPawn/LangPAWN.hpp b/apps/openmw-mp/Script/LangPawn/LangPAWN.hpp
new file mode 100644
index 000000000..fb7b6206f
--- /dev/null
+++ b/apps/openmw-mp/Script/LangPawn/LangPAWN.hpp
@@ -0,0 +1,46 @@
+//
+// Created by koncord on 08.05.16.
+//
+
+#ifndef PLUGINSYSTEM3_LANGPAWN_HPP
+#define PLUGINSYSTEM3_LANGPAWN_HPP
+
+#include "Language.hpp"
+#include <amx.h>
+
+class LangPAWN: public Language
+{
+private:
+    template<std::size_t... Is>
+    struct indices {};
+    template<std::size_t N, std::size_t... Is>
+    struct build_indices : build_indices<N-1, N-1, Is...> {};
+    template<std::size_t... Is>
+    struct build_indices<0, Is...> : indices<Is...> {};
+    template<std::size_t N>
+    using IndicesFor = build_indices<N>;
+
+public:
+    virtual void *GetInterface() override;
+    template<std::size_t... Indices>
+    static AMX_NATIVE_INFO* functions(indices<Indices...>);
+
+    AMX *amx;
+public:
+    LangPAWN();
+    LangPAWN(AMX *amx);
+    ~LangPAWN();
+    static cell MakePublic(AMX *amx, const cell *params) noexcept;
+    static cell CallPublic(AMX *amx, const cell *params) noexcept;
+    static cell CreateTimer(AMX *amx, const cell *params) noexcept;
+    static cell CreateTimerEx(AMX *amx, const cell *params) noexcept;
+
+    virtual void LoadProgram(const char *filename) override;
+    virtual int FreeProgram() override;
+    virtual bool IsCallbackPresent(const char *name) override;
+    virtual boost::any Call(const char *name, const char *argl, int buf, ...) override;
+    virtual boost::any Call(const char *name, const char *argl, const std::vector<boost::any> &args) override;
+};
+
+
+#endif //PLUGINSYSTEM3_LANGPAWN_HPP
diff --git a/apps/openmw-mp/Script/LangPawn/PawnFunc.cpp b/apps/openmw-mp/Script/LangPawn/PawnFunc.cpp
new file mode 100644
index 000000000..504ef4a49
--- /dev/null
+++ b/apps/openmw-mp/Script/LangPawn/PawnFunc.cpp
@@ -0,0 +1,154 @@
+//
+// Created by koncord on 09.05.16.
+//
+
+#include <API/PublicFnAPI.hpp>
+#include "LangPAWN.hpp"
+#include "API/TimerAPI.hpp"
+
+using namespace std;
+
+cell LangPAWN::MakePublic(AMX *amx, const cell *params) noexcept
+{
+    int len;
+    cell* source;
+
+    source = amx_Address(amx, params[1]);
+    amx_StrLen(source, &len);
+    vector<char> real;
+    real.reserve(len + 1);
+
+    amx_GetString(&real[0], source, 0, UNLIMITED);
+
+    source = amx_Address(amx, params[2]);
+    amx_StrLen(source, &len);
+    vector<char> name;
+    name.reserve(len + 1);
+
+    amx_GetString(&name[0], source, 0, UNLIMITED);
+
+    cell *ret_addr = amx_Address(amx, params[3]);
+    char ret_type = static_cast<char>(*reinterpret_cast<cell*>(&ret_addr));
+
+    source = amx_Address(amx, params[4]);
+    amx_StrLen(source, &len);
+    vector<char> def;
+    def.reserve(len + 1);
+
+    amx_GetString(&def[0], source, 0, UNLIMITED);
+
+
+
+    Public::MakePublic(&real[0], amx, &name[0], ret_type, &def[0]);
+
+    return 1;
+}
+
+cell LangPAWN::CallPublic(AMX *amx, const cell *params) noexcept
+{
+    int len;
+    cell* source;
+
+    source = amx_Address(amx, params[1]);
+    amx_StrLen(source, &len);
+    vector<char> name;
+    name.reserve(len + 1);
+
+    amx_GetString(&name[0], source, 0, UNLIMITED);
+
+    string def;
+
+    try
+    {
+        def = Public::GetDefinition(&name[0]);
+    }
+    catch (...) { return 0; }
+
+    vector<boost::any> args;
+    unsigned int count = (params[0] / sizeof(cell)) - 1;
+
+    if (count != def.length())
+        throw runtime_error("Script call: Number of arguments does not match definition");
+
+    for (unsigned int i = 0; i < count; ++i)
+    {
+        cell* data = amx_Address(amx, params[i + 2]);
+
+        switch (def[i])
+        {
+            case 'i':
+            {
+                args.emplace_back((unsigned int) *data);
+                break;
+            }
+
+            case 'q':
+            {
+                args.emplace_back((signed int) *data);
+                break;
+            }
+
+            case 'l':
+            {
+                args.emplace_back((unsigned long long) *data);
+                break;
+            }
+
+            case 'w':
+            {
+                args.emplace_back((signed long long) *data);
+                break;
+            }
+
+            case 'f':
+            {
+                args.emplace_back((double) amx_ctof(*data));
+                break;
+            }
+
+            case 'p':
+            {
+                args.emplace_back((void*) data);
+                break;
+            }
+
+            case 's':
+            {
+                amx_StrLen(data, &len);
+                vector<char> str;
+                str.reserve(len + 1);
+                amx_GetString(&str[0], data, 0, UNLIMITED);
+                args.emplace_back(string(&str[0]).c_str());
+                break;
+            }
+
+            default:
+                throw runtime_error("PAWN call: Unknown argument identifier " + def[i]);
+        }
+    }
+
+    boost::any result = Public::Call(&name[0], args);
+    if(result.empty())
+        return 0;
+
+    cell ret = 0;
+
+    if(result.type().hash_code() == typeid(signed int).hash_code())
+        ret = boost::any_cast<signed int>(result);
+    else if(result.type().hash_code() == typeid(unsigned int).hash_code())
+        ret = boost::any_cast<unsigned int>(result);
+    else if(result.type().hash_code() == typeid(double).hash_code())
+        ret = amx_ftoc(result);
+
+    return ret;
+}
+
+cell LangPAWN::CreateTimer(AMX *amx, const cell *params) noexcept
+{
+
+}
+
+cell LangPAWN::CreateTimerEx(AMX *amx, const cell *params) noexcept
+{
+
+}
\ No newline at end of file
diff --git a/apps/openmw-mp/Script/Language.hpp b/apps/openmw-mp/Script/Language.hpp
new file mode 100644
index 000000000..76872e834
--- /dev/null
+++ b/apps/openmw-mp/Script/Language.hpp
@@ -0,0 +1,27 @@
+//
+// Created by koncord on 19.03.16.
+//
+
+#ifndef PLUGINSYSTEM3_LANGUAGE_HPP
+#define PLUGINSYSTEM3_LANGUAGE_HPP
+
+#include "Types.hpp"
+
+#include <boost/any.hpp>
+#include <vector>
+
+class Language
+{
+public:
+    virtual void LoadProgram(const char* filename) = 0;
+    virtual int FreeProgram() = 0;
+    virtual bool IsCallbackPresent(const char* name) = 0;
+    virtual boost::any Call(const char* name, const char* argl, int buf, ...) = 0;
+    virtual boost::any Call(const char* name, const char* argl, const std::vector<boost::any>& args) = 0;
+
+    virtual void * GetInterface() = 0;
+
+};
+
+
+#endif //PLUGINSYSTEM3_LANGUAGE_HPP
diff --git a/apps/openmw-mp/Script/Platform.hpp b/apps/openmw-mp/Script/Platform.hpp
new file mode 100644
index 000000000..920191a09
--- /dev/null
+++ b/apps/openmw-mp/Script/Platform.hpp
@@ -0,0 +1,20 @@
+//
+// Created by koncord on 23.01.16.
+//
+
+#ifndef SOURCEPAWN_PLATFORM_HPP
+#define SOURCEPAWN_PLATFORM_HPP
+
+#if _MSC_VER
+#ifdef _M_X86
+#define ARCH_X86
+#endif
+#endif
+
+#if __GNUC__
+#ifdef __i386__
+#define ARCH_X86
+#endif
+#endif
+
+#endif //SOURCEPAWN_PLATFORM_HPP
diff --git a/apps/openmw-mp/Script/Script.cpp b/apps/openmw-mp/Script/Script.cpp
new file mode 100644
index 000000000..5d2267432
--- /dev/null
+++ b/apps/openmw-mp/Script/Script.cpp
@@ -0,0 +1,109 @@
+//
+// Created by koncord on 19.03.16.
+//
+
+#include "Script.hpp"
+#include "LangNative/LangNative.hpp"
+
+#if defined (ENABLE_PAWN)
+#include "LangPawn/LangPAWN.hpp"
+#endif
+#if defined (ENABLE_LUA)
+#include "LangLua/LangLua.hpp"
+#endif
+
+using namespace std;
+
+Script::ScriptList Script::scripts;
+
+Script::Script(const char *path)
+{
+    FILE *file = fopen(path, "rb");
+
+    if (!file)
+        throw runtime_error("Script not found: " + string(path));
+
+    fclose(file);
+
+#ifdef __WIN32__
+    if (strstr(path, ".dll"))
+#else
+    if (strstr(path, ".so"))
+#endif
+    {
+        script_type = SCRIPT_CPP;
+        lang = new LangNative();
+    }
+#if defined (ENABLE_PAWN)
+    else if (strstr(path, ".amx"))
+    {
+        lang = new LangPAWN();
+        script_type = SCRIPT_PAWN;
+    }
+#endif
+#if defined (ENABLE_LUA)
+    else if (strstr(path, ".lua") || strstr(path, ".t"))
+    {
+        lang = new LangLua();
+        script_type = SCRIPT_LUA;
+    }
+#endif
+    else
+        throw runtime_error("Script type not recognized: " + string(path));
+
+    try
+    {
+        lang->LoadProgram(path);
+    }
+    catch (...)
+    {
+        lang->FreeProgram();
+        throw;
+    }
+
+}
+
+
+Script::~Script()
+{
+    lang->FreeProgram();
+
+    delete lang;
+}
+
+void Script::LoadScripts(char *scripts, const char *base)
+{
+    char *token = strtok(scripts, ",");
+
+    try
+    {
+        while (token)
+        {
+            char path[4096];
+            snprintf(path, sizeof(path), "%s/%s/%s", base, "scripts", token);
+            Script::scripts.emplace_back(new Script(path));
+            token = strtok(nullptr, ",");
+        }
+    }
+    catch (...)
+    {
+        UnloadScripts();
+        throw;
+    }
+}
+
+void Script::UnloadScripts()
+{
+    //Public::DeleteAll();
+    scripts.clear();
+#if defined (ENABLE_LUA)
+    terra_llvmshutdown();
+#endif
+}
+
+void Script::LoadScript(const char *script, const char *base)
+{
+    char path[4096];
+    snprintf(path, sizeof(path), "%s/%s/%s", base, "scripts", script);
+    Script::scripts.emplace_back(new Script(path));
+}
\ No newline at end of file
diff --git a/apps/openmw-mp/Script/Script.hpp b/apps/openmw-mp/Script/Script.hpp
new file mode 100644
index 000000000..0699ad873
--- /dev/null
+++ b/apps/openmw-mp/Script/Script.hpp
@@ -0,0 +1,155 @@
+//
+// Created by koncord on 19.03.16.
+//
+
+#ifndef PLUGINSYSTEM3_SCRIPT_HPP
+#define PLUGINSYSTEM3_SCRIPT_HPP
+#include "Types.hpp"
+#include "SystemInterface.hpp"
+#include "ScriptFunction.hpp"
+#include "ScriptFunctions.hpp"
+#include "Language.hpp"
+
+#include <boost/any.hpp>
+#include <Utils.hpp>
+#include <unordered_map>
+#include <memory>
+
+#if defined (ENABLE_LUA)
+#include <terra/terra.h>
+#include <extern/LuaBridge/LuaBridge.h>
+#endif
+
+class Script : private ScriptFunctions
+{
+    // http://imgur.com/hU0N4EH
+private:
+
+    Language *lang;
+
+    enum
+    {
+        SCRIPT_CPP,
+        SCRIPT_PAWN,
+        SCRIPT_LUA
+    };
+
+    template<typename R>
+    R GetScript(const char *name)
+    {
+        if(script_type == SCRIPT_CPP)
+        {
+            return SystemInterface<R>(lang->GetInterface(), name).result;
+        }
+        else
+        {
+            return reinterpret_cast<R>(lang->IsCallbackPresent(name));
+        }
+    }
+
+    int script_type;
+    std::unordered_map<unsigned int, FunctionEllipsis<void>> callbacks_;
+
+    typedef std::vector<std::unique_ptr<Script>> ScriptList;
+    static ScriptList scripts;
+
+    Script(const char *path);
+
+    Script(const Script&) = delete;
+    Script& operator=(const Script&) = delete;
+
+public:
+    ~Script();
+
+    static void LoadScript(const char *script, const char* base);
+    static void LoadScripts(char* scripts, const char* base);
+    static void UnloadScripts();
+
+    static constexpr ScriptCallbackData const& CallBackData(const unsigned int I, const unsigned int N = 0) {
+        return callbacks[N].index == I ? callbacks[N] : CallBackData(I, N + 1);
+    }
+
+    template<unsigned int I>
+    using CallBackReturn = typename CharType<CallBackData(I).callback.ret>::type;
+
+    template<size_t N>
+    static constexpr unsigned int CallbackIdentity(const char(&str)[N])
+    {
+        return Utils::hash(str);
+    }
+
+
+    template<unsigned int I, bool B = false, typename... Args>
+    static unsigned int Call(CallBackReturn<I>& result, Args&&... args) {
+        constexpr ScriptCallbackData const& data = CallBackData(I);
+        static_assert(data.callback.matches(TypeString<typename std::remove_reference<Args>::type...>::value), "Wrong number or types of arguments");
+
+        unsigned int count = 0;
+
+        for (auto& script : scripts)
+        {
+            if (!script->callbacks_.count(I))
+                script->callbacks_.emplace(I, script->GetScript<FunctionEllipsis<void>>(data.name));
+
+            auto callback = script->callbacks_[I];
+
+            if (!callback)
+                continue;
+
+            if (script->script_type == SCRIPT_CPP)
+                result = reinterpret_cast<FunctionEllipsis<CallBackReturn<I>>>(callback)(std::forward<Args>(args)...);
+#if defined (ENABLE_PAWN)
+            else if(script->script_type == SCRIPT_PAWN)
+            {
+                boost::any any = script->lang->Call(data.name, data.callback.types, B, std::forward<Args>(args)...);
+                result = reinterpret_cast<CallBackReturn<I>> ((int)boost::any_cast<int64_t>(any)); // TODO: WTF?! int?!
+            }
+#endif
+#if defined (ENABLE_LUA)
+            else if(script->script_type == SCRIPT_LUA)
+            {
+                boost::any any = script->lang->Call(data.name, data.callback.types, B, std::forward<Args>(args)...);
+                result = static_cast<CallBackReturn<I>>(boost::any_cast<luabridge::LuaRef>(any).cast<CallBackReturn<I>>());
+            }
+#endif
+            ++count;
+        }
+
+        return count;
+    }
+
+    template<unsigned int I, bool B = false, typename... Args>
+    static unsigned int Call(Args&&... args) {
+        constexpr ScriptCallbackData const& data = CallBackData(I);
+        static_assert(data.callback.matches(TypeString<typename std::remove_reference<Args>::type...>::value), "Wrong number or types of arguments");
+
+        unsigned int count = 0;
+
+        for (auto& script : scripts)
+        {
+            if (!script->callbacks_.count(I))
+                script->callbacks_.emplace(I, script->GetScript<FunctionEllipsis<void>>(data.name));
+
+            auto callback = script->callbacks_[I];
+
+            if (!callback)
+                continue;
+
+            if (script->script_type == SCRIPT_CPP)
+                reinterpret_cast<FunctionEllipsis<CallBackReturn<I>>>(callback)(std::forward<Args>(args)...);
+#if defined (ENABLE_PAWN)
+            else if(script->script_type == SCRIPT_PAWN)
+                script->lang->Call(data.name, data.callback.types, B, std::forward<Args>(args)...);
+#endif
+#if defined (ENABLE_LUA)
+            else if(script->script_type == SCRIPT_LUA)
+                script->lang->Call(data.name, data.callback.types, B, std::forward<Args>(args)...);
+#endif
+            ++count;
+        }
+
+        return count;
+    }
+};
+
+#endif //PLUGINSYSTEM3_SCRIPT_HPP
diff --git a/apps/openmw-mp/Script/ScriptFunction.cpp b/apps/openmw-mp/Script/ScriptFunction.cpp
new file mode 100644
index 000000000..4c8937766
--- /dev/null
+++ b/apps/openmw-mp/Script/ScriptFunction.cpp
@@ -0,0 +1,225 @@
+//
+// Created by koncord on 23.01.16.
+//
+
+#include<iostream>
+#include <stdexcept>
+#include "ScriptFunction.hpp"
+
+#if defined (ENABLE_LUA)
+#include "LangLua/LangLua.hpp"
+#endif
+
+#if defined (ENABLE_PAWN)
+#include "LangPawn/LangPAWN.hpp"
+#endif
+
+using namespace std;
+
+ScriptFunction::ScriptFunction(ScriptFunc fCpp,char ret_type, const string &def) : fCpp(fCpp), ret_type(ret_type), def(def), script_type(SCRIPT_CPP)
+{
+
+}
+#if defined (ENABLE_LUA)
+ScriptFunction::ScriptFunction(const ScriptFuncLua &fLua, lua_State *lua, char ret_type, const std::string &def) :fLua({lua, fLua}), ret_type(ret_type), def(def), script_type(SCRIPT_LUA)
+{
+
+}
+#endif
+
+#if defined (ENABLE_PAWN)
+ScriptFunction::ScriptFunction(const ScriptFuncPAWN &fPawn, AMX *amx, char ret_type, const string &def) : fPawn({amx, fPawn}),
+                                                                                           def(def), ret_type(ret_type), script_type(SCRIPT_PAWN)
+{
+
+}
+#endif
+
+
+ScriptFunction::~ScriptFunction()
+{
+#if defined (ENABLE_PAWN)
+    if (script_type == SCRIPT_PAWN)
+        fPawn.name.~ScriptFuncPAWN();
+#if defined (ENABLE_LUA)
+    else
+#endif
+#endif
+#if defined (ENABLE_LUA)
+    if (script_type == SCRIPT_LUA)
+        fLua.name.~ScriptFuncLua();
+#endif
+}
+
+boost::any ScriptFunction::Call(const vector<boost::any> &args)
+{
+    boost::any result;
+
+    if (def.length() != args.size())
+        throw runtime_error("Script call: Number of arguments does not match definition");
+#if defined (ENABLE_PAWN)
+    if (script_type == SCRIPT_PAWN)
+    {
+        LangPAWN langPawn(fPawn.amx);
+        boost::any any = langPawn.Call(fPawn.name.c_str(), def.c_str(), args);
+        result = boost::any();
+
+        cell ret = boost::any_cast<cell>(any);
+
+        switch(ret_type)
+        {
+            case 'i':
+                result = static_cast<unsigned int>(ret);
+                break;
+            case 'q':
+                result = static_cast<signed int>(ret);
+                break;
+            case 's':
+                throw runtime_error("Pawn call: the Pawn does not supported strings in public functions");
+            case 'f':
+
+                result =  static_cast<double>(amx_ctof(ret));
+                break;
+            case 'v':
+                result = boost::any();
+                break;
+            default:
+                throw runtime_error("Pawn call: Unknown return type" + ret_type);
+        }
+    }
+#endif
+#if defined (ENABLE_LUA)
+    else if (script_type == SCRIPT_LUA)
+    {
+        LangLua langLua(fLua.lua);
+        boost::any any = langLua.Call(fLua.name.c_str(), def.c_str(), args);
+
+        switch(ret_type)
+        {
+            case 'i':
+                result = boost::any_cast<luabridge::LuaRef>(any).cast<unsigned int>();
+                break;
+            case 'q':
+                result = boost::any_cast<luabridge::LuaRef>(any).cast<signed int>();
+                break;
+            case 'f':
+                result = boost::any_cast<luabridge::LuaRef>(any).cast<double>();
+                break;
+            case 's':
+                result = boost::any_cast<luabridge::LuaRef>(any).cast<const char*>();
+                break;
+            case 'v':
+                result = boost::any();
+                break;
+            default:
+                throw runtime_error("Lua call: Unknown return type" + ret_type);
+        }
+    }
+#endif
+    else
+    {
+        throw runtime_error("Native Call: native calls does not supported yet");
+#if 0
+#ifdef ARCH_X86
+        // cdecl convention
+        string::iterator it;
+        vector<boost::any>::const_iterator it2;
+        vector<unsigned int> data;
+
+        for (it = def.begin(), it2 = args.begin(); it != def.end(); ++it, ++it2)
+        {
+            switch (*it)
+            {
+                case 'i':
+                {
+                    unsigned int value = boost::any_cast<unsigned int>(*it2);
+                    data.push_back(value);
+                    break;
+                }
+
+                case 'q':
+                {
+                    unsigned int value = boost::any_cast<signed int>(*it2);
+                    data.push_back(value);
+                    break;
+                }
+
+                case 'l':
+                {
+                    unsigned long long value = boost::any_cast<unsigned long long>(*it2);
+                    data.push_back(*reinterpret_cast<unsigned int *>(&value));
+                    data.push_back(*reinterpret_cast<unsigned int *>((unsigned) &value + 4));
+                    break;
+                }
+
+                case 'w':
+                {
+                    signed long long value = boost::any_cast<signed long long>(*it2);
+                    data.push_back(*reinterpret_cast<unsigned int *>(&value));
+                    data.push_back(*reinterpret_cast<unsigned int *>((unsigned) &value + 4));
+                    break;
+                }
+
+                case 'f':
+                {
+                    double value = boost::any_cast<double>(*it2);
+                    data.push_back(*reinterpret_cast<unsigned int *>(&value));
+                    data.push_back(*reinterpret_cast<unsigned int *>((unsigned) &value + 4));
+                    break;
+                }
+
+                case 'p':
+                {
+                    void *value = boost::any_cast<void *>(*it2);
+                    data.push_back(reinterpret_cast<unsigned int>(value));
+                    break;
+                }
+
+                case 's':
+                {
+                    const string *value = boost::any_cast<string>(&*it2);
+                    data.push_back(reinterpret_cast<unsigned int>(value->c_str()));
+                    break;
+                }
+
+                default:
+                    throw runtime_error("C++ call: Unknown argument identifier " + *it);
+            }
+        }
+
+        unsigned int result_low;
+        unsigned int result_high;
+        unsigned int *source = &data[0];
+        unsigned int size = data.size() * 4;
+
+        asm(
+            "MOV EDI,ESP\n"
+            "SUB EDI,%3\n"  // allocate memory in stack.
+            "MOV ESI,%4\n"  // move ptr of source to ESI.
+            "MOV ECX,%3\n"  // length of data.
+            "PUSH DS\n"     // move DS
+            "POP ES\n"      //         to ES.
+            "CLD\n"         // clear direction flag.
+            "REP MOVSB\n"   // Move bytes at address DS:ESI to address ES:EDI (move to stack).
+            "MOV ESI,ESP\n" // stack pointer.
+            "SUB ESP,%3\n"
+            "CALL %2\n"
+            "MOV ESP,ESI\n"
+            "MOV %0,EAX\n"  // move low result from eax
+            "MOV %1,EDX\n"  // move high result from edx
+        : "=m"(result_low), "=m"(result_high)
+        : "m"(fCpp) //2, "m"(size) //3, "m"(source) //4
+        : "eax", "edx", "ecx", "esi", "edi", "cc"
+        );
+
+        *reinterpret_cast<unsigned int *>(&result) = result_low;
+        *reinterpret_cast<unsigned int *>(((unsigned) &result) + 4) = result_high;
+#else
+        throw runtime_error("x64 Not supported yet (builtin timers and [Call/Make]Public");
+#endif
+#endif
+    }
+
+    return result;
+}
+
diff --git a/apps/openmw-mp/Script/ScriptFunction.hpp b/apps/openmw-mp/Script/ScriptFunction.hpp
new file mode 100644
index 000000000..42e5ca60e
--- /dev/null
+++ b/apps/openmw-mp/Script/ScriptFunction.hpp
@@ -0,0 +1,72 @@
+//
+// Created by koncord on 23.01.16.
+//
+
+#ifndef SOURCEPAWN_SCRIPTFUNCTION_HPP
+#define SOURCEPAWN_SCRIPTFUNCTION_HPP
+
+#include <boost/any.hpp>
+#include <string>
+#include <vector>
+#if defined (ENABLE_LUA)
+#include <terra/terra.h>
+#endif
+
+#if defined (ENABLE_PAWN)
+#include <amx.h>
+#endif
+
+typedef unsigned long long(*ScriptFunc)();
+#if defined (ENABLE_PAWN)
+typedef std::string ScriptFuncPAWN;
+#endif
+#if defined (ENABLE_LUA)
+typedef std::string ScriptFuncLua;
+#endif
+
+class ScriptFunction
+{
+protected:
+    union
+    {
+        ScriptFunc fCpp;
+#if defined (ENABLE_PAWN)
+        struct
+        {
+            AMX *amx;
+            ScriptFuncPAWN name;
+        } fPawn;
+#endif
+#if defined (ENABLE_LUA)
+        struct
+        {
+            lua_State *lua;
+            ScriptFuncLua name;
+        } fLua;
+#endif
+    };
+
+protected:
+    std::string def;
+    char ret_type;
+    int script_type;
+    enum
+    {
+        SCRIPT_CPP,
+        SCRIPT_PAWN,
+        SCRIPT_LUA
+    };
+
+    ScriptFunction(ScriptFunc fCpp, char ret_type, const std::string &def);
+#if defined (ENABLE_LUA)
+    ScriptFunction(const ScriptFuncLua &fPawn, lua_State *lua, char ret_type, const std::string &def);
+#endif
+#if defined (ENABLE_PAWN)
+    ScriptFunction(const ScriptFuncPAWN &fPawn, AMX *amx, char ret_type, const std::string &def);
+#endif
+    virtual ~ScriptFunction();
+
+    boost::any Call(const std::vector<boost::any> &args);
+};
+
+#endif //SOURCEPAWN_SCRIPTFUNCTION_HPP
diff --git a/apps/openmw-mp/Script/ScriptFunctions.cpp b/apps/openmw-mp/Script/ScriptFunctions.cpp
new file mode 100644
index 000000000..9edd643c6
--- /dev/null
+++ b/apps/openmw-mp/Script/ScriptFunctions.cpp
@@ -0,0 +1,120 @@
+//
+// Created by koncord on 24.01.16.
+//
+
+#include "ScriptFunctions.hpp"
+#include "API/PublicFnAPI.hpp"
+#include <cstdarg>
+#include <iostream>
+#include <apps/openmw-mp/Player.hpp>
+#include <apps/openmw-mp/Networking.hpp>
+#include <components/openmw-mp/NetworkMessages.hpp>
+
+template<typename... Types>
+constexpr char TypeString<Types...>::value[];
+constexpr ScriptFunctionData ScriptFunctions::functions[];
+constexpr ScriptCallbackData ScriptFunctions::callbacks[];
+
+using namespace std;
+
+void ScriptFunctions::GetArguments(std::vector<boost::any> &params, va_list args, const std::string &def)
+{
+    params.reserve(def.length());
+
+    try
+    {
+        for (char c : def)
+        {
+            switch (c)
+            {
+                case 'i':
+                {
+                    params.emplace_back(va_arg(args, unsigned int));
+                    break;
+                }
+
+                case 'q':
+                {
+                    params.emplace_back(va_arg(args, signed int));
+                    break;
+                }
+
+                case 'l':
+                {
+                    params.emplace_back(va_arg(args, unsigned long long));
+                    break;
+                }
+
+                case 'w':
+                {
+                    params.emplace_back(va_arg(args, signed long long));
+                    break;
+                }
+
+                case 'f':
+                {
+                    params.emplace_back(va_arg(args, double));
+                    break;
+                }
+
+                case 'p':
+                {
+                    params.emplace_back(va_arg(args, void*));
+                    break;
+                }
+
+                case 's':
+                {
+                    params.emplace_back(string(va_arg(args, const char*)));
+                    break;
+                }
+
+                default:
+                    throw runtime_error("C++ call: Unknown argument identifier " + c);
+            }
+        }
+    }
+
+    catch (...)
+    {
+        va_end(args);
+        throw;
+    }
+}
+
+void ScriptFunctions::MakePublic(ScriptFunc _public, const char *name, char ret_type, const char *def) noexcept
+{
+    Public::MakePublic(_public, name, ret_type, def);
+}
+
+boost::any ScriptFunctions::CallPublic(const char *name, ...) noexcept
+{
+    vector<boost::any> params;
+
+    try
+    {
+        string def = Public::GetDefinition(name);
+
+        va_list args;
+        va_start(args, name);
+        GetArguments(params, args, def);
+        va_end(args);
+
+        return Public::Call(name, params);
+    }
+    catch (...) {}
+
+    return 0;
+}
+
+void ScriptFunctions::StopServer(int code) noexcept
+{
+    mwmp::Networking::GetPtr()->StopServer(code);
+}
+
+void ScriptFunctions::Kick(unsigned short pid) noexcept
+{
+    Player *player;
+    GET_PLAYER(pid, player,);
+    mwmp::Networking::GetPtr()->KickPlayer(player->guid);
+}
diff --git a/apps/openmw-mp/Script/ScriptFunctions.hpp b/apps/openmw-mp/Script/ScriptFunctions.hpp
new file mode 100644
index 000000000..725b11c36
--- /dev/null
+++ b/apps/openmw-mp/Script/ScriptFunctions.hpp
@@ -0,0 +1,241 @@
+//
+// Created by koncord on 24.01.16.
+//
+
+#ifndef SOURCEPAWN_SCRIPTFUNCTIONS_HPP
+#define SOURCEPAWN_SCRIPTFUNCTIONS_HPP
+
+#include <RakNetTypes.h>
+//#include <amx/amx.h>
+#include <tuple>
+#include <apps/openmw-mp/Player.hpp>
+#include "ScriptFunction.hpp"
+#include "Types.hpp"
+
+#define GET_PLAYER(pid, pl, retvalue) \
+     pl = Players::GetPlayer(pid); \
+     if (player == 0) {\
+        fprintf(stderr, "%s: Player with pid \'%d\' not found\n", __PRETTY_FUNCTION__, pid);\
+        /*ScriptFunctions::StopServer(1);*/ \
+        return retvalue;\
+}
+
+
+class ScriptFunctions
+{
+public:
+
+    static void GetArguments(std::vector<boost::any> &params, va_list args, const std::string &def);
+
+    static void StopServer(int code) noexcept;
+
+    static void MakePublic(ScriptFunc _public, const char *name, char ret_type, const char *def) noexcept;
+    static boost::any CallPublic(const char *name, ...) noexcept;
+
+    static void GetPos(unsigned short pid, float *x, float *y, float *z) noexcept;
+    static double GetPosX(unsigned short pid) noexcept;
+    static double GetPosY(unsigned short pid) noexcept;
+    static double GetPosZ(unsigned short pid) noexcept;
+    static void SetPos(unsigned short pid, double x, double y, double z) noexcept;
+
+
+    static void GetAngle(unsigned short pid, float *x, float *y, float *z) noexcept;
+    static double GetAngleX(unsigned short pid) noexcept;
+    static double GetAngleY(unsigned short pid) noexcept;
+    static double GetAngleZ(unsigned short pid) noexcept;
+    static void SetAngle(unsigned short pid, double x, double y, double z) noexcept;
+
+    static void SetCell(unsigned short pid, const char *name) noexcept;
+    static const char *GetCell(unsigned short pid) noexcept;
+
+    static bool IsInInterior(unsigned short pid) noexcept;
+
+    static void SetName(unsigned short pid, const char *name) noexcept;
+    static const char *GetName(unsigned short pid) noexcept;
+
+    static void SetBirthsign(unsigned short pid, const char *name) noexcept;
+    static const char *GetBirthsign(unsigned short pid) noexcept;
+
+    static void SetRace(unsigned short pid, const char *race) noexcept;
+    static const char *GetRace(unsigned short pid) noexcept;
+
+    static void SetHead(unsigned short pid, const char *head) noexcept;
+    static const char *GetHead(unsigned short pid) noexcept;
+
+    static void SetHairstyle(unsigned short pid, const char *style) noexcept;
+    static const char *GetHairstyle(unsigned short pid) noexcept;
+
+    static void SetIsMale(unsigned short pid, int male) noexcept;
+    static int GetIsMale(unsigned short pid) noexcept;
+
+    static float GetHealth(unsigned short pid) noexcept;
+    static void SetHealth(unsigned short pid, float health) noexcept;
+    static float GetCurrentHealth(unsigned short pid) noexcept;
+    static void SetCurrentHealth(unsigned short pid, float health) noexcept;
+
+    static float GetMagicka(unsigned short pid) noexcept;
+    static void SetMagicka(unsigned short pid, float magicka) noexcept;
+    static float GetCurrentMagicka(unsigned short pid) noexcept;
+    static void SetCurrentMagicka(unsigned short pid, float magicka) noexcept;
+
+    static float GetFatigue(unsigned short pid) noexcept;
+    static void SetFatigue(unsigned short pid, float fatigue) noexcept;
+    static float GetCurrentFatigue(unsigned short pid) noexcept;
+    static void SetCurrentFatigue(unsigned short pid, float fatigue) noexcept;
+
+    static int GetAttribute(unsigned short pid, unsigned short attribute) noexcept;
+    static void SetAttribute(unsigned short pid, unsigned short attribute, int value) noexcept;
+    static int GetCurrentAttribute(unsigned short pid, unsigned short attribute) noexcept;
+    static void SetCurrentAttribute(unsigned short pid, unsigned short attribute, int value) noexcept;
+
+    static int GetSkill(unsigned short pid, unsigned short skill) noexcept;
+    static void SetSkill(unsigned short pid, unsigned short skill, int value) noexcept;
+    static int GetCurrentSkill(unsigned short pid, unsigned short skill) noexcept;
+    static void SetCurrentSkill(unsigned short pid, unsigned short skill, int value) noexcept;
+
+    static int GetIncreaseSkill(unsigned short pid, unsigned int pos) noexcept;
+    static void SetIncreaseSkill(unsigned short pid, unsigned int pos, int value) noexcept;
+
+    static void Resurrect(unsigned short pid);
+
+    //static void AddItem(unsigned short pid, const char* itemName, unsigned short count) noexcept;
+    //static void RemoveItem(unsigned short pid, const char* itemName, unsigned short count) noexcept;
+    //static void GetItemCount(unsigned short pid, const char* itemName) noexcept;
+    static void EquipItem(unsigned short pid, unsigned short slot, const char* itemName, unsigned short count) noexcept;
+    static void UnequipItem(unsigned short pid, unsigned short slot) noexcept;
+    static bool HasItemEquipped(unsigned short pid, const char* itemName);
+    static const char *GetItemSlot(unsigned short pid, unsigned short slot) noexcept;
+
+    static void SendMessage(unsigned short pid, const char *message, bool broadcast) noexcept;
+    static void CleanChat(unsigned short pid);
+    static void CleanChat();
+    static void SetCharGenStage(unsigned short pid, int start, int end) noexcept;
+
+    /**
+     * \brief Create timer
+     * \param callback
+     * \param msec
+     * \return return timer id
+     */
+    static int CreateTimer(ScriptFunc callback, int msec) noexcept;
+    static int CreateTimerEx(ScriptFunc callback, int msec, const char *types, ...) noexcept;
+
+
+    static void StartTimer(int timerId) noexcept;
+    static void StopTimer(int timerId) noexcept;
+    static void RestartTimer(int timerId, int msec) noexcept;
+    static void FreeTimer(int timerId) noexcept;
+    static bool IsTimerElapsed(int timerId) noexcept;
+
+    static void Kick(unsigned short pid) noexcept;
+
+    static constexpr ScriptFunctionData functions[]{
+            {"CreateTimer",         ScriptFunctions::CreateTimer},
+            {"CreateTimerEx",       reinterpret_cast<Function<void>>(ScriptFunctions::CreateTimerEx)},
+            {"MakePublic",          ScriptFunctions::MakePublic},
+            {"CallPublic",          reinterpret_cast<Function<void>>(ScriptFunctions::CallPublic)},
+
+
+            {"StartTimer",          ScriptFunctions::StartTimer},
+            {"StopTimer",           ScriptFunctions::StopTimer},
+            {"RestartTimer",        ScriptFunctions::RestartTimer},
+            {"FreeTimer",           ScriptFunctions::FreeTimer},
+            {"IsTimerElapsed",      ScriptFunctions::IsTimerElapsed},
+
+            {"StopServer",          ScriptFunctions::StopServer},
+
+            {"GetPos",              ScriptFunctions::GetPos},
+            {"GetPosX",             ScriptFunctions::GetPosX},
+            {"GetPosY",             ScriptFunctions::GetPosY},
+            {"GetPosZ",             ScriptFunctions::GetPosZ},
+            {"SetPos",              ScriptFunctions::SetPos},
+
+            {"GetAngle",            ScriptFunctions::GetAngle},
+            {"GetAngleX",           ScriptFunctions::GetAngleX},
+            {"GetAngleY",           ScriptFunctions::GetAngleY},
+            {"GetAngleZ",           ScriptFunctions::GetAngleZ},
+            {"SetAngle",            ScriptFunctions::SetAngle},
+
+            {"GetCell",             ScriptFunctions::GetCell},
+            {"SetCell",             ScriptFunctions::SetCell},
+            {"IsInInterior",        ScriptFunctions::IsInInterior},
+
+            {"GetName",             ScriptFunctions::GetName},
+            {"SetName",             ScriptFunctions::SetName},
+
+            {"GetRace",             ScriptFunctions::GetRace},
+            {"SetRace",             ScriptFunctions::SetRace},
+
+            {"GetHead",             ScriptFunctions::GetHead},
+            {"SetHead",             ScriptFunctions::SetHead},
+
+            {"GetHair",             ScriptFunctions::GetHairstyle},
+            {"SetHair",             ScriptFunctions::SetHairstyle},
+
+            {"GetIsMale",           ScriptFunctions::GetIsMale},
+            {"SetIsMale",           ScriptFunctions::SetIsMale},
+
+            {"GetBirthsign",        ScriptFunctions::GetBirthsign},
+            {"SetBirthsign",        ScriptFunctions::SetBirthsign},
+
+            {"GetAttribute",        ScriptFunctions::GetAttribute},
+            {"SetAttribute",        ScriptFunctions::SetAttribute},
+            {"GetCurrentAttribute", ScriptFunctions::GetCurrentAttribute},
+            {"SetCurrentAttribute", ScriptFunctions::SetCurrentAttribute},
+            {"GetSkill",            ScriptFunctions::GetSkill},
+            {"SetSkill",            ScriptFunctions::SetSkill},
+            {"GetCurrentSkill",     ScriptFunctions::GetCurrentSkill},
+            {"SetCurrentSkill",     ScriptFunctions::SetCurrentSkill},
+
+            {"GetHealth",           ScriptFunctions::GetHealth},
+            {"SetHealth",           ScriptFunctions::SetHealth},
+            {"GetCurrentHealth",    ScriptFunctions::GetCurrentHealth},
+            {"SetCurrentHealth",    ScriptFunctions::SetCurrentHealth},
+
+            {"GetMagicka",          ScriptFunctions::GetMagicka},
+            {"SetMagicka",          ScriptFunctions::SetMagicka},
+            {"GetCurrentMagicka",   ScriptFunctions::GetCurrentMagicka},
+            {"SetCurrentMagicka",   ScriptFunctions::SetCurrentMagicka},
+
+            {"SetFatigue",          ScriptFunctions::SetFatigue},
+            {"GetFatigue",          ScriptFunctions::GetFatigue},
+            {"SetCurrentFatigue",   ScriptFunctions::SetCurrentFatigue},
+            {"GetCurrentFatigue",   ScriptFunctions::GetCurrentFatigue},
+
+//            {"SetClass",          ScriptFunctions::SetClass},
+//            {"GetClass",          ScriptFunctions::GetClass},
+            {"GetIncreaseSkill",    ScriptFunctions::GetIncreaseSkill},
+            {"SetIncreaseSkill",    ScriptFunctions::SetIncreaseSkill},
+
+//            {"Cast",              ScriptFunctions::Cast},
+
+//            {"AddItem",           ScriptFunctions::AddItem},
+//            {"RemoveItem",        ScriptFunctions::RemoveItem},
+//            {"GetItemCount",      ScriptFunctions::GetItemCount},
+            {"EquipItem",           ScriptFunctions::EquipItem},
+            {"UnequipItem",         ScriptFunctions::UnequipItem},
+            {"GetItemSlot",         ScriptFunctions::GetItemSlot},
+            {"HasItemEquipped",     ScriptFunctions::HasItemEquipped},
+            {"SendMessage",         ScriptFunctions::SendMessage},
+            {"SetCharGenStage",     ScriptFunctions::SetCharGenStage},
+            {"Resurrect",           ScriptFunctions::Resurrect},
+
+            {"Kick",                ScriptFunctions::Kick},
+    };
+
+    static constexpr ScriptCallbackData callbacks[]{
+            {"Main",                  Function<int, int, int>()},
+            {"OnServerInit",          Function<void>()},
+            {"OnServerExit",          Function<void, bool>()},
+            {"OnPlayerConnect",       Function<bool, unsigned short>()},
+            {"OnPlayerDisconnect",    Function<void, unsigned short>()},
+            {"OnPlayerDeath",         Function<void, unsigned short>()},
+            {"OnPlayerResurrect",     Function<void, unsigned short>()},
+            {"OnPlayerChangeCell",    Function<void, unsigned short>()},
+            {"OnPlayerUpdateEquiped", Function<void, unsigned short>()},
+            {"OnPlayerSendMessage",   Function<bool, unsigned short, const char*>()},
+            {"OnPlayerEndCharGen",    Function<void, unsigned short>()}
+    };
+};
+
+#endif //SOURCEPAWN_SCRIPTFUNCTIONS_HPP
\ No newline at end of file
diff --git a/apps/openmw-mp/Script/SystemInterface.hpp b/apps/openmw-mp/Script/SystemInterface.hpp
new file mode 100644
index 000000000..9efd06fd3
--- /dev/null
+++ b/apps/openmw-mp/Script/SystemInterface.hpp
@@ -0,0 +1,44 @@
+//
+// Created by koncord on 19.03.16.
+//
+
+#ifndef PLUGINSYSTEM3_SYSTEMINTERFACE_HPP
+#define PLUGINSYSTEM3_SYSTEMINTERFACE_HPP
+
+#ifdef __WIN32__
+#include <winsock2.h>
+#else
+#include <dlfcn.h>
+#endif
+
+template<typename R = void*>
+struct SystemInterface
+{
+#ifdef __WIN32__
+    typedef HMODULE lib_t;
+#else
+    typedef void* lib_t;
+#endif
+
+    union
+    {
+        R result;
+#ifdef __WIN32__
+        decltype(GetProcAddress(lib_t(), nullptr)) data;
+#else
+        decltype(dlsym(lib_t(), nullptr)) data;
+#endif
+    };
+
+    static_assert(sizeof(result) == sizeof(data), "R should have the same size");
+
+    SystemInterface() : data(nullptr) {}
+    explicit operator bool() { return data; }
+
+#ifdef __WIN32__
+    SystemInterface(lib_t handle, const char* name) : data(GetProcAddress(handle, name)) {}
+#else
+    SystemInterface(lib_t handle, const char* name) : data(dlsym(handle, name)) {}
+#endif
+};
+#endif //PLUGINSYSTEM3_SYSTEMINTERFACE_HPP
diff --git a/apps/openmw-mp/Script/Types.hpp b/apps/openmw-mp/Script/Types.hpp
new file mode 100644
index 000000000..2cd9a8995
--- /dev/null
+++ b/apps/openmw-mp/Script/Types.hpp
@@ -0,0 +1,101 @@
+//
+// Created by koncord on 23.01.16.
+//
+
+#ifndef SOURCEPAWN_TMPTYPES_HPP
+#define SOURCEPAWN_TMPTYPES_HPP
+
+
+#include <cstddef>
+#include <cstdint>
+#include <type_traits>
+#include <RakNetTypes.h>
+#include <Utils.hpp>
+
+template<typename T> struct sizeof_void { enum { value = sizeof(T) }; };
+template<> struct sizeof_void<void> { enum { value = 0 }; };
+
+
+template<typename T, size_t t> struct TypeChar { static_assert(!t, "Unsupported type in variadic type list"); };
+template<typename T> struct TypeChar<T*, sizeof(void*)> { enum { value = 'p' }; };
+template<> struct TypeChar<double*, sizeof(double*)> { enum { value = 'd' }; };
+template<> struct TypeChar<RakNet::NetworkID**, sizeof(RakNet::NetworkID**)> { enum { value = 'n' }; };
+template<typename T> struct TypeChar<T, sizeof(uint8_t)> { enum { value = std::is_signed<T>::value ? 'q' : 'i' }; };
+template<typename T> struct TypeChar<T, sizeof(uint16_t)> { enum { value = std::is_signed<T>::value ? 'q' : 'i' }; };
+template<typename T> struct TypeChar<T, sizeof(uint32_t)> { enum { value = std::is_signed<T>::value ? 'q' : 'i' }; };
+template<typename T> struct TypeChar<T, sizeof(uint64_t)> { enum { value = std::is_signed<T>::value ? 'w' : 'l' }; };
+template<> struct TypeChar<double, sizeof(double)> { enum { value = 'f' }; };
+template<> struct TypeChar<char*, sizeof(char*)> { enum { value = 's' }; };
+template<> struct TypeChar<const char*, sizeof(const char*)> { enum { value = 's' }; };
+template<> struct TypeChar<void, sizeof_void<void>::value> { enum { value = 'v' }; };
+
+template<const char t> struct CharType { static_assert(!t, "Unsupported type in variadic type list"); };
+template<> struct CharType<'p'> { typedef void* type; };
+template<> struct CharType<'d'> { typedef double* type; };
+template<> struct CharType<'n'> { typedef RakNet::NetworkID** type; };
+template<> struct CharType<'q'> { typedef signed int type; };
+template<> struct CharType<'i'> { typedef unsigned int type; };
+template<> struct CharType<'w'> { typedef signed long long type; };
+template<> struct CharType<'l'> { typedef unsigned long long type; };
+template<> struct CharType<'f'> { typedef double type; };
+template<> struct CharType<'s'> { typedef const char* type; };
+template<> struct CharType<'v'> { typedef void type; };
+
+template<typename... Types>
+struct TypeString {
+    static constexpr char value[sizeof...(Types) + 1] = {
+            TypeChar<Types, sizeof(Types)>::value...
+    };
+};
+
+
+template<typename R, typename... Types>
+using Function = R(*)(Types...);
+
+template<typename R>
+using FunctionEllipsis = R(*)(...);
+
+struct ScriptIdentity
+{
+    const char* types;
+    const char ret;
+    const unsigned int numargs;
+
+    constexpr bool matches(const char* types, const unsigned int N = 0) const
+    {
+        return N < numargs ? this->types[N] == types[N] && matches(types, N + 1) : this->types[N] == types[N];
+    }
+
+    template<typename R, typename... Types>
+    constexpr ScriptIdentity(Function<R, Types...>) : types(TypeString<Types...>::value), ret(TypeChar<R, sizeof_void<R>::value>::value), numargs(sizeof(TypeString<Types...>::value) - 1) {}
+};
+
+
+
+struct ScriptFunctionPointer : public ScriptIdentity
+{
+    Function<void> addr;
+
+    template<typename R, typename... Types>
+    constexpr ScriptFunctionPointer(Function<R, Types...> addr) : ScriptIdentity(addr), addr(reinterpret_cast<Function<void>>(addr)) {}
+};
+
+struct ScriptFunctionData
+{
+    const char* name;
+    const ScriptFunctionPointer func;
+
+    constexpr ScriptFunctionData(const char* name, ScriptFunctionPointer func) : name(name), func(func) {}
+};
+
+struct ScriptCallbackData
+{
+    const char* name;
+    const unsigned int index;
+    const ScriptIdentity callback;
+
+    template<size_t N>
+    constexpr ScriptCallbackData(const char(&name)[N], ScriptIdentity _callback) : name(name), index(Utils::hash(name)), callback(_callback) {}
+};
+
+#endif //SOURCEPAWN_TMPTYPES_HPP
diff --git a/apps/openmw-mp/Utils.cpp b/apps/openmw-mp/Utils.cpp
new file mode 100644
index 000000000..b02dc7ba0
--- /dev/null
+++ b/apps/openmw-mp/Utils.cpp
@@ -0,0 +1,201 @@
+//
+// Created by koncord on 24.01.16.
+//
+
+#include "Utils.hpp"
+
+#include <cstring>
+#include <ctime>
+#include <cmath>
+
+using namespace std;
+
+void Utils::timestamp()
+{
+    time_t ltime;
+    ltime = time(nullptr);
+    char t[32];
+    snprintf(t, sizeof(t), "[%s", asctime(localtime(&ltime)));
+    char* newline = strchr(t, '\n');
+    *newline = ']';
+    strcat(t, " ");
+    printf("%s", t);
+}
+
+// http://stackoverflow.com/questions/1637587/c-libcurl-console-progress-bar
+int Utils::progress_func(double TotalToDownload, double NowDownloaded)
+{
+    // how wide you want the progress meter to be
+    int totaldotz=40;
+    double fractiondownloaded = NowDownloaded / TotalToDownload;
+    // part of the progressmeter that's already "full"
+    int dotz = round(fractiondownloaded * totaldotz);
+
+    // create the "meter"
+    int ii=0;
+    printf("%3.0f%% [",fractiondownloaded*100);
+    // part  that's full already
+    for ( ; ii < dotz;ii++) {
+        printf("=");
+    }
+    // remaining part (spaces)
+    for ( ; ii < totaldotz;ii++) {
+        printf(" ");
+    }
+    // and back to line begin - do not forget the fflush to avoid output buffering problems!
+    printf("]\r");
+    fflush(stdout);
+    return 1;
+}
+
+bool Utils::DoubleCompare(double a, double b, double epsilon)
+{
+    return fabs(a - b) < epsilon;
+}
+
+string Utils::str_replace(const string& source, const char* find, const char* replace)
+{
+    unsigned int find_len = strlen(find);
+    unsigned int replace_len = strlen(replace);
+    long pos = 0;
+
+    string dest = source;
+
+    while ((pos = dest.find(find, pos)) != string::npos)
+    {
+        dest.replace(pos, find_len, replace);
+        pos += replace_len;
+    }
+
+    return dest;
+}
+
+string& Utils::RemoveExtension(string& file)
+{
+    unsigned int pos = file.find_last_of('.');
+
+    if (pos)
+        file = file.substr(0, pos);
+
+    return file;
+}
+
+unsigned int Utils::FileLength(const char* file)
+{
+    FILE* _file = fopen(file, "rb");
+
+    if (!_file)
+        return 0;
+
+    fseek(_file, 0, SEEK_END);
+    unsigned int size = ftell(_file);
+    fclose(_file);
+
+    return size;
+}
+
+/* From:
+        http://web.archive.org/web/20080303102530/http://c.snippets.org/snip_lister.php?fname=crc_32.c
+*/
+
+#define UPDC32(octet,crc) (crc_32_tab[((crc)\
+									   ^ ((unsigned char)octet)) & 0xff] ^ ((crc) >> 8))
+
+static unsigned int crc_32_tab[] =   /* CRC polynomial 0xedb88320 */
+        {
+                0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
+                0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
+                0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
+                0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
+                0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
+                0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
+                0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
+                0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
+                0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
+                0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
+                0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
+                0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
+                0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
+                0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
+                0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
+                0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
+                0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
+                0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
+                0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
+                0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
+                0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
+                0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
+                0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
+                0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
+                0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
+                0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
+                0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
+                0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
+                0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
+                0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
+                0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
+                0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
+                0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
+                0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
+                0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
+                0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
+                0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
+                0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
+                0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
+                0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
+                0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
+                0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
+                0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
+        };
+
+unsigned int Utils::updateCRC32(unsigned char ch, unsigned int crc)
+{
+    return UPDC32(ch, crc);
+}
+
+bool Utils::crc32file(const char* name, unsigned int* crc)
+{
+    FILE* fin;
+    unsigned int oldcrc32;
+    long charcnt;
+    int c;
+
+    oldcrc32 = 0xFFFFFFFF;
+    charcnt = 0;
+
+    if ((fin = fopen(name, "rb")) == nullptr)
+    {
+        return false;
+    }
+
+    while ((c = getc(fin)) != EOF)
+    {
+        ++charcnt;
+        oldcrc32 = UPDC32(c, oldcrc32);
+    }
+
+    if (ferror(fin))
+    {
+        charcnt = -1;
+    }
+
+    fclose(fin);
+
+    *crc = oldcrc32 = ~oldcrc32;
+
+    return true;
+}
+
+unsigned int Utils::crc32buf(char* buf, size_t len)
+{
+    unsigned int oldcrc32;
+
+    oldcrc32 = 0xFFFFFFFF;
+
+    for (; len; --len, ++buf)
+    {
+        oldcrc32 = UPDC32(*buf, oldcrc32);
+    }
+
+    return ~oldcrc32;
+}
\ No newline at end of file
diff --git a/apps/openmw-mp/Utils.hpp b/apps/openmw-mp/Utils.hpp
new file mode 100644
index 000000000..d8b22b6de
--- /dev/null
+++ b/apps/openmw-mp/Utils.hpp
@@ -0,0 +1,69 @@
+//
+// Created by koncord on 24.01.16.
+//
+
+#ifndef SOURCEPAWN_UTILS_HPP
+#define SOURCEPAWN_UTILS_HPP
+
+#include <cstddef>
+#include <string>
+
+
+#if (!defined(DEBUG_PRINTF) && defined(DEBUG))
+#define DEBUG_PRINTF printf
+#else
+#define DEBUG_PRINTF(...)
+#endif
+
+namespace Utils
+{
+    template<size_t N>
+    constexpr unsigned int hash(const char(&str)[N], size_t I = N)
+    {
+        return (I == 1 ? ((2166136261u ^ str[0]) * 16777619u) : ((hash(str, I - 1) ^ str[I - 1]) * 16777619u));
+    }
+
+    inline unsigned int hash(const char *str, std::size_t I)
+    {
+        return (I == 1 ? ((2166136261u ^ str[0]) * 16777619u) : ((hash(str, I - 1) ^ str[I - 1]) * 16777619u));
+    }
+
+    void timestamp();
+
+    int progress_func(double TotalToDownload, double NowDownloaded);
+
+    bool DoubleCompare(double a, double b, double epsilon);
+
+    std::string str_replace(const std::string &source, const char *find, const char *replace);
+
+    std::string &RemoveExtension(std::string &file);
+
+    unsigned int FileLength(const char *file);
+
+    unsigned int crc32buf(char *buf, size_t len);
+
+    unsigned int updateCRC32(unsigned char ch, unsigned int crc);
+
+    bool crc32file(const char *name, unsigned int *crc);
+
+    template<typename F, typename T, typename E = void>
+    struct is_static_castable : std::false_type
+    {
+    };
+    template<typename F, typename T>
+    struct is_static_castable<F, T, typename std::conditional<true, void, decltype(static_cast<T>(std::declval<F>()))>::type>
+            : std::true_type
+    {
+    };
+
+    template<typename T, typename F>
+    inline static typename std::enable_if<is_static_castable<F *, T *>::value, T *>::type static_or_dynamic_cast(
+            F *from)
+    { return static_cast<T *>(from); }
+
+    template<typename T, typename F>
+    inline static typename std::enable_if<!is_static_castable<F *, T *>::value, T *>::type static_or_dynamic_cast(
+            F *from)
+    { return dynamic_cast<T *>(from); }
+}
+#endif //SOURCEPAWN_UTILS_HPP
diff --git a/apps/openmw-mp/amx/CMakeLists.txt b/apps/openmw-mp/amx/CMakeLists.txt
new file mode 100644
index 000000000..62602e091
--- /dev/null
+++ b/apps/openmw-mp/amx/CMakeLists.txt
@@ -0,0 +1,23 @@
+include_directories(./linux)
+
+add_definitions(-DPAWN_CELL_SIZE=64)
+
+set(source_amx
+        amxexec_gcc.c
+        amxfile.c
+        fpattern.c
+        minIni.c
+        amxcons.c
+        amxcore.c
+        amxstring.c
+        amxtime.c
+        amxfloat.c
+        amxaux.c
+        amx.c
+        linux/binreloc.c
+        linux/getch.c
+        )
+
+source_group(amx FILES ${source_amx})
+
+add_library(amx STATIC ${source_amx} )
diff --git a/apps/openmw-mp/amx/amx.c b/apps/openmw-mp/amx/amx.c
new file mode 100644
index 000000000..d583c2ea1
--- /dev/null
+++ b/apps/openmw-mp/amx/amx.c
@@ -0,0 +1,3798 @@
+/*  Pawn Abstract Machine (for the Pawn language)
+ *
+ *  Copyright (c) ITB CompuPhase, 1997-2015
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ *  use this file except in compliance with the License. You may obtain a copy
+ *  of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ *  License for the specific language governing permissions and limitations
+ *  under the License.
+ *
+ *  Version: $Id: amx.c 5181 2015-01-21 09:44:28Z thiadmer $
+ */
+
+#define WIN32_LEAN_AND_MEAN
+#if defined _UNICODE || defined __UNICODE__ || defined UNICODE
+# if !defined UNICODE   /* for Windows API */
+#   define UNICODE
+# endif
+# if !defined _UNICODE  /* for C library */
+#   define _UNICODE
+# endif
+#endif
+
+#include <assert.h>
+#include <stdarg.h>
+#include <stddef.h>     /* for wchar_t */
+#include <stdlib.h>     /* for getenv() */
+#include <string.h>
+#include "osdefs.h"
+#if defined __LINUX__ || defined __FreeBSD__ || defined __OpenBSD__ || defined __APPLE__
+  #include <sclinux.h>
+  #if !defined AMX_NODYNALOAD
+    #include <dlfcn.h>
+  #endif
+  #if defined AMX_JIT
+    #include <sys/types.h>
+    #include <sys/mman.h>
+  #endif
+#endif
+#if defined __LCC__ || defined __LINUX__
+  #include <wchar.h>    /* for wcslen() */
+#endif
+
+#if defined __ECOS__
+  /* eCos puts include files in cyg/package_name */
+  #include <cyg/pawn/amx.h>
+#else
+  #include "amx.h"
+#endif
+
+#if (defined _Windows && !defined AMX_NODYNALOAD) || (defined AMX_JIT && __WIN32__)
+  #include <windows.h>
+#endif
+
+
+/* When one or more of the AMX_funcname macros are defined, we want
+ * to compile only those functions. However, when none of these macros
+ * is present, we want to compile everything.
+ */
+#if defined AMX_ALIGN       || defined AMX_ALLOT        || defined AMX_CLEANUP
+  #define AMX_EXPLIT_FUNCTIONS
+#endif
+#if defined AMX_CLONE       || defined AMX_DEFCALLBACK  || defined AMX_EXEC
+  #define AMX_EXPLIT_FUNCTIONS
+#endif
+#if defined AMX_FLAGS       || defined AMX_INIT         || defined AMX_MEMINFO
+  #define AMX_EXPLIT_FUNCTIONS
+#endif
+#if defined AMX_NAMELENGTH   || defined AMX_NATIVEINFO  || defined AMX_PUSHXXX
+  #define AMX_EXPLIT_FUNCTIONS
+#endif
+#if defined AMX_RAISEERROR   || defined AMX_REGISTER    || defined AMX_SETCALLBACK
+  #define AMX_EXPLIT_FUNCTIONS
+#endif
+#if defined AMX_SETDEBUGHOOK || defined AMX_UTF8XXX     || defined AMX_XXXNATIVES
+  #define AMX_EXPLIT_FUNCTIONS
+#endif
+#if defined AMX_XXXPUBLICS  || defined AMX_XXXPUBVARS   || defined AMX_XXXSTRING
+  #define AMX_EXPLIT_FUNCTIONS
+#endif
+#if defined AMX_XXXTAGS     || defined AMX_XXXUSERDATA
+  #define AMX_EXPLIT_FUNCTIONS
+#endif
+#if !defined AMX_EXPLIT_FUNCTIONS
+  /* no constant set, set them all */
+  #define AMX_ALIGN             /* amx_Align16(), amx_Align32() and amx_Align64() */
+  #define AMX_ALLOT             /* amx_Allot() and amx_Release() */
+  #define AMX_DEFCALLBACK       /* amx_Callback() */
+  #define AMX_CLEANUP           /* amx_Cleanup() */
+  #define AMX_CLONE             /* amx_Clone() */
+  #define AMX_EXEC              /* amx_Exec() */
+  #define AMX_FLAGS             /* amx_Flags() */
+  #define AMX_INIT              /* amx_Init() and amx_InitJIT() */
+  #define AMX_MEMINFO           /* amx_MemInfo() */
+  #define AMX_NAMELENGTH        /* amx_NameLength() */
+  #define AMX_NATIVEINFO        /* amx_NativeInfo() */
+  #define AMX_PUSHXXX           /* amx_Push(), amx_PushAddress(), amx_PushArray() and amx_PushString() */
+  #define AMX_RAISEERROR        /* amx_RaiseError() */
+  #define AMX_REGISTER          /* amx_Register() */
+  #define AMX_SETCALLBACK       /* amx_SetCallback() */
+  #define AMX_SETDEBUGHOOK      /* amx_SetDebugHook() */
+  #define AMX_UTF8XXX           /* amx_UTF8Check(), amx_UTF8Get(), amx_UTF8Len() and amx_UTF8Put() */
+  #define AMX_XXXNATIVES        /* amx_NumNatives(), amx_GetNative() and amx_FindNative() */
+  #define AMX_XXXPUBLICS        /* amx_NumPublics(), amx_GetPublic() and amx_FindPublic() */
+  #define AMX_XXXPUBVARS        /* amx_NumPubVars(), amx_GetPubVar() and amx_FindPubVar() */
+  #define AMX_XXXSTRING         /* amx_StrLen(), amx_GetString() and amx_SetString() */
+  #define AMX_XXXTAGS           /* amx_NumTags(), amx_GetTag() and amx_FindTagId() */
+  #define AMX_XXXUSERDATA       /* amx_GetUserData() and amx_SetUserData() */
+#endif
+#undef AMX_EXPLIT_FUNCTIONS
+#if defined AMX_ANSIONLY
+  #undef AMX_UTF8XXX            /* no UTF-8 support in ANSI/ASCII-only version */
+#endif
+#if defined AMX_NO_NATIVEINFO
+  #undef AMX_NATIVEINFO
+#endif
+#if AMX_USERNUM <= 0
+  #undef AMX_XXXUSERDATA
+#endif
+#if defined AMX_JIT
+  /* JIT is incompatible with macro instructions, packed opcodes and overlays */
+  #if !defined AMX_NO_MACRO_INSTR
+    #define AMX_NO_MACRO_INSTR
+  #endif
+  #if !defined AMX_NO_PACKED_OPC
+    #define AMX_NO_PACKED_OPC
+  #endif
+  #if !defined AMX_NO_OVERLAY
+    #define AMX_NO_OVERLAY
+  #endif
+#endif
+#if (defined AMX_ASM || defined AMX_JIT) && !defined AMX_ALTCORE
+  /* do not use the standard ANSI-C amx_Exec() function */
+  #define AMX_ALTCORE
+#endif
+#if !defined AMX_NO_PACKED_OPC && !defined AMX_TOKENTHREADING
+  #define AMX_TOKENTHREADING    /* packed opcodes require token threading */
+#endif
+
+#if defined AMX_ALTCORE
+  #if defined __WIN32__
+    /* For Watcom C/C++ use register calling convention (faster); for
+     * Microsoft C/C++ (and most other C compilers) use "cdecl".
+     * The important point is that you assemble AMXEXEC.ASM with the matching
+     * calling convention, or the right JIT, respectively.
+     * AMXJITR.ASM is for Watcom's register calling convention, AMXJITS.ASM and
+     * AMXJITSN.ASM are for "cdecl".
+     */
+    #if defined __WATCOMC__ && !defined STACKARGS
+      /* register calling convention; the #pragma tells the compiler into which
+       * registers the parameters should go
+       */
+      extern cell amx_exec_run(AMX *amx,cell *retval,unsigned char *data);
+          #pragma aux amx_exec_run parm [eax] [edx] [ebx];
+      extern int amx_exec_list(const AMX *amx,const cell **opcodelist,int *numopcodes);
+          #pragma aux amx_exec_run parm [eax] [edx] [ebx];
+      extern cell amx_jit_compile(void *pcode, void *jumparray, void *nativecode);
+          #pragma aux amx_exec_run parm [eax] [edx] [ebx];
+      extern cell amx_jit_run(AMX *amx,cell *retval,unsigned char *data);
+          #pragma aux amx_jit_run parm [eax] [edx] [ebx];
+      extern int  amx_jit_list(const AMX *amx,const cell **opcodelist,int *numopcodes);
+          #pragma aux amx_exec_run parm [eax] [edx] [ebx];
+    #elif defined __GNUC__
+      /* force "cdecl" by adding an "attribute" to the declaration */
+      extern cell amx_exec_run(AMX *amx,cell *retval,unsigned char *data) __attribute__((cdecl));
+      extern int amx_exec_list(const AMX *amx,const cell **opcodelist,int *numopcodes) __attribute__((cdecl));
+      extern cell amx_jit_compile(void *pcode, void *jumparray, void *nativecode) __attribute__((cdecl));
+      extern cell amx_jit_run(AMX *amx,cell *retval,unsigned char *data) __attribute__((cdecl));
+      extern int  amx_jit_list(const AMX *amx,const cell **opcodelist,int *numopcodes) __attribute__((cdecl));
+    #else
+      /* force "cdecl" by specifying it as a "function class" with the "__cdecl" keyword */
+      extern cell __cdecl amx_exec_run(AMX *amx,cell *retval,unsigned char *data);
+      extern int __cdecl amx_exec_list(const AMX *amx,const cell **opcodelist,int *numopcodes);
+      extern cell __cdecl amx_jit_compile(void *pcode, void *jumparray, void *nativecode);
+      extern cell __cdecl amx_jit_run(AMX *amx,cell *retval,unsigned char *data);
+      extern int  __cdecl amx_jit_list(const AMX *amx,const cell **opcodelist,int *numopcodes);
+    #endif
+  #else /* __WIN32__ */
+    /* assume no specific calling conventions for other platforms than Windows */
+    extern cell amx_exec_run(AMX *amx,cell *retval,unsigned char *data);
+    extern int amx_exec_list(const AMX *amx,const cell **opcodelist,int *numopcodes);
+    extern cell amx_jit_compile(void *pcode, void *jumparray, void *nativecode);
+    extern cell amx_jit_run(AMX *amx,cell *retval,unsigned char *data);
+    extern int  amx_jit_list(const AMX *amx,const cell **opcodelist,int *numopcodes);
+  #endif /* __WIN32__ */
+#else
+  int amx_exec_list(AMX *amx,const cell **opcodelist,int *numopcodes);
+#endif /* AMX_ALTCORE */
+
+typedef enum {
+  OP_NOP,
+  OP_LOAD_PRI,
+  OP_LOAD_ALT,
+  OP_LOAD_S_PRI,
+  OP_LOAD_S_ALT,
+  OP_LREF_S_PRI,
+  OP_LREF_S_ALT,
+  OP_LOAD_I,
+  OP_LODB_I,
+  OP_CONST_PRI,
+  OP_CONST_ALT,
+  OP_ADDR_PRI,
+  OP_ADDR_ALT,
+  OP_STOR,
+  OP_STOR_S,
+  OP_SREF_S,
+  OP_STOR_I,
+  OP_STRB_I,
+  OP_ALIGN_PRI,
+  OP_LCTRL,
+  OP_SCTRL,
+  OP_XCHG,
+  OP_PUSH_PRI,
+  OP_PUSH_ALT,
+  OP_PUSHR_PRI,
+  OP_POP_PRI,
+  OP_POP_ALT,
+  OP_PICK,
+  OP_STACK,
+  OP_HEAP,
+  OP_PROC,
+  OP_RET,
+  OP_RETN,
+  OP_CALL,
+  OP_JUMP,
+  OP_JZER,
+  OP_JNZ,
+  OP_SHL,
+  OP_SHR,
+  OP_SSHR,
+  OP_SHL_C_PRI,
+  OP_SHL_C_ALT,
+  OP_SMUL,
+  OP_SDIV,
+  OP_ADD,
+  OP_SUB,
+  OP_AND,
+  OP_OR,
+  OP_XOR,
+  OP_NOT,
+  OP_NEG,
+  OP_INVERT,
+  OP_EQ,
+  OP_NEQ,
+  OP_SLESS,
+  OP_SLEQ,
+  OP_SGRTR,
+  OP_SGEQ,
+  OP_INC_PRI,
+  OP_INC_ALT,
+  OP_INC_I,
+  OP_DEC_PRI,
+  OP_DEC_ALT,
+  OP_DEC_I,
+  OP_MOVS,
+  OP_CMPS,
+  OP_FILL,
+  OP_HALT,
+  OP_BOUNDS,
+  OP_SYSREQ,
+  OP_SWITCH,
+  OP_SWAP_PRI,
+  OP_SWAP_ALT,
+  OP_BREAK,
+  OP_CASETBL,
+  /* patched instructions */
+  OP_SYSREQ_D,
+  OP_SYSREQ_ND,
+  /* overlay instructions */
+  OP_CALL_OVL,
+  OP_RETN_OVL,
+  OP_SWITCH_OVL,
+  OP_CASETBL_OVL,
+#if !defined AMX_NO_MACRO_INSTR
+  /* supplemental & macro instructions */
+  OP_LIDX,
+  OP_LIDX_B,
+  OP_IDXADDR,
+  OP_IDXADDR_B,
+  OP_PUSH_C,
+  OP_PUSH,
+  OP_PUSH_S,
+  OP_PUSH_ADR,
+  OP_PUSHR_C,
+  OP_PUSHR_S,
+  OP_PUSHR_ADR,
+  OP_JEQ,
+  OP_JNEQ,
+  OP_JSLESS,
+  OP_JSLEQ,
+  OP_JSGRTR,
+  OP_JSGEQ,
+  OP_SDIV_INV,
+  OP_SUB_INV,
+  OP_ADD_C,
+  OP_SMUL_C,
+  OP_ZERO_PRI,
+  OP_ZERO_ALT,
+  OP_ZERO,
+  OP_ZERO_S,
+  OP_EQ_C_PRI,
+  OP_EQ_C_ALT,
+  OP_INC,
+  OP_INC_S,
+  OP_DEC,
+  OP_DEC_S,
+  /* macro instructions */
+  OP_SYSREQ_N,
+  OP_PUSHM_C,
+  OP_PUSHM,
+  OP_PUSHM_S,
+  OP_PUSHM_ADR,
+  OP_PUSHRM_C,
+  OP_PUSHRM_S,
+  OP_PUSHRM_ADR,
+  OP_LOAD2,
+  OP_LOAD2_S,
+  OP_CONST,
+  OP_CONST_S,
+#endif
+#if !defined AMX_NO_PACKED_OPC
+  /* packed instructions */
+  OP_LOAD_P_PRI,
+  OP_LOAD_P_ALT,
+  OP_LOAD_P_S_PRI,
+  OP_LOAD_P_S_ALT,
+  OP_LREF_P_S_PRI,
+  OP_LREF_P_S_ALT,
+  OP_LODB_P_I,
+  OP_CONST_P_PRI,
+  OP_CONST_P_ALT,
+  OP_ADDR_P_PRI,
+  OP_ADDR_P_ALT,
+  OP_STOR_P,
+  OP_STOR_P_S,
+  OP_SREF_P_S,
+  OP_STRB_P_I,
+  OP_LIDX_P_B,
+  OP_IDXADDR_P_B,
+  OP_ALIGN_P_PRI,
+  OP_PUSH_P_C,
+  OP_PUSH_P,
+  OP_PUSH_P_S,
+  OP_PUSH_P_ADR,
+  OP_PUSHR_P_C,
+  OP_PUSHR_P_S,
+  OP_PUSHR_P_ADR,
+  OP_PUSHM_P_C,
+  OP_PUSHM_P,
+  OP_PUSHM_P_S,
+  OP_PUSHM_P_ADR,
+  OP_PUSHRM_P_C,
+  OP_PUSHRM_P_S,
+  OP_PUSHRM_P_ADR,
+  OP_STACK_P,
+  OP_HEAP_P,
+  OP_SHL_P_C_PRI,
+  OP_SHL_P_C_ALT,
+  OP_ADD_P_C,
+  OP_SMUL_P_C,
+  OP_ZERO_P,
+  OP_ZERO_P_S,
+  OP_EQ_P_C_PRI,
+  OP_EQ_P_C_ALT,
+  OP_INC_P,
+  OP_INC_P_S,
+  OP_DEC_P,
+  OP_DEC_P_S,
+  OP_MOVS_P,
+  OP_CMPS_P,
+  OP_FILL_P,
+  OP_HALT_P,
+  OP_BOUNDS_P,
+#endif
+  /* ----- */
+  OP_NUM_OPCODES
+} OPCODE;
+
+#define NUMENTRIES(hdr,field,nextfield) \
+                        (unsigned)(((hdr)->nextfield - (hdr)->field) / (hdr)->defsize)
+#define GETENTRY(hdr,table,index) \
+                        (AMX_FUNCSTUB *)((unsigned char*)(hdr) + (unsigned)(hdr)->table + (unsigned)index*(hdr)->defsize)
+#define GETENTRYNAME(hdr,entry) \
+                        (char *)((unsigned char*)(hdr) + (unsigned)((AMX_FUNCSTUB*)(entry))->nameofs)
+
+#if !defined NDEBUG
+  static int check_endian(void)
+  {
+    uint16_t val=0x00ff;
+    unsigned char *ptr=(unsigned char *)&val;
+    /* "ptr" points to the starting address of "val". If that address
+     * holds the byte "0xff", the computer stored the low byte of "val"
+     * at the lower address, and so the memory lay out is Little Endian.
+     */
+    assert(*ptr==0xff || *ptr==0x00);
+    #if BYTE_ORDER==BIG_ENDIAN
+      return *ptr==0x00;  /* return "true" if big endian */
+    #else
+      return *ptr==0xff;  /* return "true" if little endian */
+    #endif
+  }
+#endif
+
+#if BYTE_ORDER==BIG_ENDIAN || PAWN_CELL_SIZE==16
+  void amx_Swap16(uint16_t *v)
+  {
+    unsigned char *s = (unsigned char *)v;
+    unsigned char t;
+
+    assert_static(sizeof(*v)==2);
+    /* swap two bytes */
+    t=s[0];
+    s[0]=s[1];
+    s[1]=t;
+  }
+#endif
+
+#if BYTE_ORDER==BIG_ENDIAN || PAWN_CELL_SIZE==32
+  void amx_Swap32(uint32_t *v)
+  {
+    unsigned char *s = (unsigned char *)v;
+    unsigned char t;
+
+    assert_static(sizeof(*v)==4);
+    /* swap outer two bytes */
+    t=s[0];
+    s[0]=s[3];
+    s[3]=t;
+    /* swap inner two bytes */
+    t=s[1];
+    s[1]=s[2];
+    s[2]=t;
+  }
+#endif
+
+#if (BYTE_ORDER==BIG_ENDIAN || PAWN_CELL_SIZE==64) && (defined _I64_MAX || defined HAVE_I64)
+  void amx_Swap64(uint64_t *v)
+  {
+    unsigned char *s = (unsigned char *)v;
+    unsigned char t;
+
+    assert(sizeof(*v)==8);
+
+    t=s[0];
+    s[0]=s[7];
+    s[7]=t;
+
+    t=s[1];
+    s[1]=s[6];
+    s[6]=t;
+
+    t=s[2];
+    s[2]=s[5];
+    s[5]=t;
+
+    t=s[3];
+    s[3]=s[4];
+    s[4]=t;
+  }
+#endif
+
+#if defined AMX_ALIGN || defined AMX_INIT
+uint16_t * AMXAPI amx_Align16(uint16_t *v)
+{
+  assert_static(sizeof(*v)==2);
+  assert(check_endian());
+  #if BYTE_ORDER==BIG_ENDIAN
+    amx_Swap16(v);
+  #endif
+  return v;
+}
+
+uint32_t * AMXAPI amx_Align32(uint32_t *v)
+{
+  assert_static(sizeof(*v)==4);
+  assert(check_endian());
+  #if BYTE_ORDER==BIG_ENDIAN
+    amx_Swap32(v);
+  #endif
+  return v;
+}
+
+#if defined _I64_MAX || defined HAVE_I64
+uint64_t * AMXAPI amx_Align64(uint64_t *v)
+{
+  assert(sizeof(*v)==8);
+  assert(check_endian());
+  #if BYTE_ORDER==BIG_ENDIAN
+    amx_Swap64(v);
+  #endif
+  return v;
+}
+#endif  /* _I64_MAX || HAVE_I64 */
+#endif  /* AMX_ALIGN || AMX_INIT */
+
+#if defined AMX_FLAGS
+int AMXAPI amx_Flags(AMX *amx,uint16_t *flags)
+{
+  AMX_HEADER *hdr;
+
+  *flags=0;
+  if (amx==NULL)
+    return AMX_ERR_FORMAT;
+  hdr=(AMX_HEADER *)amx->base;
+  if (hdr->magic!=AMX_MAGIC)
+    return AMX_ERR_FORMAT;
+  if (hdr->file_version>CUR_FILE_VERSION || hdr->amx_version<MIN_FILE_VERSION)
+    return AMX_ERR_VERSION;
+  *flags=hdr->flags;
+  return AMX_ERR_NONE;
+}
+#endif /* AMX_FLAGS */
+
+#if defined AMX_DEFCALLBACK
+int AMXAPI amx_Callback(AMX *amx, cell index, cell *result, const cell *params)
+{
+#if defined AMX_NATIVETABLE
+  extern AMX_NATIVE const AMX_NATIVETABLE[];
+#endif
+  AMX_HEADER *hdr;
+  AMX_FUNCSTUB *func;
+  AMX_NATIVE f;
+
+  assert(amx!=NULL);
+  hdr=(AMX_HEADER *)amx->base;
+  assert(hdr!=NULL);
+  assert(hdr->magic==AMX_MAGIC);
+  assert(hdr->natives<=hdr->libraries);
+#if defined AMX_NATIVETABLE
+  if (index<0) {
+    /* size of AMX_NATIVETABLE is unknown here, so we cannot verify index */
+    f=(AMX_NATIVETABLE)[-(index+1)];
+  } else {
+#endif
+    assert(index>=0 && index<(cell)NUMENTRIES(hdr,natives,libraries));
+    func=GETENTRY(hdr,natives,index);
+    f=(AMX_NATIVE)(intptr_t)func->address;
+#if defined AMX_NATIVETABLE
+  } /* if */
+#endif
+  assert(f!=NULL);
+
+  /* Now that we have found the function, patch the program so that any
+   * subsequent call will call the function directly (bypassing this
+   * callback).
+   * This trick cannot work in the JIT, because the program would need to
+   * be re-JIT-compiled after patching a P-code instruction.
+   */
+  assert((amx->flags & AMX_FLAG_JITC)==0 || amx->sysreq_d==0);
+  if (amx->sysreq_d!=0) {
+    /* at the point of the call, the CIP pseudo-register points directly
+     * behind the SYSREQ(.N) instruction and its parameter(s)
+     */
+    unsigned char *code=amx->code+(int)amx->cip-sizeof(cell);
+    if (amx->flags & AMX_FLAG_SYSREQN)		/* SYSREQ.N has 2 parameters */
+      code-=sizeof(cell);
+    assert(amx->code!=NULL);
+    assert(amx->cip>=4 && amx->cip<(hdr->dat - hdr->cod));
+    assert(sizeof(f)<=sizeof(cell)); /* function pointer must fit in a cell */
+    assert(*(cell*)code==index);
+    #if defined AMX_TOKENTHREADING || !(defined __GNUC__ || defined __ICC || defined AMX_ASM || defined AMX_JIT)
+      assert(!(amx->flags & AMX_FLAG_SYSREQN) && *(cell*)(code-sizeof(cell))==OP_SYSREQ
+             || (amx->flags & AMX_FLAG_SYSREQN) && *(cell*)(code-sizeof(cell))==OP_SYSREQ_N);
+    #endif
+    *(cell*)(code-sizeof(cell))=amx->sysreq_d;
+    *(cell*)code=(cell)(intptr_t)f;
+  } /* if */
+
+  /* Note:
+   *   params[0] == number of bytes for the additional parameters passed to the native function
+   *   params[1] == first argument
+   *   etc.
+   */
+
+  amx->error=AMX_ERR_NONE;
+  *result = f(amx,params);
+  return amx->error;
+}
+#endif /* defined AMX_DEFCALLBACK */
+
+
+#if defined AMX_JIT
+  /* convert from relative addresses to absolute physical addresses */
+  #define RELOC_ABS(base,off)   (*(ucell *)((base)+(int)(off)) += (ucell)(base)+(int)(off)-sizeof(cell))
+#else
+  #define JUMPREL(ip)           ((cell*)((intptr_t)(ip)+*(cell*)(ip)-sizeof(cell)))
+#endif
+#if defined AMX_ASM || defined AMX_JIT
+  #define RELOCATE_ADDR(base,v) ((v)+((ucell)(base)))
+#else
+  #define RELOCATE_ADDR(base,v) (v)
+#endif
+
+#define DBGPARAM(v)     ( (v)=*(cell *)(amx->code+(int)cip), cip+=sizeof(cell) )
+
+#if !defined GETOPCODE
+  #if defined AMX_NO_PACKED_OPC
+    #define GETOPCODE(c)  (OPCODE)(c)
+  #else
+    #define GETOPCODE(c)  (OPCODE)((c) & ((1 << sizeof(cell)*4)-1))
+  #endif
+#endif
+#if !defined GETPARAM_P
+  #define GETPARAM_P(v,o) ( v=((cell)(o) >> (int)(sizeof(cell)*4)) )
+#endif
+
+#if defined AMX_INIT
+
+static int VerifyPcode(AMX *amx)
+{
+  AMX_HEADER *hdr;
+  cell op,cip,tgt,opmask;
+  int sysreq_flg,max_opcode;
+  int datasize,stacksize;
+  const cell *opcode_list;
+  #if defined AMX_JIT
+    int opcode_count=0;
+    int reloc_count=0;
+    int jit_codesize=0;
+  #endif
+
+  assert(amx!=NULL);
+  hdr=(AMX_HEADER *)amx->base;
+  assert(hdr!=NULL);
+  assert(hdr->magic==AMX_MAGIC);
+  amx->flags|=AMX_FLAG_VERIFY;
+  datasize=hdr->hea-hdr->dat;
+  stacksize=hdr->stp-hdr->hea;
+
+  #if defined AMX_ASM && defined AMX_JIT
+    if ((amx->flags & AMX_FLAG_JITC)!=0)
+      jit_codesize=amx_jit_list(amx,&opcode_list,&max_opcode);
+    else
+      amx_exec_list(amx,&opcode_list,&max_opcode);
+  #elif defined AMX_JIT
+    jit_codesize=amx_jit_list(amx,&opcode_list,&max_opcode);
+  #else
+    amx_exec_list(amx,&opcode_list,&max_opcode);
+  #endif
+  #if defined AMX_TOKENTHREADING
+    opcode_list=NULL; /* avoid token translation if token threading is in effect */
+  #endif
+  #if defined AMX_NO_PACKED_OPC
+    opmask= ~0;
+  #else
+    opmask=(1 << sizeof(cell)*4)-1;
+  #endif
+
+  /* sanity checks */
+  assert_static(OP_XCHG==21);
+  assert_static(OP_SMUL==42);
+  assert_static(OP_MOVS==64);
+  #if !defined AMX_NO_MACRO_INSTR
+    assert_static(OP_LIDX==81);
+    assert_static(OP_ZERO_PRI==102);
+    assert_static(OP_LOAD2==120);
+  #endif
+  #if !defined AMX_NO_PACKED_OPC
+    assert_static(OP_LOAD_P_PRI==124);
+    assert_static(OP_ALIGN_P_PRI==141);
+    assert_static(OP_BOUNDS_P==174);
+  #endif
+
+  sysreq_flg=0;
+  if (opcode_list!=NULL) {
+    if (amx->sysreq_d==opcode_list[OP_SYSREQ_D])
+      sysreq_flg=0x01;
+    else if (amx->sysreq_d==opcode_list[OP_SYSREQ_ND])
+      sysreq_flg=0x02;
+  } else {
+    if (amx->sysreq_d==OP_SYSREQ_D)
+      sysreq_flg=0x01;
+    else if (amx->sysreq_d==OP_SYSREQ_ND)
+      sysreq_flg=0x02;
+  } /* if */
+  amx->sysreq_d=0;      /* preset */
+
+  /* start browsing code */
+  assert(amx->code!=NULL);  /* should already have been set in amx_Init() */
+  for (cip=0; cip<amx->codesize; ) {
+    op=*(cell *)(amx->code+(int)cip);
+    if ((op & opmask)>=max_opcode) {
+      amx->flags &= ~AMX_FLAG_VERIFY;
+      return AMX_ERR_INVINSTR;
+    } /* if */
+    /* relocate opcode (only works if the size of an opcode is at least
+     * as big as the size of a pointer (jump address); so basically we
+     * rely on the opcode and a pointer being 32-bit
+     */
+    if (opcode_list!=NULL) {
+      /* verify that opcode_list[op]!=NULL, if it is, this instruction
+       * is unsupported
+       */
+      if (opcode_list[op & opmask]==0) {
+        amx->flags &= ~AMX_FLAG_VERIFY;
+        return AMX_ERR_INVINSTR;
+      } /* if */
+      *(cell *)(amx->code+(int)cip)=opcode_list[op & opmask];
+    } /* if */
+    #if defined AMX_JIT
+      opcode_count++;
+    #endif
+    cip+=sizeof(cell);
+    switch (op & opmask) {
+#if !defined AMX_NO_MACRO_INSTR
+    case OP_PUSHM_C:    /* instructions with variable number of parameters */
+    case OP_PUSHM:
+    case OP_PUSHM_S:
+    case OP_PUSHM_ADR:
+    case OP_PUSHRM_C:
+    case OP_PUSHRM_S:
+    case OP_PUSHRM_ADR:
+      tgt=*(cell*)(amx->code+(int)cip); /* get count */
+      cip+=sizeof(cell)*(tgt+1);
+      break;
+
+    case OP_LOAD2:
+      tgt=*(cell*)(amx->code+(int)cip); /* verify both addresses */
+      if (tgt<0 || tgt>=datasize) {
+        amx->flags &= ~AMX_FLAG_VERIFY;
+        return AMX_ERR_BOUNDS;
+      } /* if */
+      tgt=*(cell*)(amx->code+(int)cip+(int)sizeof(cell));
+      if (tgt<0 || tgt>=datasize) {
+        amx->flags &= ~AMX_FLAG_VERIFY;
+        return AMX_ERR_BOUNDS;
+      } /* if */
+      cip+=sizeof(cell)*2;
+      break;
+
+    case OP_LOAD2_S:
+      tgt=*(cell*)(amx->code+(int)cip); /* verify both addresses */
+      if (tgt<-stacksize || tgt>stacksize) {
+        amx->flags &= ~AMX_FLAG_VERIFY;
+        return AMX_ERR_BOUNDS;
+      } /* if */
+      tgt=*(cell*)(amx->code+(int)cip+(int)sizeof(cell));
+      if (tgt<-stacksize || tgt>stacksize) {
+        amx->flags &= ~AMX_FLAG_VERIFY;
+        return AMX_ERR_BOUNDS;
+      } /* if */
+      cip+=sizeof(cell)*2;
+      break;
+
+    case OP_CONST:
+      tgt=*(cell*)(amx->code+(int)cip); /* verify address */
+      if (tgt<0 || tgt>=datasize) {
+        amx->flags &= ~AMX_FLAG_VERIFY;
+        return AMX_ERR_BOUNDS;
+      } /* if */
+      cip+=sizeof(cell)*2;
+      break;
+
+    case OP_CONST_S:
+      tgt=*(cell*)(amx->code+(int)cip); /* verify both addresses */
+      if (tgt<-stacksize || tgt>stacksize) {
+        amx->flags &= ~AMX_FLAG_VERIFY;
+        return AMX_ERR_BOUNDS;
+      } /* if */
+      cip+=sizeof(cell)*2;
+      break;
+#endif /* !defined AMX_NO_MACRO_INSTR */
+
+#if !defined AMX_NO_PACKED_OPC
+    case OP_LODB_P_I:   /* instructions with 1 parameter packed inside the same cell */
+    case OP_CONST_P_PRI:
+    case OP_CONST_P_ALT:
+    case OP_ADDR_P_PRI:
+    case OP_ADDR_P_ALT:
+    case OP_STRB_P_I:
+    case OP_LIDX_P_B:
+    case OP_IDXADDR_P_B:
+    case OP_ALIGN_P_PRI:
+    case OP_PUSH_P_C:
+    case OP_PUSH_P:
+    case OP_PUSH_P_S:
+    case OP_PUSH_P_ADR:
+    case OP_PUSHR_P_C:
+    case OP_PUSHR_P_S:
+    case OP_PUSHR_P_ADR:
+    case OP_STACK_P:
+    case OP_HEAP_P:
+    case OP_SHL_P_C_PRI:
+    case OP_SHL_P_C_ALT:
+    case OP_ADD_P_C:
+    case OP_SMUL_P_C:
+    case OP_ZERO_P:
+    case OP_ZERO_P_S:
+    case OP_EQ_P_C_PRI:
+    case OP_EQ_P_C_ALT:
+    case OP_MOVS_P:
+    case OP_CMPS_P:
+    case OP_FILL_P:
+    case OP_HALT_P:
+    case OP_BOUNDS_P:
+      break;
+
+    case OP_LOAD_P_PRI: /* data instructions with 1 parameter packed inside the same cell */
+    case OP_LOAD_P_ALT:
+    case OP_STOR_P:
+    case OP_INC_P:
+    case OP_DEC_P:
+      GETPARAM_P(tgt,op); /* verify address */
+      if (tgt<0 || tgt>=datasize) {
+        amx->flags &= ~AMX_FLAG_VERIFY;
+        return AMX_ERR_BOUNDS;
+      } /* if */
+      break;
+
+    case OP_LOAD_P_S_PRI: /* stack instructions with 1 parameter packed inside the same cell */
+    case OP_LOAD_P_S_ALT:
+    case OP_LREF_P_S_PRI:
+    case OP_LREF_P_S_ALT:
+    case OP_STOR_P_S:
+    case OP_SREF_P_S:
+    case OP_INC_P_S:
+    case OP_DEC_P_S:
+      GETPARAM_P(tgt,op); /* verify address */
+      if (tgt<-stacksize || tgt>stacksize) {
+        amx->flags &= ~AMX_FLAG_VERIFY;
+        return AMX_ERR_BOUNDS;
+      } /* if */
+      break;
+
+    case OP_PUSHM_P_C:    /* instructions with variable number of parameters */
+    case OP_PUSHM_P:
+    case OP_PUSHM_P_S:
+    case OP_PUSHM_P_ADR:
+    case OP_PUSHRM_P_C:
+    case OP_PUSHRM_P_S:
+    case OP_PUSHRM_P_ADR:
+      GETPARAM_P(tgt,op); /* verify address */
+      cip+=sizeof(cell)*tgt;
+      break;
+#endif /* !defined AMX_NO_PACKED_OPC */
+
+    case OP_LODB_I:     /* instructions with 1 parameter (not packed) */
+    case OP_CONST_PRI:
+    case OP_CONST_ALT:
+    case OP_ADDR_PRI:
+    case OP_ADDR_ALT:
+    case OP_STRB_I:
+    case OP_ALIGN_PRI:
+    case OP_LCTRL:
+    case OP_SCTRL:
+    case OP_PICK:
+    case OP_STACK:
+    case OP_HEAP:
+    case OP_SHL_C_PRI:
+    case OP_SHL_C_ALT:
+    case OP_MOVS:
+    case OP_CMPS:
+    case OP_FILL:
+    case OP_HALT:
+    case OP_BOUNDS:
+#if !defined AMX_NO_MACRO_INSTR
+    case OP_LIDX_B:
+    case OP_IDXADDR_B:
+    case OP_PUSH_C:
+    case OP_PUSH_ADR:
+    case OP_PUSHR_C:
+    case OP_PUSHR_ADR:
+    case OP_ADD_C:
+    case OP_SMUL_C:
+    case OP_ZERO:
+    case OP_ZERO_S:
+    case OP_EQ_C_PRI:
+    case OP_EQ_C_ALT:
+#endif
+      cip+=sizeof(cell);
+      break;
+
+    case OP_LOAD_PRI:
+    case OP_LOAD_ALT:
+    case OP_STOR:
+#if !defined AMX_NO_MACRO_INSTR
+    case OP_PUSH:
+    case OP_INC:
+    case OP_DEC:
+#endif
+      tgt=*(cell*)(amx->code+(int)cip); /* verify address */
+      if (tgt<0 || tgt>=datasize) {
+        amx->flags &= ~AMX_FLAG_VERIFY;
+        return AMX_ERR_BOUNDS;
+      } /* if */
+      cip+=sizeof(cell);
+      break;
+
+    case OP_LOAD_S_PRI:
+    case OP_LOAD_S_ALT:
+    case OP_LREF_S_PRI:
+    case OP_LREF_S_ALT:
+    case OP_STOR_S:
+    case OP_SREF_S:
+#if !defined AMX_NO_MACRO_INSTR
+    case OP_PUSH_S:
+    case OP_PUSHR_S:
+    case OP_INC_S:
+    case OP_DEC_S:
+#endif
+      tgt=*(cell*)(amx->code+(int)cip); /* verify address */
+      if (tgt<-stacksize || tgt>stacksize) {
+        amx->flags &= ~AMX_FLAG_VERIFY;
+        return AMX_ERR_BOUNDS;
+      } /* if */
+      cip+=sizeof(cell);
+      break;
+
+    case OP_NOP:        /* instructions without parameters */
+    case OP_LOAD_I:
+    case OP_STOR_I:
+    case OP_XCHG:
+    case OP_PUSH_PRI:
+    case OP_PUSH_ALT:
+    case OP_PUSHR_PRI:
+    case OP_POP_PRI:
+    case OP_POP_ALT:
+    case OP_PROC:
+    case OP_RET:
+    case OP_RETN:
+    case OP_SHL:
+    case OP_SHR:
+    case OP_SSHR:
+    case OP_SMUL:
+    case OP_SDIV:
+    case OP_ADD:
+    case OP_SUB:
+    case OP_AND:
+    case OP_OR:
+    case OP_XOR:
+    case OP_NOT:
+    case OP_NEG:
+    case OP_INVERT:
+    case OP_EQ:
+    case OP_NEQ:
+    case OP_SLESS:
+    case OP_SLEQ:
+    case OP_SGRTR:
+    case OP_SGEQ:
+    case OP_INC_PRI:
+    case OP_INC_ALT:
+    case OP_INC_I:
+    case OP_DEC_PRI:
+    case OP_DEC_ALT:
+    case OP_DEC_I:
+    case OP_SWAP_PRI:
+    case OP_SWAP_ALT:
+    case OP_BREAK:
+#if !defined AMX_NO_MACRO_INSTR
+    case OP_LIDX:
+    case OP_IDXADDR:
+    case OP_SDIV_INV:
+    case OP_SUB_INV:
+    case OP_ZERO_PRI:
+    case OP_ZERO_ALT:
+#endif
+      break;
+
+    case OP_CALL:       /* opcodes that need relocation (JIT only), or conversion to position-independent code */
+    case OP_JUMP:
+    case OP_JZER:
+    case OP_JNZ:
+    case OP_SWITCH:
+#if !defined AMX_NO_MACRO_INSTR
+    case OP_JEQ:
+    case OP_JNEQ:
+    case OP_JSLESS:
+    case OP_JSLEQ:
+    case OP_JSGRTR:
+    case OP_JSGEQ:
+#endif
+      tgt=*(cell*)(amx->code+(int)cip)+cip-sizeof(cell);
+      if (tgt<0 || tgt>amx->codesize) {
+        amx->flags &= ~AMX_FLAG_VERIFY;
+        return AMX_ERR_BOUNDS;
+      } /* if */
+      #if defined AMX_JIT
+        reloc_count++;
+        RELOC_ABS(amx->code, cip);  /* change to absolute physical address */
+      #endif
+      cip+=sizeof(cell);
+      break;
+
+#if !defined AMX_NO_OVERLAY
+    /* overlay opcodes (overlays must be enabled) */
+    case OP_SWITCH_OVL:
+      assert(hdr->file_version>=10);
+      tgt=*(cell*)(amx->code+(int)cip)+cip-sizeof(cell);
+      if (tgt<0 || tgt>amx->codesize) {
+        amx->flags &= ~AMX_FLAG_VERIFY;
+        return AMX_ERR_BOUNDS;
+      } /* if */
+      /* drop through */
+    case OP_CALL_OVL:
+      cip+=sizeof(cell);
+      /* drop through */
+    case OP_RETN_OVL:
+      assert(hdr->overlays!=0 && hdr->overlays!=hdr->nametable);
+      #if defined AMX_JIT
+        if ((amx->flags & AMX_FLAG_JITC)!=0)
+          return AMX_ERR_OVERLAY;     /* JIT does not support overlays */
+      #endif
+      if (amx->overlay==NULL)
+        return AMX_ERR_OVERLAY;       /* no overlay callback */
+      break;
+    case OP_CASETBL_OVL: {
+      cell num;
+      DBGPARAM(num);    /* number of records follows the opcode */
+      cip+=(2*num + 1)*sizeof(cell);
+      if (amx->overlay==NULL)
+        return AMX_ERR_OVERLAY;       /* no overlay callback */
+      break;
+    } /* case */
+#endif
+
+    case OP_SYSREQ:
+      cip+=sizeof(cell);
+      sysreq_flg|=0x01; /* mark SYSREQ found */
+      break;
+#if !defined AMX_NO_MACRO_INSTR
+    case OP_SYSREQ_N:
+      cip+=sizeof(cell)*2;
+      sysreq_flg|=0x02; /* mark SYSREQ.N found */
+      break;
+#endif
+
+    case OP_CASETBL: {
+      cell num,offs;
+      int i;
+      DBGPARAM(num);    /* number of records follows the opcode */
+      for (i=0; i<=num; i++) {
+        offs=cip+2*i*sizeof(cell);
+        tgt=*(cell*)(amx->code+(int)offs)+offs-sizeof(cell);
+        if (tgt<0 || tgt>amx->codesize) {
+          amx->flags &= ~AMX_FLAG_VERIFY;
+          return AMX_ERR_BOUNDS;
+        } /* if */
+        #if defined AMX_JIT
+          RELOC_ABS(amx->code, cip+2*i*sizeof(cell));
+          reloc_count++;
+        #endif
+      } /* for */
+      cip+=(2*num + 1)*sizeof(cell);
+      break;
+    } /* case */
+
+    default:
+      amx->flags &= ~AMX_FLAG_VERIFY;
+      return AMX_ERR_INVINSTR;
+    } /* switch */
+  } /* for */
+
+  #if !defined AMX_DONT_RELOCATE
+    /* only either type of system request opcode should be found (otherwise,
+     * we probably have a non-conforming compiler
+     */
+    if ((sysreq_flg==0x01 || sysreq_flg==0x02) && (amx->flags & AMX_FLAG_JITC)==0) {
+      /* to use direct system requests, a function pointer must fit in a cell;
+       * because the native function's address will be stored as the parameter
+       * of SYSREQ.(N)D
+       */
+      if (sizeof(AMX_NATIVE)<=sizeof(cell)) {
+        if (opcode_list!=NULL)
+          amx->sysreq_d=(sysreq_flg==0x01) ? opcode_list[OP_SYSREQ_D] : opcode_list[OP_SYSREQ_ND];
+        else
+          amx->sysreq_d=(sysreq_flg==0x01) ? OP_SYSREQ_D : OP_SYSREQ_ND;
+      } /* if */
+    } /* if */
+  #endif
+
+  #if defined AMX_JIT
+    /* adjust the code size to mean: estimated code size of the native code
+     * (instead of the size of the P-code)
+     */
+    amx->codesize=jit_codesize*opcode_count + hdr->cod + (hdr->stp - hdr->dat);
+    amx->reloc_size=2*sizeof(cell)*reloc_count;
+  #endif
+
+  amx->flags &= ~AMX_FLAG_VERIFY;
+  amx->flags |= AMX_FLAG_INIT;
+  if (sysreq_flg & 0x02)
+    amx->flags |= AMX_FLAG_SYSREQN;
+
+  return AMX_ERR_NONE;
+}
+
+/* definitions used for amx_Init() and amx_Cleanup() */
+#if (defined _Windows || defined __LINUX__ || defined __FreeBSD__ || defined __OpenBSD__ || defined __APPLE__) && !defined AMX_NODYNALOAD
+  typedef int AMXEXPORT (AMXAPI _FAR *AMX_ENTRY)(AMX _FAR *amx);
+#endif
+
+int AMXAPI amx_Init(AMX *amx,void *program)
+{
+  AMX_HEADER *hdr;
+  int err;
+  uint16_t *namelength;
+  unsigned char *data;
+  #if (defined _Windows || defined __LINUX__ || defined __FreeBSD__ || defined __OpenBSD__ || defined __APPLE__) && !defined AMX_NODYNALOAD
+    #if defined _Windows
+      char libname[sNAMEMAX+8]; /* +1 for '\0', +3 for 'amx' prefix, +4 for extension */
+      HINSTANCE hlib;
+    #elif defined __LINUX__ || defined __FreeBSD__ || defined __OpenBSD__ || defined __APPLE__
+      char libname[_MAX_PATH];
+      char *root;
+      void *hlib;
+      #if !defined AMX_LIBPATH
+        #define AMX_LIBPATH     "AMXLIB"
+      #endif
+    #endif
+    int numlibraries;
+    AMX_FUNCSTUB *lib;
+    AMX_ENTRY libinit;
+  #endif
+
+  if ((amx->flags & AMX_FLAG_INIT)!=0)
+    return AMX_ERR_INIT;  /* already initialized (may not do so twice) */
+
+  hdr=(AMX_HEADER *)program;
+  /* the header is in Little Endian, on a Big Endian machine, swap all
+   * multi-byte words
+   */
+  assert(check_endian());
+  #if BYTE_ORDER==BIG_ENDIAN
+    amx_Align32((uint32_t*)&hdr->size);
+    amx_Align16(&hdr->magic);
+    amx_Align16((uint16_t*)&hdr->flags);
+    amx_Align16((uint16_t*)&hdr->defsize);
+    amx_Align32((uint32_t*)&hdr->cod);
+    amx_Align32((uint32_t*)&hdr->dat);
+    amx_Align32((uint32_t*)&hdr->hea);
+    amx_Align32((uint32_t*)&hdr->stp);
+    amx_Align32((uint32_t*)&hdr->cip);
+    amx_Align32((uint32_t*)&hdr->publics);
+    amx_Align32((uint32_t*)&hdr->natives);
+    amx_Align32((uint32_t*)&hdr->libraries);
+    amx_Align32((uint32_t*)&hdr->pubvars);
+    amx_Align32((uint32_t*)&hdr->tags);
+    if (hdr->file_version>=10)
+      amx_Align32((uint32_t*)&hdr->overlays);
+  #endif
+
+  if (hdr->magic!=AMX_MAGIC)
+    return AMX_ERR_FORMAT;
+  if (hdr->file_version>CUR_FILE_VERSION || hdr->amx_version<MIN_FILE_VERSION)
+    return AMX_ERR_VERSION;
+  if (hdr->defsize!=sizeof(AMX_FUNCSTUB))
+    return AMX_ERR_FORMAT;
+  /* check the maximum name length in the separate name table */
+  amx_Align32((uint32_t*)&hdr->nametable);
+  namelength=(uint16_t*)((unsigned char*)program + (unsigned)hdr->nametable);
+  amx_Align16(namelength);
+  if (*namelength>sNAMEMAX)
+    return AMX_ERR_FORMAT;
+  if (hdr->stp<=0)
+    return AMX_ERR_FORMAT;
+  assert(hdr->hea == hdr->size);
+  #if BYTE_ORDER==BIG_ENDIAN
+    if ((hdr->flags & AMX_FLAG_COMPACT)==0) {
+      ucell *code=(ucell *)((unsigned char *)program+(int)hdr->cod);
+      while (code<(ucell *)((unsigned char *)program+(int)hdr->hea))
+        amx_SwapCell(code++);
+    } /* if */
+  #endif
+
+  amx->base=(unsigned char *)program;
+
+  /* set initial values */
+  amx->hlw=hdr->hea - hdr->dat; /* stack and heap relative to data segment */
+  amx->stp=hdr->stp - hdr->dat - sizeof(cell);
+  amx->hea=amx->hlw;
+  amx->stk=amx->stp;
+  #if defined AMX_DEFCALLBACK
+    if (amx->callback==NULL)
+      amx->callback=amx_Callback;
+  #endif
+
+  /* when running P-code from ROM (with the header with the native function
+   * table in RAM), the "code" field must be set to a non-NULL value on
+   * initialization, before calling amx_Init(); in an overlay scheme, the
+   * code field is modified dynamically by the overlay callback
+   */
+  if (amx->code==NULL)
+    amx->code=amx->base+(int)hdr->cod;
+  if (amx->codesize==0)
+    amx->codesize=hdr->dat-hdr->cod;
+
+  /* to split the data segment off the code segment, the "data" field must
+   * be set to a non-NULL value on initialization, before calling amx_Init();
+   * you may also need to explicitly initialize the data section with the
+   * contents read from the AMX file
+   */
+  if (amx->data!=NULL) {
+    data=amx->data;
+    if ((amx->flags & AMX_FLAG_DSEG_INIT)==0 && amx->overlay==NULL)
+      memcpy(data,amx->base+(int)hdr->dat,(size_t)(hdr->hea-hdr->dat));
+  } else {
+    data=amx->base+(int)hdr->dat;
+  } /* if */
+
+  /* Set a zero cell at the top of the stack, which functions
+   * as a sentinel for strings.
+   */
+  * (cell *)(data+(int)(hdr->stp-hdr->dat-sizeof(cell)))=0;
+
+  /* also align all addresses in the public function, public variable,
+   * public tag and native function tables --offsets into the name table
+   * (if present) must also be swapped.
+   */
+  #if BYTE_ORDER==BIG_ENDIAN
+  { /* local */
+    AMX_FUNCSTUB *fs;
+    int i,num;
+
+    fs=GETENTRY(hdr,natives,0);
+    num=NUMENTRIES(hdr,natives,libraries);
+    for (i=0; i<num; i++) {
+      amx_Align32(&fs->address);  /* redundant, because it should be zero */
+      amx_Align32(&fs->nameofs);
+      fs=(AMX_FUNCSTUB*)((unsigned char *)fs+hdr->defsize);
+    } /* for */
+
+    fs=GETENTRY(hdr,publics,0);
+    assert(hdr->publics<=hdr->natives);
+    num=NUMENTRIES(hdr,publics,natives);
+    for (i=0; i<num; i++) {
+      amx_Align32(&fs->address);
+      amx_Align32(&fs->nameofs);
+      fs=(AMX_FUNCSTUB*)((unsigned char *)fs+hdr->defsize);
+    } /* for */
+
+    fs=GETENTRY(hdr,pubvars,0);
+    assert(hdr->pubvars<=hdr->tags);
+    num=NUMENTRIES(hdr,pubvars,tags);
+    for (i=0; i<num; i++) {
+      amx_Align32(&fs->address);
+      amx_Align32(&fs->nameofs);
+      fs=(AMX_FUNCSTUB*)((unsigned char *)fs+hdr->defsize);
+    } /* for */
+
+    fs=GETENTRY(hdr,tags,0);
+    if (hdr->file_version<7) {  /* file version 7 introduced the name table */
+      assert(hdr->tags<=hdr->cod);
+      num=NUMENTRIES(hdr,tags,cod);
+    } else {
+      assert(hdr->tags<=hdr->nametable);
+      num=NUMENTRIES(hdr,tags,nametable);
+    } /* if */
+    for (i=0; i<num; i++) {
+      amx_Align32(&fs->address);
+      amx_Align32(&fs->nameofs);
+      fs=(AMX_FUNCSTUB*)((unsigned char *)fs+hdr->defsize);
+    } /* for */
+  } /* local */
+  #endif
+
+  /* verify P-code and relocate address in the case of the JIT */
+  if ((hdr->flags & AMX_FLAG_OVERLAY)==0) {
+    err=VerifyPcode(amx);
+  } else {
+    int i;
+    err=(amx->overlay==NULL) ? AMX_ERR_OVERLAY : AMX_ERR_NONE;
+    /* load every overlay on initialization and verify explicitly; we must
+     * do this to know whether to use new or old system requests
+     */
+    for (i=0; err==AMX_ERR_NONE && i<(int)((hdr->nametable - hdr->overlays)/sizeof(AMX_OVERLAYINFO)); i++) {
+      err=amx->overlay(amx, i);
+      if (err==AMX_ERR_NONE)
+        err=VerifyPcode(amx);
+    } /* for */
+  } /* if */
+  if (err!=AMX_ERR_NONE)
+    return err;
+
+  /* load any extension modules that the AMX refers to */
+  #if (defined _Windows || defined __LINUX__ || defined __FreeBSD__ || defined __OpenBSD__ || defined __APPLE__) && !defined AMX_NODYNALOAD
+  { /* local */
+    int i;
+    #if defined __LINUX__ || defined __FreeBSD__ || defined __OpenBSD__ || defined __APPLE__
+      root=getenv("AMXLIB");
+    #endif
+    hdr=(AMX_HEADER *)amx->base;
+    numlibraries=NUMENTRIES(hdr,libraries,pubvars);
+    for (i=0; i<numlibraries; i++) {
+      lib=GETENTRY(hdr,libraries,i);
+      libname[0]='\0';
+      #if defined __LINUX__ || defined __FreeBSD__ || defined __OpenBSD__ || defined __APPLE__
+        if (root!=NULL && *root!='\0') {
+          strcpy(libname,root);
+          if (libname[strlen(libname)-1]!='/')
+            strcat(libname,"/");
+        } /* if */
+      #endif
+      strcat(libname,"amx");
+      strcat(libname,GETENTRYNAME(hdr,lib));
+      #if defined _Windows
+        strcat(libname,".dll");
+        #if defined __WIN32__
+          hlib=LoadLibraryA(libname);
+        #else
+          hlib=LoadLibrary(libname);
+          if (hlib<=HINSTANCE_ERROR)
+            hlib=NULL;
+        #endif
+      #elif defined __LINUX__ || defined __FreeBSD__ || defined __OpenBSD__ || defined __APPLE__
+        strcat(libname,".so");
+        hlib=dlopen(libname,RTLD_NOW);
+      #endif
+      if (hlib!=NULL) {
+        /* a library that cannot be loaded or that does not have the required
+         * initialization function is simply ignored
+         */
+        char funcname[sNAMEMAX+9]; /* +1 for '\0', +4 for 'amx_', +4 for 'Init' */
+        strcpy(funcname,"amx_");
+        strcat(funcname,GETENTRYNAME(hdr,lib));
+        strcat(funcname,"Init");
+        #if defined _Windows
+          libinit=(AMX_ENTRY)GetProcAddress(hlib,funcname);
+        #elif defined __LINUX__ || defined __FreeBSD__ || defined __OpenBSD__ || defined __APPLE__
+          libinit=(AMX_ENTRY)dlsym(hlib,funcname);
+        #endif
+        if (libinit!=NULL)
+          libinit(amx);
+      } /* if */
+      lib->address=(ucell)(intptr_t)hlib;
+    } /* for */
+  } /* local */
+  #endif
+
+  return AMX_ERR_NONE;
+}
+
+#if defined AMX_JIT
+
+  #define CODESIZE_JIT    8192  /* approximate size of the code for the JIT */
+
+  #if defined __WIN32__   /* this also applies to Win32 "console" applications */
+
+    #define ALIGN(addr)     (addr)
+
+    #define PROT_READ       0x1         /* page can be read */
+    #define PROT_WRITE      0x2         /* page can be written */
+    #define PROT_EXEC       0x4         /* page can be executed */
+    #define PROT_NONE       0x0         /* page can not be accessed */
+
+    static int mprotect(void *addr, size_t len, int prot)
+    {
+      DWORD prev, p = 0;
+      if ((prot & PROT_WRITE)!=0)
+        p = PAGE_EXECUTE_READWRITE;
+      else
+        p |= PAGE_EXECUTE_READ;
+      return !VirtualProtect(addr, len, p, &prev);
+    }
+
+  #elif defined __LINUX__ || defined __FreeBSD__ || defined __OpenBSD__ || defined __APPLE__
+
+    /* Linux, BSD and OSX already have mprotect() */
+    #define ALIGN(addr) (char *)(((long)addr + sysconf(_SC_PAGESIZE)-1) & ~(sysconf(_SC_PAGESIZE)-1))
+
+  #else
+
+    // TODO: Add cases for Mac OS/X and other operating systems
+
+    /* DOS32 has no imposed limits on its segments */
+    #define ALIGN(addr)     (addr)
+    #define mprotect(addr, len, prot)   (0)
+
+  #endif /* #if defined __WIN32 __ */
+
+int AMXAPI amx_InitJIT(AMX *amx, void *reloc_table, void *native_code)
+{
+  int res;
+  AMX_HEADER *hdr;
+
+  if ((amx->flags & AMX_FLAG_JITC)==0)
+    return AMX_ERR_INIT_JIT;    /* flag not set, this AMX is not prepared for JIT */
+  if (hdr->file_version>MAX_FILE_VER_JIT)
+    return AMX_ERR_VERSION;     /* JIT may not support the newest file version(s) */
+  /* the JIT does not support overlays, but this is already checked in VerifyPcode()
+   * the same goes for macro instructions: not supported in the JIT, but already
+   * checked in VerifyPcode()
+   */
+
+  /* Patching SYSREQ(.N) opcodes to SYSREQ.(N)D cannot work in the JIT, because
+   * the program would need to be re-JIT-compiled after patching a P-code
+   * instruction. If this field is not zero, something went wrong in
+   * VerifyPcode().
+   */
+  assert(amx->sysreq_d==0);
+
+  if (mprotect(ALIGN(amx_jit_compile), CODESIZE_JIT, PROT_READ | PROT_WRITE | PROT_EXEC) != 0)
+    return AMX_ERR_INIT_JIT;
+
+  /* copy the prefix */
+  memcpy(native_code, amx->base, ((AMX_HEADER *)(amx->base))->cod);
+  hdr = native_code;
+
+  /* MP: added check for correct compilation */
+  if ((res = amx_jit_compile(amx->base, reloc_table, native_code)) == 0) {
+    /* update the required memory size (the previous value was a
+     * conservative estimate, now we know the exact size)
+     */
+    amx->codesize = (hdr->dat + hdr->stp + sizeof(cell)) & ~(sizeof(cell)-1);
+    /* The compiled code is relocatable, since only relative jumps are
+     * used for destinations within the generated code, and absolute
+     * addresses are only for jumps into the runtime, which is fixed
+     * in memory.
+     */
+    /* set the new pointers */
+    amx->base = (unsigned char*)native_code;
+    amx->code = amx->base + (int)hdr->cod;
+    amx->cip = hdr->cip;
+  } /* if */
+
+  return (res == 0) ? AMX_ERR_NONE : AMX_ERR_INIT_JIT;
+}
+
+#else /* #if defined AMX_JIT */
+
+int AMXAPI amx_InitJIT(AMX *amx,void *compiled_program,void *reloc_table)
+{
+  (void)amx;
+  (void)compiled_program;
+  (void)reloc_table;
+  return AMX_ERR_INIT_JIT;
+}
+
+#endif  /* #if defined AMX_JIT */
+
+#endif  /* AMX_INIT */
+
+#if defined AMX_CLEANUP
+int AMXAPI amx_Cleanup(AMX *amx)
+{
+  #if (defined _Windows || defined __LINUX__ || defined __FreeBSD__ || defined __OpenBSD__ || defined __APPLE__) && !defined AMX_NODYNALOAD
+    AMX_HEADER *hdr;
+    int numlibraries,i;
+    AMX_FUNCSTUB *lib;
+    AMX_ENTRY libcleanup;
+  #endif
+
+  /* unload all extension modules */
+  #if (defined _Windows || defined __LINUX__ || defined __FreeBSD__ || defined __OpenBSD__ || defined __APPLE__) && !defined AMX_NODYNALOAD
+    hdr=(AMX_HEADER *)amx->base;
+    assert(hdr->magic==AMX_MAGIC);
+    numlibraries=NUMENTRIES(hdr,libraries,pubvars);
+    for (i=0; i<numlibraries; i++) {
+      lib=GETENTRY(hdr,libraries,i);
+      if (lib->address!=0) {
+        char funcname[sNAMEMAX+12]; /* +1 for '\0', +4 for 'amx_', +7 for 'Cleanup' */
+        strcpy(funcname,"amx_");
+        strcat(funcname,GETENTRYNAME(hdr,lib));
+        strcat(funcname,"Cleanup");
+        #if defined _Windows
+          libcleanup=(AMX_ENTRY)GetProcAddress((HINSTANCE)lib->address,funcname);
+        #elif defined __LINUX__ || defined __FreeBSD__ || defined __OpenBSD__ || defined __APPLE__
+          libcleanup=(AMX_ENTRY)dlsym((void*)(intptr_t)lib->address,funcname);
+        #endif
+        if (libcleanup!=NULL)
+          libcleanup(amx);
+        #if defined _Windows
+          FreeLibrary((HINSTANCE)lib->address);
+        #elif defined __LINUX__ || defined __FreeBSD__ || defined __OpenBSD__ || defined __APPLE__
+          dlclose((void*)(intptr_t)lib->address);
+        #endif
+      } /* if */
+    } /* for */
+  #else
+    (void)amx;
+  #endif
+  return AMX_ERR_NONE;
+}
+#endif /* AMX_CLEANUP */
+
+#if defined AMX_CLONE
+int AMXAPI amx_Clone(AMX *amxClone, AMX *amxSource, void *data)
+{
+  AMX_HEADER *hdr;
+  unsigned char _FAR *dataSource;
+
+  if (amxSource==NULL)
+    return AMX_ERR_FORMAT;
+  if (amxClone==NULL)
+    return AMX_ERR_PARAMS;
+  if ((amxSource->flags & AMX_FLAG_INIT)==0)
+    return AMX_ERR_INIT;
+  hdr=(AMX_HEADER *)amxSource->base;
+  if (hdr->magic!=AMX_MAGIC)
+    return AMX_ERR_FORMAT;
+  if (hdr->file_version>CUR_FILE_VERSION || hdr->amx_version<MIN_FILE_VERSION)
+    return AMX_ERR_VERSION;
+
+  /* set initial values */
+  amxClone->base=amxSource->base;
+  amxClone->code=amxSource->code;
+  amxClone->codesize=amxSource->codesize;
+  amxClone->hlw=hdr->hea - hdr->dat; /* stack and heap relative to data segment */
+  amxClone->stp=hdr->stp - hdr->dat - sizeof(cell);
+  amxClone->hea=amxClone->hlw;
+  amxClone->stk=amxClone->stp;
+  if (amxClone->callback==NULL)
+    amxClone->callback=amxSource->callback;
+  if (amxClone->debug==NULL)
+    amxClone->debug=amxSource->debug;
+  amxClone->flags=amxSource->flags;
+
+  /* copy the data segment; the stack and the heap can be left uninitialized */
+  assert(data!=NULL);
+  amxClone->data=(unsigned char _FAR *)data;
+  dataSource=(amxSource->data!=NULL) ? amxSource->data : amxSource->base+(int)hdr->dat;
+  memcpy(amxClone->data,dataSource,(size_t)(hdr->hea-hdr->dat));
+
+  /* Set a zero cell at the top of the stack, which functions
+   * as a sentinel for strings.
+   */
+  * (cell *)(amxClone->data+(int)amxClone->stp) = 0;
+
+  return AMX_ERR_NONE;
+}
+#endif /* AMX_CLONE */
+
+#if defined AMX_MEMINFO
+int AMXAPI amx_MemInfo(AMX *amx, long *codesize, long *datasize, long *stackheap)
+{
+  AMX_HEADER *hdr;
+
+  if (amx==NULL)
+    return AMX_ERR_FORMAT;
+  hdr=(AMX_HEADER *)amx->base;
+  if (hdr->magic!=AMX_MAGIC)
+    return AMX_ERR_FORMAT;
+  if (hdr->file_version>CUR_FILE_VERSION || hdr->amx_version<MIN_FILE_VERSION)
+    return AMX_ERR_VERSION;
+
+  if (codesize!=NULL)
+    *codesize=amx->codesize;
+  if (datasize!=NULL)
+    *datasize=hdr->hea - hdr->dat;
+  if (stackheap!=NULL)
+    *stackheap=hdr->stp - hdr->hea;
+
+  return AMX_ERR_NONE;
+}
+#endif /* AMX_MEMINFO */
+
+#if defined AMX_NAMELENGTH
+int AMXAPI amx_NameLength(AMX *amx, int *length)
+{
+  AMX_HEADER *hdr;
+  uint16_t *namelength;
+
+  assert(amx!=NULL);
+  hdr=(AMX_HEADER *)amx->base;
+  assert(hdr!=NULL);
+  assert(hdr->magic==AMX_MAGIC);
+  namelength=(uint16_t*)(amx->base + (unsigned)hdr->nametable);
+  *length=*namelength;
+  return AMX_ERR_NONE;
+}
+#endif /* AMX_NAMELENGTH */
+
+#if defined AMX_XXXNATIVES
+int AMXAPI amx_NumNatives(AMX *amx, int *number)
+{
+  AMX_HEADER *hdr=(AMX_HEADER *)amx->base;
+  assert(hdr!=NULL);
+  assert(hdr->magic==AMX_MAGIC);
+  assert(hdr->natives<=hdr->libraries);
+  *number=NUMENTRIES(hdr,natives,libraries);
+  return AMX_ERR_NONE;
+}
+
+int AMXAPI amx_GetNative(AMX *amx, int index, char *name)
+{
+  AMX_HEADER *hdr;
+  AMX_FUNCSTUB *func;
+
+  hdr=(AMX_HEADER *)amx->base;
+  assert(hdr!=NULL);
+  assert(hdr->magic==AMX_MAGIC);
+  assert(hdr->natives<=hdr->libraries);
+  if (index>=(cell)NUMENTRIES(hdr,natives,libraries))
+    return AMX_ERR_INDEX;
+
+  func=GETENTRY(hdr,natives,index);
+  strcpy(name,GETENTRYNAME(hdr,func));
+  return AMX_ERR_NONE;
+}
+
+int AMXAPI amx_FindNative(AMX *amx, const char *name, int *index)
+{
+  int idx,last;
+  char pname[sNAMEMAX+1];
+
+  amx_NumNatives(amx, &last);
+  /* linear search, the natives table is not sorted alphabetically */
+  for (idx=0; idx<last; idx++) {
+    amx_GetNative(amx,idx,pname);
+    if (strcmp(pname,name)==0) {
+      *index=idx;
+      return AMX_ERR_NONE;
+    } /* if */
+  } /* for */
+  *index=INT_MAX;
+  return AMX_ERR_NOTFOUND;
+}
+#endif /* AMX_XXXNATIVES */
+
+#if defined AMX_XXXPUBLICS
+int AMXAPI amx_NumPublics(AMX *amx, int *number)
+{
+  AMX_HEADER *hdr=(AMX_HEADER *)amx->base;
+  assert(hdr!=NULL);
+  assert(hdr->magic==AMX_MAGIC);
+  assert(hdr->publics<=hdr->natives);
+  *number=NUMENTRIES(hdr,publics,natives);
+  return AMX_ERR_NONE;
+}
+
+int AMXAPI amx_GetPublic(AMX *amx, int index, char *name, ucell *address)
+{
+  AMX_HEADER *hdr;
+  AMX_FUNCSTUB *func;
+
+  hdr=(AMX_HEADER *)amx->base;
+  assert(hdr!=NULL);
+  assert(hdr->magic==AMX_MAGIC);
+  assert(hdr->publics<=hdr->natives);
+  if (index>=(cell)NUMENTRIES(hdr,publics,natives))
+    return AMX_ERR_INDEX;
+
+  func=GETENTRY(hdr,publics,index);
+  if (name!=NULL)
+    strcpy(name,GETENTRYNAME(hdr,func));
+  if (address!=NULL)
+    *address=func->address;
+  return AMX_ERR_NONE;
+}
+
+int AMXAPI amx_FindPublic(AMX *amx, const char *name, int *index)
+{
+  int first,last,mid,result;
+  char pname[sNAMEMAX+1];
+
+  amx_NumPublics(amx, &last);
+  last--;       /* last valid index is 1 less than the number of functions */
+  first=0;
+  /* binary search */
+  while (first<=last) {
+    mid=(first+last)/2;
+    amx_GetPublic(amx,mid,pname,NULL);
+    result=strcmp(pname,name);
+    if (result>0) {
+      last=mid-1;
+    } else if (result<0) {
+      first=mid+1;
+    } else {
+      *index=mid;
+      return AMX_ERR_NONE;
+    } /* if */
+  } /* while */
+  /* not found, set to an invalid index, so amx_Exec() on this index will fail
+   * with an error
+   */
+  *index=INT_MAX;
+  return AMX_ERR_NOTFOUND;
+}
+#endif /* AMX_XXXPUBLICS */
+
+#if defined AMX_XXXPUBVARS
+int AMXAPI amx_NumPubVars(AMX *amx, int *number)
+{
+  AMX_HEADER *hdr;
+
+  assert(amx!=NULL);
+  hdr=(AMX_HEADER *)amx->base;
+  assert(hdr!=NULL);
+  assert(hdr->magic==AMX_MAGIC);
+  assert(hdr->pubvars<=hdr->tags);
+  *number=NUMENTRIES(hdr,pubvars,tags);
+  return AMX_ERR_NONE;
+}
+
+int AMXAPI amx_GetPubVar(AMX *amx, int index, char *name, cell **address)
+{
+  AMX_HEADER *hdr;
+  AMX_FUNCSTUB *var;
+  unsigned char *data;
+
+  assert(amx!=NULL);
+  hdr=(AMX_HEADER *)amx->base;
+  assert(hdr!=NULL);
+  assert(hdr->magic==AMX_MAGIC);
+  assert(hdr->pubvars<=hdr->tags);
+  if (index>=(cell)NUMENTRIES(hdr,pubvars,tags))
+    return AMX_ERR_INDEX;
+
+  var=GETENTRY(hdr,pubvars,index);
+  strcpy(name,GETENTRYNAME(hdr,var));
+  data=(amx->data!=NULL) ? amx->data : amx->base+(int)hdr->dat;
+  assert(address!=NULL);
+  *address=(cell *)(data+(int)var->address);
+  return AMX_ERR_NONE;
+}
+
+int AMXAPI amx_FindPubVar(AMX *amx, const char *name, cell **address)
+{
+  int first,last,mid,result;
+  char pname[sNAMEMAX+1];
+
+  amx_NumPubVars(amx,&last);
+  last--;       /* last valid index is 1 less than the number of functions */
+  first=0;
+  /* binary search */
+  while (first<=last) {
+    mid=(first+last)/2;
+    amx_GetPubVar(amx,mid,pname,address);
+    result=strcmp(pname,name);
+    if (result>0)
+      last=mid-1;
+    else if (result<0)
+      first=mid+1;
+    else
+      return AMX_ERR_NONE;
+  } /* while */
+  /* not found */
+  assert(address!=NULL);
+  *address=NULL;
+  return AMX_ERR_NOTFOUND;
+}
+#endif /* AMX_XXXPUBVARS */
+
+#if defined AMX_XXXTAGS
+int AMXAPI amx_NumTags(AMX *amx, int *number)
+{
+  AMX_HEADER *hdr=(AMX_HEADER *)amx->base;
+  assert(hdr!=NULL);
+  assert(hdr->magic==AMX_MAGIC);
+  if (hdr->file_version<5) {    /* the tagname table appeared in file format 5 */
+    *number=0;
+    return AMX_ERR_VERSION;
+  } /* if */
+  if (hdr->file_version<7) {    /* file version 7 introduced the name table */
+    assert(hdr->tags<=hdr->cod);
+    *number=NUMENTRIES(hdr,tags,cod);
+  } else {
+    assert(hdr->tags<=hdr->nametable);
+    *number=NUMENTRIES(hdr,tags,nametable);
+  } /* if */
+  return AMX_ERR_NONE;
+}
+
+int AMXAPI amx_GetTag(AMX *amx, int index, char *tagname, cell *tag_id)
+{
+  AMX_HEADER *hdr;
+  AMX_FUNCSTUB *tag;
+
+  hdr=(AMX_HEADER *)amx->base;
+  assert(hdr!=NULL);
+  assert(hdr->magic==AMX_MAGIC);
+  if (hdr->file_version<5) {    /* the tagname table appeared in file format 5 */
+    *tagname='\0';
+    *tag_id=0;
+    return AMX_ERR_VERSION;
+  } /* if */
+
+  if (hdr->file_version<7) {    /* file version 7 introduced the name table */
+    assert(hdr->tags<=hdr->cod);
+    if (index>=(cell)NUMENTRIES(hdr,tags,cod))
+      return AMX_ERR_INDEX;
+  } else {
+    assert(hdr->tags<=hdr->nametable);
+    if (index>=(cell)NUMENTRIES(hdr,tags,nametable))
+      return AMX_ERR_INDEX;
+  } /* if */
+
+  tag=GETENTRY(hdr,tags,index);
+  strcpy(tagname,GETENTRYNAME(hdr,tag));
+  *tag_id=tag->address;
+
+  return AMX_ERR_NONE;
+}
+
+int AMXAPI amx_FindTagId(AMX *amx, cell tag_id, char *tagname)
+{
+  int first,last,mid;
+  cell mid_id;
+
+  #if !defined NDEBUG
+    /* verify that the tagname table is sorted on the tag_id */
+    amx_NumTags(amx, &last);
+    if (last>0) {
+      cell cur_id;
+      amx_GetTag(amx,0,tagname,&cur_id);
+      for (first=1; first<last; first++) {
+        amx_GetTag(amx,first,tagname,&mid_id);
+        assert(cur_id<mid_id);
+        cur_id=mid_id;
+      } /* for */
+    } /* if */
+  #endif
+
+  amx_NumTags(amx, &last);
+  last--;       /* last valid index is 1 less than the number of functions */
+  first=0;
+  /* binary search */
+  while (first<=last) {
+    mid=(first+last)/2;
+    amx_GetTag(amx,mid,tagname,&mid_id);
+    if (mid_id>tag_id)
+      last=mid-1;
+    else if (mid_id<tag_id)
+      first=mid+1;
+    else
+      return AMX_ERR_NONE;
+  } /* while */
+  /* not found */
+  *tagname='\0';
+  return AMX_ERR_NOTFOUND;
+}
+#endif /* AMX_XXXTAGS */
+
+#if defined AMX_XXXUSERDATA
+int AMXAPI amx_GetUserData(AMX *amx, long tag, void **ptr)
+{
+  int index;
+
+  assert(amx!=NULL);
+  assert(tag!=0);
+  for (index=0; index<AMX_USERNUM && amx->usertags[index]!=tag; index++)
+    /* nothing */;
+  if (index>=AMX_USERNUM)
+    return AMX_ERR_USERDATA;
+  *ptr=amx->userdata[index];
+  return AMX_ERR_NONE;
+}
+
+int AMXAPI amx_SetUserData(AMX *amx, long tag, void *ptr)
+{
+  int index;
+
+  assert(amx!=NULL);
+  assert(tag!=0);
+  /* try to find existing tag */
+  for (index=0; index<AMX_USERNUM && amx->usertags[index]!=tag; index++)
+    /* nothing */;
+  /* if not found, try to find empty tag */
+  if (index>=AMX_USERNUM)
+    for (index=0; index<AMX_USERNUM && amx->usertags[index]!=0; index++)
+      /* nothing */;
+  /* if still not found, quit with error */
+  if (index>=AMX_USERNUM)
+    return AMX_ERR_INDEX;
+  /* set the tag and the value */
+  amx->usertags[index]=tag;
+  amx->userdata[index]=ptr;
+  return AMX_ERR_NONE;
+}
+#endif /* AMX_XXXUSERDATA */
+
+#if defined AMX_REGISTER
+static AMX_NATIVE findfunction(char *name, const AMX_NATIVE_INFO *list, int number)
+{
+  int i;
+
+  assert(list!=NULL);
+  for (i=0; list[i].name!=NULL && (i<number || number==-1); i++)
+    if (strcmp(name,list[i].name)==0)
+      return list[i].func;
+  return NULL;
+}
+
+int AMXAPI amx_Register(AMX *amx, const AMX_NATIVE_INFO *list, int number)
+{
+  AMX_FUNCSTUB *func;
+  AMX_HEADER *hdr;
+  int i,numnatives,err;
+  AMX_NATIVE funcptr;
+
+  assert(amx!=NULL);
+  hdr=(AMX_HEADER *)amx->base;
+  assert(hdr!=NULL);
+  assert(hdr->magic==AMX_MAGIC);
+  assert(hdr->natives<=hdr->libraries);
+  numnatives=NUMENTRIES(hdr,natives,libraries);
+
+  err=AMX_ERR_NONE;
+  func=GETENTRY(hdr,natives,0);
+  for (i=0; i<numnatives; i++) {
+    if (func->address==0) {
+      /* this function is not yet located */
+      funcptr=(list!=NULL) ? findfunction(GETENTRYNAME(hdr,func),list,number) : NULL;
+      if (funcptr!=NULL)
+        func->address=(ucell)(intptr_t)funcptr;
+      else
+        err=AMX_ERR_NOTFOUND;
+    } /* if */
+    func=(AMX_FUNCSTUB*)((unsigned char*)func+hdr->defsize);
+  } /* for */
+  if (err==AMX_ERR_NONE)
+    amx->flags|=AMX_FLAG_NTVREG;
+  return err;
+}
+#endif /* AMX_REGISTER */
+
+#if defined AMX_NATIVEINFO
+AMX_NATIVE_INFO * AMXAPI amx_NativeInfo(const char *name, AMX_NATIVE func)
+{
+  static AMX_NATIVE_INFO n;
+  n.name=name;
+  n.func=func;
+  return &n;
+}
+#endif /* AMX_NATIVEINFO */
+
+
+#define STKMARGIN       ((cell)(16*sizeof(cell)))
+
+#if defined AMX_PUSHXXX
+
+int AMXAPI amx_Push(AMX *amx, cell value)
+{
+  AMX_HEADER *hdr;
+  unsigned char *data;
+
+  if (amx->hea+STKMARGIN>amx->stk)
+    return AMX_ERR_STACKERR;
+  hdr=(AMX_HEADER *)amx->base;
+  data=(amx->data!=NULL) ? amx->data : amx->base+(int)hdr->dat;
+  amx->stk-=sizeof(cell);
+  amx->paramcount+=1;
+  *(cell *)(data+(int)amx->stk)=value;
+  return AMX_ERR_NONE;
+}
+
+int AMXAPI amx_PushAddress(AMX *amx, cell *address)
+{
+  AMX_HEADER *hdr;
+  unsigned char *data;
+  cell xaddr;
+
+  /* reverse relocate the address */
+  assert(amx!=NULL);
+  hdr=(AMX_HEADER *)amx->base;
+  assert(hdr!=NULL);
+  assert(hdr->magic==AMX_MAGIC);
+  data=(amx->data!=NULL) ? amx->data : amx->base+(int)hdr->dat;
+  xaddr=(cell)((unsigned char*)address-data);
+  if ((ucell)xaddr>=(ucell)amx->stp)
+    return AMX_ERR_MEMACCESS;
+  return amx_Push(amx,xaddr);
+}
+
+int AMXAPI amx_PushArray(AMX *amx, cell **address, const cell array[], int numcells)
+{
+  cell xaddr,*paddr;
+  int err;
+
+  assert(amx!=NULL);
+  assert(array!=NULL);
+
+  xaddr=amx->hea; /* save, before it is modified by amx_Allot() */
+  err=amx_Allot(amx,numcells,&paddr);
+  if (err==AMX_ERR_NONE) {
+    memcpy(paddr,array,numcells*sizeof(cell));
+    err=amx_Push(amx,xaddr);
+  } /* if */
+  if (address!=NULL)
+    *address=paddr;
+  return err;
+}
+
+int AMXAPI amx_PushString(AMX *amx, cell **address, const char *string, int pack, int use_wchar)
+{
+  cell xaddr,*paddr;
+  int numcells,err;
+
+  assert(amx!=NULL);
+  assert(string!=NULL);
+
+  #if defined AMX_ANSIONLY
+    numcells=strlen(string) + 1;
+  #else
+    numcells= (int)(use_wchar ? wcslen((const wchar_t*)string) : strlen(string)) + 1;
+  #endif
+  if (pack)
+    numcells=(numcells+sizeof(cell)-1)/sizeof(cell);
+  xaddr=amx->hea; /* save, before it is modified by amx_Allot() */
+  err=amx_Allot(amx,numcells,&paddr);
+  if (err==AMX_ERR_NONE) {
+    amx_SetString(paddr,string,pack,use_wchar,numcells);
+    err=amx_Push(amx,xaddr);
+  } /* if */
+  if (address!=NULL)
+    *address=paddr;
+  return err;
+}
+#endif /* AMX_PUSHXXX */
+
+#if defined AMX_EXEC
+
+/* It is assumed that the abstract machine can simply access the memory area
+ * for the global data and the stack. If this is not the case, you need to
+ * define the macro sets _R() and _W(), for reading and writing to memory.
+ */
+#if !defined _R
+  #define _R_DEFAULT            /* mark default memory access */
+  #define _R(base,addr)         (* (cell *)((unsigned char*)(base)+(int)(addr)))
+  #define _R8(base,addr)        (* (unsigned char *)((unsigned char*)(base)+(int)(addr)))
+  #define _R16(base,addr)       (* (uint16_t *)((unsigned char*)(base)+(int)(addr)))
+  #define _R32(base,addr)       (* (uint32_t *)((unsigned char*)(base)+(int)(addr)))
+#endif
+#if !defined _W
+  #define _W_DEFAULT            /* mark default memory access */
+  #define _W(base,addr,value)   ((*(cell *)((unsigned char*)(base)+(int)(addr)))=(cell)(value))
+  #define _W8(base,addr,value)  ((*(unsigned char *)((unsigned char*)(base)+(int)(addr)))=(unsigned char)(value))
+  #define _W16(base,addr,value) ((*(uint16_t *)((unsigned char*)(base)+(int)(addr)))=(uint16_t)(value))
+  #define _W32(base,addr,value) ((*(uint32_t *)((unsigned char*)(base)+(int)(addr)))=(uint32_t)(value))
+#endif
+
+#if -8/3==-2 && 8/-3==-2
+  #define TRUNC_SDIV    /* signed divisions are truncated on this platform */
+#else
+  #define IABS(a)       ((a)>=0 ? (a) : (-a))
+#endif
+
+/* The pseudo-instructions come from the code stream. Normally, these are just
+ * accessed from memory. When the instructions must be fetched in some other
+ * way, the definition below must be pre-defined.
+ * N.B.:
+ *   - reading from a code address should increment the instruction pointer
+ *     (called "cip")
+ *   - only cell-sized accesses occur in code memory
+ */
+#if !defined _RCODE
+  #define _RCODE()      ( *cip++ )
+#endif
+
+#if !defined GETPARAM
+  #define GETPARAM(v)   ( v=_RCODE() )   /* read a parameter from the opcode stream */
+#endif
+#if !defined SKIPPARAM
+  #define SKIPPARAM(n)  ( cip=(cell *)cip+(n) ) /* for obsolete opcodes */
+#endif
+
+#define AMXPUSH(v)      ( amx->stk-=sizeof(cell), *(cell*)(data+amx->stk)=(v) )
+#define ABORT(amx,v)    { (amx)->stk=reset_stk; (amx)->hea=reset_hea; return v; }
+
+
+#if !defined AMX_ALTCORE
+int amx_exec_list(AMX *amx,const cell **opcodelist,int *numopcodes)
+{
+  (void)amx;
+  assert(opcodelist!=NULL);
+  *opcodelist=NULL;
+  assert(numopcodes!=NULL);
+  *numopcodes=OP_NUM_OPCODES;
+  return 0;
+}
+#endif
+
+int AMXAPI amx_Exec(AMX *amx, cell *retval, int index)
+{
+  AMX_HEADER *hdr;
+  AMX_FUNCSTUB *func;
+  unsigned char *data;
+  cell reset_stk,reset_hea;
+  int i;
+#if !defined AMX_ALTCORE
+  cell pri,alt,stk,frm,hea;
+  cell *cip,op,offs,val;
+#endif
+
+  assert(amx!=NULL);
+  if ((amx->flags & AMX_FLAG_INIT)==0)
+    return AMX_ERR_INIT;
+  if (amx->callback==NULL)
+    return AMX_ERR_CALLBACK;
+
+  hdr=(AMX_HEADER *)amx->base;
+  assert(hdr!=NULL);
+  assert(hdr->magic==AMX_MAGIC);
+
+  if ((amx->flags & AMX_FLAG_NTVREG)==0) {
+    /* verify that all native functions have been registered (or do not
+     * need registering)
+     */
+    int numnatives;
+    assert(hdr->natives<=hdr->libraries);
+    numnatives=NUMENTRIES(hdr,natives,libraries);
+    func=GETENTRY(hdr,natives,0);
+    for (i=0; i<numnatives && func->address!=0; i++)
+      func=(AMX_FUNCSTUB*)((unsigned char*)func+hdr->defsize);
+    if (i<numnatives)
+      return AMX_ERR_NOTFOUND;
+    amx->flags|=AMX_FLAG_NTVREG;  /* no need to check this again */
+  } /* if */
+  assert((amx->flags & AMX_FLAG_VERIFY)==0);
+
+  /* set up the registers */
+  assert(hdr!=NULL && hdr->magic==AMX_MAGIC);
+  assert(amx->code!=NULL || hdr->overlays!=hdr->nametable);
+  data=(amx->data!=NULL) ? amx->data : amx->base+(int)hdr->dat;
+  reset_stk=amx->stk;
+  reset_hea=amx->hea;
+  amx->error=AMX_ERR_NONE;
+
+  /* get the start address */
+  if (index==AMX_EXEC_MAIN) {
+    if (hdr->cip<0)
+      return AMX_ERR_INDEX;
+    amx->cip=hdr->cip;
+    if (hdr->overlays!=hdr->nametable) {
+      assert(hdr->overlays!=0);
+      assert(amx->overlay!=NULL);
+      amx->ovl_index=(int)hdr->cip;
+      if ((i=amx->overlay(amx,amx->ovl_index))!=AMX_ERR_NONE)
+        return i;
+      amx->cip=0;
+    } /* if */
+  } else if (index==AMX_EXEC_CONT) {
+    /* restore registers reset_stk & reset_hea */
+    reset_stk=amx->reset_stk;
+    reset_hea=amx->reset_hea;
+    if (hdr->overlays!=hdr->nametable) {
+      assert(hdr->overlays!=0);
+      assert(amx->overlay!=NULL);
+      if ((i=amx->overlay(amx,amx->ovl_index))!=AMX_ERR_NONE)
+        return i;
+    } /* if */
+  } else if (index<0) {
+    return AMX_ERR_INDEX;
+  } else {
+    if (index>=(int)NUMENTRIES(hdr,publics,natives))
+      return AMX_ERR_INDEX;
+    func=GETENTRY(hdr,publics,index);
+    amx->cip=func->address;
+    if (hdr->overlays!=hdr->nametable) {
+      assert(hdr->overlays!=0);
+      assert(amx->overlay!=NULL);
+      amx->ovl_index=func->address;
+      if ((i=amx->overlay(amx,amx->ovl_index))!=AMX_ERR_NONE)
+        return i;
+      amx->cip=0;
+    } /* if */
+  } /* if */
+  /* check values just copied */
+  if (amx->stk>amx->stp)
+    return AMX_ERR_STACKLOW;
+  if (amx->hea<amx->hlw)
+    return AMX_ERR_HEAPLOW;
+  assert(check_endian());
+
+  /* sanity checks */
+  assert_static(OP_XCHG==21);
+  assert_static(OP_SMUL==42);
+  assert_static(OP_MOVS==64);
+  #if !defined AMX_NO_MACRO_INSTR
+    assert_static(OP_LIDX==81);
+    assert_static(OP_ZERO_PRI==102);
+    assert_static(OP_LOAD2==120);
+  #endif
+  #if !defined AMX_NO_PACKED_OPC
+    assert_static(OP_LOAD_P_PRI==124);
+    assert_static(OP_ALIGN_P_PRI==141);
+    assert_static(OP_BOUNDS_P==174);
+  #endif
+  #if PAWN_CELL_SIZE==16
+    assert_static(sizeof(cell)==2);
+  #elif PAWN_CELL_SIZE==32
+    assert_static(sizeof(cell)==4);
+  #elif PAWN_CELL_SIZE==64
+    assert_static(sizeof(cell)==8);
+  #else
+    #error Unsupported cell size
+  #endif
+
+  if (index!=AMX_EXEC_CONT) {
+    reset_stk+=amx->paramcount*sizeof(cell);
+    AMXPUSH(amx->paramcount*sizeof(cell));
+    amx->paramcount=0;          /* push the parameter count to the stack & reset */
+    AMXPUSH(0);                 /* return address (for overlays: overlay 0, offset 0) */
+  } /* if */
+  /* check stack/heap before starting to run */
+  if (amx->hea+STKMARGIN>amx->stk)
+    return AMX_ERR_STACKERR;
+
+#if defined AMX_ALTCORE
+
+  /* start running either the ARM or 80x86 assembler abstract machine or the JIT */
+  #if defined AMX_ASM && defined AMX_JIT
+    if ((amx->flags & AMX_FLAG_JITC)!=0)
+      i = amx_jit_run(amx,retval,data);
+    else
+      i = amx_exec_run(amx,retval,data);
+  #elif defined AMX_JIT
+    i = amx_jit_run(amx,retval,data);
+  #else
+    /* also for GNU GCC and Intel C/C++ versions */
+    i = amx_exec_run(amx,retval,data);
+  #endif
+  if (i == AMX_ERR_SLEEP) {
+    amx->reset_stk=reset_stk;
+    amx->reset_hea=reset_hea;
+  } else {
+    /* remove parameters from the stack; do this the "hard" way, because
+     * the assembler version has no internal knowledge of the local
+     * variables, so any "clean" way would be a kludge anyway.
+     */
+    amx->stk=reset_stk;
+    amx->hea=reset_hea;
+  } /* if */
+  return i;
+
+#else
+
+  #define CHKMARGIN()   if (hea+STKMARGIN>stk) return AMX_ERR_STACKERR
+  #define CHKSTACK()    if (stk>amx->stp) return AMX_ERR_STACKLOW
+  #define CHKHEAP()     if (hea<amx->hlw) return AMX_ERR_HEAPLOW
+
+  /* PUSH() and POP() are defined in terms of the _R() and _W() macros */
+  #define PUSH(v)       ( stk-=sizeof(cell), _W(data,stk,v) )
+  #define POP(v)        ( v=_R(data,stk), stk+=sizeof(cell) )
+
+  /* set up registers for ANSI-C core: pri, alt, frm, cip, hea, stk */
+  pri=amx->pri;
+  alt=amx->alt;
+  frm=amx->frm;
+  cip=(cell *)(amx->code+(int)amx->cip);
+  hea=amx->hea;
+  stk=amx->stk;
+
+  /* start running */
+  for ( ;; ) {
+    op=_RCODE();
+    switch (GETOPCODE(op)) {
+    /* core instruction set */
+    case OP_NOP:
+      break;
+    case OP_LOAD_PRI:
+      GETPARAM(offs);
+      pri=_R(data,offs);
+      break;
+    case OP_LOAD_ALT:
+      GETPARAM(offs);
+      alt=_R(data,offs);
+      break;
+    case OP_LOAD_S_PRI:
+      GETPARAM(offs);
+      pri=_R(data,frm+offs);
+      break;
+    case OP_LOAD_S_ALT:
+      GETPARAM(offs);
+      alt=_R(data,frm+offs);
+      break;
+    case OP_LREF_S_PRI:
+      GETPARAM(offs);
+      offs=_R(data,frm+offs);
+      pri=_R(data,offs);
+      break;
+    case OP_LREF_S_ALT:
+      GETPARAM(offs);
+      offs=_R(data,frm+offs);
+      alt=_R(data,offs);
+      break;
+    case OP_LOAD_I:
+      /* verify address */
+      if (pri>=hea && pri<stk || (ucell)pri>=(ucell)amx->stp)
+        ABORT(amx,AMX_ERR_MEMACCESS);
+      pri=_R(data,pri);
+      break;
+    case OP_LODB_I:
+      GETPARAM(offs);
+    __lodb_i:
+      /* verify address */
+      if (pri>=hea && pri<stk || (ucell)pri>=(ucell)amx->stp)
+        ABORT(amx,AMX_ERR_MEMACCESS);
+      switch ((int)offs) {
+      case 1:
+        pri=_R8(data,pri);
+        break;
+      case 2:
+        pri=_R16(data,pri);
+        break;
+      case 4:
+        pri=_R32(data,pri);
+        break;
+      } /* switch */
+      break;
+    case OP_CONST_PRI:
+      GETPARAM(pri);
+      break;
+    case OP_CONST_ALT:
+      GETPARAM(alt);
+      break;
+    case OP_ADDR_PRI:
+      GETPARAM(pri);
+      pri+=frm;
+      break;
+    case OP_ADDR_ALT:
+      GETPARAM(alt);
+      alt+=frm;
+      break;
+    case OP_STOR:
+      GETPARAM(offs);
+      _W(data,offs,pri);
+      break;
+    case OP_STOR_S:
+      GETPARAM(offs);
+      _W(data,frm+offs,pri);
+      break;
+    case OP_SREF_S:
+      GETPARAM(offs);
+      offs=_R(data,frm+offs);
+      _W(data,offs,pri);
+      break;
+    case OP_STOR_I:
+      /* verify address */
+      if (alt>=hea && alt<stk || (ucell)alt>=(ucell)amx->stp)
+        ABORT(amx,AMX_ERR_MEMACCESS);
+      _W(data,alt,pri);
+      break;
+    case OP_STRB_I:
+      GETPARAM(offs);
+    __strb_i:
+      /* verify address */
+      if (alt>=hea && alt<stk || (ucell)alt>=(ucell)amx->stp)
+        ABORT(amx,AMX_ERR_MEMACCESS);
+      switch ((int)offs) {
+      case 1:
+        _W8(data,alt,pri);
+        break;
+      case 2:
+        _W16(data,alt,pri);
+        break;
+      case 4:
+        _W32(data,alt,pri);
+        break;
+      } /* switch */
+      break;
+    case OP_ALIGN_PRI:
+      GETPARAM(offs);
+      #if BYTE_ORDER==LITTLE_ENDIAN
+        if ((size_t)offs<sizeof(cell))
+          pri ^= sizeof(cell)-offs;
+      #endif
+      break;
+    case OP_LCTRL:
+      GETPARAM(offs);
+      switch ((int)offs) {
+      case 0:
+        pri=hdr->cod;
+        break;
+      case 1:
+        pri=hdr->dat;
+        break;
+      case 2:
+        pri=hea;
+        break;
+      case 3:
+        pri=amx->stp;
+        break;
+      case 4:
+        pri=stk;
+        break;
+      case 5:
+        pri=frm;
+        break;
+      case 6:
+        pri=(cell)((unsigned char *)cip-amx->code);
+        break;
+      } /* switch */
+      break;
+    case OP_SCTRL:
+      GETPARAM(offs);
+      switch ((int)offs) {
+      case 0:
+      case 1:
+      case 3:
+        /* cannot change these parameters */
+        break;
+      case 2:
+        hea=pri;
+        break;
+      case 4:
+        stk=pri;
+        break;
+      case 5:
+        frm=pri;
+        break;
+      case 6:
+        cip=(cell *)(amx->code + (int)pri);
+        break;
+      } /* switch */
+      break;
+    case OP_XCHG:
+      offs=pri;         /* offs is a temporary variable */
+      pri=alt;
+      alt=offs;
+      break;
+    case OP_PUSH_PRI:
+      PUSH(pri);
+      break;
+    case OP_PUSH_ALT:
+      PUSH(alt);
+      break;
+    case OP_PUSHR_PRI:
+      PUSH((intptr_t)data+pri);
+      break;
+    case OP_POP_PRI:
+      POP(pri);
+      break;
+    case OP_POP_ALT:
+      POP(alt);
+      break;
+    case OP_PICK:
+      GETPARAM(offs);
+      pri=_R(data,stk+offs);
+      break;
+    case OP_STACK:
+      GETPARAM(offs);
+      alt=stk;
+      stk+=offs;
+      CHKMARGIN();
+      CHKSTACK();
+      break;
+    case OP_HEAP:
+      GETPARAM(offs);
+      alt=hea;
+      hea+=offs;
+      CHKMARGIN();
+      CHKHEAP();
+      break;
+    case OP_PROC:
+      PUSH(frm);
+      frm=stk;
+      CHKMARGIN();
+      break;
+    case OP_RET:
+      POP(frm);
+      POP(offs);
+      /* verify the return address */
+      if ((long)offs>=amx->codesize)
+        ABORT(amx,AMX_ERR_MEMACCESS);
+      cip=(cell *)(amx->code+(int)offs);
+      break;
+    case OP_RETN:
+      POP(frm);
+      POP(offs);
+      /* verify the return address */
+      if ((long)offs>=amx->codesize)
+        ABORT(amx,AMX_ERR_MEMACCESS);
+      cip=(cell *)(amx->code+(int)offs);
+      stk+=_R(data,stk)+sizeof(cell);   /* remove parameters from the stack */
+      break;
+    case OP_CALL:
+      PUSH(((unsigned char *)cip-amx->code)+sizeof(cell));/* skip address */
+      cip=JUMPREL(cip);                 /* jump to the address */
+      break;
+    case OP_JUMP:
+      /* since the GETPARAM() macro modifies cip, you cannot
+       * do GETPARAM(cip) directly */
+      cip=JUMPREL(cip);
+      break;
+    case OP_JZER:
+      if (pri==0)
+        cip=JUMPREL(cip);
+      else
+        SKIPPARAM(1);
+      break;
+    case OP_JNZ:
+      if (pri!=0)
+        cip=JUMPREL(cip);
+      else
+        SKIPPARAM(1);
+      break;
+    case OP_SHL:
+      pri<<=alt;
+      break;
+    case OP_SHR:
+      pri=(ucell)pri >> (int)alt;
+      break;
+    case OP_SSHR:
+      pri>>=alt;
+      break;
+    case OP_SHL_C_PRI:
+      GETPARAM(offs);
+      pri<<=offs;
+      break;
+    case OP_SHL_C_ALT:
+      GETPARAM(offs);
+      alt<<=offs;
+      break;
+    case OP_SMUL:
+      pri*=alt;
+      break;
+    case OP_SDIV:
+      if (pri==0)
+        ABORT(amx,AMX_ERR_DIVIDE);
+      /* use floored division and matching remainder */
+      offs=pri;
+      #if defined TRUNC_SDIV
+        pri=alt/offs;
+        alt=alt%offs;
+      #else
+        val=alt;                /* portable routine for truncated division */
+        pri=IABS(alt)/IABS(offs);
+        if ((cell)(val ^ offs)<0)
+          pri=-pri;
+        alt=val-pri*offs;       /* calculate the matching remainder */
+      #endif
+      /* now "fiddle" with the values to get floored division */
+      if (alt!=0 && (cell)(alt ^ offs)<0) {
+        pri--;
+        alt+=offs;
+      } /* if */
+      break;
+    case OP_ADD:
+      pri+=alt;
+      break;
+    case OP_SUB:
+      pri=alt-pri;
+      break;
+    case OP_AND:
+      pri&=alt;
+      break;
+    case OP_OR:
+      pri|=alt;
+      break;
+    case OP_XOR:
+      pri^=alt;
+      break;
+    case OP_NOT:
+      pri=!pri;
+      break;
+    case OP_NEG:
+      pri=-pri;
+      break;
+    case OP_INVERT:
+      pri=~pri;
+      break;
+    case OP_EQ:
+      pri= pri==alt ? 1 : 0;
+      break;
+    case OP_NEQ:
+      pri= pri!=alt ? 1 : 0;
+      break;
+    case OP_SLESS:
+      pri= pri<alt ? 1 : 0;
+      break;
+    case OP_SLEQ:
+      pri= pri<=alt ? 1 : 0;
+      break;
+    case OP_SGRTR:
+      pri= pri>alt ? 1 : 0;
+      break;
+    case OP_SGEQ:
+      pri= pri>=alt ? 1 : 0;
+      break;
+    case OP_INC_PRI:
+      pri++;
+      break;
+    case OP_INC_ALT:
+      alt++;
+      break;
+    case OP_INC_I:
+      #if defined _R_DEFAULT
+        *(cell *)(data+(int)pri) += 1;
+      #else
+        val=_R(data,pri);
+        _W(data,pri,val+1);
+      #endif
+      break;
+    case OP_DEC_PRI:
+      pri--;
+      break;
+    case OP_DEC_ALT:
+      alt--;
+      break;
+    case OP_DEC_I:
+      #if defined _R_DEFAULT
+        *(cell *)(data+(int)pri) -= 1;
+      #else
+        val=_R(data,pri);
+        _W(data,pri,val-1);
+      #endif
+      break;
+    case OP_MOVS:
+      GETPARAM(offs);
+    __movs:
+      /* verify top & bottom memory addresses, for both source and destination
+       * addresses
+       */
+      if (pri>=hea && pri<stk || (ucell)pri>=(ucell)amx->stp)
+        ABORT(amx,AMX_ERR_MEMACCESS);
+      if ((pri+offs)>hea && (pri+offs)<stk || (ucell)(pri+offs)>(ucell)amx->stp)
+        ABORT(amx,AMX_ERR_MEMACCESS);
+      if (alt>=hea && alt<stk || (ucell)alt>=(ucell)amx->stp)
+        ABORT(amx,AMX_ERR_MEMACCESS);
+      if ((alt+offs)>hea && (alt+offs)<stk || (ucell)(alt+offs)>(ucell)amx->stp)
+        ABORT(amx,AMX_ERR_MEMACCESS);
+      #if defined _R_DEFAULT
+        memcpy(data+(int)alt, data+(int)pri, (int)offs);
+      #else
+        for (i=0; i+4<offs; i+=4) {
+          val=_R32(data,pri+i);
+          _W32(data,alt+i,val);
+        } /* for */
+        for ( ; i<offs; i++) {
+          val=_R8(data,pri+i);
+          _W8(data,alt+i,val);
+        } /* for */
+      #endif
+      break;
+    case OP_CMPS:
+      GETPARAM(offs);
+    __cmps:
+      /* verify top & bottom memory addresses, for both source and destination
+       * addresses
+       */
+      if (pri>=hea && pri<stk || (ucell)pri>=(ucell)amx->stp)
+        ABORT(amx,AMX_ERR_MEMACCESS);
+      if ((pri+offs)>hea && (pri+offs)<stk || (ucell)(pri+offs)>(ucell)amx->stp)
+        ABORT(amx,AMX_ERR_MEMACCESS);
+      if (alt>=hea && alt<stk || (ucell)alt>=(ucell)amx->stp)
+        ABORT(amx,AMX_ERR_MEMACCESS);
+      if ((alt+offs)>hea && (alt+offs)<stk || (ucell)(alt+offs)>(ucell)amx->stp)
+        ABORT(amx,AMX_ERR_MEMACCESS);
+      #if defined _R_DEFAULT
+        pri=memcmp(data+(int)alt, data+(int)pri, (int)offs);
+      #else
+        pri=0;
+        for (i=0; i+4<offs && pri==0; i+=4)
+          pri=_R32(data,alt+i)-_R32(data,pri+i);
+        for ( ; i<offs && pri==0; i++)
+          pri=_R8(data,alt+i)-_R8(data,pri+i);
+      #endif
+      break;
+    case OP_FILL:
+      GETPARAM(offs);
+    __fill:
+      /* verify top & bottom memory addresses (destination only) */
+      if (alt>=hea && alt<stk || (ucell)alt>=(ucell)amx->stp)
+        ABORT(amx,AMX_ERR_MEMACCESS);
+      if ((alt+offs)>hea && (alt+offs)<stk || (ucell)(alt+offs)>(ucell)amx->stp)
+        ABORT(amx,AMX_ERR_MEMACCESS);
+      for (i=(int)alt; (size_t)offs>=sizeof(cell); i+=sizeof(cell), offs-=sizeof(cell))
+        _W32(data,i,pri);
+      break;
+    case OP_HALT:
+      GETPARAM(offs);
+    __halt:
+      if (retval!=NULL)
+        *retval=pri;
+      /* store complete status (stk and hea are already set in the ABORT macro) */
+      amx->frm=frm;
+      amx->pri=pri;
+      amx->alt=alt;
+      amx->cip=(cell)((unsigned char*)cip-amx->code);
+      if (offs==AMX_ERR_SLEEP) {
+        amx->stk=stk;
+        amx->hea=hea;
+        amx->reset_stk=reset_stk;
+        amx->reset_hea=reset_hea;
+        return (int)offs;
+      } /* if */
+      ABORT(amx,(int)offs);
+    case OP_BOUNDS:
+      GETPARAM(offs);
+      if ((ucell)pri>(ucell)offs) {
+        amx->cip=(cell)((unsigned char *)cip-amx->code);
+        ABORT(amx,AMX_ERR_BOUNDS);
+      } /* if */
+      break;
+    case OP_SYSREQ:
+      GETPARAM(offs);
+      /* save a few registers */
+      amx->cip=(cell)((unsigned char *)cip-amx->code);
+      amx->hea=hea;
+      amx->frm=frm;
+      amx->stk=stk;
+      i=amx->callback(amx,offs,&pri,(cell *)(data+(int)stk));
+      if (i!=AMX_ERR_NONE) {
+        if (i==AMX_ERR_SLEEP) {
+          amx->pri=pri;
+          amx->alt=alt;
+          amx->reset_stk=reset_stk;
+          amx->reset_hea=reset_hea;
+          return i;
+        } /* if */
+        ABORT(amx,i);
+      } /* if */
+      break;
+    case OP_SWITCH: {
+      cell *cptr=JUMPREL(cip)+1;/* +1, to skip the "casetbl" opcode */
+      assert(*JUMPREL(cip)==OP_CASETBL);
+      cip=JUMPREL(cptr+1);      /* preset to "none-matched" case */
+      i=(int)*cptr;             /* number of records in the case table */
+      for (cptr+=2; i>0 && *cptr!=pri; i--,cptr+=2)
+        /* nothing */;
+      if (i>0)
+        cip=JUMPREL(cptr+1);    /* case found */
+      break;
+    } /* case */
+    case OP_SWAP_PRI:
+      offs=_R(data,stk);
+      _W32(data,stk,pri);
+      pri=offs;
+      break;
+    case OP_SWAP_ALT:
+      offs=_R(data,stk);
+      _W32(data,stk,alt);
+      alt=offs;
+      break;
+    case OP_BREAK:
+      assert((amx->flags & AMX_FLAG_VERIFY)==0);
+      if (amx->debug!=NULL) {
+        /* store status */
+        amx->frm=frm;
+        amx->stk=stk;
+        amx->hea=hea;
+        amx->cip=(cell)((unsigned char*)cip-amx->code);
+        i=amx->debug(amx);
+        if (i!=AMX_ERR_NONE) {
+          if (i==AMX_ERR_SLEEP) {
+            amx->pri=pri;
+            amx->alt=alt;
+            amx->reset_stk=reset_stk;
+            amx->reset_hea=reset_hea;
+            return i;
+          } /* if */
+          ABORT(amx,i);
+        } /* if */
+      } /* if */
+      break;
+#if !defined AMX_DONT_RELOCATE
+    case OP_SYSREQ_D:    /* see SYSREQ */
+      GETPARAM(offs);
+      /* save a few registers */
+      amx->cip=(cell)((unsigned char *)cip-amx->code);
+      amx->hea=hea;
+      amx->frm=frm;
+      amx->stk=stk;
+      pri=((AMX_NATIVE)(intptr_t)offs)(amx,(cell*)(data+(int)stk));
+      if (amx->error!=AMX_ERR_NONE) {
+        if (amx->error==AMX_ERR_SLEEP) {
+          amx->pri=pri;
+          amx->alt=alt;
+          amx->reset_stk=reset_stk;
+          amx->reset_hea=reset_hea;
+          return AMX_ERR_SLEEP;
+        } /* if */
+        ABORT(amx,amx->error);
+      } /* if */
+      break;
+#endif
+#if !defined AMX_NO_MACRO_INSTR && !defined AMX_DONT_RELOCATE
+    case OP_SYSREQ_ND:    /* see SYSREQ_N */
+      GETPARAM(offs);
+      GETPARAM(val);
+      PUSH(val);
+      /* save a few registers */
+      amx->cip=(cell)((unsigned char *)cip-amx->code);
+      amx->hea=hea;
+      amx->frm=frm;
+      amx->stk=stk;
+      pri=((AMX_NATIVE)(intptr_t)offs)(amx,(cell*)(data+(int)stk));
+      stk+=val+4;
+      if (amx->error!=AMX_ERR_NONE) {
+        if (amx->error==AMX_ERR_SLEEP) {
+          amx->pri=pri;
+          amx->alt=alt;
+          amx->stk=stk;
+          amx->reset_stk=reset_stk;
+          amx->reset_hea=reset_hea;
+          return AMX_ERR_SLEEP;
+        } /* if */
+        ABORT(amx,amx->error);
+      } /* if */
+      break;
+#endif
+
+    /* overlay instructions */
+#if !defined AMX_NO_OVERLAY
+    case OP_CALL_OVL:
+      offs=(cell)((unsigned char *)cip-amx->code+sizeof(cell)); /* skip address */
+      assert(offs>=0 && offs<(1<<(sizeof(cell)*4)));
+      PUSH((offs<<(sizeof(cell)*4)) | amx->ovl_index);
+      amx->ovl_index=(int)*cip;
+      assert(amx->overlay!=NULL);
+      if ((i=amx->overlay(amx,amx->ovl_index))!=AMX_ERR_NONE)
+        ABORT(amx,i);
+      cip=(cell*)amx->code;
+      break;
+    case OP_RETN_OVL:
+      assert(amx->overlay!=NULL);
+      POP(frm);
+      POP(offs);
+      amx->ovl_index=offs & (((ucell)~0)>>4*sizeof(cell));
+      offs=(ucell)offs >> (sizeof(cell)*4);
+      /* verify the index */
+      stk+=_R(data,stk)+sizeof(cell);   /* remove parameters from the stack */
+      i=amx->overlay(amx,amx->ovl_index); /* reload overlay */
+      if (i!=AMX_ERR_NONE || (long)offs>=amx->codesize)
+        ABORT(amx,AMX_ERR_MEMACCESS);
+      cip=(cell *)(amx->code+(int)offs);
+      break;
+    case OP_SWITCH_OVL: {
+      cell *cptr=JUMPREL(cip)+1;  /* +1, to skip the "icasetbl" opcode */
+      assert(*JUMPREL(cip)==OP_CASETBL_OVL);
+      amx->ovl_index=*(cptr+1);   /* preset to "none-matched" case */
+      i=(int)*cptr;               /* number of records in the case table */
+      for (cptr+=2; i>0 && *cptr!=pri; i--,cptr+=2)
+        /* nothing */;
+      if (i>0)
+        amx->ovl_index=*(cptr+1); /* case found */
+      assert(amx->overlay!=NULL);
+      if ((i=amx->overlay(amx,amx->ovl_index))!=AMX_ERR_NONE)
+        ABORT(amx,i);
+      cip=(cell*)amx->code;
+      break;
+    } /* case */
+#endif
+
+    /* supplemental and macro instructions */
+#if !defined AMX_NO_MACRO_INSTR
+    case OP_LIDX:
+      offs=pri*sizeof(cell)+alt;
+      /* verify address */
+      if (offs>=hea && offs<stk || (ucell)offs>=(ucell)amx->stp)
+        ABORT(amx,AMX_ERR_MEMACCESS);
+      pri=_R(data,offs);
+      break;
+    case OP_LIDX_B:
+      GETPARAM(offs);
+      offs=(pri << (int)offs)+alt;
+      /* verify address */
+      if (offs>=hea && offs<stk || (ucell)offs>=(ucell)amx->stp)
+        ABORT(amx,AMX_ERR_MEMACCESS);
+      pri=_R(data,offs);
+      break;
+    case OP_IDXADDR:
+      pri=pri*sizeof(cell)+alt;
+      break;
+    case OP_IDXADDR_B:
+      GETPARAM(offs);
+      pri=(pri << (int)offs)+alt;
+      break;
+    case OP_PUSH_C:
+      GETPARAM(offs);
+      PUSH(offs);
+      break;
+    case OP_PUSH:
+      GETPARAM(offs);
+      PUSH(_R(data,offs));
+      break;
+    case OP_PUSH_S:
+      GETPARAM(offs);
+      PUSH(_R(data,frm+offs));
+      break;
+    case OP_PUSH_ADR:
+      GETPARAM(offs);
+      PUSH(frm+offs);
+      break;
+    case OP_PUSHR_C:
+      GETPARAM(offs);
+      PUSH((intptr_t)data+offs);
+      break;
+    case OP_PUSHR_S:
+      GETPARAM(offs);
+      PUSH((intptr_t)data+_R(data,frm+offs));
+      break;
+    case OP_PUSHR_ADR:
+      GETPARAM(offs);
+      PUSH((intptr_t)data+frm+offs);
+      break;
+    case OP_JEQ:
+      if (pri==alt)
+        cip=JUMPREL(cip);
+      else
+        SKIPPARAM(1);
+      break;
+    case OP_JNEQ:
+      if (pri!=alt)
+        cip=JUMPREL(cip);
+      else
+        SKIPPARAM(1);
+      break;
+    case OP_JSLESS:
+      if (pri<alt)
+        cip=JUMPREL(cip);
+      else
+        SKIPPARAM(1);
+      break;
+    case OP_JSLEQ:
+      if (pri<=alt)
+        cip=JUMPREL(cip);
+      else
+        SKIPPARAM(1);
+      break;
+    case OP_JSGRTR:
+      if (pri>alt)
+        cip=JUMPREL(cip);
+      else
+        SKIPPARAM(1);
+      break;
+    case OP_JSGEQ:
+      if (pri>=alt)
+        cip=JUMPREL(cip);
+      else
+        SKIPPARAM(1);
+      break;
+    case OP_SDIV_INV:
+      if (alt==0)
+        ABORT(amx,AMX_ERR_DIVIDE);
+      /* use floored division and matching remainder */
+      offs=alt;
+      #if defined TRUNC_SDIV
+        pri=pri/offs;
+        alt=pri%offs;
+      #else
+        val=pri;                /* portable routine for truncated division */
+        pri=IABS(pri)/IABS(offs);
+        if ((cell)(val ^ offs)<0)
+          pri=-pri;
+        alt=val-pri*offs;       /* calculate the matching remainder */
+      #endif
+      /* now "fiddle" with the values to get floored division */
+      if (alt!=0 && (cell)(alt ^ offs)<0) {
+        pri--;
+        alt+=offs;
+      } /* if */
+      break;
+    case OP_SUB_INV:
+      pri-=alt;
+      break;
+    case OP_ADD_C:
+      GETPARAM(offs);
+      pri+=offs;
+      break;
+    case OP_SMUL_C:
+      GETPARAM(offs);
+      pri*=offs;
+      break;
+    case OP_ZERO_PRI:
+      pri=0;
+      break;
+    case OP_ZERO_ALT:
+      alt=0;
+      break;
+    case OP_ZERO:
+      GETPARAM(offs);
+      _W(data,offs,0);
+      break;
+    case OP_ZERO_S:
+      GETPARAM(offs);
+      _W(data,frm+offs,0);
+      break;
+    case OP_EQ_C_PRI:
+      GETPARAM(offs);
+      pri= pri==offs ? 1 : 0;
+      break;
+    case OP_EQ_C_ALT:
+      GETPARAM(offs);
+      pri= alt==offs ? 1 : 0;
+      break;
+    case OP_INC:
+      GETPARAM(offs);
+      #if defined _R_DEFAULT
+        *(cell *)(data+(int)offs) += 1;
+      #else
+        val=_R(data,offs);
+        _W(data,offs,val+1);
+      #endif
+      break;
+    case OP_INC_S:
+      GETPARAM(offs);
+      #if defined _R_DEFAULT
+        *(cell *)(data+(int)(frm+offs)) += 1;
+      #else
+        val=_R(data,frm+offs);
+        _W(data,frm+offs,val+1);
+      #endif
+      break;
+    case OP_DEC:
+      GETPARAM(offs);
+      #if defined _R_DEFAULT
+        *(cell *)(data+(int)offs) -= 1;
+      #else
+        val=_R(data,offs);
+        _W(data,offs,val-1);
+      #endif
+      break;
+    case OP_DEC_S:
+      GETPARAM(offs);
+      #if defined _R_DEFAULT
+        *(cell *)(data+(int)(frm+offs)) -= 1;
+      #else
+        val=_R(data,frm+offs);
+        _W(data,frm+offs,val-1);
+      #endif
+      break;
+    case OP_SYSREQ_N:
+      GETPARAM(offs);
+      GETPARAM(val);
+      PUSH(val);
+      /* save a few registers */
+      amx->cip=(cell)((unsigned char *)cip-amx->code);
+      amx->hea=hea;
+      amx->frm=frm;
+      amx->stk=stk;
+      i=amx->callback(amx,offs,&pri,(cell *)(data+(int)stk));
+      stk+=val+4;
+      if (i!=AMX_ERR_NONE) {
+        if (i==AMX_ERR_SLEEP) {
+          amx->pri=pri;
+          amx->alt=alt;
+          amx->stk=stk;
+          amx->reset_stk=reset_stk;
+          amx->reset_hea=reset_hea;
+          return i;
+        } /* if */
+        ABORT(amx,i);
+      } /* if */
+      break;
+    case OP_PUSHM_C:
+      GETPARAM(val);
+      while (val--) {
+        GETPARAM(offs);
+        PUSH(offs);
+      } /* while */
+      break;
+    case OP_PUSHM:
+      GETPARAM(val);
+      while (val--) {
+        GETPARAM(offs);
+        PUSH(_R(data,offs));
+      } /* while */
+      break;
+    case OP_PUSHM_S:
+      GETPARAM(val);
+      while (val--) {
+        GETPARAM(offs);
+        PUSH(_R(data,frm+offs));
+      } /* while */
+      break;
+    case OP_PUSHM_ADR:
+      GETPARAM(val);
+      while (val--) {
+        GETPARAM(offs);
+        PUSH(frm+offs);
+      } /* while */
+      break;
+    case OP_PUSHRM_C:
+      GETPARAM(val);
+      while (val--) {
+        GETPARAM(offs);
+        PUSH((intptr_t)data+offs);
+      } /* while */
+      break;
+    case OP_PUSHRM_S:
+      GETPARAM(val);
+      while (val--) {
+        GETPARAM(offs);
+        PUSH((intptr_t)data+_R(data,frm+offs));
+      } /* while */
+      break;
+    case OP_PUSHRM_ADR:
+      GETPARAM(val);
+      while (val--) {
+        GETPARAM(offs);
+        PUSH((intptr_t)data+frm+offs);
+      } /* while */
+      break;
+    case OP_LOAD2:
+      GETPARAM(offs);
+      pri=_R(data,offs);
+      GETPARAM(offs);
+      alt=_R(data,offs);
+      break;
+    case OP_LOAD2_S:
+      GETPARAM(offs);
+      pri=_R(data,frm+offs);
+      GETPARAM(offs);
+      alt=_R(data,frm+offs);
+      break;
+    case OP_CONST:
+      GETPARAM(offs);
+      GETPARAM(val);
+      _W32(data,offs,val);
+      break;
+    case OP_CONST_S:
+      GETPARAM(offs);
+      GETPARAM(val);
+      _W32(data,frm+offs,val);
+      break;
+#endif  /* AMX_NO_MACRO_INSTR */
+
+#if !defined AMX_NO_PACKED_OPC
+    case OP_LOAD_P_PRI:
+      GETPARAM_P(offs,op);
+      pri=_R(data,offs);
+      break;
+    case OP_LOAD_P_ALT:
+      GETPARAM_P(offs,op);
+      alt=_R(data,offs);
+      break;
+    case OP_LOAD_P_S_PRI:
+      GETPARAM_P(offs,op);
+      pri=_R(data,frm+offs);
+      break;
+    case OP_LOAD_P_S_ALT:
+      GETPARAM_P(offs,op);
+      alt=_R(data,frm+offs);
+      break;
+    case OP_LREF_P_S_PRI:
+      GETPARAM_P(offs,op);
+      offs=_R(data,frm+offs);
+      pri=_R(data,offs);
+      break;
+    case OP_LREF_P_S_ALT:
+      GETPARAM_P(offs,op);
+      offs=_R(data,frm+offs);
+      alt=_R(data,offs);
+      break;
+    case OP_LODB_P_I:
+      GETPARAM_P(offs,op);
+      goto __lodb_i;
+    case OP_CONST_P_PRI:
+      GETPARAM_P(pri,op);
+      break;
+    case OP_CONST_P_ALT:
+      GETPARAM_P(alt,op);
+      break;
+    case OP_ADDR_P_PRI:
+      GETPARAM_P(pri,op);
+      pri+=frm;
+      break;
+    case OP_ADDR_P_ALT:
+      GETPARAM_P(alt,op);
+      alt+=frm;
+      break;
+    case OP_STOR_P:
+      GETPARAM_P(offs,op);
+      _W(data,offs,pri);
+      break;
+    case OP_STOR_P_S:
+      GETPARAM_P(offs,op);
+      _W(data,frm+offs,pri);
+      break;
+    case OP_SREF_P_S:
+      GETPARAM_P(offs,op);
+      offs=_R(data,frm+offs);
+      _W(data,offs,pri);
+      break;
+    case OP_STRB_P_I:
+      GETPARAM_P(offs,op);
+      goto __strb_i;
+    case OP_LIDX_P_B:
+      GETPARAM_P(offs,op);
+      offs=(pri << (int)offs)+alt;
+      /* verify address */
+      if (offs>=hea && offs<stk || (ucell)offs>=(ucell)amx->stp)
+        ABORT(amx,AMX_ERR_MEMACCESS);
+      pri=_R(data,offs);
+      break;
+    case OP_IDXADDR_P_B:
+      GETPARAM_P(offs,op);
+      pri=(pri << (int)offs)+alt;
+      break;
+    case OP_ALIGN_P_PRI:
+      GETPARAM_P(offs,op);
+      #if BYTE_ORDER==LITTLE_ENDIAN
+        if ((size_t)offs<sizeof(cell))
+          pri ^= sizeof(cell)-offs;
+      #endif
+      break;
+    case OP_PUSH_P_C:
+      GETPARAM_P(offs,op);
+      PUSH(offs);
+      break;
+    case OP_PUSH_P:
+      GETPARAM_P(offs,op);
+      PUSH(_R(data,offs));
+      break;
+    case OP_PUSH_P_S:
+      GETPARAM_P(offs,op);
+      PUSH(_R(data,frm+offs));
+      break;
+    case OP_PUSH_P_ADR:
+      GETPARAM_P(offs,op);
+      PUSH(frm+offs);
+      break;
+    case OP_PUSHR_P_C:
+      GETPARAM_P(offs,op);
+      PUSH((intptr_t)data+offs);
+      break;
+    case OP_PUSHR_P_S:
+      GETPARAM_P(offs,op);
+      PUSH((intptr_t)data+_R(data,frm+offs));
+      break;
+    case OP_PUSHR_P_ADR:
+      GETPARAM_P(offs,op);
+      PUSH((intptr_t)data+frm+offs);
+      break;
+    case OP_PUSHM_P:
+      GETPARAM_P(val,op);
+      while (val--) {
+        GETPARAM(offs);
+        PUSH(_R(data,offs));
+      } /* while */
+      break;
+    case OP_PUSHM_P_S:
+      GETPARAM_P(val,op);
+      while (val--) {
+        GETPARAM(offs);
+        PUSH(_R(data,frm+offs));
+      } /* while */
+      break;
+    case OP_PUSHM_P_C:
+      GETPARAM_P(val,op);
+      while (val--) {
+        GETPARAM(offs);
+        PUSH(offs);
+      } /* while */
+      break;
+    case OP_PUSHM_P_ADR:
+      GETPARAM_P(val,op);
+      while (val--) {
+        GETPARAM(offs);
+        PUSH(frm+offs);
+      } /* while */
+      break;
+    case OP_PUSHRM_P_C:
+      GETPARAM_P(val,op);
+      while (val--) {
+        GETPARAM(offs);
+        PUSH((intptr_t)data+offs);
+      } /* while */
+      break;
+    case OP_PUSHRM_P_S:
+      GETPARAM_P(val,op);
+      while (val--) {
+        GETPARAM(offs);
+        PUSH((intptr_t)data+_R(data,frm+offs));
+      } /* while */
+      break;
+    case OP_PUSHRM_P_ADR:
+      GETPARAM_P(val,op);
+      while (val--) {
+        GETPARAM(offs);
+        PUSH((intptr_t)data+frm+offs);
+      } /* while */
+      break;
+    case OP_STACK_P:
+      GETPARAM_P(offs,op);
+      alt=stk;
+      stk+=offs;
+      CHKMARGIN();
+      CHKSTACK();
+      break;
+    case OP_HEAP_P:
+      GETPARAM_P(offs,op);
+      alt=hea;
+      hea+=offs;
+      CHKMARGIN();
+      CHKHEAP();
+      break;
+    case OP_SHL_P_C_PRI:
+      GETPARAM_P(offs,op);
+      pri<<=offs;
+      break;
+    case OP_SHL_P_C_ALT:
+      GETPARAM_P(offs,op);
+      alt<<=offs;
+      break;
+    case OP_ADD_P_C:
+      GETPARAM_P(offs,op);
+      pri+=offs;
+      break;
+    case OP_SMUL_P_C:
+      GETPARAM_P(offs,op);
+      pri*=offs;
+      break;
+    case OP_ZERO_P:
+      GETPARAM_P(offs,op);
+      _W(data,offs,0);
+      break;
+    case OP_ZERO_P_S:
+      GETPARAM_P(offs,op);
+      _W(data,frm+offs,0);
+      break;
+    case OP_EQ_P_C_PRI:
+      GETPARAM_P(offs,op);
+      pri= pri==offs ? 1 : 0;
+      break;
+    case OP_EQ_P_C_ALT:
+      GETPARAM_P(offs,op);
+      pri= alt==offs ? 1 : 0;
+      break;
+    case OP_INC_P:
+      GETPARAM_P(offs,op);
+      #if defined _R_DEFAULT
+        *(cell *)(data+(int)offs) += 1;
+      #else
+        val=_R(data,offs);
+        _W(data,offs,val+1);
+      #endif
+      break;
+    case OP_INC_P_S:
+      GETPARAM_P(offs,op);
+      #if defined _R_DEFAULT
+        *(cell *)(data+(int)(frm+offs)) += 1;
+      #else
+        val=_R(data,frm+offs);
+        _W(data,frm+offs,val+1);
+      #endif
+      break;
+    case OP_DEC_P:
+      GETPARAM_P(offs,op);
+      #if defined _R_DEFAULT
+        *(cell *)(data+(int)offs) -= 1;
+      #else
+        val=_R(data,offs);
+        _W(data,offs,val-1);
+      #endif
+      break;
+    case OP_DEC_P_S:
+      GETPARAM_P(offs,op);
+      #if defined _R_DEFAULT
+        *(cell *)(data+(int)(frm+offs)) -= 1;
+      #else
+        val=_R(data,frm+offs);
+        _W(data,frm+offs,val-1);
+      #endif
+      break;
+    case OP_MOVS_P:
+      GETPARAM_P(offs,op);
+      goto __movs;
+    case OP_CMPS_P:
+      GETPARAM_P(offs,op);
+      goto __cmps;
+    case OP_FILL_P:
+      GETPARAM_P(offs,op);
+      goto __fill;
+    case OP_HALT_P:
+      GETPARAM_P(offs,op);
+      goto __halt;
+    case OP_BOUNDS_P:
+      GETPARAM_P(offs,op);
+      if ((ucell)pri>(ucell)offs) {
+        amx->cip=(cell)((unsigned char *)cip-amx->code);
+        ABORT(amx,AMX_ERR_BOUNDS);
+      } /* if */
+      break;
+#endif /* AMX_NO_PACKED_OPC */
+    default:
+      assert(0);  /* invalid instructions should already have been caught in VerifyPcode() */
+      ABORT(amx,AMX_ERR_INVINSTR);
+    } /* switch */
+  } /* for */
+#endif /* AMX_ALTCORE */
+}
+
+#endif /* AMX_EXEC */
+
+#if defined AMX_SETCALLBACK
+int AMXAPI amx_SetCallback(AMX *amx,AMX_CALLBACK callback)
+{
+  assert(amx!=NULL);
+  assert(callback!=NULL);
+  amx->callback=callback;
+  return AMX_ERR_NONE;
+}
+#endif /* AMX_SETCALLBACK */
+
+#if defined AMX_SETDEBUGHOOK
+int AMXAPI amx_SetDebugHook(AMX *amx,AMX_DEBUG debug)
+{
+  assert(amx!=NULL);
+  amx->debug=debug;
+  return AMX_ERR_NONE;
+}
+#endif /* AMX_SETDEBUGHOOK */
+
+#if defined AMX_RAISEERROR
+int AMXAPI amx_RaiseError(AMX *amx, int error)
+{
+  assert(error>0);
+  amx->error=error;
+  return AMX_ERR_NONE;
+}
+#endif /* AMX_RAISEERROR */
+
+#if defined AMX_ALLOT || defined AMX_PUSHXXX
+int AMXAPI amx_Allot(AMX *amx,int cells,cell **address)
+{
+  AMX_HEADER *hdr;
+  unsigned char *data;
+
+  assert(amx!=NULL);
+  hdr=(AMX_HEADER *)amx->base;
+  assert(hdr!=NULL);
+  assert(hdr->magic==AMX_MAGIC);
+  data=(amx->data!=NULL) ? amx->data : amx->base+(int)hdr->dat;
+
+  if (amx->stk - amx->hea - cells*sizeof(cell) < STKMARGIN)
+    return AMX_ERR_MEMORY;
+  if (address!=NULL)
+    *address=(cell *)(data+(int)amx->hea);
+  amx->hea+=cells*sizeof(cell);
+  return AMX_ERR_NONE;
+}
+
+int AMXAPI amx_Release(AMX *amx,cell *address)
+{
+  AMX_HEADER *hdr;
+  unsigned char *data;
+  cell amx_addr;
+
+  assert(amx!=NULL);
+  hdr=(AMX_HEADER *)amx->base;
+  assert(hdr!=NULL);
+  assert(hdr->magic==AMX_MAGIC);
+  data=(amx->data!=NULL) ? amx->data : amx->base+(int)hdr->dat;
+  amx_addr=(cell)((unsigned char*)address-data);
+  if (amx->hea>amx_addr)
+    amx->hea=amx_addr;
+  return AMX_ERR_NONE;
+}
+#endif /* AMX_ALLOT || AMX_PUSHXXX */
+
+#if defined AMX_XXXSTRING || defined AMX_UTF8XXX
+
+#define CHARBITS        (8*sizeof(char))
+#if PAWN_CELL_SIZE==16
+  #define CHARMASK      (0xffffu << 8*(2-sizeof(char)))
+#elif PAWN_CELL_SIZE==32
+  #define CHARMASK      (0xffffffffuL << 8*(4-sizeof(char)))
+#elif PAWN_CELL_SIZE==64
+  #define CHARMASK      (0xffffffffffffffffuLL << 8*(8-sizeof(char)))
+#else
+  #error Unsupported cell size
+#endif
+
+int AMXAPI amx_StrLen(const cell *cstr, int *length)
+{
+  int len;
+  #if BYTE_ORDER==LITTLE_ENDIAN
+    cell c;
+  #endif
+
+  assert(length!=NULL);
+  if (cstr==NULL) {
+    *length=0;
+    return AMX_ERR_PARAMS;
+  } /* if */
+
+  if ((ucell)*cstr>UNPACKEDMAX) {
+    /* packed string */
+    assert_static(sizeof(char)==1);
+    len=(int)strlen((char *)cstr);      /* find '\0' */
+    assert(check_endian());
+    #if BYTE_ORDER==LITTLE_ENDIAN
+      /* on Little Endian machines, toggle the last bytes */
+      c=cstr[len/sizeof(cell)];         /* get last cell */
+      len=len - len % sizeof(cell);     /* len = multiple of "cell" bytes */
+      while ((c & CHARMASK)!=0) {
+        len++;
+        c <<= 8*sizeof(char);
+      } /* if */
+    #endif
+  } else {
+    for (len=0; cstr[len]!=0; len++)
+      /* nothing */;
+  } /* if */
+  *length = len;
+  return AMX_ERR_NONE;
+}
+#endif
+
+#if defined AMX_XXXSTRING || defined AMX_PUSHXXX
+int AMXAPI amx_SetString(cell *dest,const char *source,int pack,int use_wchar,size_t size)
+{                 /* the memory blocks should not overlap */
+  int i;
+  size_t len;
+
+  assert_static(UNLIMITED>0);
+  #if defined AMX_ANSIONLY
+    (void)use_wchar;
+    len=strlen(source);
+  #else
+    len= use_wchar ? wcslen((const wchar_t*)source) : strlen(source);
+  #endif
+  if (pack) {
+    /* create a packed string */
+    if (size<UNLIMITED/sizeof(cell) && (size_t)len>=size*sizeof(cell))
+      len=size*sizeof(cell)-1;
+    dest[len/sizeof(cell)]=0;   /* clear last bytes of last (semi-filled) cell*/
+    #if defined AMX_ANSIONLY
+      memcpy(dest,source,len);
+    #else
+      if (use_wchar) {
+        for (i=0; i<len; i++)
+          ((char*)dest)[i]=(char)(((wchar_t*)source)[i]);
+      } else {
+        memcpy(dest,source,len);
+      } /* if */
+    #endif
+    /* On Big Endian machines, the characters are well aligned in the
+     * cells; on Little Endian machines, we must swap all cells.
+     */
+    assert(check_endian());
+    #if BYTE_ORDER==LITTLE_ENDIAN
+      for (i=(int)(len/sizeof(cell)); i>=0; i--)
+        amx_SwapCell((ucell *)&dest[i]);
+    #endif
+  } else {
+    /* create an unpacked string */
+    if (size<UNLIMITED && (size_t)len>=size)
+      len=size-1;
+    #if defined AMX_ANSIONLY
+      for (i=0; i<len; i++)
+        dest[i]=(cell)source[i];
+    #else
+      if (use_wchar) {
+        for (i=0; i<len; i++)
+          dest[i]=(cell)(((wchar_t*)source)[i]);
+      } else {
+        for (i=0; i<len; i++)
+          dest[i]=(cell)source[i];
+      } /* if */
+    #endif
+    dest[len]=0;
+  } /* if */
+  return AMX_ERR_NONE;
+}
+#endif
+
+#if defined AMX_XXXSTRING
+int AMXAPI amx_GetString(char *dest,const cell *source,int use_wchar,size_t size)
+{
+  int len=0;
+  #if defined AMX_ANSIONLY
+    (void)use_wchar;    /* unused parameter (if ANSI only) */
+  #endif
+  if ((ucell)*source>UNPACKEDMAX) {
+    /* source string is packed */
+    cell c=0;           /* initialize to 0 to avoid a compiler warning */
+    int i=sizeof(cell)-1;
+    char ch;
+    while ((size_t)len<size) {
+      if (i==sizeof(cell)-1)
+        c=*source++;
+      ch=(char)(c >> i*CHARBITS);
+      if (ch=='\0')
+        break;          /* terminating zero character found */
+      #if defined AMX_ANSIONLY
+        dest[len++]=ch;
+      #else
+        if (use_wchar)
+          ((wchar_t*)dest)[len++]=ch;
+        else
+          dest[len++]=ch;
+      #endif
+      i=(i+sizeof(cell)-1) % sizeof(cell);
+    } /* while */
+  } else {
+    /* source string is unpacked */
+    #if defined AMX_ANSIONLY
+      while (*source!=0 && (size_t)len<size)
+        dest[len++]=(char)*source++;
+    #else
+      if (use_wchar) {
+        while (*source!=0 && (size_t)len<size)
+          ((wchar_t*)dest)[len++]=(wchar_t)*source++;
+      } else {
+        while (*source!=0 && (size_t)len<size)
+          dest[len++]=(char)*source++;
+      } /* if */
+    #endif
+  } /* if */
+  /* store terminator */
+  if ((size_t)len>=size)
+    len=(int)size-1;
+  if (len>=0) {
+    #if defined AMX_ANSIONLY
+      dest[len]='\0';
+    #else
+      if (use_wchar)
+        ((wchar_t*)dest)[len]=0;
+      else
+        dest[len]='\0';
+    #endif
+  } /* IF */
+  return AMX_ERR_NONE;
+}
+#endif /* AMX_XXXSTRING */
+
+#if defined AMX_UTF8XXX
+  #if defined __BORLANDC__
+    #pragma warn -amb -8000     /* ambiguous operators need parentheses */
+  #endif
+/* amx_UTF8Get()
+ * Extract a single UTF-8 encoded character from a string and return a pointer
+ * to the character just behind that UTF-8 character. The parameters "endptr"
+ * and "value" may be NULL.
+ * If the code is not valid UTF-8, "endptr" has the value of the input
+ * parameter "string" and "value" is zero.
+ */
+int AMXAPI amx_UTF8Get(const char *string, const char **endptr, cell *value)
+{
+static const char utf8_count[16]={ 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 3, 4 };
+static const long utf8_lowmark[5] = { 0x80, 0x800, 0x10000L, 0x200000L, 0x4000000L };
+  unsigned char c;
+  cell result;
+  int followup;
+
+  assert(string!=NULL);
+  if (value!=NULL)      /* preset, in case of an error */
+    *value=0;
+  if (endptr!=NULL)
+    *endptr=string;
+
+  c = *(const unsigned char*)string++;
+  if (c<0x80) {
+    /* ASCII */
+    result=c;
+  } else {
+    if (c<0xc0 || c>=0xfe)
+      return AMX_ERR_PARAMS;  /* invalid or "follower" code, quit with error */
+    /* At this point we know that the two top bits of c are ones. The two
+     * bottom bits are always part of the code. We only need to consider
+     * the 4 remaining bits; i.e., a 16-byte table. This is "utf8_count[]".
+     * (Actually the utf8_count[] table records the number of follow-up
+     * bytes minus 1. This is just for convenience.)
+     */
+    assert((c & 0xc0)==0xc0);
+    followup=(int)utf8_count[(c >> 2) & 0x0f];
+    /* The mask depends on the code length; this is just a very simple
+     * relation.
+     */
+    #define utf8_mask   (0x1f >> followup)
+    result= c & utf8_mask;
+    /* Collect the follow-up codes using a drop-through switch statement;
+     * this avoids a loop. In each case, verify the two leading bits.
+     */
+    assert(followup>=0 && followup<=4);
+    switch (followup) {
+    case 4:
+      if (((c=*string++) & 0xc0) != 0x80) goto error;
+      result = (result << 6) | c & 0x3f;
+    case 3:
+      if (((c=*string++) & 0xc0) != 0x80) goto error;
+      result = (result << 6) | c & 0x3f;
+    case 2:
+      if (((c=*string++) & 0xc0) != 0x80) goto error;
+      result = (result << 6) | c & 0x3f;
+    case 1:
+      if (((c=*string++) & 0xc0) != 0x80) goto error;
+      result = (result << 6) | c & 0x3f;
+    case 0:
+      if (((c=*string++) & 0xc0) != 0x80) goto error;
+      result = (result << 6) | c & 0x3f;
+    } /* switch */
+    /* Do additional checks: shortest encoding & reserved positions. The
+     * lowmark limits also depends on the code length; it can be read from
+     * a table with 5 elements. This is "utf8_lowmark[]".
+     */
+    if (result<utf8_lowmark[followup])
+      goto error;
+    if (result>=0xd800 && result<=0xdfff || result==0xfffe || result==0xffff)
+      goto error;
+  } /* if */
+
+  if (value!=NULL)
+    *value=result;
+  if (endptr!=NULL)
+    *endptr=string;
+
+  return AMX_ERR_NONE;
+
+error:
+  return AMX_ERR_PARAMS;
+}
+
+/* amx_UTF8Put()
+ * Encode a single character into a byte string. The character may result in
+ * a string of up to 6 bytes. The function returns an error code if "maxchars"
+ * is lower than the required number of characters; in this case nothing is
+ * stored.
+ * The function does not zero-terminate the string.
+ */
+int AMXAPI amx_UTF8Put(char *string, char **endptr, int maxchars, cell value)
+{
+  assert(string!=NULL);
+  if (endptr!=NULL)     /* preset, in case of an error */
+    *endptr=string;
+
+  if (value<0x80) {
+    /* 0xxxxxxx */
+    if (maxchars < 1) goto error;
+    *string++ = (char)value;
+  } else if (value<0x800) {
+    /* 110xxxxx 10xxxxxx */
+    if (maxchars < 2) goto error;
+    *string++ = (char)((value>>6) & 0x1f | 0xc0);
+    *string++ = (char)(value & 0x3f | 0x80);
+  } else if (value<0x10000) {
+    /* 1110xxxx 10xxxxxx 10xxxxxx (16 bits, BMP plane) */
+    if (maxchars < 3) goto error;
+    if (value>=0xd800 && value<=0xdfff || value==0xfffe || value==0xffff)
+      goto error;       /* surrogate pairs and invalid characters */
+    *string++ = (char)((value>>12) & 0x0f | 0xe0);
+    *string++ = (char)((value>>6) & 0x3f | 0x80);
+    *string++ = (char)(value & 0x3f | 0x80);
+  } else if (value<0x200000) {
+    /* 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */
+    if (maxchars < 4) goto error;
+    *string++ = (char)((value>>18) & 0x07 | 0xf0);
+    *string++ = (char)((value>>12) & 0x3f | 0x80);
+    *string++ = (char)((value>>6) & 0x3f | 0x80);
+    *string++ = (char)(value & 0x3f | 0x80);
+  } else if (value<0x4000000) {
+    /* 111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx */
+    if (maxchars < 5) goto error;
+    *string++ = (char)((value>>24) & 0x03 | 0xf8);
+    *string++ = (char)((value>>18) & 0x3f | 0x80);
+    *string++ = (char)((value>>12) & 0x3f | 0x80);
+    *string++ = (char)((value>>6) & 0x3f | 0x80);
+    *string++ = (char)(value & 0x3f | 0x80);
+  } else {
+    /* 1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx (31 bits) */
+    if (maxchars < 6) goto error;
+    *string++ = (char)((value>>30) & 0x01 | 0xfc);
+    *string++ = (char)((value>>24) & 0x3f | 0x80);
+    *string++ = (char)((value>>18) & 0x3f | 0x80);
+    *string++ = (char)((value>>12) & 0x3f | 0x80);
+    *string++ = (char)((value>>6) & 0x3f | 0x80);
+    *string++ = (char)(value & 0x3f | 0x80);
+  } /* if */
+
+  if (endptr!=NULL)
+    *endptr=string;
+  return AMX_ERR_NONE;
+
+error:
+  return AMX_ERR_PARAMS;
+}
+
+/* amx_UTF8Check()
+ * Run through a zero-terminated string and check the validity of the UTF-8
+ * encoding. The function returns an error code, it is AMX_ERR_NONE if the
+ * string is valid UTF-8 (or valid ASCII for that matter).
+ */
+int AMXAPI amx_UTF8Check(const char *string, int *length)
+{
+  int err=AMX_ERR_NONE;
+  int len=0;
+  while (err==AMX_ERR_NONE && *string!='\0') {
+    err=amx_UTF8Get(string,&string,NULL);
+    len++;
+  } /* while */
+  if (length!=NULL)
+    *length=len;
+  return err;
+}
+
+/* amx_UTF8Len()
+ * Run through a wide string and return how many 8-bit characters are needed to
+ * store the string in UTF-8 format. The returned cound excludes the terminating
+ * zero byte. The function returns an error code.
+ */
+int AMXAPI amx_UTF8Len(const cell *cstr, int *length)
+{
+  int err;
+
+  assert(length!=NULL);
+  err=amx_StrLen(cstr, length);
+  if (err==AMX_ERR_NONE && (ucell)*cstr<=UNPACKEDMAX) {
+    char buffer[10];  /* maximum UTF-8 code is 6 characters */
+    char *endptr;
+    int len=*length, count=0;
+    while (len-->0) {
+      amx_UTF8Put(buffer, &endptr, sizeof buffer, *cstr++);
+      count+=(int)(endptr-buffer);
+    } /* while */
+    *length=count;
+  } /* while */
+  return err;
+}
+#endif /* AMX_UTF8XXX */
diff --git a/apps/openmw-mp/amx/amx.h b/apps/openmw-mp/amx/amx.h
new file mode 100644
index 000000000..10cafadd9
--- /dev/null
+++ b/apps/openmw-mp/amx/amx.h
@@ -0,0 +1,545 @@
+/*  Pawn Abstract Machine (for the Pawn language)
+ *
+ *  Copyright (c) ITB CompuPhase, 1997-2015
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ *  use this file except in compliance with the License. You may obtain a copy
+ *  of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ *  License for the specific language governing permissions and limitations
+ *  under the License.
+ *
+ *  Version: $Id: amx.h 5181 2015-01-21 09:44:28Z thiadmer $
+ */
+
+#ifndef AMX_H_INCLUDED
+#define AMX_H_INCLUDED
+
+#include <stdlib.h>   /* for size_t */
+#include <limits.h>
+
+#if (defined __linux || defined __linux__) && !defined __LINUX__
+  #define __LINUX__
+#endif
+#if defined FREEBSD && !defined __FreeBSD__
+  #define __FreeBSD__
+#endif
+#if defined __LINUX__ || defined __FreeBSD__ || defined __OpenBSD__ || defined __APPLE__
+  #include <sclinux.h>
+#endif
+
+#if defined __GNUC__
+ #define GCC_VERSION (__GNUC__ * 10000 \
+                               + __GNUC_MINOR__ * 100 \
+                               + __GNUC_PATCHLEVEL__)
+#endif
+
+#if !defined HAVE_STDINT_H
+  #if (defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L) \
+      || defined __GNUC__ || defined __LCC__ || defined __DMC__ \
+      || (defined __WATCOMC__ && __WATCOMC__ >= 1200)
+    #define HAVE_STDINT_H 1
+  #endif
+#endif
+#if !defined HAVE_INTTYPES_H
+  #if defined __FreeBSD__ || defined __APPLE__
+    #define HAVE_INTTYPES_H 1
+  #endif
+#endif
+#if defined HAVE_STDINT_H
+  #include <stdint.h>
+#elif defined HAVE_INTTYPES_H
+  #include <inttypes.h>
+#else
+  #if defined __MACH__
+    #include <ppc/types.h>
+  #endif
+  typedef short int           int16_t;
+  typedef unsigned short int  uint16_t;
+  #if defined SN_TARGET_PS2
+    typedef int               int32_t;
+    typedef unsigned int      uint32_t;
+  #else
+    typedef long int          int32_t;
+    typedef unsigned long int uint32_t;
+  #endif
+  #if defined __WIN32__ || defined _WIN32 || defined WIN32
+    typedef __int64	          int64_t;
+    typedef unsigned __int64  uint64_t;
+    #define HAVE_I64
+  #endif
+  #if !defined _INTPTR_T_DEFINED
+    #if defined _LP64 || defined WIN64 || defined _WIN64
+      typedef __int64         intptr_t;
+    #else
+      typedef int32_t         intptr_t;
+    #endif
+  #endif
+#endif
+#if defined _LP64 || defined WIN64 || defined _WIN64
+  #if !defined __64BIT__
+    #define __64BIT__
+  #endif
+#endif
+
+#if !defined HAVE_ALLOCA_H
+  #if defined __GNUC__ || defined __LCC__ || defined __DMC__ || defined __ARMCC_VERSION
+    #define HAVE_ALLOCA_H 1
+  #elif defined __WATCOMC__ && __WATCOMC__ >= 1200
+    #define HAVE_ALLOCA_H 1
+  #endif
+#endif
+#if defined HAVE_ALLOCA_H && HAVE_ALLOCA_H
+  #include <alloca.h>
+#elif defined __BORLANDC__
+  #include <malloc.h>
+#endif
+#if defined __WIN32__ || defined _WIN32 || defined WIN32 /* || defined __MSDOS__ */
+  #if !defined alloca
+    #define alloca(n)   _alloca(n)
+  #endif
+#endif
+
+#if !defined assert_static
+  #if (defined __STDC_VERSION__ && __STDC_VERSION__ >= 201112) || GCC_VERSION >= 40600
+    #define assert_static(test) _Static_assert(test, "assert")
+  #else
+    /* see "Compile-Time Assertions" by Greg Miller,
+     * (with modifications to port it to C)
+     */
+    #define _ASSERT_STATIC_SYMBOL_INNER(line) __ASSERT_STATIC_ ## line
+    #define _ASSERT_STATIC_SYMBOL(line) _ASSERT_STATIC_SYMBOL_INNER(line)
+    #define assert_static(test) \
+      do { \
+        typedef char _ASSERT_STATIC_SYMBOL(__LINE__)[ ((test) ? 1 : -1) ]; \
+      } while (0)
+  #endif
+#endif
+
+#if defined  __cplusplus
+extern  "C" {
+#endif
+
+#if defined PAWN_DLL
+  #if !defined AMX_NATIVE_CALL
+    #define AMX_NATIVE_CALL __stdcall
+  #endif
+  #if !defined AMXAPI
+    #define AMXAPI          __stdcall
+  #endif
+  #if !defined AMXEXPORT
+    #define AMXEXPORT       __declspec(dllexport)
+  #endif
+#endif
+
+/* calling convention for native functions */
+#if !defined AMX_NATIVE_CALL
+  #define AMX_NATIVE_CALL
+#endif
+/* calling convention for all interface functions and callback functions */
+#if !defined AMXAPI
+  #if defined STDECL
+    #define AMXAPI      __stdcall
+  #elif defined CDECL
+    #define AMXAPI      __cdecl
+  #elif defined GCC_HASCLASSVISIBILITY
+    #define AMXAPI      __attribute__((visibility("default")))
+  #else
+    #define AMXAPI
+  #endif
+#endif
+#if !defined AMXEXPORT
+  #define AMXEXPORT
+#endif
+
+/* File format version (in CUR_FILE_VERSION)
+ *   0 original version
+ *   1 opcodes JUMP.pri, SWITCH and CASETBL
+ *   2 compressed files
+ *   3 public variables
+ *   4 opcodes SWAP.pri/alt and PUSHADDR
+ *   5 tagnames table
+ *   6 reformatted header
+ *   7 name table, opcodes SYMTAG & SYSREQ.D
+ *   8 opcode BREAK, renewed debug interface
+ *   9 macro opcodes
+ *  10 position-independent code, overlays, packed instructions
+ *  11 relocating instructions for the native interface, reorganized instruction set
+ * MIN_FILE_VERSION is the lowest file version number that the current AMX
+ * implementation supports. If the AMX file header gets new fields, this number
+ * often needs to be incremented. MIN_AMX_VERSION is the lowest AMX version that
+ * is needed to support the current file version. When there are new opcodes,
+ * this number needs to be incremented.
+ * The file version supported by the JIT may run behind MIN_AMX_VERSION. So
+ * there is an extra constant for it: MAX_FILE_VER_JIT.
+ */
+
+#define CUR_FILE_VERSION 11     /* current file version; also the current AMX version */
+#define MIN_FILE_VERSION 11     /* lowest supported file format version for the current AMX version */
+#define MIN_AMX_VERSION  11     /* minimum AMX version needed to support the current file format */
+#define MAX_FILE_VER_JIT 11     /* file version supported by the JIT */
+#define MIN_AMX_VER_JIT  11     /* AMX version supported by the JIT */
+
+#if !defined PAWN_CELL_SIZE
+  #define PAWN_CELL_SIZE 32     /* by default, use 32-bit cells */
+#endif
+#if PAWN_CELL_SIZE==16
+  typedef uint16_t  ucell;
+  typedef int16_t   cell;
+#elif PAWN_CELL_SIZE==32
+  typedef uint32_t  ucell;
+  typedef int32_t   cell;
+#elif PAWN_CELL_SIZE==64
+  typedef uint64_t  ucell;
+  typedef int64_t   cell;
+  #define HAVE_I64
+#else
+  #error Unsupported cell size (PAWN_CELL_SIZE)
+#endif
+
+#define UNPACKEDMAX   (((cell)1 << (sizeof(cell)-1)*8) - 1)
+#define UNLIMITED     (~1u >> 1)
+
+struct tagAMX;
+typedef cell (AMX_NATIVE_CALL *AMX_NATIVE)(struct tagAMX *amx, const cell *params);
+typedef int (AMXAPI *AMX_CALLBACK)(struct tagAMX *amx, cell index,
+                                   cell *result, const cell *params);
+typedef int (AMXAPI *AMX_DEBUG)(struct tagAMX *amx);
+typedef int (AMXAPI *AMX_OVERLAY)(struct tagAMX *amx, int index);
+typedef int (AMXAPI *AMX_IDLE)(struct tagAMX *amx, int AMXAPI Exec(struct tagAMX *, cell *, int));
+#if !defined _FAR
+  #define _FAR
+#endif
+
+#if defined _MSC_VER
+  #pragma warning(disable:4100)  /* "'%$S' : unreferenced formal parameter" */
+  #pragma warning(disable:4103)  /* disable warning message 4103 that complains
+                                  * about pragma pack in a header file */
+  #pragma warning(disable:4127)  /* "conditional expression is constant" (needed for static_assert) */
+  #pragma warning(disable:4996)  /* POSIX name is deprecated */
+#endif
+
+/* Some compilers do not support the #pragma align, which should be fine. Some
+ * compilers give a warning on unknown #pragmas, which is not so fine...
+ */
+#if (defined SN_TARGET_PS2 || defined __GNUC__) && !defined AMX_NO_ALIGN
+  #define AMX_NO_ALIGN
+#endif
+
+#if defined __GNUC__
+  #define PACKED        __attribute__((packed))
+#else
+  #define PACKED
+#endif
+
+#if !defined AMX_NO_ALIGN
+  #if defined __LINUX__ || defined __FreeBSD__ || defined __APPLE__
+    #pragma pack(1)         /* structures must be packed (byte-aligned) */
+  #elif defined MACOS && defined __MWERKS__
+    #pragma options align=mac68k
+  #else
+    #pragma pack(push)
+    #pragma pack(1)         /* structures must be packed (byte-aligned) */
+    #if defined __TURBOC__
+      #pragma option -a-    /* "pack" pragma for older Borland compilers */
+    #endif
+  #endif
+#endif
+
+typedef struct tagAMX_NATIVE_INFO {
+  const char _FAR *name;
+  AMX_NATIVE func;
+} PACKED AMX_NATIVE_INFO;
+
+#if !defined AMX_USERNUM
+#define AMX_USERNUM     4
+#endif
+#define sEXPMAX         19  /* maximum name length for file version <= 6 */
+#define sNAMEMAX        31  /* maximum name length of symbol name */
+
+typedef struct tagFUNCSTUB {
+  uint32_t address;
+  uint32_t nameofs;
+} PACKED AMX_FUNCSTUB;
+
+typedef struct tagOVERLAYINFO {
+  int32_t offset;           /* offset relative to the start of the code block */
+  int32_t size;             /* size in bytes */
+} PACKED AMX_OVERLAYINFO;
+
+/* The AMX structure is the internal structure for many functions. Not all
+ * fields are valid at all times; many fields are cached in local variables.
+ */
+typedef struct tagAMX {
+  unsigned char _FAR *base; /* points to the AMX header, perhaps followed by P-code and data */
+  unsigned char _FAR *code; /* points to P-code block, possibly in ROM or in an overlay pool */
+  unsigned char _FAR *data; /* points to separate data+stack+heap, may be NULL */
+  AMX_CALLBACK callback;    /* native function callback */
+  AMX_DEBUG debug;          /* debug callback */
+  AMX_OVERLAY overlay;      /* overlay reader callback */
+  /* for external functions a few registers must be accessible from the outside */
+  cell cip;                 /* instruction pointer: relative to base + amxhdr->cod */
+  cell frm;                 /* stack frame base: relative to base + amxhdr->dat */
+  cell hea;                 /* top of the heap: relative to base + amxhdr->dat */
+  cell hlw;                 /* bottom of the heap: relative to base + amxhdr->dat */
+  cell stk;                 /* stack pointer: relative to base + amxhdr->dat */
+  cell stp;                 /* top of the stack: relative to base + amxhdr->dat */
+  int flags;                /* current status, see amx_Flags() */
+  /* user data */
+  #if AMX_USERNUM > 0
+    long usertags[AMX_USERNUM];
+    void _FAR *userdata[AMX_USERNUM];
+  #endif
+  /* native functions can raise an error */
+  int error;
+  /* passing parameters requires a "count" field */
+  int paramcount;
+  /* the sleep opcode needs to store the full AMX status */
+  cell pri;
+  cell alt;
+  cell reset_stk;
+  cell reset_hea;
+  /* extra fields for increased performance */
+  cell sysreq_d;            /* relocated address/value for the SYSREQ.D opcode */
+  /* fields for overlay support and JIT support */
+  int ovl_index;            /* current overlay index */
+  long codesize;            /* size of the overlay, or estimated memory footprint of the native code */
+  #if defined AMX_JIT
+    /* support variables for the JIT */
+    int reloc_size;         /* required temporary buffer for relocations */
+  #endif
+} PACKED AMX;
+
+/* The AMX_HEADER structure is both the memory format as the file format. The
+ * structure is used internaly.
+ */
+typedef struct tagAMX_HEADER {
+  int32_t size;             /* size of the "file" */
+  uint16_t magic;           /* signature */
+  char    file_version;     /* file format version */
+  char    amx_version;      /* required version of the AMX */
+  int16_t flags;
+  int16_t defsize;          /* size of a definition record */
+  int32_t cod;              /* initial value of COD - code block */
+  int32_t dat;              /* initial value of DAT - data block */
+  int32_t hea;              /* initial value of HEA - start of the heap */
+  int32_t stp;              /* initial value of STP - stack top */
+  int32_t cip;              /* initial value of CIP - the instruction pointer */
+  int32_t publics;          /* offset to the "public functions" table */
+  int32_t natives;          /* offset to the "native functions" table */
+  int32_t libraries;        /* offset to the table of libraries */
+  int32_t pubvars;          /* offset to the "public variables" table */
+  int32_t tags;             /* offset to the "public tagnames" table */
+  int32_t nametable;        /* offset to the name table */
+  int32_t overlays;         /* offset to the overlay table */
+} PACKED AMX_HEADER;
+
+#define AMX_MAGIC_16    0xf1e2
+#define AMX_MAGIC_32    0xf1e0
+#define AMX_MAGIC_64    0xf1e1
+#if PAWN_CELL_SIZE==16
+  #define AMX_MAGIC     AMX_MAGIC_16
+#elif PAWN_CELL_SIZE==32
+  #define AMX_MAGIC     AMX_MAGIC_32
+#elif PAWN_CELL_SIZE==64
+  #define AMX_MAGIC     AMX_MAGIC_64
+#endif
+
+enum {
+  AMX_ERR_NONE,
+  /* reserve the first 15 error codes for exit codes of the abstract machine */
+  AMX_ERR_EXIT,         /* forced exit */
+  AMX_ERR_ASSERT,       /* assertion failed */
+  AMX_ERR_STACKERR,     /* stack/heap collision */
+  AMX_ERR_BOUNDS,       /* index out of bounds */
+  AMX_ERR_MEMACCESS,    /* invalid memory access */
+  AMX_ERR_INVINSTR,     /* invalid instruction */
+  AMX_ERR_STACKLOW,     /* stack underflow */
+  AMX_ERR_HEAPLOW,      /* heap underflow */
+  AMX_ERR_CALLBACK,     /* no callback, or invalid callback */
+  AMX_ERR_NATIVE,       /* native function failed */
+  AMX_ERR_DIVIDE,       /* divide by zero */
+  AMX_ERR_SLEEP,        /* go into sleepmode - code can be restarted */
+  AMX_ERR_INVSTATE,     /* no implementation for this state, no fall-back */
+
+  AMX_ERR_MEMORY = 16,  /* out of memory */
+  AMX_ERR_FORMAT,       /* invalid file format */
+  AMX_ERR_VERSION,      /* file is for a newer version of the AMX */
+  AMX_ERR_NOTFOUND,     /* function not found */
+  AMX_ERR_INDEX,        /* invalid index parameter (bad entry point) */
+  AMX_ERR_DEBUG,        /* debugger cannot run */
+  AMX_ERR_INIT,         /* AMX not initialized (or doubly initialized) */
+  AMX_ERR_USERDATA,     /* unable to set user data field (table full) */
+  AMX_ERR_INIT_JIT,     /* cannot initialize the JIT */
+  AMX_ERR_PARAMS,       /* parameter error */
+  AMX_ERR_DOMAIN,       /* domain error, expression result does not fit in range */
+  AMX_ERR_GENERAL,      /* general error (unknown or unspecific error) */
+  AMX_ERR_OVERLAY,      /* overlays are unsupported (JIT) or uninitialized */
+};
+
+#define AMX_FLAG_OVERLAY  0x01  /* all function calls use overlays */
+#define AMX_FLAG_DEBUG    0x02  /* symbolic info. available */
+#define AMX_FLAG_NOCHECKS 0x04  /* no array bounds checking; no BREAK opcodes */
+#define AMX_FLAG_SLEEP    0x08  /* script uses the sleep instruction (possible re-entry or power-down mode) */
+#define AMX_FLAG_CRYPT    0x10  /* file is encrypted */
+#define AMX_FLAG_DSEG_INIT 0x20 /* data section is explicitly initialized */
+#define AMX_FLAG_SYSREQN 0x800  /* script uses new (optimized) version of SYSREQ opcode */
+#define AMX_FLAG_NTVREG 0x1000  /* all native functions are registered */
+#define AMX_FLAG_JITC   0x2000  /* abstract machine is JIT compiled */
+#define AMX_FLAG_VERIFY 0x4000  /* busy verifying P-code */
+#define AMX_FLAG_INIT   0x8000  /* AMX has been initialized */
+
+#define AMX_EXEC_MAIN   (-1)    /* start at program entry point */
+#define AMX_EXEC_CONT   (-2)    /* continue from last address */
+
+#define AMX_USERTAG(a,b,c,d)    ((a) | ((b)<<8) | ((long)(c)<<16) | ((long)(d)<<24))
+
+/* for native functions that use floating point parameters, the following
+ * two macros are convenient for casting a "cell" into a "float" type _without_
+ * changing the bit pattern
+ */
+#if PAWN_CELL_SIZE==32
+  #define amx_ftoc(f)   ( * ((cell*)&f) )   /* float to cell */
+  #define amx_ctof(c)   ( * ((float*)&c) )  /* cell to float */
+#elif PAWN_CELL_SIZE==64
+  #define amx_ftoc(f)   ( * ((cell*)&f) )   /* float to cell */
+  #define amx_ctof(c)   ( * ((double*)&c) ) /* cell to float */
+#else
+  // amx_ftoc() and amx_ctof() cannot be used
+#endif
+
+/* when a pointer cannot be stored in a cell, cells that hold relocated
+ * addresses need to be expanded
+ */
+#if defined __64BIT__ && PAWN_CELL_SIZE<64
+  #define CELLMASK      (((int64_t)1 << PAWN_CELL_SIZE) - 1)
+  #define amx_Address(amx,addr) \
+                        (cell*)(((int64_t)((amx)->data ? (amx)->data : (amx)->code) & ~CELLMASK) | ((int64_t)(addr) & CELLMASK))
+#elif defined __32BIT__ && PAWN_CELL_SIZE<32
+  #define CELLMASK      ((1L << PAWN_CELL_SIZE) - 1)
+  #define amx_Address(amx,addr) \
+                        (cell*)(((int32_t)((amx)->data ? (amx)->data : (amx)->code) & ~CELLMASK) | ((int32_t)(addr) & CELLMASK))
+#else
+  #define amx_Address(amx,addr) ((void)(amx),(cell*)(addr))
+#endif
+
+#if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L
+  /* C99: use variable-length arrays */
+  #define amx_StrParam_Type(amx,param,result,type)                          \
+    int result##_length_;                                                   \
+    amx_StrLen(amx_Address(amx,param),&result##_length_);                   \
+    char result##_vla_[(result##_length_+1)*sizeof(*(result))];             \
+    (result)=(type)result##_vla_;                                           \
+    amx_GetString((char*)(result),amx_Address(amx,param),                   \
+                  sizeof(*(result))>1,result##_length_+1)
+  #define amx_StrParam(amx,param,result) \
+    amx_StrParam_Type(amx,param,result,void*)
+#else
+  /* macro using alloca() */
+  #define amx_StrParam_Type(amx,param,result,type)                          \
+    do {                                                                    \
+      int result##_length_;                                                 \
+      amx_StrLen(amx_Address(amx,param),&result##_length_);                 \
+      if (result##_length_>0 &&                                             \
+          ((result)=(type)alloca((result##_length_+1)*sizeof(*(result))))!=NULL) \
+        amx_GetString((char*)(result),amx_Address(amx,param),               \
+                      sizeof(*(result))>1,result##_length_+1);              \
+      else (result) = NULL;                                                 \
+    } while (0)
+  #define amx_StrParam(amx,param,result) \
+    amx_StrParam_Type(amx,param,result,void*)
+#endif
+
+uint16_t * AMXAPI amx_Align16(uint16_t *v);
+uint32_t * AMXAPI amx_Align32(uint32_t *v);
+#if defined _I64_MAX || defined INT64_MAX || defined HAVE_I64
+  uint64_t * AMXAPI amx_Align64(uint64_t *v);
+#endif
+int AMXAPI amx_Allot(AMX *amx, int cells, cell **address);
+int AMXAPI amx_Callback(AMX *amx, cell index, cell *result, const cell *params);
+int AMXAPI amx_Cleanup(AMX *amx);
+int AMXAPI amx_Clone(AMX *amxClone, AMX *amxSource, void *data);
+int AMXAPI amx_Exec(AMX *amx, cell *retval, int index);
+int AMXAPI amx_FindNative(AMX *amx, const char *name, int *index);
+int AMXAPI amx_FindPublic(AMX *amx, const char *name, int *index);
+int AMXAPI amx_FindPubVar(AMX *amx, const char *name, cell **address);
+int AMXAPI amx_FindTagId(AMX *amx, cell tag_id, char *tagname);
+int AMXAPI amx_Flags(AMX *amx,uint16_t *flags);
+int AMXAPI amx_GetNative(AMX *amx, int index, char *name);
+int AMXAPI amx_GetPublic(AMX *amx, int index, char *name, ucell *address);
+int AMXAPI amx_GetPubVar(AMX *amx, int index, char *name, cell **address);
+int AMXAPI amx_GetString(char *dest,const cell *source, int use_wchar, size_t size);
+int AMXAPI amx_GetTag(AMX *amx, int index, char *tagname, cell *tag_id);
+int AMXAPI amx_GetUserData(AMX *amx, long tag, void **ptr);
+int AMXAPI amx_Init(AMX *amx, void *program);
+int AMXAPI amx_InitJIT(AMX *amx, void *reloc_table, void *native_code);
+int AMXAPI amx_MemInfo(AMX *amx, long *codesize, long *datasize, long *stackheap);
+int AMXAPI amx_NameLength(AMX *amx, int *length);
+AMX_NATIVE_INFO * AMXAPI amx_NativeInfo(const char *name, AMX_NATIVE func);
+int AMXAPI amx_NumNatives(AMX *amx, int *number);
+int AMXAPI amx_NumPublics(AMX *amx, int *number);
+int AMXAPI amx_NumPubVars(AMX *amx, int *number);
+int AMXAPI amx_NumTags(AMX *amx, int *number);
+int AMXAPI amx_Push(AMX *amx, cell value);
+int AMXAPI amx_PushAddress(AMX *amx, cell *address);
+int AMXAPI amx_PushArray(AMX *amx, cell **address, const cell array[], int numcells);
+int AMXAPI amx_PushString(AMX *amx, cell **address, const char *string, int pack, int use_wchar);
+int AMXAPI amx_RaiseError(AMX *amx, int error);
+int AMXAPI amx_Register(AMX *amx, const AMX_NATIVE_INFO *nativelist, int number);
+int AMXAPI amx_Release(AMX *amx, cell *address);
+int AMXAPI amx_SetCallback(AMX *amx, AMX_CALLBACK callback);
+int AMXAPI amx_SetDebugHook(AMX *amx, AMX_DEBUG debug);
+int AMXAPI amx_SetString(cell *dest, const char *source, int pack, int use_wchar, size_t size);
+int AMXAPI amx_SetUserData(AMX *amx, long tag, void *ptr);
+int AMXAPI amx_StrLen(const cell *cstring, int *length);
+int AMXAPI amx_UTF8Check(const char *string, int *length);
+int AMXAPI amx_UTF8Get(const char *string, const char **endptr, cell *value);
+int AMXAPI amx_UTF8Len(const cell *cstr, int *length);
+int AMXAPI amx_UTF8Put(char *string, char **endptr, int maxchars, cell value);
+
+#if PAWN_CELL_SIZE==16
+  void amx_Swap16(uint16_t *v);
+#endif
+#if PAWN_CELL_SIZE==32
+  void amx_Swap32(uint32_t *v);
+#endif
+#if PAWN_CELL_SIZE==64 && (defined _I64_MAX || defined INT64_MAX || defined HAVE_I64)
+  void amx_Swap64(uint64_t *v);
+#endif
+
+#if PAWN_CELL_SIZE==16
+  #define amx_AlignCell(v) amx_Align16((uint16_t*)(v))
+  #define amx_SwapCell(v)  amx_Swap16((uint16_t*)(v))
+#elif PAWN_CELL_SIZE==32
+  #define amx_AlignCell(v) amx_Align32((uint32_t*)(v))
+  #define amx_SwapCell(v)  amx_Swap32((uint32_t*)(v))
+#elif PAWN_CELL_SIZE==64 && (defined _I64_MAX || defined INT64_MAX || defined HAVE_I64)
+  #define amx_AlignCell(v) amx_Align64((uint64_t*)(v))
+  #define amx_SwapCell(v)  amx_Swap64((uint64_t*)(v))
+#else
+  #error Unsupported cell size
+#endif
+
+#define amx_RegisterFunc(amx, name, func) \
+  amx_Register((amx), amx_NativeInfo((name),(func)), 1);
+
+#if !defined AMX_NO_ALIGN
+  #if defined __LINUX__ || defined __FreeBSD__ || defined __APPLE__
+    #pragma pack()    /* reset default packing */
+  #elif defined MACOS && defined __MWERKS__
+    #pragma options align=reset
+  #else
+    #pragma pack(pop) /* reset previous packing */
+  #endif
+#endif
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif /* AMX_H_INCLUDED */
diff --git a/apps/openmw-mp/amx/amxaux.c b/apps/openmw-mp/amx/amxaux.c
new file mode 100644
index 000000000..f4bebeacc
--- /dev/null
+++ b/apps/openmw-mp/amx/amxaux.c
@@ -0,0 +1,164 @@
+/*  Support routines for the Pawn Abstract Machine
+ *
+ *  Copyright (c) ITB CompuPhase, 2003-2011
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ *  use this file except in compliance with the License. You may obtain a copy
+ *  of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ *  License for the specific language governing permissions and limitations
+ *  under the License.
+ *
+ *  Version: $Id: amxaux.c 4523 2011-06-21 15:03:47Z thiadmer $
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "amx.h"
+#include "amxaux.h"
+
+size_t AMXAPI aux_ProgramSize(const char *filename)
+{
+  FILE *fp;
+  AMX_HEADER hdr;
+
+  if ((fp=fopen(filename,"rb")) == NULL)
+    return 0;
+  fread(&hdr, sizeof hdr, 1, fp);
+  fclose(fp);
+
+  amx_Align16(&hdr.magic);
+  amx_Align32((uint32_t *)&hdr.stp);
+  return (hdr.magic==AMX_MAGIC) ? (size_t)hdr.stp : 0;
+}
+
+int AMXAPI aux_LoadProgram(AMX *amx, const char *filename, void *memblock)
+{
+  FILE *fp;
+  AMX_HEADER hdr;
+  int result, didalloc;
+
+  /* open the file, read and check the header */
+  if ((fp = fopen(filename, "rb")) == NULL)
+    return AMX_ERR_NOTFOUND;
+  fread(&hdr, sizeof hdr, 1, fp);
+  amx_Align16(&hdr.magic);
+  amx_Align32((uint32_t *)&hdr.size);
+  amx_Align32((uint32_t *)&hdr.stp);
+  if (hdr.magic != AMX_MAGIC) {
+    fclose(fp);
+    return AMX_ERR_FORMAT;
+  } /* if */
+
+  /* allocate the memblock if it is NULL */
+  didalloc = 0;
+  if (memblock == NULL) {
+    if ((memblock = malloc(hdr.stp)) == NULL) {
+      fclose(fp);
+      return AMX_ERR_MEMORY;
+    } /* if */
+    didalloc = 1;
+    /* after amx_Init(), amx->base points to the memory block */
+  } /* if */
+
+  /* read in the file */
+  rewind(fp);
+  fread(memblock, 1, (size_t)hdr.size, fp);
+  fclose(fp);
+
+  /* initialize the abstract machine */
+  memset(amx, 0, sizeof *amx);
+  result = amx_Init(amx, memblock);
+
+  /* free the memory block on error, if it was allocated here */
+  if (result != AMX_ERR_NONE && didalloc) {
+    free(memblock);
+    amx->base = NULL;                   /* avoid a double free */
+  } /* if */
+
+  return result;
+}
+
+int AMXAPI aux_FreeProgram(AMX *amx)
+{
+  if (amx->base!=NULL) {
+    amx_Cleanup(amx);
+    free(amx->base);
+    memset(amx, 0, sizeof(AMX));
+  } /* if */
+  return AMX_ERR_NONE;
+}
+
+char * AMXAPI aux_StrError(int errnum)
+{
+static char *messages[] = {
+      /* AMX_ERR_NONE      */ "(none)",
+      /* AMX_ERR_EXIT      */ "Forced exit",
+      /* AMX_ERR_ASSERT    */ "Assertion failed",
+      /* AMX_ERR_STACKERR  */ "Stack/heap collision (insufficient stack size)",
+      /* AMX_ERR_BOUNDS    */ "Array index out of bounds",
+      /* AMX_ERR_MEMACCESS */ "Invalid memory access",
+      /* AMX_ERR_INVINSTR  */ "Invalid instruction",
+      /* AMX_ERR_STACKLOW  */ "Stack underflow",
+      /* AMX_ERR_HEAPLOW   */ "Heap underflow",
+      /* AMX_ERR_CALLBACK  */ "No (valid) native function callback",
+      /* AMX_ERR_NATIVE    */ "Native function failed",
+      /* AMX_ERR_DIVIDE    */ "Divide by zero",
+      /* AMX_ERR_SLEEP     */ "(sleep mode)",
+      /* AMX_ERR_INVSTATE  */ "Invalid state",
+      /* 14 */                "(reserved)",
+      /* 15 */                "(reserved)",
+      /* AMX_ERR_MEMORY    */ "Out of memory",
+      /* AMX_ERR_FORMAT    */ "Invalid/unsupported P-code file format",
+      /* AMX_ERR_VERSION   */ "File is for a newer version of the AMX",
+      /* AMX_ERR_NOTFOUND  */ "File or function is not found",
+      /* AMX_ERR_INDEX     */ "Invalid index parameter (bad entry point)",
+      /* AMX_ERR_DEBUG     */ "Debugger cannot run",
+      /* AMX_ERR_INIT      */ "AMX not initialized (or doubly initialized)",
+      /* AMX_ERR_USERDATA  */ "Unable to set user data field (table full)",
+      /* AMX_ERR_INIT_JIT  */ "Cannot initialize the JIT",
+      /* AMX_ERR_PARAMS    */ "Parameter error",
+      /* AMX_ERR_DOMAIN    */ "Domain error, expression result does not fit in range",
+      /* AMX_ERR_GENERAL   */ "General error (unknown or unspecific error)",
+      /* AMX_ERR_OVERLAY   */ "Overlays are unsupported (JIT) or uninitialized",
+    };
+  if (errnum < 0 || errnum >= sizeof messages / sizeof messages[0])
+    return "(unknown)";
+  return messages[errnum];
+}
+
+int AMXAPI aux_GetSection(const AMX *amx, int section, cell **start, size_t *size)
+{
+  AMX_HEADER *hdr;
+
+  if (amx == NULL || start == NULL || size == NULL)
+    return AMX_ERR_PARAMS;
+
+  hdr = (AMX_HEADER*)amx->base;
+  switch(section) {
+  case CODE_SECTION:
+    *start = (cell *)(amx->base + hdr->cod);
+    *size = hdr->dat - hdr->cod;
+    break;
+  case DATA_SECTION:
+    *start = (cell *)(amx->data);
+    *size = hdr->hea - hdr->dat;
+    break;
+  case HEAP_SECTION:
+    *start = (cell *)(amx->data + hdr->hea);
+    *size = amx->hea - hdr->hea;
+    break;
+  case STACK_SECTION:
+    *start = (cell *)(amx->data + amx->stk);
+    *size = amx->stp - amx->stk;
+    break;
+  default:
+    return AMX_ERR_PARAMS;
+  } /* switch */
+  return AMX_ERR_NONE;
+}
diff --git a/apps/openmw-mp/amx/amxaux.h b/apps/openmw-mp/amx/amxaux.h
new file mode 100644
index 000000000..093a96fa6
--- /dev/null
+++ b/apps/openmw-mp/amx/amxaux.h
@@ -0,0 +1,50 @@
+/*  Support routines for the Pawn Abstract Machine
+ *
+ *  Copyright (c) ITB CompuPhase, 2003-2011
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ *  use this file except in compliance with the License. You may obtain a copy
+ *  of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ *  License for the specific language governing permissions and limitations
+ *  under the License.
+ *
+ *  Version: $Id: amxaux.h 4523 2011-06-21 15:03:47Z thiadmer $
+ */
+#ifndef AMXAUX_H_INCLUDED
+#define AMXAUX_H_INCLUDED
+
+#include "amx.h"
+
+#ifdef  __cplusplus
+extern  "C" {
+#endif
+
+/* loading and freeing programs */
+size_t AMXAPI aux_ProgramSize(const char *filename);
+int AMXAPI aux_LoadProgram(AMX *amx, const char *filename, void *memblock);
+int AMXAPI aux_FreeProgram(AMX *amx);
+
+/* a readable error message from an error code */
+char * AMXAPI aux_StrError(int errnum);
+
+enum {
+  CODE_SECTION,
+  DATA_SECTION,
+  HEAP_SECTION,
+  STACK_SECTION,
+  /* ----- */
+  NUM_SECTIONS
+};
+int AMXAPI aux_GetSection(const AMX *amx, int section, cell **start, size_t *size);
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif /* AMXAUX_H_INCLUDED */
diff --git a/apps/openmw-mp/amx/amxcons.c b/apps/openmw-mp/amx/amxcons.c
new file mode 100644
index 000000000..f02b2feda
--- /dev/null
+++ b/apps/openmw-mp/amx/amxcons.c
@@ -0,0 +1,1448 @@
+/* Console output module (terminal I/O) for the Pawn AMX
+ *
+ *  Since some of these routines go further than those of standard C, they
+ *  cannot always be implemented with portable C functions. In other words,
+ *  these routines must be ported to other environments.
+ *
+ *  Copyright (c) ITB CompuPhase, 1997-2015
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ *  use this file except in compliance with the License. You may obtain a copy
+ *  of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ *  License for the specific language governing permissions and limitations
+ *  under the License.
+ *
+ *  Version: $Id: amxcons.c 5181 2015-01-21 09:44:28Z thiadmer $
+ */
+
+#if defined _UNICODE || defined __UNICODE__ || defined UNICODE
+# if !defined UNICODE   /* for Windows */
+#   define UNICODE
+# endif
+# if !defined _UNICODE  /* for C library */
+#   define _UNICODE
+# endif
+#endif
+
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#if defined __WIN32__ || defined _WIN32 || defined WIN32 || defined __MSDOS__
+  #define HAVE_CONIO
+  #include <conio.h>
+  #include <malloc.h>
+#endif
+#if defined USE_CURSES || defined HAVE_CURSES_H
+  #include <curses.h>
+  #if !defined CURSES
+    #define CURSES  1
+  #endif
+#endif
+#include "osdefs.h"
+#if defined __ECOS__
+  /* eCos puts include files in cyg/package_name */
+  #include <cyg/hal/hal_if.h>
+  #include <cyg/infra/diag.h>
+  #include <cyg/hal/hal_diag.h>
+  #include <cyg/pawn/amx.h>
+#else
+  #include "amx.h"
+#endif
+#if defined __WIN32__ || defined _WIN32 || defined WIN32
+  #include <windows.h>
+#endif
+
+#if defined _UNICODE
+# include <tchar.h>
+#elif !defined __T
+  typedef char          TCHAR;
+# define __T(string)    string
+# define _fgetts        fgets
+# define _puttchar      putchar
+# define _stprintf      sprintf
+# define _tcschr        strchr
+# define _tcscpy        strcpy
+# define _tcsdup        strdup
+# define _tcslen        strlen
+# define _tprintf       printf
+#endif
+#include "amxcons.h"
+
+#if defined AMX_TERMINAL
+  #define EOL_CHAR       '\r'
+#endif
+#if defined __WIN32__ || defined _WIN32 || defined WIN32 || defined __MSDOS__
+  #define EOL_CHAR       '\r'
+#endif
+#if !defined EOL_CHAR
+  /* if not a "known" operating system, assume Linux/Unix */
+  #define EOL_CHAR     '\n'
+#endif
+
+#if !defined AMX_STRING_LIB
+
+#if defined AMX_TERMINAL
+  /* required functions are implemented elsewhere */
+  int amx_putstr(const TCHAR *);
+  int amx_putchar(int);
+  int amx_fflush(void);
+  int amx_getch(void);
+  TCHAR *amx_gets(TCHAR *,int);
+  int amx_termctl(int,int);
+  void amx_clrscr(void);
+  void amx_clreol(void);
+  int amx_gotoxy(int x,int y);
+  void amx_wherexy(int *x,int *y);
+  unsigned int amx_setattr(int foregr,int backgr,int highlight);
+  void amx_console(int columns, int lines, int flags);
+  void amx_viewsize(int *width,int *height);
+  int amx_kbhit(void);
+#elif defined CURSES && CURSES != 0
+  /* Use the "curses" library to implement the console */
+  static WINDOW *curseswin;
+  #define amx_putstr(s)       printw("%s",(s))
+  #define amx_putchar(c)      addch(c)
+  #define amx_fflush()        refresh()
+  #define amx_getch()         getch()
+  #define amx_gets(s,n)       getnstr((s),(n))
+  #define amx_clrscr()        clear()
+  #define amx_clreol()        clrtoeol()
+  #define amx_gotoxy(x,y)     move((y)-1,(x)-1)
+  #define amx_console(c,l,f)  ((void)(c),(void)(l),(void)(f))
+  unsigned int amx_setattr(int foregr,int backgr,int highlight)
+  {
+    if (highlight>0)
+      attron(A_STANDOUT);
+    else
+      attroff(A_STANDOUT);
+    //??? in future, also handle colours
+  }
+  void CreateConsole(void);
+  int amx_kbhit(void)
+  {
+    int result;
+    CreateConsole();
+    nodelay(curseswin,TRUE);    /* enter non-blocking state */
+    result=getch();             /* read key (if any) */
+    nodelay(curseswin,FALSE);   /* leave non-blocking state */
+    if (result!=ERR)
+      ungetch(result);          /* a key is waiting, push it back */
+    return (result==ERR) ? 0 : 1;
+  }
+  int amx_termctl(int code,int value)
+  {
+    switch (code) {
+    case 0:           /* query terminal support */
+      return 1;
+    /* case 1: */     /* switch auto-wrap on/off (not supported in curses!) */
+    /* case 2: */     /* create/switch to another console */
+    case 3:           /* set emphasized font */
+      if (value)
+        attron(A_BOLD);
+      else
+        attroff(A_BOLD);
+      return 1;
+    /* case 4: */     /* query whether a terminal is "open" */
+    default:
+      return 0;
+    } /* switch */
+  }
+  void amx_wherexy(int *x,int *y)
+  {
+    int row,col;
+    getyx(curseswin,row,col);
+    if (x!=NULL)
+      *x=col+1;
+    if (y!=NULL)
+      *y=row+1;
+  }
+  void amx_viewsize(int *width,int *height)
+  {
+    int row,col;
+    getmaxyx(curseswin,row,col);
+    if (width!=NULL)
+      *width=col;
+    if (height!=NULL)
+      *height=row;
+  }
+#elif defined VT100 || defined __LINUX__ || defined ANSITERM || defined __ECOS__
+  /* ANSI/VT100 terminal, or shell emulating "xterm" */
+  #if defined __ECOS__
+    #define AMXCONSOLE_NOIDLE
+  #endif
+
+  #if CYGPKG_PAWN_AMXCONSOLE_DIAG==1
+    /* eCos has basically two ways to make simple exchanges with a terminal:
+     * - with the diag_*() functions (no input provided!)
+     * - with f*() functions (fprintf(),fputs(), etc).
+     */
+    #define amx_fflush()
+
+    static int amx_putstr(TCHAR *s)
+    {
+      diag_write_string(s);
+      return 1;
+    }
+    static int amx_putchar(TCHAR c)
+    {
+      diag_write_char(c);
+      return c;
+    }
+    static char amx_getch(void)
+    {
+      char c=-1;
+      HAL_DIAG_READ_CHAR(c);
+      return c;
+    }
+  #else
+
+    #define amx_putstr(s)     fputs((s),stdout)
+    #define amx_putchar(c)    putchar(c)
+    #define amx_fflush()      fflush(stdout)
+    #define amx_getch()       getch()
+    #define amx_gets(s,n)     fgets(s,n,stdin)
+    #define amx_kbhit()       kbhit()
+  #endif
+
+  int amx_termctl(int code,int value)
+  {
+    switch (code) {
+    case 0:             /* query terminal support */
+      return 1;
+
+    case 1:             /* switch "auto-wrap" on or off */
+      if (value)
+        amx_putstr("\033[?7h"); /* enable "auto-wrap" */
+      else
+        amx_putstr("\033[?7l"); /* disable "auto-wrap" */
+      return 1;
+
+    #if 0
+      /* next to swapping buffers, more information should be saved and swapped,
+       * such as the cursor position and the current terminal attributes
+       */
+    case 2:             /* swap console buffers */
+      amx_fflush();
+      if (value==1) {
+        amx_putstr("\033[?47h");
+      } else {
+        amx_putstr("\033[?47l");
+      } /* if */
+      amx_fflush();
+      return 1;
+    #endif
+
+    case 3:             /* set bold/highlighted font */
+      return 0;
+
+    default:
+      return 0;
+    } /* switch */
+  }
+  void amx_clrscr(void)
+  {
+    amx_putstr("\033[2J");
+    amx_fflush();        /* pump through the terminal codes */
+  }
+  void amx_clreol(void)
+  {
+    amx_putstr("\033[K");
+    amx_fflush();        /* pump through the terminal codes */
+  }
+  int amx_gotoxy(int x,int y)
+  {
+    char str[30];
+    _stprintf(str,"\033[%d;%dH",y,x);
+    amx_putstr(str);
+    amx_fflush();        /* pump through the terminal codes */
+    return 1;
+  }
+  void amx_wherexy(int *x,int *y)
+  {
+    int val,i;
+    char str[10];
+
+    assert(x!=NULL && y!=NULL);
+    amx_putstr("\033[6n");
+    amx_fflush();
+    while (amx_getch()!='\033')
+      /* nothing */;
+    val=amx_getch();
+    assert(val=='[');
+    for (i=0; i<8 && (val=amx_getch())!=';'; i++)
+      str[i]=(char)val;
+    str[i]='\0';
+    if (y!=NULL)
+      *y=atoi(str);
+    for (i=0; i<8 && (val=amx_getch())!='R'; i++)
+      str[i]=(char)val;
+    str[i]='\0';
+    if (x!=NULL)
+      *x=atoi(str);
+    #if defined ANSITERM
+      val=amx_getch();
+      assert(val=='\r');    /* ANSI driver adds CR to the end of the command */
+    #endif
+  }
+  unsigned int amx_setattr(int foregr,int backgr,int highlight)
+  {
+    static short current=(0 << 8) | 7;
+    short prev = current;
+    char str[30];
+
+    if (foregr>=0) {
+      _stprintf(str,"\x1b[%dm",foregr+30);
+      amx_putstr(str);
+      current=(current & 0xff00) | (foregr & 0x0f);
+    } /* if */
+    if (backgr>=0) {
+      _stprintf(str,"\x1b[%dm",backgr+40);
+      amx_putstr(str);
+      current=(current & 0x00ff) | ((backgr & 0x0f) << 8);
+    } /* if */
+    if (highlight>=0) {
+      _stprintf(str,"\x1b[%dm",highlight);
+      amx_putstr(str);
+      current=(current & 0x7fff) | ((highlight & 0x01) << 15);
+    } /* if */
+    return prev;
+  }
+  void amx_console(int columns, int lines, int flags)
+  {
+    char str[30];
+
+    (void)flags;
+    /* There is no ANSI code (or VT100/VT220) to set the size of the console
+     * (indeed, the terminal was that of the alphanumeric display). In xterm (a
+     * terminal emulator) we can set the terminal size though, and most
+     * terminals that in use today are in fact emulators.
+     * Putty understands this code too, by many others do not.
+     */
+    sprintf(str,"\033[8;%d;%dt",lines,columns);
+    amx_putstr(str);
+    amx_fflush();
+  }
+  void amx_viewsize(int *width,int *height)
+  {
+    /* a trick to get the size of the terminal is to position the cursor far
+     * away and then read it back
+     */
+    amx_gotoxy(999,999);
+    amx_wherexy(width,height);
+  }
+#elif defined __WIN32__ || defined _WIN32 || defined WIN32
+  /* Win32 console */
+  #define amx_putstr(s)       _tprintf("%s",(s))
+  #define amx_putchar(c)      _puttchar(c)
+  #define amx_fflush()        fflush(stdout)
+  #define amx_gets(s,n)       _fgetts(s,n,stdin)
+
+  int amx_termctl(int code,int value)
+  {
+    switch (code) {
+    case 0:             /* query terminal support */
+      return 1;
+
+    case 1: {           /* switch auto-wrap on/off */
+      /* only works in Windows 2000/XP */
+      HANDLE hConsole=GetStdHandle(STD_OUTPUT_HANDLE);
+      DWORD mode;
+      GetConsoleMode(hConsole,&mode);
+      if (value)
+        mode |= ENABLE_WRAP_AT_EOL_OUTPUT;
+      else
+        mode &= ~ENABLE_WRAP_AT_EOL_OUTPUT;
+      SetConsoleMode(hConsole,mode);
+      return 1;
+    } /* case */
+
+    /* case 2: */     /* create/switch to another console */
+    /* case 3: */     /* set emphasized font */
+    /* case 4: */     /* query whether a terminal is "open" */
+    default:
+      return 0;
+    } /* switch */
+  }
+  void amx_clrscr(void)
+  {
+    COORD coordScreen={0,0};
+    DWORD cCharsWritten;
+    CONSOLE_SCREEN_BUFFER_INFO csbi;
+    DWORD dwConSize;
+    HANDLE hConsole=GetStdHandle(STD_OUTPUT_HANDLE);
+
+    amx_fflush();       /* make sure the I/O buffer is empty */
+    GetConsoleScreenBufferInfo(hConsole,&csbi);
+    dwConSize=csbi.dwSize.X*csbi.dwSize.Y;
+    FillConsoleOutputCharacter(hConsole,' ',dwConSize,coordScreen,&cCharsWritten);
+    FillConsoleOutputAttribute(hConsole,csbi.wAttributes,dwConSize,coordScreen, &cCharsWritten);
+    SetConsoleCursorPosition(hConsole,coordScreen);
+  }
+  void amx_clreol(void)
+  {
+    DWORD cCharsWritten;
+    CONSOLE_SCREEN_BUFFER_INFO csbi;
+    DWORD dwConSize;
+    HANDLE hConsole=GetStdHandle(STD_OUTPUT_HANDLE);
+
+    amx_fflush();       /* make sure all output is written */
+    GetConsoleScreenBufferInfo(hConsole,&csbi);
+    dwConSize=csbi.dwSize.X - csbi.dwCursorPosition.X;
+    FillConsoleOutputCharacter(hConsole,' ',dwConSize,csbi.dwCursorPosition,&cCharsWritten);
+    FillConsoleOutputAttribute(hConsole,csbi.wAttributes,dwConSize,csbi.dwCursorPosition,&cCharsWritten);
+  }
+  int amx_gotoxy(int x,int y)
+  {
+    COORD point;
+    CONSOLE_SCREEN_BUFFER_INFO csbi;
+    HANDLE hConsole=GetStdHandle(STD_OUTPUT_HANDLE);
+
+    GetConsoleScreenBufferInfo(hConsole, &csbi);
+    if (x<=0 || x>csbi.dwSize.X || y<=0 || y>csbi.dwSize.Y)
+      return 0;
+    amx_fflush();       /* make sure all output is written */
+    point.X=(short)(x-1);
+    point.Y=(short)(y-1);
+    SetConsoleCursorPosition(hConsole,point);
+    return 1;
+  }
+  void amx_wherexy(int *x,int *y)
+  {
+    CONSOLE_SCREEN_BUFFER_INFO csbi;
+    amx_fflush();       /* make sure all output is written */
+    GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi);
+    if (x!=NULL)
+      *x=csbi.dwCursorPosition.X+1;
+    if (y!=NULL)
+      *y=csbi.dwCursorPosition.Y+1;
+  }
+  unsigned int amx_setattr(int foregr,int backgr,int highlight)
+  {
+    static int ansi_colours[] = { 0, 4, 2, 6, 1, 5, 3, 7 };
+    CONSOLE_SCREEN_BUFFER_INFO csbi;
+    int f,b,h,prev;
+    HANDLE hConsole=GetStdHandle(STD_OUTPUT_HANDLE);
+
+    amx_fflush();       /* make sure all output is written */
+    GetConsoleScreenBufferInfo(hConsole,&csbi);
+    f=csbi.wAttributes & 0x07;
+    b=(csbi.wAttributes >> 4) & 0x0f;
+    h=(csbi.wAttributes & 0x08) ? 1 : 0;
+    prev=(b << 8) | f | (h << 15);
+    if (foregr>=0 && foregr<8)
+      f=ansi_colours[foregr];
+    if (backgr>=0 && backgr<8)
+      b=ansi_colours[backgr];
+    if (highlight>=0)
+      h=highlight!=0;
+    SetConsoleTextAttribute(hConsole, (WORD)((b << 4) | f | (h << 3)));
+    return prev;
+  }
+  void amx_console(int columns, int lines, int flags)
+  {
+    SMALL_RECT rect;
+    COORD dwSize;
+    HANDLE hConsole;
+    (void)flags;
+    dwSize.X=(short)columns;
+    dwSize.Y=(short)lines;
+    hConsole=GetStdHandle(STD_OUTPUT_HANDLE);
+    SetConsoleScreenBufferSize(hConsole,dwSize);
+    rect.Left=0;
+    rect.Top=0;
+    rect.Right=(short)(columns-1);
+    rect.Bottom=(short)(lines-1);
+    SetConsoleWindowInfo(hConsole,TRUE,&rect);
+  }
+  void amx_viewsize(int *width,int *height)
+  {
+    CONSOLE_SCREEN_BUFFER_INFO csbi;
+    GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE),&csbi);
+    if (width!=NULL)
+      *width=(int)csbi.dwSize.X;
+    if (height!=NULL)
+      *height=(int)(csbi.srWindow.Bottom-csbi.srWindow.Top+1);
+  }
+  int amx_getch(void)
+  {
+    TCHAR ch;
+    DWORD count,mode;
+    HANDLE hConsole=GetStdHandle(STD_INPUT_HANDLE);
+    GetConsoleMode(hConsole,&mode);
+    SetConsoleMode(hConsole,mode & ~(ENABLE_LINE_INPUT|ENABLE_ECHO_INPUT));
+    while (ReadFile(hConsole,&ch,1,&count,NULL) && count==0)
+      /* nothing */;
+    SetConsoleMode(hConsole,mode);
+    if (count>0)
+      return ch;
+    return EOF;
+  }
+  int amx_kbhit(void)
+  {
+    DWORD count=0;
+    HANDLE hConsole;
+    hConsole=GetStdHandle(STD_INPUT_HANDLE);
+    if (GetFileType(hConsole)==FILE_TYPE_PIPE) {
+      PeekNamedPipe(hConsole,NULL,0,NULL,&count,NULL);
+    } else {
+      INPUT_RECORD rec;
+      while (PeekConsoleInput(hConsole,&rec,1,&count)) {
+        if (count==0 || (rec.EventType==KEY_EVENT && rec.Event.KeyEvent.bKeyDown))
+          break;
+        ReadConsoleInput(hConsole,&rec,1,&count);
+      }
+    }
+    return (count>0);
+  }
+#else
+  /* assume a streaming terminal; limited features (no colour, no cursor
+   * control)
+   */
+  #define amx_putstr(s)       printf("%s",(s))
+  #define amx_putchar(c)      putchar(c)
+  #define amx_fflush()        fflush(stdout)
+  #define amx_gets(s,n)       fgets(s,n,stdin)
+  #define amx_clrscr()        (void)(0)
+  #define amx_clreol()        (void)(0)
+  #define amx_gotoxy(x,y)     ((void)(x),(void)(y),(0))
+  #define amx_wherexy(x,y)    (*(x)=*(y)=0)
+  #define amx_setattr(c,b,h)  ((void)(c),(void)(b),(void)(h),(0))
+  #define amx_termctl(c,v)    ((void)(c),(void)(v),(0))
+  #define amx_console(c,l,f)  ((void)(c),(void)(l),(void)(f))
+  #define amx_viewsize        (*(x)=80,*(y)=25)
+  #if defined HAVE_CONIO
+    #define amx_getch()       getch()
+    #define amx_kbhit()       kbhit()
+  #else
+    #define amx_getch()       getchar()
+    #define amx_kbhit()       (0)
+  #endif
+#endif
+
+#if !defined AMX_TERMINAL && (defined __WIN32__ || defined _WIN32 || defined WIN32)
+  void CreateConsole(void)
+  { static int createdconsole=0;
+    if (!createdconsole) {
+  	  AllocConsole();
+  	  createdconsole=1;
+  	} /* if */
+  }
+#elif defined CURSES && CURSES != 0
+  // The Mac OS X build variant uses curses.
+  void CreateConsole(void)
+  { static int createdconsole=0;
+    if (!createdconsole) {
+      curseswin=initscr();
+      if (has_colors())
+        start_color();
+      cbreak();
+      noecho();
+      nonl();
+      scrollok(curseswin,TRUE);
+      intrflush(curseswin,FALSE);
+      keypad(curseswin,TRUE);
+      createdconsole=1;
+    } /* if */
+  }
+#else
+  #define CreateConsole()
+#endif
+
+static int cons_putstr(void *dest,const TCHAR *str)
+{
+  (void)dest;
+  return amx_putstr(str);
+}
+
+static int cons_putchar(void *dest,TCHAR ch)
+{
+  (void)dest;
+  return amx_putchar(ch);
+}
+
+#endif /* AMX_STRING_LIB */
+
+enum {
+  SV_DECIMAL,
+  SV_HEX
+};
+
+static TCHAR *reverse(TCHAR *string,int stop)
+{
+	int start=0;
+	TCHAR temp;
+
+	/* swap the string */
+	stop--;				/* avoid swapping the '\0' byte to the first position */
+	while (stop - start > 0) {
+		temp = string[start];
+		string[start] = string[stop];
+		string[stop] = temp;
+		start++;
+		stop--;
+	} /* while */
+	return string;
+}
+
+/* Converts an integral value to a string, with optional padding with spaces or
+ * zeros.
+ * The "format" must be decimal or hexadecimal
+ * The number is right-aligned in the field with the size of the absolute value
+ * of the "width" parameter.
+ * If the width value is positive, the string is padded with spaces; if it is
+ * negative, it is padded with zeros.
+ */
+static TCHAR *amx_strval(TCHAR buffer[], long value, int format, int width)
+{
+	int start, stop;
+	TCHAR temp;
+
+	start = stop = 0;
+	if (format == SV_DECIMAL) {
+		if (value < 0) {
+			buffer[0] = __T('-');
+			start = stop = 1;
+			value = -value;
+		} /* if */
+		do {
+			buffer[stop++] = (TCHAR)((value % 10) + __T('0'));
+			value /= 10;
+		} while (value > 0);
+	} else {
+		/* hexadecimal */
+		unsigned long v = (unsigned long)value;	/* copy to unsigned value for shifting */
+		do {
+			buffer[stop] = (TCHAR)((v & 0x0f) + __T('0'));
+			if (buffer[stop] > __T('9'))
+				buffer[stop] += (TCHAR)(__T('A') - __T('0') - 10);
+			v >>= 4;
+			stop++;
+		} while (v != 0);
+	} /* if */
+
+	/* pad to given width */
+	if (width < 0) {
+		temp = __T('0');
+		width = -width;
+	} else {
+		temp = __T(' ');
+	} /* if */
+	while (stop < width)
+		buffer[stop++] = temp;
+
+	buffer[stop] = __T('\0');
+
+	/* swap the string, and we are done */
+	reverse(buffer+start,stop-start);
+	return buffer;
+}
+
+#if defined FIXEDPOINT
+  #define FIXEDMULT     1000
+  #define FIXEDDIGITS   3
+
+static TCHAR *formatfixed(TCHAR *string,cell value,TCHAR align,int width,TCHAR decpoint,int digits,TCHAR filler)
+{
+  int i, len;
+  cell ipart,v;
+  TCHAR vsign=__T('\0');
+
+  /* make the value positive (but keep the sign) */
+  if (value<0) {
+    value=-value;
+    vsign=__T('-');
+  } /* if */
+
+  /* "prepare" the value so that when it is truncated to the requested
+   * number of digits, the result is rounded towards the dropped digits
+   */
+  assert(digits<INT_MAX);
+  v=FIXEDMULT/2;
+  for (i=0; i<digits; i++)
+    v/=10;
+  value+=v;
+
+  /* get the integer part and remove it from the value */
+  ipart=value/FIXEDMULT;
+  value-=FIXEDMULT*ipart;
+  assert(ipart>=0);
+  assert(value>=0);
+
+  /* truncate the fractional part to the requested number of digits */
+  for (i=FIXEDDIGITS; i>digits; i--)
+    value/=10;
+
+  string[0]=__T('\0');
+
+  /* add sign */
+  i=(int)_tcslen(string);
+  string[i]=vsign;
+  string[i+1]=__T('\0');
+
+  /* add integer part */
+  amx_strval(string+_tcslen(string),(long)ipart,SV_DECIMAL,0);
+
+  /* add fractional part */
+  if (digits>0) {
+    i=(int)_tcslen(string);
+    string[i]=decpoint;
+    amx_strval(string+i+1,(long)value,SV_DECIMAL,-digits);
+  } /* if */
+
+  len=(int)_tcslen(string);
+  if (len<width) {
+    /* pad to the requested width */
+    for (i=len; i<width; i++)
+      string[i]=filler;
+    string[i]=__T('\0');
+    /* optionally move the padding to the beginning of the string, using the handwaving algorithm */
+    if (align!=__T('-')) {
+      assert(i==(int)_tcslen(string));
+      assert(i>=len);
+      reverse(string,len);
+      reverse(string+len,i-len);
+      reverse(string,i);
+    } /* if */
+  } /* if */
+
+  return string;
+}
+#endif
+
+
+static int dochar(AMX *amx,TCHAR ch,cell param,TCHAR sign,TCHAR decpoint,int width,int digits,TCHAR filler,
+                  int (*f_putstr)(void*,const TCHAR *),int (*f_putchar)(void*,TCHAR),void *user)
+{
+  cell *cptr;
+  TCHAR buffer[40];
+  #if defined FLOATPOINT
+    TCHAR formatstring[40];
+  #endif
+
+  #if !defined FIXEDPOINT && !defined FLOATPOINT
+    (void)decpoint;
+  #endif
+  assert(f_putstr!=NULL);
+  assert(f_putchar!=NULL);
+
+  switch (ch) {
+  case __T('c'):
+    cptr=amx_Address(amx,param);
+    width--;            /* single character itself has a with of 1 */
+    if (sign!=__T('-'))
+      while (width-->0)
+        f_putchar(user,filler);
+    f_putchar(user,(TCHAR)*cptr);
+    while (width-->0)
+      f_putchar(user,filler);
+    return 1;
+
+  case __T('d'): {
+    cell value;
+    int length=1;
+    cptr=amx_Address(amx,param);
+    value=*cptr;
+    if (value<0 || sign==__T('+'))
+      length++;
+    if (value<0)
+      value=-value;
+    while (value>=10) {
+      length++;
+      value/=10;
+    } /* while */
+    width-=length;
+    if (sign!=__T('-'))
+      while (width-->0)
+        f_putchar(user,filler);
+    amx_strval(buffer,*cptr,SV_DECIMAL,0);
+    if (sign==__T('+') && *cptr>=0)
+      f_putchar(user,sign);
+    f_putstr(user,buffer);
+    while (width-->0)
+      f_putchar(user,filler);
+    return 1;
+  } /* case */
+
+#if defined FLOATPOINT
+  case __T('f'): /* 32-bit floating point number */
+  case __T('r'): /* if floating point is enabled, %r == %f */
+    /* build a format string */
+    if (digits==INT_MAX)
+      digits=5;
+    else if (digits>25)
+      digits=25;
+    _tcscpy(formatstring,__T("%"));
+    if (sign!=__T('\0'))
+      _stprintf(formatstring+_tcslen(formatstring),__T("%c"),sign);
+    if (width>0)
+      _stprintf(formatstring+_tcslen(formatstring),__T("%d"),width);
+    _stprintf(formatstring+_tcslen(formatstring),__T(".%df"),digits);
+    cptr=amx_Address(amx,param);
+    #if PAWN_CELL_SIZE == 64
+      _stprintf(buffer,formatstring,*(double*)cptr);
+    #else
+      _stprintf(buffer,formatstring,*(float*)cptr);
+    #endif
+    if (decpoint==__T(',')) {
+      TCHAR *ptr=_tcschr(buffer,__T('.'));
+      if (ptr!=NULL)
+        *ptr=__T(',');
+    } /* if */
+    f_putstr(user,buffer);
+    return 1;
+#endif
+
+#if defined FIXEDPOINT
+  #define FIXEDMULT 1000
+  case __T('q'): /* 32-bit fixed point number */
+#if !defined FLOATPOINT
+  case __T('r'): /* if fixed point is enabled, and floating point is not, %r == %q */
+#endif
+    cptr=amx_Address(amx,param);
+    /* format the number */
+    if (digits==INT_MAX)
+      digits=3;
+    else if (digits>25)
+      digits=25;
+    formatfixed(buffer,*cptr,sign,width,decpoint,digits,filler);
+    assert(_tcslen(buffer)<sizeof buffer);
+    f_putstr(user,buffer);
+    return 1;
+#endif
+
+#if !defined FLOATPOINT && !defined FIXEDPOINT
+  case __T('f'):
+  case __T('q'):
+  case __T('r'):
+    f_putstr(user,__T("(no rational number support)"));
+    return 0; /* flag this as an error */
+#endif
+
+  case __T('s'): {
+    AMX_FMTINFO info;
+    memset(&info,0,sizeof info);
+    info.length=digits;
+    info.f_putstr=f_putstr;
+    info.f_putchar=f_putchar;
+    info.user=user;
+    cptr=amx_Address(amx,param);
+    amx_printstring(amx,cptr,&info);
+    return 1;
+  } /* case */
+
+  case __T('x'): {
+    ucell value;
+    int length=1;
+    cptr=amx_Address(amx,param);
+    value=*(ucell*)cptr;
+    while (value>=0x10) {
+      length++;
+      value>>=4;
+    } /* while */
+    width-=length;
+    if (sign!=__T('-'))
+      while (width-->0)
+        f_putchar(user,filler);
+    amx_strval(buffer,(long)*cptr,SV_HEX,0);
+    f_putstr(user,buffer);
+    while (width-->0)
+      f_putchar(user,filler);
+    return 1;
+  } /* case */
+
+  } /* switch */
+  /* error in the string format, try to repair */
+  f_putchar(user,ch);
+  return 0;
+}
+
+enum {
+  FMT_NONE,   /* not in format state; accept '%' */
+  FMT_START,  /* found '%', accept '+', '-' (START), '0' (filler; START), digit (WIDTH), '.' (DECIM), or '%' or format letter (done) */
+  FMT_WIDTH,  /* found digit after '%' or sign, accept digit (WIDTH), '.' (DECIM) or format letter (done) */
+  FMT_DECIM,  /* found digit after '.', accept accept digit (DECIM) or format letter (done) */
+};
+
+static int formatstate(TCHAR c,int *state,TCHAR *sign,TCHAR *decpoint,int *width,int *digits,TCHAR *filler)
+{
+  assert(state!=NULL && sign!=NULL && decpoint!=NULL && width!=NULL && digits!=NULL && filler!=NULL);
+  switch (*state) {
+  case FMT_NONE:
+    if (c==__T('%')) {
+      *state=FMT_START;
+      *sign=__T('\0');
+      *decpoint=__T('.');
+      *width=0;
+      *digits=INT_MAX;
+      *filler=__T(' ');
+    } else {
+      return -1;  /* print a single character */
+    } /* if */
+    break;
+  case FMT_START:
+    if (c==__T('+') || c==__T('-')) {
+      *sign=c;
+    } else if (c==__T('0')) {
+      *filler=c;
+    } else if (c>=__T('1') && c<=__T('9')) {
+      *width=(int)(c-__T('0'));
+      *state=FMT_WIDTH;
+    } else if (c==__T('.') || c==__T(',')) {
+      *decpoint=c;
+      *digits=0;
+      *state=FMT_DECIM;
+    } else if (c==__T('%')) {
+      *state=FMT_NONE;
+      return -1;  /* print literal '%' */
+    } else {
+      return 1;   /* print formatted character */
+    } /* if */
+    break;
+  case FMT_WIDTH:
+    if (c>=__T('0') && c<=__T('9')) {
+      *width=*width*10+(int)(c-__T('0'));
+    } else if (c==__T('.') || c==__T(',')) {
+      *decpoint=c;
+      *digits=0;
+      *state=FMT_DECIM;
+    } else {
+      return 1;   /* print formatted character */
+    } /* if */
+    break;
+  case FMT_DECIM:
+    if (c>=__T('0') && c<=__T('9')) {
+      *digits=*digits*10+(int)(c-__T('0'));
+    } else {
+      return 1;   /* print formatted character */
+    } /* if */
+    break;
+  } /* switch */
+
+  return 0;
+}
+
+int amx_printstring(AMX *amx,cell *cstr,AMX_FMTINFO *info)
+{
+  int i,paramidx=0;
+  int fmtstate=FMT_NONE,width,digits;
+  TCHAR sign,decpoint,filler;
+  int (*f_putstr)(void*,const TCHAR *);
+  int (*f_putchar)(void*,TCHAR);
+  void *user;
+  int skip,length;
+
+  if (info!=NULL) {
+    f_putstr=info->f_putstr;
+    f_putchar=info->f_putchar;
+    user=info->user;
+    skip=info->skip;
+    length=info->length;
+  } else {
+    f_putstr=NULL;
+    f_putchar=NULL;
+    user=NULL;
+    skip=0;
+    length=INT_MAX;
+  } /* if */
+  #if !defined AMX_STRING_LIB
+    if (f_putstr==NULL)
+      f_putstr=cons_putstr;
+    if (f_putchar==NULL)
+      f_putchar=cons_putchar;
+  #else
+    assert(f_putstr!=NULL && f_putchar!=NULL);
+  #endif
+
+  /* if no placeholders appear, we can use a quicker routine */
+  if (info==NULL || info->params==NULL) {
+
+    TCHAR cache[100];
+    int idx=0;
+
+    if ((ucell)*cstr>UNPACKEDMAX) {
+      int j=sizeof(cell)-sizeof(char);
+      char c;
+      /* the string is packed */
+      i=0;
+      for ( ; ; ) {
+        c=(char)((ucell)cstr[i] >> 8*j);
+        if (c==0)
+          break;
+        if (skip>0) {
+          skip--;               /* skip a number of characters */
+        } else {
+          if (length--<=0)
+            break;              /* print up to a certain length */
+          assert(idx<sizeof cache);
+          cache[idx++]=c;
+          if (idx==sizeof cache - 1) {
+            cache[idx]=__T('\0');
+            f_putstr(user,cache);
+            idx=0;
+          } /* if */
+        } /* if */
+        if (j==0)
+          i++;
+        j=(j+sizeof(cell)-sizeof(char)) % sizeof(cell);
+      } /* for */
+    } else {
+      /* unpacked string */
+      for (i=0; cstr[i]!=0; i++) {
+      	if (skip-->0)
+      	  continue;
+        assert(idx<sizeof cache);
+        cache[idx++]=(TCHAR)cstr[i];
+        if (idx==sizeof cache - 1) {
+          cache[idx]=__T('\0');
+          f_putstr(user,cache);
+          idx=0;
+        } /* if */
+      } /* for */
+    } /* if */
+    if (idx>0) {
+      cache[idx]=__T('\0');
+      f_putstr(user,cache);
+    } /* if */
+
+  } else {
+
+    /* check whether this is a packed string */
+    if ((ucell)*cstr>UNPACKEDMAX) {
+      int j=sizeof(cell)-sizeof(char);
+      char c;
+      /* the string is packed */
+      i=0;
+      for ( ; ; ) {
+        c=(char)((ucell)cstr[i] >> 8*j);
+        if (c==0)
+          break;
+        switch (formatstate(c,&fmtstate,&sign,&decpoint,&width,&digits,&filler)) {
+        case -1:
+          f_putchar(user,c);
+          break;
+        case 0:
+          break;
+        case 1:
+          assert(info!=NULL && info->params!=NULL);
+          if (paramidx>=info->numparams)  /* insufficient parameters passed */
+            amx_RaiseError(amx, AMX_ERR_NATIVE);
+          else
+            paramidx+=dochar(amx,c,info->params[paramidx],sign,decpoint,width,digits,filler,
+                             f_putstr,f_putchar,user);
+          fmtstate=FMT_NONE;
+          break;
+        default:
+          assert(0);
+        } /* switch */
+        if (j==0)
+          i++;
+        j=(j+sizeof(cell)-sizeof(char)) % sizeof(cell);
+      } /* for */
+    } else {
+      /* the string is unpacked */
+      for (i=0; cstr[i]!=0; i++) {
+        switch (formatstate((TCHAR)cstr[i],&fmtstate,&sign,&decpoint,&width,&digits,&filler)) {
+        case -1:
+          f_putchar(user,(TCHAR)cstr[i]);
+          break;
+        case 0:
+          break;
+        case 1:
+          assert(info!=NULL && info->params!=NULL);
+          if (paramidx>=info->numparams)  /* insufficient parameters passed */
+            amx_RaiseError(amx, AMX_ERR_NATIVE);
+          else
+            paramidx+=dochar(amx,(TCHAR)cstr[i],info->params[paramidx],sign,decpoint,width,digits,filler,
+                             f_putstr,f_putchar,user);
+          fmtstate=FMT_NONE;
+          break;
+        default:
+          assert(0);
+        } /* switch */
+      } /* for */
+    } /* if */
+
+  } /* if (info==NULL || info->params==NULL) */
+
+  return paramidx;
+}
+
+#if !defined AMX_STRING_LIB
+
+#if defined AMX_ALTPRINT
+/* print(const string[], start=0, end=cellmax) */
+static cell AMX_NATIVE_CALL n_print(AMX *amx,const cell *params)
+{
+  cell *cstr;
+  AMX_FMTINFO info;
+
+  memset(&info,0,sizeof info);
+  info.skip= ((size_t)params[0]>=2*sizeof(cell)) ? (int)params[2] : 0;
+  info.length= ((size_t)params[0]>=3*sizeof(cell)) ? (int)(params[3]-info.skip) : INT_MAX;
+
+  CreateConsole();
+  cstr=amx_Address(amx,params[1]);
+  amx_printstring(amx,cstr,&info);
+  amx_fflush();
+  return 0;
+}
+#else
+/* print(const string[], foreground=-1, background=-1, highlight=-1) */
+static cell AMX_NATIVE_CALL n_print(AMX *amx,const cell *params)
+{
+  cell *cstr;
+  int oldcolours;
+
+  CreateConsole();
+
+  /* set the new colours */
+  oldcolours=amx_setattr((int)params[2],(int)params[3],(int)params[4]);
+
+  cstr=amx_Address(amx,params[1]);
+  amx_printstring(amx,cstr,NULL);
+
+  /* reset the colours */
+  (void)amx_setattr(oldcolours & 0xff,(oldcolours >> 8) & 0x7f,(oldcolours >> 15) & 0x01);
+  amx_fflush();
+  return 0;
+}
+#endif
+
+static cell AMX_NATIVE_CALL n_printf(AMX *amx,const cell *params)
+{
+  cell *cstr;
+  AMX_FMTINFO info;
+
+  memset(&info,0,sizeof info);
+  info.params=params+2;
+  info.numparams=(int)(params[0]/sizeof(cell))-1;
+  info.skip=0;
+  info.length=INT_MAX;
+
+  CreateConsole();
+  cstr=amx_Address(amx,params[1]);
+  amx_printstring(amx,cstr,&info);
+  amx_fflush();
+  return 0;
+}
+
+/* getchar(bool:echo=true) */
+static cell AMX_NATIVE_CALL n_getchar(AMX *amx,const cell *params)
+{
+  int c;
+
+  (void)amx;
+  CreateConsole();
+  c=amx_getch();
+  if (params[1]) {
+    #if defined(SUPPRESS_ECHO)
+ 	  /* For Mac OS X, non-Curses, don't echo the character */
+    #else
+      amx_putchar((TCHAR)c);
+      amx_fflush();
+    #endif
+  } /* if */
+  return c;
+}
+
+/* getstring(string[], size=sizeof string, bool:pack=false) */
+static cell AMX_NATIVE_CALL n_getstring(AMX *amx,const cell *params)
+{
+  int c,chars,max;
+  cell *cptr;
+
+  (void)amx;
+  CreateConsole();
+  chars=0;
+  max=(int)params[2];
+  if (max>0) {
+    #if __STDC_VERSION__ >= 199901L
+      TCHAR str[max];   /* use C99 feature if available */
+    #else
+      TCHAR *str=(TCHAR *)alloca(max*sizeof(TCHAR));
+      if (str==NULL)
+        return chars;
+    #endif
+
+    c=amx_getch();
+    while (c!=EOF && c!=EOL_CHAR && chars<max-1) {
+      str[chars++]=(TCHAR)c;
+      #if defined(SUPPRESS_ECHO)
+ 	    /* For Mac OS X, non-Curses, don't echo the character */
+      #else
+        amx_putchar((TCHAR)c);
+        amx_fflush();
+      #endif
+      if (chars<max-1)
+        c=amx_getch();
+    } /* while */
+
+    if (c==EOL_CHAR)
+      amx_putchar('\n');
+    assert(chars<max);
+    str[chars]='\0';
+
+    cptr=amx_Address(amx,params[1]);
+    amx_SetString(cptr,(char*)str,(int)params[3],sizeof(TCHAR)>1,max);
+
+  } /* if */
+  return chars;
+}
+
+static void acceptchar(int c,int *num)
+{
+  switch (c) {
+  case '\b':
+    amx_putchar('\b');
+    *num-=1;
+    #if defined amx_putchar && (defined __BORLANDC__ || defined __WATCOMC__)
+      /* the backspace key does not erase the
+       * character, so do this explicitly */
+      amx_putchar(' ');     /* erase */
+      amx_putchar('\b');    /* go back */
+    #endif
+    break;
+  case EOL_CHAR:
+    amx_putchar('\n');
+    *num+=1;
+    break;
+  default:
+    #if defined(SUPPRESS_ECHO)
+ 	  /* For Mac OS X, non-Curses, don't echo the character */
+    #else
+      amx_putchar((TCHAR)c);
+    #endif
+    *num+=1;
+  } /* switch */
+  amx_fflush();
+}
+
+static int inlist(AMX *amx,int c,const cell *params,int num)
+{
+  int i, key;
+
+  (void)amx;
+  for (i=0; i<num; i++) {
+    if (i==0) {
+      /* first key is passed by value, others are passed by reference */
+      key = (int)params[i];
+    } else {
+      cell *cptr;
+      cptr=amx_Address(amx,params[i]);
+      key=(int)*cptr;
+    } /* if */
+    if (c==key || c==-key)
+      return key;
+  } /* for */
+  return 0;
+}
+
+static cell AMX_NATIVE_CALL n_getvalue(AMX *amx,const cell *params)
+{
+  cell value;
+  int base,sign,c,d;
+  int chars,n;
+
+  CreateConsole();
+  base=(int)params[1];
+  if (base<2 || base>36)
+    return 0;
+
+  chars=0;
+  value=0;
+  sign=1;       /* to avoid a compiler warning (Microsoft Visual C/C++ 6.0) */
+
+  c=amx_getch();
+  while (c!=EOF) {
+    /* check for sign (if any) */
+    if (chars==0) {
+      if (c=='-') {
+        sign=-1;
+        acceptchar(c,&chars);
+        c=amx_getch();
+      } else {
+        sign=1;
+      } /* if */
+    } /* if */
+
+    /* check end of input */
+    #if EOL_CHAR!='\r'
+      if (c==EOL_CHAR && inlist(amx,'\r',params+2,(int)params[0]/sizeof(cell)-1)!=0)
+        c='\r';
+    #endif
+    if ((chars>1 || chars>0 && sign>0)
+        && (n=inlist(amx,c,params+2,(int)params[0]/sizeof(cell)-1))!=0)
+    {
+      if (n>0)
+        acceptchar(c,&chars);
+      break;
+    } /* if */
+    #if EOL_CHAR!='\r'
+      if (c=='\r')
+        c=EOL_CHAR;
+    #endif
+
+    /* get value */
+    d=base;     /* by default, do not accept the character */
+    if (c>='0' && c<='9') {
+      d=c-'0';
+    } else if (c>='a' && c<='z') {
+      d=c-'a'+10;
+    } else if (c>='A' && c<='Z') {
+      d=c-'A'+10;
+    } else if (c=='\b') {
+      if (chars>0) {
+        value/=base;
+        acceptchar(c,&chars);
+      } /* if */
+    } /* if */
+    if (d<base) {
+      acceptchar(c,&chars);
+      value=value*base + d;
+    } /* if */
+    c=amx_getch();
+  } /* while */
+  return sign*value;
+}
+
+static cell AMX_NATIVE_CALL n_clrscr(AMX *amx,const cell *params)
+{
+  (void)amx;
+  (void)params;
+  CreateConsole();
+  amx_clrscr();
+  return 0;
+}
+
+static cell AMX_NATIVE_CALL n_clreol(AMX *amx,const cell *params)
+{
+  (void)amx;
+  (void)params;
+  CreateConsole();
+  amx_clreol();
+  return 0;
+}
+
+static cell AMX_NATIVE_CALL n_gotoxy(AMX *amx,const cell *params)
+{
+  (void)amx;
+  CreateConsole();
+  return amx_gotoxy((int)params[1],(int)params[2]);
+}
+
+static cell AMX_NATIVE_CALL n_wherexy(AMX *amx,const cell *params)
+{
+  cell *px,*py;
+  int x,y;
+
+  (void)amx;
+  CreateConsole();
+  amx_wherexy(&x,&y);
+  px=amx_Address(amx,params[1]);
+  py=amx_Address(amx,params[2]);
+  *px=x;
+  *py=y;
+  return 0;
+}
+
+static cell AMX_NATIVE_CALL n_setattr(AMX *amx,const cell *params)
+{
+  (void)amx;
+  CreateConsole();
+  (void)amx_setattr((int)params[1],(int)params[2],(int)params[3]);
+  return 0;
+}
+
+static cell AMX_NATIVE_CALL n_consctrl(AMX *amx,const cell *params)
+{
+  (void)amx;
+  CreateConsole();
+  (void)amx_termctl((int)params[1],(int)params[2]);
+  return 0;
+}
+
+static cell AMX_NATIVE_CALL n_console(AMX *amx,const cell *params)
+{
+  (void)amx;
+  CreateConsole();
+  amx_console((int)params[1],(int)params[2],(int)params[3]);
+  return 0;
+}
+
+
+#if !defined AMXCONSOLE_NOIDLE
+static AMX_IDLE PrevIdle = NULL;
+static int idxKeyPressed = -1;
+
+static int AMXAPI amx_ConsoleIdle(AMX *amx, int AMXAPI Exec(AMX *, cell *, int))
+{
+  int err=0, key;
+
+  assert(idxKeyPressed >= 0);
+
+  if (PrevIdle != NULL)
+    PrevIdle(amx, Exec);
+
+  if (amx_kbhit()) {
+    key = amx_getch();
+    amx_Push(amx, key);
+    err = Exec(amx, NULL, idxKeyPressed);
+    while (err == AMX_ERR_SLEEP)
+      err = Exec(amx, NULL, AMX_EXEC_CONT);
+  } /* if */
+
+  return err;
+}
+#endif
+
+#if defined __cplusplus
+  extern "C"
+#endif
+const AMX_NATIVE_INFO console_Natives[] = {
+  { "getchar",   n_getchar },
+  { "getstring", n_getstring },
+  { "getvalue",  n_getvalue },
+  { "print",     n_print },
+  { "printf",    n_printf },
+  { "clrscr",    n_clrscr },
+  { "clreol",    n_clreol },
+  { "gotoxy",    n_gotoxy },
+  { "wherexy",   n_wherexy },
+  { "setattr",   n_setattr },
+  { "console",   n_console },
+  { "consctrl",  n_consctrl },
+  { NULL, NULL }        /* terminator */
+};
+
+int AMXEXPORT AMXAPI amx_ConsoleInit(AMX *amx)
+{
+  #if !defined AMXCONSOLE_NOIDLE
+    /* see whether there is an @keypressed() function */
+    if (amx_FindPublic(amx, "@keypressed", &idxKeyPressed) == AMX_ERR_NONE) {
+      if (amx_GetUserData(amx, AMX_USERTAG('I','d','l','e'), (void**)&PrevIdle) != AMX_ERR_NONE)
+        PrevIdle = NULL;
+      amx_SetUserData(amx, AMX_USERTAG('I','d','l','e'), (void*)amx_ConsoleIdle);
+    } /* if */
+  #endif
+
+  return amx_Register(amx, console_Natives, -1);
+}
+
+int AMXEXPORT AMXAPI amx_ConsoleCleanup(AMX *amx)
+{
+  (void)amx;
+  #if !defined AMXCONSOLE_NOIDLE
+    PrevIdle = NULL;
+  #endif
+  return AMX_ERR_NONE;
+}
+
+#endif /* AMX_STRING_LIB */
diff --git a/apps/openmw-mp/amx/amxcons.h b/apps/openmw-mp/amx/amxcons.h
new file mode 100644
index 000000000..f0c0def2a
--- /dev/null
+++ b/apps/openmw-mp/amx/amxcons.h
@@ -0,0 +1,17 @@
+#ifndef AMXCONS_H_INCLUDED
+#define AMXCONS_H_INCLUDED
+
+typedef struct tagFMTINFO {
+  const cell *params;
+  int numparams;
+  int skip;     /* number of characters to skip from the beginning */
+  int length;   /* number of characters to print */
+  /* helper functions */
+  int (*f_putstr)(void *dest,const TCHAR *);
+  int (*f_putchar)(void *dest,TCHAR);
+  void *user;   /* user data */
+} AMX_FMTINFO;
+
+int amx_printstring(AMX *amx,cell *cstr,AMX_FMTINFO *info);
+
+#endif /* AMXCONS_H_INCLUDED */
diff --git a/apps/openmw-mp/amx/amxcore.c b/apps/openmw-mp/amx/amxcore.c
new file mode 100644
index 000000000..14c86e30a
--- /dev/null
+++ b/apps/openmw-mp/amx/amxcore.c
@@ -0,0 +1,500 @@
+/*  Core module for the Pawn AMX
+ *
+ *  Copyright (c) ITB CompuPhase, 1997-2012
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ *  use this file except in compliance with the License. You may obtain a copy
+ *  of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ *  License for the specific language governing permissions and limitations
+ *  under the License.
+ *
+ *  Version: $Id: amxcore.c 4708 2012-05-18 12:52:49Z  $
+ */
+#if defined _UNICODE || defined __UNICODE__ || defined UNICODE
+# if !defined UNICODE   /* for Windows */
+#   define UNICODE
+# endif
+# if !defined _UNICODE  /* for C library */
+#   define _UNICODE
+# endif
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+#include <assert.h>
+#include "osdefs.h"
+#if defined __ECOS__
+  /* eCos puts include files in cyg/package_name */
+  #include <cyg/pawn/amx.h>
+  #define  stricmp(a,b) strcasecmp(a,b)
+#else
+  #include "amx.h"
+#endif
+#if defined __WIN32__ || defined _WIN32 || defined WIN32 || defined _Windows
+  #include <windows.h>
+#endif
+
+/* A few compilers do not provide the ANSI C standard "time" functions */
+#if !defined SN_TARGET_PS2 && !defined _WIN32_WCE && !defined __ICC430__
+  #include <time.h>
+#endif
+
+#if defined _UNICODE
+# include <tchar.h>
+#elif !defined __T
+  typedef char          TCHAR;
+# define __T(string)    string
+# define _tcschr        strchr
+# define _tcscpy        strcpy
+# define _tcsdup        strdup
+# define _tcslen        strlen
+#endif
+
+
+#define CHARBITS        (8*sizeof(char))
+typedef unsigned char   uchar;
+
+#if !defined AMX_NOPROPLIST
+typedef struct _property_list {
+  struct _property_list *next;
+  cell id;
+  char *name;
+  cell value;
+} proplist;
+
+static proplist proproot = { NULL, 0, NULL, 0 };
+
+static proplist *list_additem(proplist *root)
+{
+  proplist *item;
+
+  assert(root!=NULL);
+  if ((item=(proplist *)malloc(sizeof(proplist)))==NULL)
+    return NULL;
+  item->name=NULL;
+  item->id=0;
+  item->value=0;
+  item->next=root->next;
+  root->next=item;
+  return item;
+}
+static void list_delete(proplist *pred,proplist *item)
+{
+  assert(pred!=NULL);
+  assert(item!=NULL);
+  pred->next=item->next;
+  assert(item->name!=NULL);
+  free(item->name);
+  free(item);
+}
+static void list_setitem(proplist *item,cell id,char *name,cell value)
+{
+  char *ptr;
+
+  assert(item!=NULL);
+  if ((ptr=(char *)malloc(strlen(name)+1))==NULL)
+    return;
+  if (item->name!=NULL)
+    free(item->name);
+  strcpy(ptr,name);
+  item->name=ptr;
+  item->id=id;
+  item->value=value;
+}
+static proplist *list_finditem(proplist *root,cell id,char *name,cell value,
+                               proplist **pred)
+{
+  proplist *item=root->next;
+  proplist *prev=root;
+
+  /* check whether to find by name or by value */
+  assert(name!=NULL);
+  if (strlen(name)>0) {
+    /* find by name */
+    while (item!=NULL && (item->id!=id || stricmp(item->name,name)!=0)) {
+      prev=item;
+      item=item->next;
+    } /* while */
+  } else {
+    /* find by value */
+    while (item!=NULL && (item->id!=id || item->value!=value)) {
+      prev=item;
+      item=item->next;
+    } /* while */
+  } /* if */
+  if (pred!=NULL)
+    *pred=prev;
+  return item;
+}
+#endif
+
+static cell AMX_NATIVE_CALL numargs(AMX *amx,const cell *params)
+{
+  AMX_HEADER *hdr;
+  uchar *data;
+  cell bytes;
+
+  (void)params;
+  hdr=(AMX_HEADER *)amx->base;
+  data=amx->data ? amx->data : amx->base+(int)hdr->dat;
+  /* the number of bytes is on the stack, at "frm + 2*cell" */
+  bytes= * (cell *)(data+(int)amx->frm+2*sizeof(cell));
+  /* the number of arguments is the number of bytes divided
+   * by the size of a cell */
+  return bytes/sizeof(cell);
+}
+
+static cell AMX_NATIVE_CALL getarg(AMX *amx,const cell *params)
+{
+  AMX_HEADER *hdr;
+  uchar *data;
+  cell value;
+
+  hdr=(AMX_HEADER *)amx->base;
+  data=amx->data ? amx->data : amx->base+(int)hdr->dat;
+  /* get the base value */
+  value= * (cell *)(data+(int)amx->frm+((int)params[1]+3)*sizeof(cell));
+  /* adjust the address in "value" in case of an array access */
+  value+=params[2]*sizeof(cell);
+  /* get the value indirectly */
+  value= * (cell *)(data+(int)value);
+  return value;
+}
+
+static cell AMX_NATIVE_CALL setarg(AMX *amx,const cell *params)
+{
+  AMX_HEADER *hdr;
+  uchar *data;
+  cell value;
+
+  hdr=(AMX_HEADER *)amx->base;
+  data=amx->data ? amx->data : amx->base+(int)hdr->dat;
+  /* get the base value */
+  value= * (cell *)(data+(int)amx->frm+((int)params[1]+3)*sizeof(cell));
+  /* adjust the address in "value" in case of an array access */
+  value+=params[2]*sizeof(cell);
+  /* verify the address */
+  if (value<0 || value>=amx->hea && value<amx->stk)
+    return 0;
+  /* set the value indirectly */
+  * (cell *)(data+(int)value) = params[3];
+  return 1;
+}
+
+static cell AMX_NATIVE_CALL heapspace(AMX *amx,const cell *params)
+{
+  (void)params;
+  return amx->stk - amx->hea;
+}
+
+static cell AMX_NATIVE_CALL funcidx(AMX *amx,const cell *params)
+{
+  char name[64];
+  cell *cstr;
+  int index,err;
+
+  cstr=amx_Address(amx,params[1]);
+  amx_GetString(name,cstr,0,sizeof name);
+  err=amx_FindPublic(amx,name,&index);
+  if (err!=AMX_ERR_NONE)
+    index=-1;   /* this is not considered a fatal error */
+  return index;
+}
+
+void amx_swapcell(cell *pc)
+{
+  union {
+    cell c;
+    #if PAWN_CELL_SIZE==16
+      uchar b[2];
+    #elif PAWN_CELL_SIZE==32
+      uchar b[4];
+    #elif PAWN_CELL_SIZE==64
+      uchar b[8];
+	#else
+	  #error Unsupported cell size
+    #endif
+  } value;
+  uchar t;
+
+  assert(pc!=NULL);
+  value.c = *pc;
+  #if PAWN_CELL_SIZE==16
+    t = value.b[0];
+    value.b[0] = value.b[1];
+    value.b[1] = t;
+  #elif PAWN_CELL_SIZE==32
+    t = value.b[0];
+    value.b[0] = value.b[3];
+    value.b[3] = t;
+    t = value.b[1];
+    value.b[1] = value.b[2];
+    value.b[2] = t;
+  #elif PAWN_CELL_SIZE==64
+    t = value.b[0];
+    value.b[0] = value.b[7];
+    value.b[7] = t;
+	t = value.b[1];
+	value.b[1] = value.b[6];
+	value.b[6] = t;
+	t = value.b[2];
+	value.b[2] = value.b[5];
+	value.b[5] = t;
+	t = value.b[3];
+    value.b[3] = value.b[4];
+    value.b[4] = t;
+  #else
+    #error Unsupported cell size
+  #endif
+  *pc = value.c;
+}
+
+static cell AMX_NATIVE_CALL swapchars(AMX *amx,const cell *params)
+{
+  cell c;
+
+  (void)amx;
+  assert((size_t)params[0]==sizeof(cell));
+
+  c=params[1];
+  amx_swapcell(&c);
+  return c;
+}
+
+static cell AMX_NATIVE_CALL core_tolower(AMX *amx,const cell *params)
+{
+  (void)amx;
+  #if defined __WIN32__ || defined _WIN32 || defined WIN32
+    return (cell)CharLower((LPTSTR)params[1]);
+  #elif defined _Windows
+    return (cell)AnsiLower((LPSTR)params[1]);
+  #else
+    if ((unsigned)(params[1]-'A')<26u)
+      return params[1]+'a'-'A';
+    return params[1];
+  #endif
+}
+
+static cell AMX_NATIVE_CALL core_toupper(AMX *amx,const cell *params)
+{
+  (void)amx;
+  #if defined __WIN32__ || defined _WIN32 || defined WIN32
+    return (cell)CharUpper((LPTSTR)params[1]);
+  #elif defined _Windows
+    return (cell)AnsiUpper((LPSTR)params[1]);
+  #else
+    if ((unsigned)(params[1]-'a')<26u)
+      return params[1]+'A'-'a';
+    return params[1];
+  #endif
+}
+
+static cell AMX_NATIVE_CALL core_min(AMX *amx,const cell *params)
+{
+  (void)amx;
+  return params[1] <= params[2] ? params[1] : params[2];
+}
+
+static cell AMX_NATIVE_CALL core_max(AMX *amx,const cell *params)
+{
+  (void)amx;
+  return params[1] >= params[2] ? params[1] : params[2];
+}
+
+static cell AMX_NATIVE_CALL core_clamp(AMX *amx,const cell *params)
+{
+  cell value = params[1];
+  if (params[2] > params[3])  /* minimum value > maximum value ! */
+    amx_RaiseError(amx,AMX_ERR_NATIVE);
+  if (value < params[2])
+    value = params[2];
+  else if (value > params[3])
+    value = params[3];
+  return value;
+}
+
+#if !defined AMX_NOPROPLIST
+static char *MakePackedString(cell *cptr)
+{
+  int len;
+  char *dest;
+
+  amx_StrLen(cptr,&len);
+  dest=(char *)malloc(len+sizeof(cell));
+  amx_GetString(dest,cptr,0,len+sizeof(cell));
+  return dest;
+}
+
+/* getproperty(id=0, const name[]="", value=cellmin, string[]="", size=sizeof string) */
+static cell AMX_NATIVE_CALL getproperty(AMX *amx,const cell *params)
+{
+  cell *cstr;
+  char *name;
+  proplist *item;
+
+  (void)amx;
+  cstr=amx_Address(amx,params[2]);
+  name=MakePackedString(cstr);
+  item=list_finditem(&proproot,params[1],name,params[3],NULL);
+  /* if list_finditem() found the value, store the name */
+  if (item!=NULL && item->value==params[3] && strlen(name)==0) {
+    cstr=amx_Address(amx,params[4]);
+    amx_SetString(cstr,item->name,1,0,params[5]);
+  } /* if */
+  free(name);
+  return (item!=NULL) ? item->value : 0;
+}
+
+/* setproperty(id=0, const name[]="", value=cellmin, const string[]="") */
+static cell AMX_NATIVE_CALL setproperty(AMX *amx,const cell *params)
+{
+  cell prev=0;
+  cell *cstr;
+  char *name;
+  proplist *item;
+
+  cstr=amx_Address(amx,params[2]);
+  name=MakePackedString(cstr);
+  item=list_finditem(&proproot,params[1],name,params[3],NULL);
+  if (item==NULL)
+    item=list_additem(&proproot);
+  if (item==NULL) {
+    amx_RaiseError(amx,AMX_ERR_MEMORY);
+  } else {
+    prev=item->value;
+    if (strlen(name)==0) {
+      free(name);
+      cstr=amx_Address(amx,params[4]);
+      name=MakePackedString(cstr);
+    } /* if */
+    list_setitem(item,params[1],name,params[3]);
+  } /* if */
+  free(name);
+  return prev;
+}
+
+/* deleteproperty(id=0, const name[]="", value=cellmin) */
+static cell AMX_NATIVE_CALL delproperty(AMX *amx,const cell *params)
+{
+  cell prev=0;
+  cell *cstr;
+  char *name;
+  proplist *item,*pred;
+
+  (void)amx;
+  cstr=amx_Address(amx,params[2]);
+  name=MakePackedString(cstr);
+  item=list_finditem(&proproot,params[1],name,params[3],&pred);
+  if (item!=NULL) {
+    prev=item->value;
+    list_delete(pred,item);
+  } /* if */
+  free(name);
+  return prev;
+}
+
+/* existproperty(id=0, const name[]="", value=cellmin) */
+static cell AMX_NATIVE_CALL existproperty(AMX *amx,const cell *params)
+{
+  cell *cstr;
+  char *name;
+  proplist *item;
+
+  (void)amx;
+  cstr=amx_Address(amx,params[2]);
+  name=MakePackedString(cstr);
+  item=list_finditem(&proproot,params[1],name,params[3],NULL);
+  free(name);
+  return (item!=NULL);
+}
+#endif
+
+#if !defined AMX_NORANDOM
+/* This routine comes from the book "Inner Loops" by Rick Booth, Addison-Wesley
+ * (ISBN 0-201-47960-5). This is a "multiplicative congruential random number
+ * generator" that has been extended to 31-bits (the standard C version returns
+ * only 15-bits).
+ */
+#define INITIAL_SEED  0xcaa938dbL
+static unsigned long IL_StandardRandom_seed = INITIAL_SEED; /* always use a non-zero seed */
+#define IL_RMULT 1103515245L
+#if defined __BORLANDC__ || defined __WATCOMC__
+  #pragma argsused
+#endif
+static cell AMX_NATIVE_CALL core_random(AMX *amx,const cell *params)
+{
+    unsigned long lo, hi, ll, lh, hh, hl;
+    unsigned long result;
+
+    /* one-time initialization (or, mostly one-time) */
+    #if !defined SN_TARGET_PS2 && !defined _WIN32_WCE && !defined __ICC430__
+        if (IL_StandardRandom_seed == INITIAL_SEED)
+            IL_StandardRandom_seed=(unsigned long)time(NULL);
+    #endif
+
+    (void)amx;
+
+    lo = IL_StandardRandom_seed & 0xffff;
+    hi = IL_StandardRandom_seed >> 16;
+    IL_StandardRandom_seed = IL_StandardRandom_seed * IL_RMULT + 12345;
+    ll = lo * (IL_RMULT  & 0xffff);
+    lh = lo * (IL_RMULT >> 16    );
+    hl = hi * (IL_RMULT  & 0xffff);
+    hh = hi * (IL_RMULT >> 16    );
+    result = ((ll + 12345) >> 16) + lh + hl + (hh << 16);
+    result &= ~LONG_MIN;        /* remove sign bit */
+    if (params[1]!=0)
+        result %= params[1];
+    return (cell)result;
+}
+#endif
+
+
+#if defined __cplusplus
+  extern "C"
+#endif
+const AMX_NATIVE_INFO core_Natives[] = {
+  { "numargs",       numargs },
+  { "getarg",        getarg },
+  { "setarg",        setarg },
+  { "heapspace",     heapspace },
+  { "funcidx",       funcidx },
+  { "swapchars",     swapchars },
+  { "tolower",       core_tolower },
+  { "toupper",       core_toupper },
+  { "min",           core_min },
+  { "max",           core_max },
+  { "clamp",         core_clamp },
+#if !defined AMX_NORANDOM
+  { "random",        core_random },
+#endif
+#if !defined AMX_NOPROPLIST
+  { "getproperty",   getproperty },
+  { "setproperty",   setproperty },
+  { "deleteproperty",delproperty },
+  { "existproperty", existproperty },
+#endif
+  { NULL, NULL }        /* terminator */
+};
+
+int AMXEXPORT AMXAPI amx_CoreInit(AMX *amx)
+{
+  return amx_Register(amx, core_Natives, -1);
+}
+
+int AMXEXPORT AMXAPI amx_CoreCleanup(AMX *amx)
+{
+  (void)amx;
+  #if !defined AMX_NOPROPLIST
+    while (proproot.next!=NULL)
+      list_delete(&proproot,proproot.next);
+  #endif
+  return AMX_ERR_NONE;
+}
diff --git a/apps/openmw-mp/amx/amxexec_gcc.c b/apps/openmw-mp/amx/amxexec_gcc.c
new file mode 100644
index 000000000..a036dbec9
--- /dev/null
+++ b/apps/openmw-mp/amx/amxexec_gcc.c
@@ -0,0 +1,1361 @@
+/*  Example implementation of an optimized abstract machine.
+ *
+ *  This abstract machine uses the "labels as values" feature of the GNU GCC
+ *  compiler to create a fast "indirect threaded" interpreter. The Intel C/C++
+ *  compiler supports this too.
+ *
+ *  Copyright (c) ITB CompuPhase, 1998-2013
+ *
+ *  This software is provided "as-is", without any express or implied warranty.
+ *  In no event will the authors be held liable for any damages arising from
+ *  the use of this software.
+ *
+ *  Permission is granted to anyone to use this software for any purpose,
+ *  including commercial applications, and to alter it and redistribute it
+ *  freely, subject to the following restrictions:
+ *
+ *  1.  The origin of this software must not be misrepresented; you must not
+ *      claim that you wrote the original software. If you use this software in
+ *      a product, an acknowledgment in the product documentation would be
+ *      appreciated but is not required.
+ *  2.  Altered source versions must be plainly marked as such, and must not be
+ *      misrepresented as being the original software.
+ *  3.  This notice may not be removed or altered from any source distribution.
+ *
+ *  Version: $Id: amxcons.c 3821 2007-10-15 16:54:20Z thiadmer $
+ */
+#include <assert.h>
+#include <stddef.h>
+#include <string.h>
+#include "osdefs.h"
+#if defined __ECOS__
+  /* eCos puts include files in cyg/package_name */
+  #include <cyg/pawn/amx.h>
+#else
+  #include "amx.h"
+#endif
+
+#if !(defined __GNUC__ || defined __ICC)
+  #error The GNU GCC or the Intel C/C++ compiler is required for this file.
+#endif
+
+#if !defined sizearray
+  #define sizearray(a)  (sizeof(a)/sizeof((a)[0]))
+#endif
+
+/* It is assumed that the abstract machine can simply access the memory area
+ * for the global data and the stack. If this is not the case, you need to
+ * define the macro sets _R() and _W(), for reading and writing to memory.
+ */
+#if !defined _R
+  #define _R_DEFAULT            /* mark default memory access */
+  #define _R(base,addr)         (* (cell *)((unsigned char*)(base)+(int)(addr)))
+  #define _R8(base,addr)        (* (unsigned char *)((unsigned char*)(base)+(int)(addr)))
+  #define _R16(base,addr)       (* (uint16_t *)((unsigned char*)(base)+(int)(addr)))
+  #define _R32(base,addr)       (* (uint32_t *)((unsigned char*)(base)+(int)(addr)))
+#endif
+#if !defined _W
+  #define _W_DEFAULT            /* mark default memory access */
+  #define _W(base,addr,value)   ((*(cell *)((unsigned char*)(base)+(int)(addr)))=(cell)(value))
+  #define _W8(base,addr,value)  ((*(unsigned char *)((unsigned char*)(base)+(int)(addr)))=(unsigned char)(value))
+  #define _W16(base,addr,value) ((*(uint16_t *)((unsigned char*)(base)+(int)(addr)))=(uint16_t)(value))
+  #define _W32(base,addr,value) ((*(uint32_t *)((unsigned char*)(base)+(int)(addr)))=(uint32_t)(value))
+#endif
+
+#if -8/3==-2 && 8/-3==-2
+  #define TRUNC_SDIV    /* signed divisions are truncated on this platform */
+#else
+  #define IABS(a)       ((a)>=0 ? (a) : (-a))
+#endif
+
+#if !defined GETPARAM
+  #define GETPARAM(v)   ( v=*cip++ )  /* read a parameter from the opcode stream */
+#endif
+#if !defined GETPARAM_P
+  #define GETPARAM_P(v,o) ( v=((cell)(o) >> (int)(sizeof(cell)*4)) )
+#endif
+#if !defined SKIPPARAM
+  #define SKIPPARAM(n)  ( cip=(cell *)cip+(n) ) /* for obsolete opcodes */
+#endif
+
+/* PUSH() and POP() are defined in terms of the _R() and _W() macros */
+#define PUSH(v)         ( stk-=sizeof(cell), _W(data,stk,v) )
+#define POP(v)          ( v=_R(data,stk), stk+=sizeof(cell) )
+
+#define ABORT(amx,v)    { (amx)->stk=reset_stk; (amx)->hea=reset_hea; return v; }
+
+#define STKMARGIN       ((cell)(16*sizeof(cell)))
+#define CHKMARGIN()     if (hea+STKMARGIN>stk) return AMX_ERR_STACKERR
+#define CHKSTACK()      if (stk>amx->stp) return AMX_ERR_STACKLOW
+#define CHKHEAP()       if (hea<amx->hlw) return AMX_ERR_HEAPLOW
+
+#define JUMPREL(ip)     ((cell*)((unsigned long)(ip)+*(cell*)(ip)-sizeof(cell)))
+
+
+#if !defined AMX_NO_PACKED_OPC && !defined AMX_TOKENTHREADING
+  #define AMX_TOKENTHREADING    /* packed opcodes require token threading */
+#endif
+#if defined AMX_TOKENTHREADING
+  #if defined AMX_NO_PACKED_OPC
+    #define NEXT(cip,op) goto *amx_opcodelist[*cip++]
+  #else
+    #define NEXT(cip,op) goto *amx_opcodelist[(op=*cip++) & ((1 << sizeof(cell)*4)-1)]
+  #endif
+#else
+  #if !defined AMX_NO_PACKED_OPC
+    #error Packed opcodes support requires token threading
+  #endif
+  #define NEXT(cip,op)   goto **cip++
+#endif
+
+cell amx_exec_run(AMX *amx,cell *retval,unsigned char *data)
+{
+static const void * const amx_opcodelist[] = {
+        /* core set */
+        &&op_nop,         &&op_load_pri,    &&op_load_alt,    &&op_load_s_pri,
+        &&op_load_s_alt,  &&op_lref_s_pri,  &&op_lref_s_alt,  &&op_load_i,
+        &&op_lodb_i,      &&op_const_pri,   &&op_const_alt,   &&op_addr_pri,
+        &&op_addr_alt,    &&op_stor,        &&op_stor_s,      &&op_sref_s,
+        &&op_stor_i,      &&op_strb_i,      &&op_align_pri,   &&op_lctrl,
+        &&op_sctrl,       &&op_xchg,        &&op_push_pri,    &&op_push_alt,
+        &&op_pushr_pri,   &&op_pop_pri,     &&op_pop_alt,     &&op_pick,
+        &&op_stack,       &&op_heap,        &&op_proc,        &&op_ret,
+        &&op_retn,        &&op_call,        &&op_jump,        &&op_jzer,
+        &&op_jnz,         &&op_shl,         &&op_shr,         &&op_sshr,
+        &&op_shl_c_pri,   &&op_shl_c_alt,   &&op_smul,        &&op_sdiv,
+        &&op_add,         &&op_sub,         &&op_and,         &&op_or,
+        &&op_xor,         &&op_not,         &&op_neg,         &&op_invert,
+        &&op_eq,          &&op_neq,         &&op_sless,       &&op_sleq,
+        &&op_sgrtr,       &&op_sgeq,        &&op_inc_pri,     &&op_inc_alt,
+        &&op_inc_i,       &&op_dec_pri,     &&op_dec_alt,     &&op_dec_i,
+        &&op_movs,        &&op_cmps,        &&op_fill,        &&op_halt,
+        &&op_bounds,      &&op_sysreq,      &&op_switch,      &&op_swap_pri,
+        &&op_swap_alt,    &&op_break,       &&op_casetbl,
+        /* patched instructions */
+        /* if op_sysreq_d and/or op_sysreq_nd are not implemented, their entries
+         * in this table must be NULL
+         */
+        &&op_sysreq_d,    &&op_sysreq_nd,
+        /* overlay instructions */
+        &&op_call_ovl,    &&op_retn_ovl,    &&op_switch_ovl,  &&op_casetbl_ovl,
+        /* supplemental and macro instructions */
+#if !defined AMX_NO_MACRO_INSTR
+        &&op_lidx,        &&op_lidx_b,      &&op_idxaddr,     &&op_idxaddr_b,
+        &&op_push_c,      &&op_push,        &&op_push_s,      &&op_push_adr,
+        &&op_pushr_c,     &&op_pushr_s,     &&op_pushr_adr,   &&op_jeq,
+        &&op_jneq,        &&op_jsless,      &&op_jsleq,       &&op_jsgrtr,
+        &&op_jsgeq,       &&op_sdiv_inv,    &&op_sub_inv,     &&op_add_c,
+        &&op_smul_c,      &&op_zero_pri,    &&op_zero_alt,    &&op_zero,
+        &&op_zero_s,      &&op_eq_c_pri,    &&op_eq_c_alt,    &&op_inc,
+        &&op_inc_s,       &&op_dec,         &&op_dec_s,       &&op_sysreq_n,
+        &&op_pushm_c,     &&op_pushm,       &&op_pushm_s,     &&op_pushm_adr,
+        &&op_pushrm_c,    &&op_pushrm_s,    &&op_pushrm_adr,  &&op_load2,
+        &&op_load2_s,     &&op_const,       &&op_const_s,
+#endif
+#if !defined AMX_NO_PACKED_OPC
+        &&op_load_p_pri,  &&op_load_p_alt,  &&op_load_p_s_pri,&&op_load_p_s_alt,
+        &&op_lref_p_s_pri,&&op_lref_p_s_alt,&&op_lodb_p_i,    &&op_const_p_pri,
+        &&op_const_p_alt, &&op_addr_p_pri,  &&op_addr_p_alt,  &&op_stor_p,
+        &&op_stor_p_s,    &&op_sref_p_s,    &&op_strb_p_i,    &&op_lidx_p_b,
+        &&op_idxaddr_p_b, &&op_align_p_pri, &&op_push_p_c,    &&op_push_p,
+        &&op_push_p_s,    &&op_push_p_adr,  &&op_pushr_p_c,   &&op_pushr_p_s,
+        &&op_pushr_p_adr, &&op_pushm_p_c,   &&op_pushm_p,     &&op_pushm_p_s,
+        &&op_pushm_p_adr, &&op_pushrm_p_c,  &&op_pushrm_p_s,  &&op_pushrm_p_adr,
+        &&op_stack_p,     &&op_heap_p,      &&op_shl_p_c_pri, &&op_shl_p_c_alt,
+        &&op_add_p_c,     &&op_smul_p_c,    &&op_zero_p,      &&op_zero_p_s,
+        &&op_eq_p_c_pri,  &&op_eq_p_c_alt,  &&op_inc_p,       &&op_inc_p_s,
+        &&op_dec_p,       &&op_dec_p_s,     &&op_movs_p,      &&op_cmps_p,
+        &&op_fill_p,      &&op_halt_p,      &&op_bounds_p
+#endif
+};
+  AMX_HEADER *hdr;
+  cell pri,alt,stk,frm,hea;
+  cell reset_stk, reset_hea, *cip;
+  cell offs,val;
+  int num,i;
+  #if !defined AMX_NO_PACKED_OPC
+    int op;
+  #endif
+
+  assert(amx!=NULL);
+  /* HACK: return label table and opcode count (for VerifyPcode()) if amx
+   * structure has the flags set to all ones (see amx_exec_list() above)
+   */
+  if (amx->flags==~0) {
+    assert(sizeof(cell)==sizeof(void *));
+    assert(data==NULL);
+    assert(retval!=NULL);
+    *retval=(cell)amx_opcodelist;
+    return sizearray(amx_opcodelist);
+  } /* if */
+
+  /* set up the registers */
+  hdr=(AMX_HEADER *)amx->base;
+  assert(hdr->magic==AMX_MAGIC);
+  assert(hdr->file_version>=11);
+  cip=(cell*)amx->cip;
+  hea=amx->hea;
+  stk=amx->stk;
+  reset_stk=stk;
+  reset_hea=hea;
+  alt=frm=pri=0;/* just to avoid compiler warnings */
+  num=0;        /* just to avoid compiler warnings */
+
+  /* start running */
+  assert(amx->code!=NULL);
+  assert(data!=NULL);
+  cip=(cell *)(amx->code+(int)amx->cip);
+  NEXT(cip,op);
+
+  op_nop:
+    NEXT(cip,op);
+  op_load_pri:
+    GETPARAM(offs);
+    pri=_R(data,offs);
+    NEXT(cip,op);
+  op_load_alt:
+    GETPARAM(offs);
+    alt=_R(data,offs);
+    NEXT(cip,op);
+  op_load_s_pri:
+    GETPARAM(offs);
+    pri=_R(data,frm+offs);
+    NEXT(cip,op);
+  op_load_s_alt:
+    GETPARAM(offs);
+    alt=_R(data,frm+offs);
+    NEXT(cip,op);
+  op_lref_s_pri:
+    GETPARAM(offs);
+    offs=_R(data,frm+offs);
+    pri=_R(data,offs);
+    NEXT(cip,op);
+  op_lref_s_alt:
+    GETPARAM(offs);
+    offs=_R(data,frm+offs);
+    alt=_R(data,offs);
+    NEXT(cip,op);
+  op_load_i:
+    /* verify address */
+    if (pri>=hea && pri<stk || (ucell)pri>=(ucell)amx->stp)
+      ABORT(amx,AMX_ERR_MEMACCESS);
+    pri=_R(data,pri);
+    NEXT(cip,op);
+  op_lodb_i:
+    GETPARAM(offs);
+  __lodb_i:
+    /* verify address */
+    if (pri>=hea && pri<stk || (ucell)pri>=(ucell)amx->stp)
+      ABORT(amx,AMX_ERR_MEMACCESS);
+    switch (offs) {
+    case 1:
+      pri=_R8(data,pri);
+      break;
+    case 2:
+      pri=_R16(data,pri);
+      break;
+    case 4:
+      pri=_R32(data,pri);
+      break;
+    } /* switch */
+    NEXT(cip,op);
+  op_const_pri:
+    GETPARAM(pri);
+    NEXT(cip,op);
+  op_const_alt:
+    GETPARAM(alt);
+    NEXT(cip,op);
+  op_addr_pri:
+    GETPARAM(pri);
+    pri+=frm;
+    NEXT(cip,op);
+  op_addr_alt:
+    GETPARAM(alt);
+    alt+=frm;
+    NEXT(cip,op);
+  op_stor:
+    GETPARAM(offs);
+    _W(data,offs,pri);
+    NEXT(cip,op);
+  op_stor_s:
+    GETPARAM(offs);
+    _W(data,frm+offs,pri);
+    NEXT(cip,op);
+  op_sref_s:
+    GETPARAM(offs);
+    offs=_R(data,frm+offs);
+    _W(data,offs,pri);
+    NEXT(cip,op);
+  op_stor_i:
+    /* verify address */
+    if (alt>=hea && alt<stk || (ucell)alt>=(ucell)amx->stp)
+      ABORT(amx,AMX_ERR_MEMACCESS);
+    _W(data,alt,pri);
+    NEXT(cip,op);
+  op_strb_i:
+    GETPARAM(offs);
+  __strb_i:
+    /* verify address */
+    if (alt>=hea && alt<stk || (ucell)alt>=(ucell)amx->stp)
+      ABORT(amx,AMX_ERR_MEMACCESS);
+    switch (offs) {
+    case 1:
+      _W8(data,alt,pri);
+      break;
+    case 2:
+      _W16(data,alt,pri);
+      break;
+    case 4:
+      _W32(data,alt,pri);
+      break;
+    } /* switch */
+    NEXT(cip,op);
+  op_align_pri:
+    GETPARAM(offs);
+    #if BYTE_ORDER==LITTLE_ENDIAN
+      if (offs<(int)sizeof(cell))
+        pri ^= sizeof(cell)-offs;
+    #endif
+    NEXT(cip,op);
+  op_lctrl:
+    GETPARAM(offs);
+    switch (offs) {
+    case 0:
+      pri=hdr->cod;
+      break;
+    case 1:
+      pri=hdr->dat;
+      break;
+    case 2:
+      pri=hea;
+      break;
+    case 3:
+      pri=amx->stp;
+      break;
+    case 4:
+      pri=stk;
+      break;
+    case 5:
+      pri=frm;
+      break;
+    case 6:
+      pri=(cell)((unsigned char *)cip - amx->code);
+      break;
+    } /* switch */
+    NEXT(cip,op);
+  op_sctrl:
+    GETPARAM(offs);
+    switch (offs) {
+    case 0:
+    case 1:
+    case 3:
+      /* cannot change these parameters */
+      break;
+    case 2:
+      hea=pri;
+      break;
+    case 4:
+      stk=pri;
+      break;
+    case 5:
+      frm=pri;
+      break;
+    case 6:
+      cip=(cell *)(amx->code + (int)pri);
+      break;
+    } /* switch */
+    NEXT(cip,op);
+  op_xchg:
+    offs=pri;         /* offs is a temporary variable */
+    pri=alt;
+    alt=offs;
+    NEXT(cip,op);
+  op_push_pri:
+    PUSH(pri);
+    NEXT(cip,op);
+  op_push_alt:
+    PUSH(alt);
+    NEXT(cip,op);
+  op_pushr_pri:
+    PUSH(data+pri);
+    NEXT(cip,op);
+  op_pop_pri:
+    POP(pri);
+    NEXT(cip,op);
+  op_pop_alt:
+    POP(alt);
+    NEXT(cip,op);
+  op_pick:
+    GETPARAM(offs);
+    pri=_R(data,stk+offs);
+    NEXT(cip,op);
+  op_stack:
+    GETPARAM(offs);
+    alt=stk;
+    stk+=offs;
+    CHKMARGIN();
+    CHKSTACK();
+    NEXT(cip,op);
+  op_heap:
+    GETPARAM(offs);
+    alt=hea;
+    hea+=offs;
+    CHKMARGIN();
+    CHKHEAP();
+    NEXT(cip,op);
+  op_proc:
+    PUSH(frm);
+    frm=stk;
+    CHKMARGIN();
+    NEXT(cip,op);
+  op_ret:
+    POP(frm);
+    POP(offs);
+    /* verify the return address */
+    if ((long)offs>=amx->codesize)
+      ABORT(amx,AMX_ERR_MEMACCESS);
+    cip=(cell *)(amx->code+(int)offs);
+    NEXT(cip,op);
+  op_retn:
+    POP(frm);
+    POP(offs);
+    /* verify the return address */
+    if ((long)offs>=amx->codesize)
+      ABORT(amx,AMX_ERR_MEMACCESS);
+    cip=(cell *)(amx->code+(int)offs);
+    stk+= _R(data,stk) + sizeof(cell);  /* remove parameters from the stack */
+    NEXT(cip,op);
+  op_call:
+    PUSH(((unsigned char *)cip-amx->code)+sizeof(cell));/* push address behind instruction */
+    cip=JUMPREL(cip);                   /* jump to the address */
+    NEXT(cip,op);
+  op_jump:
+    /* since the GETPARAM() macro modifies cip, you cannot
+     * do GETPARAM(cip) directly */
+    cip=JUMPREL(cip);
+    NEXT(cip,op);
+  op_jzer:
+    if (pri==0)
+      cip=JUMPREL(cip);
+    else
+      SKIPPARAM(1);
+    NEXT(cip,op);
+  op_jnz:
+    if (pri!=0)
+      cip=JUMPREL(cip);
+    else
+      SKIPPARAM(1);
+    NEXT(cip,op);
+  op_shl:
+    pri<<=alt;
+    NEXT(cip,op);
+  op_shr:
+    pri=(ucell)pri >> (ucell)alt;
+    NEXT(cip,op);
+  op_sshr:
+    pri>>=alt;
+    NEXT(cip,op);
+  op_shl_c_pri:
+    GETPARAM(offs);
+    pri<<=offs;
+    NEXT(cip,op);
+  op_shl_c_alt:
+    GETPARAM(offs);
+    alt<<=offs;
+    NEXT(cip,op);
+  op_smul:
+    pri*=alt;
+    NEXT(cip,op);
+  op_sdiv:
+    if (pri==0)
+      ABORT(amx,AMX_ERR_DIVIDE);
+    /* use floored division and matching remainder */
+    offs=pri;
+    #if defined TRUNC_SDIV
+      pri=alt/offs;
+      alt=alt%offs;
+    #else
+      val=alt;                  /* portable routine for truncated division */
+      pri=IABS(alt)/IABS(offs);
+      if ((cell)(val ^ offs)<0)
+        pri=-pri;
+      alt=val-pri*offs;         /* calculate the matching remainder */
+    #endif
+    /* now "fiddle" with the values to get floored division */
+    if (alt!=0 && (cell)(alt ^ offs)<0) {
+      pri--;
+      alt+=offs;
+    } /* if */
+    NEXT(cip,op);
+  op_add:
+    pri+=alt;
+    NEXT(cip,op);
+  op_sub:
+    pri=alt-pri;
+    NEXT(cip,op);
+  op_and:
+    pri&=alt;
+    NEXT(cip,op);
+  op_or:
+    pri|=alt;
+    NEXT(cip,op);
+  op_xor:
+    pri^=alt;
+    NEXT(cip,op);
+  op_not:
+    pri=!pri;
+    NEXT(cip,op);
+  op_neg:
+    pri=-pri;
+    NEXT(cip,op);
+  op_invert:
+    pri=~pri;
+    NEXT(cip,op);
+  op_eq:
+    pri= pri==alt ? 1 : 0;
+    NEXT(cip,op);
+  op_neq:
+    pri= pri!=alt ? 1 : 0;
+    NEXT(cip,op);
+  op_sless:
+    pri= pri<alt ? 1 : 0;
+    NEXT(cip,op);
+  op_sleq:
+    pri= pri<=alt ? 1 : 0;
+    NEXT(cip,op);
+  op_sgrtr:
+    pri= pri>alt ? 1 : 0;
+    NEXT(cip,op);
+  op_sgeq:
+    pri= pri>=alt ? 1 : 0;
+    NEXT(cip,op);
+  op_inc_pri:
+    pri++;
+    NEXT(cip,op);
+  op_inc_alt:
+    alt++;
+    NEXT(cip,op);
+  op_inc_i:
+    #if defined _R_DEFAULT
+      *(cell *)(data+(int)pri) += 1;
+    #else
+      val=_R(data,pri);
+      _W(data,pri,val+1);
+    #endif
+    NEXT(cip,op);
+  op_dec_pri:
+    pri--;
+    NEXT(cip,op);
+  op_dec_alt:
+    alt--;
+    NEXT(cip,op);
+  op_dec_i:
+    #if defined _R_DEFAULT
+      *(cell *)(data+(int)pri) -= 1;
+    #else
+      val=_R(data,pri);
+      _W(data,pri,val-1);
+    #endif
+    NEXT(cip,op);
+  op_movs:
+    GETPARAM(offs);
+  __movs:
+    /* verify top & bottom memory addresses, for both source and destination
+     * addresses
+     */
+    if (pri>=hea && pri<stk || (ucell)pri>=(ucell)amx->stp)
+      ABORT(amx,AMX_ERR_MEMACCESS);
+    if ((pri+offs)>hea && (pri+offs)<stk || (ucell)(pri+offs)>(ucell)amx->stp)
+      ABORT(amx,AMX_ERR_MEMACCESS);
+    if (alt>=hea && alt<stk || (ucell)alt>=(ucell)amx->stp)
+      ABORT(amx,AMX_ERR_MEMACCESS);
+    if ((alt+offs)>hea && (alt+offs)<stk || (ucell)(alt+offs)>(ucell)amx->stp)
+      ABORT(amx,AMX_ERR_MEMACCESS);
+    #if defined _R_DEFAULT
+      memcpy(data+(int)alt, data+(int)pri, (int)offs);
+    #else
+      for (i=0; i+4<offs; i+=4) {
+        val=_R32(data,pri+i);
+        _W32(data,alt+i,val);
+      } /* for */
+      for ( ; i<offs; i++) {
+        val=_R8(data,pri+i);
+        _W8(data,alt+i,val);
+      } /* for */
+    #endif
+    NEXT(cip,op);
+  op_cmps:
+    GETPARAM(offs);
+  __cmps:
+    /* verify top & bottom memory addresses, for both source and destination
+     * addresses
+     */
+    if (pri>=hea && pri<stk || (ucell)pri>=(ucell)amx->stp)
+      ABORT(amx,AMX_ERR_MEMACCESS);
+    if ((pri+offs)>hea && (pri+offs)<stk || (ucell)(pri+offs)>(ucell)amx->stp)
+      ABORT(amx,AMX_ERR_MEMACCESS);
+    if (alt>=hea && alt<stk || (ucell)alt>=(ucell)amx->stp)
+      ABORT(amx,AMX_ERR_MEMACCESS);
+    if ((alt+offs)>hea && (alt+offs)<stk || (ucell)(alt+offs)>(ucell)amx->stp)
+      ABORT(amx,AMX_ERR_MEMACCESS);
+    #if defined _R_DEFAULT
+      pri=memcmp(data+(int)alt, data+(int)pri, (int)offs);
+    #else
+      pri=0;
+      for (i=0; i+4<offs && pri==0; i+=4)
+        pri=_R32(data,alt+i)-_R32(data,pri+i);
+      for ( ; i<offs && pri==0; i++)
+        pri=_R8(data,alt+i)-_R8(data,pri+i);
+    #endif
+    NEXT(cip,op);
+  op_fill:
+    GETPARAM(offs);
+  __fill:
+    /* verify top & bottom memory addresses */
+    if (alt>=hea && alt<stk || (ucell)alt>=(ucell)amx->stp)
+      ABORT(amx,AMX_ERR_MEMACCESS);
+    if ((alt+offs)>hea && (alt+offs)<stk || (ucell)(alt+offs)>(ucell)amx->stp)
+      ABORT(amx,AMX_ERR_MEMACCESS);
+    for (i=(int)alt; offs>=(int)sizeof(cell); i+=sizeof(cell), offs-=sizeof(cell))
+      _W32(data,i,pri);
+    NEXT(cip,op);
+  op_halt:
+    GETPARAM(offs);
+  __halt:
+    if (retval!=NULL)
+      *retval=pri;
+    /* store complete status (stk and hea are already set in the ABORT macro) */
+    amx->frm=frm;
+    amx->pri=pri;
+    amx->alt=alt;
+    amx->cip=(cell)((unsigned char*)cip-amx->code);
+    if (offs==AMX_ERR_SLEEP) {
+      amx->stk=stk;
+      amx->hea=hea;
+      amx->reset_stk=reset_stk;
+      amx->reset_hea=reset_hea;
+      return (int)offs;
+    } /* if */
+    ABORT(amx,(int)offs);
+  op_bounds:
+    GETPARAM(offs);
+    if ((ucell)pri>(ucell)offs) {
+      amx->cip=(cell)((unsigned char *)cip-amx->code);
+      ABORT(amx,AMX_ERR_BOUNDS);
+    } /* if */
+    NEXT(cip,op);
+  op_sysreq:
+    GETPARAM(offs);
+    /* save a few registers */
+    amx->cip=(cell)((unsigned char *)cip-amx->code);
+    amx->hea=hea;
+    amx->frm=frm;
+    amx->stk=stk;
+    num=amx->callback(amx,offs,&pri,(cell *)(data+(int)stk));
+    if (num!=AMX_ERR_NONE) {
+      if (num==AMX_ERR_SLEEP) {
+        amx->pri=pri;
+        amx->alt=alt;
+        amx->reset_stk=reset_stk;
+        amx->reset_hea=reset_hea;
+        return num;
+      } /* if */
+      ABORT(amx,num);
+    } /* if */
+    NEXT(cip,op);
+  op_switch: {
+    cell *cptr=JUMPREL(cip)+1;  /* +1, to skip the "casetbl" opcode */
+    cip=JUMPREL(cptr+1);        /* preset to "none-matched" case */
+    num=(int)*cptr;             /* number of records in the case table */
+    for (cptr+=2; num>0 && *cptr!=pri; num--,cptr+=2)
+      /* nothing */;
+    if (num>0)
+      cip=JUMPREL(cptr+1);      /* case found */
+    NEXT(cip,op);
+    }
+  op_swap_pri:
+    offs=_R(data,stk);
+    _W(data,stk,pri);
+    pri=offs;
+    NEXT(cip,op);
+  op_swap_alt:
+    offs=_R(data,stk);
+    _W(data,stk,alt);
+    alt=offs;
+    NEXT(cip,op);
+  op_break:
+    assert((amx->flags & AMX_FLAG_VERIFY)==0);
+    if (amx->debug!=NULL) {
+      /* store status */
+      amx->frm=frm;
+      amx->stk=stk;
+      amx->hea=hea;
+      amx->cip=(cell)((unsigned char*)cip-amx->code);
+      num=amx->debug(amx);
+      if (num!=AMX_ERR_NONE) {
+        if (num==AMX_ERR_SLEEP) {
+          amx->pri=pri;
+          amx->alt=alt;
+          amx->reset_stk=reset_stk;
+          amx->reset_hea=reset_hea;
+          return num;
+        } /* if */
+        ABORT(amx,num);
+      } /* if */
+    } /* if */
+    NEXT(cip,op);
+  op_casetbl:
+    assert(0);                  /* this should not occur during execution */
+    ABORT(amx,AMX_ERR_INVINSTR);
+  op_sysreq_d:          /* see op_sysreq */
+    #if !defined AMX_DONT_RELOCATE
+      GETPARAM(offs);
+      /* save a few registers */
+      amx->cip=(cell)((unsigned char *)cip-amx->code);
+      amx->hea=hea;
+      amx->frm=frm;
+      amx->stk=stk;
+      pri=((AMX_NATIVE)offs)(amx,(cell *)(data+(int)stk));
+      if (amx->error!=AMX_ERR_NONE) {
+        if (amx->error==AMX_ERR_SLEEP) {
+          amx->pri=pri;
+          amx->alt=alt;
+          amx->reset_stk=reset_stk;
+          amx->reset_hea=reset_hea;
+          return AMX_ERR_SLEEP;
+        } /* if */
+        ABORT(amx,amx->error);
+      } /* if */
+      NEXT(cip,op);
+    #else
+      ABORT(amx,AMX_ERR_INVINSTR);
+    #endif
+  op_sysreq_nd:    /* see op_sysreq_n */
+    #if !defined AMX_NO_MACRO_INSTR && !defined AMX_DONT_RELOCATE
+      GETPARAM(offs);
+      GETPARAM(val);
+      PUSH(val);
+      /* save a few registers */
+      amx->cip=(cell)((unsigned char *)cip-amx->code);
+      amx->hea=hea;
+      amx->frm=frm;
+      amx->stk=stk;
+      pri=((AMX_NATIVE)offs)(amx,(cell *)(data+(int)stk));
+      stk+=val+4;
+      if (amx->error!=AMX_ERR_NONE) {
+        if (amx->error==AMX_ERR_SLEEP) {
+          amx->pri=pri;
+          amx->alt=alt;
+          amx->stk=stk;
+          amx->reset_stk=reset_stk;
+          amx->reset_hea=reset_hea;
+          return AMX_ERR_SLEEP;
+        } /* if */
+        ABORT(amx,amx->error);
+      } /* if */
+      NEXT(cip,op);
+    #else
+      ABORT(amx,AMX_ERR_INVINSTR);
+    #endif
+
+    /* overlay instructions */
+#if !defined AMX_NO_OVERLAY
+  op_call_ovl:
+    offs=(unsigned char *)cip-amx->code+sizeof(cell); /* skip address */
+    assert(offs>=0 && offs<(1<<(sizeof(cell)*4)));
+    PUSH((offs<<(sizeof(cell)*4)) | amx->ovl_index);
+    amx->ovl_index=(int)*cip;
+    assert(amx->overlay!=NULL);
+    if ((num=amx->overlay(amx,amx->ovl_index))!=AMX_ERR_NONE)
+      ABORT(amx,num);
+    cip=(cell*)amx->code;
+    NEXT(cip,op);
+  op_retn_ovl:
+    assert(amx->overlay!=NULL);
+    POP(frm);
+    POP(offs);
+    amx->ovl_index=offs & (((ucell)~0)>>4*sizeof(cell));
+    offs=(ucell)offs >> (sizeof(cell)*4);
+    /* verify the index */
+    stk+=_R(data,stk)+sizeof(cell);   /* remove parameters from the stack */
+    num=amx->overlay(amx,amx->ovl_index); /* reload overlay */
+    if (num!=AMX_ERR_NONE || (long)offs>=amx->codesize)
+      ABORT(amx,AMX_ERR_MEMACCESS);
+    cip=(cell *)(amx->code+(int)offs);
+    NEXT(cip,op);
+  op_switch_ovl: {
+    cell *cptr=JUMPREL(cip)+1;  /* +1, to skip the "icasetbl" opcode */
+    amx->ovl_index=*(cptr+1);   /* preset to "none-matched" case */
+    num=(int)*cptr;             /* number of records in the case table */
+    for (cptr+=2; num>0 && *cptr!=pri; num--,cptr+=2)
+      /* nothing */;
+    if (num>0)
+      amx->ovl_index=*(cptr+1); /* case found */
+    assert(amx->overlay!=NULL);
+    if ((num=amx->overlay(amx,amx->ovl_index))!=AMX_ERR_NONE)
+      ABORT(amx,num);
+    cip=(cell*)amx->code;
+    NEXT(cip,op);
+    }
+#else
+  op_call_ovl:
+  op_retn_ovl:
+  op_switch_ovl:
+    ABORT(amx,AMX_ERR_INVINSTR);
+#endif
+  op_casetbl_ovl:
+    assert(0);                  /* this should not occur during execution */
+    ABORT(amx,AMX_ERR_INVINSTR);
+
+    /* supplemental and macro instructions */
+#if !defined AMX_NO_MACRO_INSTR
+  op_lidx:
+    offs=pri*sizeof(cell)+alt;  /* implicit shift value for a cell */
+    /* verify address */
+    if (offs>=hea && offs<stk || (ucell)offs>=(ucell)amx->stp)
+      ABORT(amx,AMX_ERR_MEMACCESS);
+    pri=_R(data,offs);
+    NEXT(cip,op);
+  op_lidx_b:
+    GETPARAM(offs);
+    offs=(pri << (int)offs)+alt;
+    /* verify address */
+    if (offs>=hea && offs<stk || (ucell)offs>=(ucell)amx->stp)
+      ABORT(amx,AMX_ERR_MEMACCESS);
+    pri=_R(data,offs);
+    NEXT(cip,op);
+  op_idxaddr:
+    pri=pri*sizeof(cell)+alt;
+    NEXT(cip,op);
+  op_idxaddr_b:
+    GETPARAM(offs);
+    pri=(pri << (int)offs)+alt;
+    NEXT(cip,op);
+  op_push_c:
+    GETPARAM(offs);
+    PUSH(offs);
+    NEXT(cip,op);
+  op_push:
+    GETPARAM(offs);
+    PUSH(_R(data,offs));
+    NEXT(cip,op);
+  op_push_s:
+    GETPARAM(offs);
+    PUSH(_R(data,frm+offs));
+    NEXT(cip,op);
+  op_push_adr:
+    GETPARAM(offs);
+    PUSH(frm+offs);
+    NEXT(cip,op);
+  op_pushr_c:
+    GETPARAM(offs);
+    PUSH(data+offs);
+    NEXT(cip,op);
+  op_pushr_s:
+    GETPARAM(offs);
+    PUSH(data+_R(data,frm+offs));
+    NEXT(cip,op);
+  op_pushr_adr:
+    GETPARAM(offs);
+    PUSH(data+frm+offs);
+    NEXT(cip,op);
+  op_jeq:
+    if (pri==alt)
+      cip=JUMPREL(cip);
+    else
+      SKIPPARAM(1);
+    NEXT(cip,op);
+  op_jneq:
+    if (pri!=alt)
+      cip=JUMPREL(cip);
+    else
+      SKIPPARAM(1);
+    NEXT(cip,op);
+  op_jsless:
+    if (pri<alt)
+      cip=JUMPREL(cip);
+    else
+      SKIPPARAM(1);
+    NEXT(cip,op);
+  op_jsleq:
+    if (pri<=alt)
+      cip=JUMPREL(cip);
+    else
+      SKIPPARAM(1);
+    NEXT(cip,op);
+  op_jsgrtr:
+    if (pri>alt)
+      cip=JUMPREL(cip);
+    else
+      SKIPPARAM(1);
+    NEXT(cip,op);
+  op_jsgeq:
+    if (pri>=alt)
+      cip=JUMPREL(cip);
+    else
+      SKIPPARAM(1);
+    NEXT(cip,op);
+  op_sdiv_inv:
+    if (alt==0)
+      ABORT(amx,AMX_ERR_DIVIDE);
+    /* use floored division and matching remainder */
+    offs=alt;
+    #if defined TRUNC_SDIV
+      pri=pri/offs;
+      alt=pri%offs;
+    #else
+      val=pri;                  /* portable routine for truncated division */
+      pri=IABS(pri)/IABS(offs);
+      if ((cell)(val ^ offs)<0)
+        pri=-pri;
+      alt=val-pri*offs;         /* calculate the matching remainder */
+    #endif
+    /* now "fiddle" with the values to get floored division */
+    if (alt!=0 && (cell)(alt ^ offs)<0) {
+      pri--;
+      alt+=offs;
+    } /* if */
+    NEXT(cip,op);
+  op_sub_inv:
+    pri-=alt;
+    NEXT(cip,op);
+  op_add_c:
+    GETPARAM(offs);
+    pri+=offs;
+    NEXT(cip,op);
+  op_smul_c:
+    GETPARAM(offs);
+    pri*=offs;
+    NEXT(cip,op);
+  op_zero_pri:
+    pri=0;
+    NEXT(cip,op);
+  op_zero_alt:
+    alt=0;
+    NEXT(cip,op);
+  op_zero:
+    GETPARAM(offs);
+    _W(data,offs,0);
+    NEXT(cip,op);
+  op_zero_s:
+    GETPARAM(offs);
+    _W(data,frm+offs,0);
+    NEXT(cip,op);
+  op_eq_c_pri:
+    GETPARAM(offs);
+    pri= pri==offs ? 1 : 0;
+    NEXT(cip,op);
+  op_eq_c_alt:
+    GETPARAM(offs);
+    pri= alt==offs ? 1 : 0;
+    NEXT(cip,op);
+  op_inc:
+    GETPARAM(offs);
+    #if defined _R_DEFAULT
+      *(cell *)(data+(int)offs) += 1;
+    #else
+      val=_R(data,offs);
+      _W(data,offs,val+1);
+    #endif
+    NEXT(cip,op);
+  op_inc_s:
+    GETPARAM(offs);
+    #if defined _R_DEFAULT
+      *(cell *)(data+(int)(frm+offs)) += 1;
+    #else
+      val=_R(data,frm+offs);
+      _W(data,frm+offs,val+1);
+    #endif
+    NEXT(cip,op);
+  op_dec:
+    GETPARAM(offs);
+    #if defined _R_DEFAULT
+      *(cell *)(data+(int)offs) -= 1;
+    #else
+      val=_R(data,offs);
+      _W(data,offs,val-1);
+    #endif
+    NEXT(cip,op);
+  op_dec_s:
+    GETPARAM(offs);
+    #if defined _R_DEFAULT
+      *(cell *)(data+(int)(frm+offs)) -= 1;
+    #else
+      val=_R(data,frm+offs);
+      _W(data,frm+offs,val-1);
+    #endif
+    NEXT(cip,op);
+  op_sysreq_n:
+    GETPARAM(offs);
+    GETPARAM(val);
+    PUSH(val);
+    /* save a few registers */
+    amx->cip=(cell)((unsigned char *)cip-amx->code);
+    amx->hea=hea;
+    amx->frm=frm;
+    amx->stk=stk;
+    num=amx->callback(amx,offs,&pri,(cell *)(data+(int)stk));
+    stk+=val+4;
+    if (num!=AMX_ERR_NONE) {
+      if (num==AMX_ERR_SLEEP) {
+        amx->pri=pri;
+        amx->alt=alt;
+        amx->stk=stk;
+        amx->reset_stk=reset_stk;
+        amx->reset_hea=reset_hea;
+        return num;
+      } /* if */
+      ABORT(amx,num);
+    } /* if */
+    NEXT(cip,op);
+  op_pushm_c:
+    GETPARAM(val);
+    while (val--) {
+      GETPARAM(offs);
+      PUSH(offs);
+    } /* while */
+    NEXT(cip,op);
+  op_pushm:
+    GETPARAM(val);
+    while (val--) {
+      GETPARAM(offs);
+      PUSH(_R(data,offs));
+    } /* while */
+    NEXT(cip,op);
+  op_pushm_s:
+    GETPARAM(val);
+    while (val--) {
+      GETPARAM(offs);
+      PUSH(_R(data,frm+offs));
+    } /* while */
+    NEXT(cip,op);
+  op_pushm_adr:
+    GETPARAM(val);
+    while (val--) {
+      GETPARAM(offs);
+      PUSH(frm+offs);
+    } /* while */
+    NEXT(cip,op);
+  op_pushrm_c:
+    GETPARAM(val);
+    while (val--) {
+      GETPARAM(offs);
+      PUSH(data+offs);
+    } /* while */
+    NEXT(cip,op);
+  op_pushrm_s:
+    GETPARAM(val);
+    while (val--) {
+      GETPARAM(offs);
+      PUSH(data+_R(data,frm+offs));
+    } /* while */
+    NEXT(cip,op);
+  op_pushrm_adr:
+    GETPARAM(val);
+    while (val--) {
+      GETPARAM(offs);
+      PUSH(data+frm+offs);
+    } /* while */
+    NEXT(cip,op);
+  op_load2:
+    GETPARAM(offs);
+    pri=_R(data,offs);
+    GETPARAM(offs);
+    alt=_R(data,offs);
+    NEXT(cip,op);
+  op_load2_s:
+    GETPARAM(offs);
+    pri=_R(data,frm+offs);
+    GETPARAM(offs);
+    alt=_R(data,frm+offs);
+    NEXT(cip,op);
+  op_const:
+    GETPARAM(offs);
+    GETPARAM(val);
+    _W(data,offs,val);
+    NEXT(cip,op);
+  op_const_s:
+    GETPARAM(offs);
+    GETPARAM(val);
+    _W(data,frm+offs,val);
+    NEXT(cip,op);
+#endif
+
+#if !defined AMX_NO_PACKED_OPC
+  op_load_p_pri:
+    GETPARAM_P(offs,op);
+    pri=_R(data,offs);
+    NEXT(cip,op);
+  op_load_p_alt:
+    GETPARAM_P(offs,op);
+    alt=_R(data,offs);
+    NEXT(cip,op);
+  op_load_p_s_pri:
+    GETPARAM_P(offs,op);
+    pri=_R(data,frm+offs);
+    NEXT(cip,op);
+  op_load_p_s_alt:
+    GETPARAM_P(offs,op);
+    alt=_R(data,frm+offs);
+    NEXT(cip,op);
+  op_lref_p_s_pri:
+    GETPARAM_P(offs,op);
+    offs=_R(data,frm+offs);
+    pri=_R(data,offs);
+    NEXT(cip,op);
+  op_lref_p_s_alt:
+    GETPARAM_P(offs,op);
+    offs=_R(data,frm+offs);
+    alt=_R(data,offs);
+    NEXT(cip,op);
+  op_lodb_p_i:
+    GETPARAM_P(offs,op);
+    goto __lodb_i;
+  op_const_p_pri:
+    GETPARAM_P(pri,op);
+    NEXT(cip,op);
+  op_const_p_alt:
+    GETPARAM_P(alt,op);
+    NEXT(cip,op);
+  op_addr_p_pri:
+    GETPARAM_P(pri,op);
+    pri+=frm;
+    NEXT(cip,op);
+  op_addr_p_alt:
+    GETPARAM_P(alt,op);
+    alt+=frm;
+    NEXT(cip,op);
+  op_stor_p:
+    GETPARAM_P(offs,op);
+    _W(data,offs,pri);
+    NEXT(cip,op);
+  op_stor_p_s:
+    GETPARAM_P(offs,op);
+    _W(data,frm+offs,pri);
+    NEXT(cip,op);
+  op_sref_p_s:
+    GETPARAM_P(offs,op);
+    offs=_R(data,frm+offs);
+    _W(data,offs,pri);
+    NEXT(cip,op);
+  op_strb_p_i:
+    GETPARAM_P(offs,op);
+    goto __strb_i;
+  op_lidx_p_b:
+    GETPARAM_P(offs,op);
+    offs=(pri << (int)offs)+alt;
+    /* verify address */
+    if (offs>=hea && offs<stk || (ucell)offs>=(ucell)amx->stp)
+      ABORT(amx,AMX_ERR_MEMACCESS);
+    pri=_R(data,offs);
+    NEXT(cip,op);
+  op_idxaddr_p_b:
+    GETPARAM_P(offs,op);
+    pri=(pri << (int)offs)+alt;
+    NEXT(cip,op);
+  op_align_p_pri:
+    GETPARAM_P(offs,op);
+    #if BYTE_ORDER==LITTLE_ENDIAN
+      if ((size_t)offs<sizeof(cell))
+        pri ^= sizeof(cell)-offs;
+    #endif
+    NEXT(cip,op);
+  op_push_p_c:
+    GETPARAM_P(offs,op);
+    PUSH(offs);
+    NEXT(cip,op);
+  op_push_p:
+    GETPARAM_P(offs,op);
+    PUSH(_R(data,offs));
+    NEXT(cip,op);
+  op_push_p_s:
+    GETPARAM_P(offs,op);
+    PUSH(_R(data,frm+offs));
+    NEXT(cip,op);
+  op_push_p_adr:
+    GETPARAM_P(offs,op);
+    PUSH(frm+offs);
+    NEXT(cip,op);
+  op_pushr_p_c:
+    GETPARAM_P(offs,op);
+    PUSH(data+offs);
+    NEXT(cip,op);
+  op_pushr_p_s:
+    GETPARAM_P(offs,op);
+    PUSH(data+_R(data,frm+offs));
+    NEXT(cip,op);
+  op_pushr_p_adr:
+    GETPARAM_P(offs,op);
+    PUSH(data+frm+offs);
+    NEXT(cip,op);
+  op_pushm_p_c:
+    GETPARAM_P(val,op);
+    while (val--) {
+      GETPARAM(offs);
+      PUSH(offs);
+    } /* while */
+    NEXT(cip,op);
+  op_pushm_p:
+    GETPARAM_P(val,op);
+    while (val--) {
+      GETPARAM(offs);
+      PUSH(_R(data,offs));
+    } /* while */
+    NEXT(cip,op);
+  op_pushm_p_s:
+    GETPARAM_P(val,op);
+    while (val--) {
+      GETPARAM(offs);
+      PUSH(_R(data,frm+offs));
+    } /* while */
+    NEXT(cip,op);
+  op_pushm_p_adr:
+    GETPARAM_P(val,op);
+    while (val--) {
+      GETPARAM(offs);
+      PUSH(frm+offs);
+    } /* while */
+    NEXT(cip,op);
+  op_pushrm_p_c:
+    GETPARAM_P(val,op);
+    while (val--) {
+      GETPARAM(offs);
+      PUSH(data+offs);
+    } /* while */
+    NEXT(cip,op);
+  op_pushrm_p_s:
+    GETPARAM_P(val,op);
+    while (val--) {
+      GETPARAM(offs);
+      PUSH(data+_R(data,frm+offs));
+    } /* while */
+    NEXT(cip,op);
+  op_pushrm_p_adr:
+    GETPARAM_P(val,op);
+    while (val--) {
+      GETPARAM(offs);
+      PUSH(data+frm+offs);
+    } /* while */
+    NEXT(cip,op);
+  op_stack_p:
+    GETPARAM_P(offs,op);
+    alt=stk;
+    stk+=offs;
+    CHKMARGIN();
+    CHKSTACK();
+    NEXT(cip,op);
+  op_heap_p:
+    GETPARAM_P(offs,op);
+    alt=hea;
+    hea+=offs;
+    CHKMARGIN();
+    CHKHEAP();
+    NEXT(cip,op);
+  op_shl_p_c_pri:
+    GETPARAM_P(offs,op);
+    pri<<=offs;
+    NEXT(cip,op);
+  op_shl_p_c_alt:
+    GETPARAM_P(offs,op);
+    alt<<=offs;
+    NEXT(cip,op);
+  op_add_p_c:
+    GETPARAM_P(offs,op);
+    pri+=offs;
+    NEXT(cip,op);
+  op_smul_p_c:
+    GETPARAM_P(offs,op);
+    pri*=offs;
+    NEXT(cip,op);
+  op_zero_p:
+    GETPARAM_P(offs,op);
+    _W(data,offs,0);
+    NEXT(cip,op);
+  op_zero_p_s:
+    GETPARAM_P(offs,op);
+    _W(data,frm+offs,0);
+    NEXT(cip,op);
+  op_eq_p_c_pri:
+    GETPARAM_P(offs,op);
+    pri= pri==offs ? 1 : 0;
+    NEXT(cip,op);
+  op_eq_p_c_alt:
+    GETPARAM_P(offs,op);
+    pri= alt==offs ? 1 : 0;
+    NEXT(cip,op);
+  op_inc_p:
+    GETPARAM_P(offs,op);
+    #if defined _R_DEFAULT
+      *(cell *)(data+(int)offs) += 1;
+    #else
+      val=_R(data,offs);
+      _W(data,offs,val+1);
+    #endif
+    NEXT(cip,op);
+  op_inc_p_s:
+    GETPARAM_P(offs,op);
+    #if defined _R_DEFAULT
+      *(cell *)(data+(int)(frm+offs)) += 1;
+    #else
+      val=_R(data,frm+offs);
+      _W(data,frm+offs,val+1);
+    #endif
+    NEXT(cip,op);
+  op_dec_p:
+    GETPARAM_P(offs,op);
+    #if defined _R_DEFAULT
+      *(cell *)(data+(int)offs) -= 1;
+    #else
+      val=_R(data,offs);
+      _W(data,offs,val-1);
+    #endif
+    NEXT(cip,op);
+  op_dec_p_s:
+    GETPARAM_P(offs,op);
+    #if defined _R_DEFAULT
+      *(cell *)(data+(int)(frm+offs)) -= 1;
+    #else
+      val=_R(data,frm+offs);
+      _W(data,frm+offs,val-1);
+    #endif
+    NEXT(cip,op);
+  op_movs_p:
+    GETPARAM_P(offs,op);
+    goto __movs;
+  op_cmps_p:
+    GETPARAM_P(offs,op);
+    goto __cmps;
+  op_fill_p:
+    GETPARAM_P(offs,op);
+    goto __fill;
+  op_halt_p:
+    GETPARAM_P(offs,op);
+    goto __halt;
+  op_bounds_p:
+    GETPARAM_P(offs,op);
+    if ((ucell)pri>(ucell)offs) {
+      amx->cip=(cell)((unsigned char *)cip-amx->code);
+      ABORT(amx,AMX_ERR_BOUNDS);
+    } /* if */
+    NEXT(cip,op);
+#endif
+}
+
+void amx_exec_list(const AMX *amx,const cell **opcodelist,int *numopcodes)
+{
+  /* since the opcode list of the GNU GCC version of the abstract machine core
+   * must be a local variable (as it references code labels, which are local
+   * too), we use a trick to get the opcode list: call amx_Exec() while a
+   * special flags value is set in the AMX header.
+   */
+   int orgflags;
+   AMX *amxptr=(AMX*)amx;
+
+   assert(amx!=NULL);
+   assert(opcodelist!=NULL);
+   assert(numopcodes!=NULL);
+   orgflags=amx->flags;
+   amxptr->flags=~0;
+   *numopcodes=amx_exec_run(amxptr, (cell*)opcodelist, NULL);
+   amxptr->flags=orgflags;
+}
diff --git a/apps/openmw-mp/amx/amxfile.c b/apps/openmw-mp/amx/amxfile.c
new file mode 100644
index 000000000..4e0f37818
--- /dev/null
+++ b/apps/openmw-mp/amx/amxfile.c
@@ -0,0 +1,1274 @@
+/* Text file I/O module for the Pawn Abstract Machine
+ *
+ *  Copyright (c) ITB CompuPhase, 2003-2015
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ *  use this file except in compliance with the License. You may obtain a copy
+ *  of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ *  License for the specific language governing permissions and limitations
+ *  under the License.
+ *
+ *  Version: $Id: amxfile.c 5181 2015-01-21 09:44:28Z thiadmer $
+ */
+#if defined _UNICODE || defined __UNICODE__ || defined UNICODE
+# if !defined UNICODE   /* for Windows */
+#   define UNICODE
+# endif
+# if !defined _UNICODE  /* for C library */
+#   define _UNICODE
+# endif
+#endif
+
+#include <assert.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <sys/stat.h>
+#include "osdefs.h"
+
+#if defined __BORLANDC__
+#include <dir.h>
+#endif
+#if defined __BORLANDC__ || defined __LINUX__ || defined __FreeBSD__ || defined __OpenBSD__ || defined MACOS || defined __APPLE__
+
+#include <utime.h>
+#include <unistd.h>
+
+#else
+#include <sys/utime.h>
+#endif
+#if defined __WIN32__ || defined __MSDOS__
+#include <malloc.h>
+#endif
+#if defined __WATCOMC__ || defined _MSC_VER
+#include <direct.h>
+#endif
+#if defined __LINUX__ || defined __FreeBSD__ || defined __OpenBSD__ || defined MACOS || defined __APPLE__
+
+#include <dirent.h>
+
+#else
+#include <io.h>
+#endif
+
+#include "amx.h"
+
+#if defined __WIN32__ || defined _Windows
+#include <windows.h>
+#endif
+
+#include "fpattern.c"
+
+#if !defined AMXFILE_VAR
+#define AMXFILE_VAR   "AMXFILE"
+#endif
+
+#if !defined sizearray
+#define sizearray(a)  (sizeof(a)/sizeof((a)[0]))
+#endif
+
+#if defined _UNICODE
+#include <tchar.h>
+#elif !defined __T
+typedef char TCHAR;
+#define __T(string)   string
+#define _tchmod       chmod
+#define _tcscat       strcat
+#define _tcschr       strchr
+#define _tcscmp       strcmp
+#define _tcscpy       strcpy
+#define _tcsdup       strdup
+#define _tcslen       strlen
+#define _tcsncpy      strncpy
+#define _tcsnicmp     strnicmp
+#define _tcspbrk      strpbrk
+#define _tcsrchr      strrchr
+#define _tcstol       strtol
+#define _tfopen       fopen
+#define _tfputs       fputs
+#define _tgetenv      getenv
+#define _tremove      remove
+#define _trename      rename
+#if defined __APPLE__
+#define _tmkdir     mkdir
+#define _trmdir     rmdir
+#define _tstat      stat
+#define _tutime     utime
+#else
+#define _tmkdir     mkdir
+#define _trmdir     rmdir
+#define _tstat      stat
+#define _tutime     utime
+#endif
+#endif
+#if !(defined __WIN32__ || defined _WIN32 || defined WIN32)
+#define _stat(n, b)  stat(n,b)
+#endif
+#if !defined S_ISDIR
+#define S_ISDIR(mode) (((mode) & _S_IFDIR) != 0)
+#endif
+
+#include "minIni.h"
+
+enum filemode
+{
+    io_read, /* file must exist */
+            io_write, /* creates a new file */
+            io_readwrite, /* file must exist */
+            io_append,    /* file must exist, opened for writing only and seek to the end */
+};
+
+enum seek_whence
+{
+    seek_start,
+    seek_current,
+    seek_end,
+};
+
+
+/* This function only stores unpacked strings. UTF-8 is used for
+ * Unicode, and packed strings can only store 7-bit and 8-bit
+ * character sets (ASCII, Latin-1).
+ */
+static size_t fgets_cell(FILE *fp, cell *string, size_t max, int utf8mode)
+{
+    size_t index;
+    fpos_t pos;
+    cell c;
+    int follow, lastcr;
+    cell lowmark;
+
+    assert(sizeof(cell) >= 4);
+    assert(fp != NULL);
+    assert(string != NULL);
+    if (max == 0)
+        return 0;
+
+    /* get the position, in case we have to back up */
+    fgetpos(fp, &pos);
+
+    index = 0;
+    follow = 0;
+    lowmark = 0;
+    lastcr = 0;
+    for (; ;)
+    {
+        assert(index < max);
+        if (index == max - 1)
+            break;                    /* string fully filled */
+        if ((c = fgetc(fp)) == EOF)
+        {
+            if (!utf8mode || follow == 0)
+                break;                  /* no more characters */
+            /* If an EOF happened halfway an UTF-8 code, the string cannot be
+             * UTF-8 mode, and we must restart.
+             */
+            index = 0;
+            fsetpos(fp, &pos);
+            continue;
+        } /* if */
+
+        /* 8-bit characters are unsigned */
+        if (c < 0)
+            c = -c;
+
+        if (utf8mode)
+        {
+            if (follow > 0 && (c & 0xc0) == 0x80)
+            {
+                /* leader code is active, combine with earlier code */
+                string[index] = (string[index] << 6) | ((unsigned char) c & 0x3f);
+                if (--follow == 0)
+                {
+                    /* encoding a character in more bytes than is strictly needed,
+                     * is not really valid UTF-8; we are strict here to increase
+                     * the chance of heuristic dectection of non-UTF-8 text
+                     * (JAVA writes zero bytes as a 2-byte code UTF-8, which is invalid)
+                     */
+                    if (string[index] < lowmark)
+                        utf8mode = 0;
+                    /* the code positions 0xd800--0xdfff and 0xfffe & 0xffff do not
+                     * exist in UCS-4 (and hence, they do not exist in Unicode)
+                     */
+                    if (string[index] >= 0xd800 && string[index] <= 0xdfff
+                        || string[index] == 0xfffe || string[index] == 0xffff)
+                        utf8mode = 0;
+                    index++;
+                } /* if */
+            } else if (follow == 0 && (c & 0x80) == 0x80)
+            {
+                /* UTF-8 leader code */
+                if ((c & 0xe0) == 0xc0)
+                {
+                    /* 110xxxxx 10xxxxxx */
+                    follow = 1;
+                    lowmark = 0x80;
+                    string[index] = c & 0x1f;
+                } else if ((c & 0xf0) == 0xe0)
+                {
+                    /* 1110xxxx 10xxxxxx 10xxxxxx (16 bits, BMP plane) */
+                    follow = 2;
+                    lowmark = 0x800;
+                    string[index] = c & 0x0f;
+                } else if ((c & 0xf8) == 0xf0)
+                {
+                    /* 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */
+                    follow = 3;
+                    lowmark = 0x10000;
+                    string[index] = c & 0x07;
+                } else if ((c & 0xfc) == 0xf8)
+                {
+                    /* 111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx */
+                    follow = 4;
+                    lowmark = 0x200000;
+                    string[index] = c & 0x03;
+                } else if ((c & 0xfe) == 0xfc)
+                {
+                    /* 1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx (31 bits) */
+                    follow = 5;
+                    lowmark = 0x4000000;
+                    string[index] = c & 0x01;
+                } else
+                {
+                    /* this is invalid UTF-8 */
+                    utf8mode = 0;
+                } /* if */
+            } else if (follow == 0 && (c & 0x80) == 0x00)
+            {
+                /* 0xxxxxxx (US-ASCII) */
+                string[index++] = c;
+                if (c == __T('\n'))
+                    break;        /* read newline, done */
+            } else
+            {
+                /* this is invalid UTF-8 */
+                utf8mode = 0;
+            } /* if */
+            if (!utf8mode)
+            {
+                /* UTF-8 mode was switched just off, which means that non-conforming
+                 * UTF-8 codes were found, which means in turn that the string is
+                 * probably not intended as UTF-8; start over again
+                 */
+                index = 0;
+                fsetpos(fp, &pos);
+            } /* if */
+        } else
+        {
+            string[index++] = c;
+            if (c == __T('\n'))
+            {
+                break;                  /* read newline, done */
+            } else if (lastcr)
+            {
+                ungetc(c, fp);           /* carriage return was read, no newline follows */
+                break;
+            } /* if */
+            lastcr = (c == __T('\r'));
+        } /* if */
+    } /* for */
+    assert(index < max);
+    string[index] = __T('\0');
+
+    return index;
+}
+
+static size_t fputs_cell(FILE *fp, cell *string, int utf8mode)
+{
+    size_t count = 0;
+
+    assert(sizeof(cell) >= 4);
+    assert(fp != NULL);
+    assert(string != NULL);
+
+    while (*string != 0)
+    {
+        if (utf8mode)
+        {
+            cell c = *string;
+            if (c < 0x80)
+            {
+                /* 0xxxxxxx */
+                fputc((unsigned char) c, fp);
+            } else if (c < 0x800)
+            {
+                /* 110xxxxx 10xxxxxx */
+                fputc((unsigned char) ((c >> 6) & 0x1f | 0xc0), fp);
+                fputc((unsigned char) (c & 0x3f | 0x80), fp);
+            } else if (c < 0x10000)
+            {
+                /* 1110xxxx 10xxxxxx 10xxxxxx (16 bits, BMP plane) */
+                fputc((unsigned char) ((c >> 12) & 0x0f | 0xe0), fp);
+                fputc((unsigned char) ((c >> 6) & 0x3f | 0x80), fp);
+                fputc((unsigned char) (c & 0x3f | 0x80), fp);
+            } else if (c < 0x200000)
+            {
+                /* 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */
+                fputc((unsigned char) ((c >> 18) & 0x07 | 0xf0), fp);
+                fputc((unsigned char) ((c >> 12) & 0x3f | 0x80), fp);
+                fputc((unsigned char) ((c >> 6) & 0x3f | 0x80), fp);
+                fputc((unsigned char) (c & 0x3f | 0x80), fp);
+            } else if (c < 0x4000000)
+            {
+                /* 111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx */
+                fputc((unsigned char) ((c >> 24) & 0x03 | 0xf8), fp);
+                fputc((unsigned char) ((c >> 18) & 0x3f | 0x80), fp);
+                fputc((unsigned char) ((c >> 12) & 0x3f | 0x80), fp);
+                fputc((unsigned char) ((c >> 6) & 0x3f | 0x80), fp);
+                fputc((unsigned char) (c & 0x3f | 0x80), fp);
+            } else
+            {
+                /* 1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx (31 bits) */
+                fputc((unsigned char) ((c >> 30) & 0x01 | 0xfc), fp);
+                fputc((unsigned char) ((c >> 24) & 0x3f | 0x80), fp);
+                fputc((unsigned char) ((c >> 18) & 0x3f | 0x80), fp);
+                fputc((unsigned char) ((c >> 12) & 0x3f | 0x80), fp);
+                fputc((unsigned char) ((c >> 6) & 0x3f | 0x80), fp);
+                fputc((unsigned char) (c & 0x3f | 0x80), fp);
+            } /* if */
+        } else
+        {
+            /* not UTF-8 mode */
+            fputc((unsigned char) *string, fp);
+        } /* if */
+        string++;
+        count++;
+    } /* while */
+    return count;
+}
+
+static size_t fgets_char(FILE *fp, char *string, size_t max)
+{
+    size_t index;
+    int c, lastcr;
+
+    index = 0;
+    lastcr = 0;
+    for (; ;)
+    {
+        assert(index < max);
+        if (index == max - 1)
+            break;                    /* string fully filled */
+        if ((c = fgetc(fp)) == EOF)
+            break;                    /* no more characters */
+        string[index++] = (char) c;
+        if (c == __T('\n'))
+        {
+            break;                    /* read newline, done */
+        } else if (lastcr)
+        {
+            ungetc(c, fp);             /* carriage return was read, no newline follows */
+            break;
+        } /* if */
+        lastcr = (c == __T('\r'));
+    } /* for */
+    assert(index < max);
+    string[index] = __T('\0');
+
+    return index;
+}
+
+#if (defined __WIN32__ || defined _WIN32 || defined WIN32) && _MSC_VER < 1500
+#if defined _UNICODE
+wchar_t *_wgetenv(wchar_t *name)
+{
+static wchar_t buffer[_MAX_PATH];
+  buffer[0]=L'\0';
+  GetEnvironmentVariable(name,buffer,sizearray(buffer));
+  return buffer[0]!=L'\0' ? buffer : NULL;
+}
+#else
+char *getenv(const char *name)
+{
+static char buffer[_MAX_PATH];
+  buffer[0]='\0';
+  GetEnvironmentVariable(name,buffer,sizearray(buffer));
+  return buffer[0]!='\0' ? buffer : NULL;
+}
+#endif
+#endif
+
+static char *completename(TCHAR *dest, TCHAR *src, size_t size)
+{
+#if defined AMXFILE_VAR
+    TCHAR *prefix, *ptr;
+    size_t len;
+
+    /* only files below a specific path are accessible */
+    prefix = getenv(AMXFILE_VAR);
+
+    /* if no specific path for files is present, use the "temporary" path */
+    if (prefix == NULL)
+        prefix = getenv(__T("tmp"));    /* common under Windows and Unix */
+    if (prefix == NULL)
+        prefix = getenv(__T("temp"));   /* common under Windows */
+    if (prefix == NULL)
+        prefix = getenv(__T("tmpdir")); /* common under Unix */
+
+    /* if no path for files is defined, and no temporary directory exists,
+     * fail the function; this is for security reasons.
+     */
+    if (prefix == NULL)
+        return NULL;
+
+    if (_tcslen(prefix) + 1 >= size) /* +1 because directory separator is appended */
+        return NULL;
+    _tcscpy(dest, prefix);
+    /* append a directory separator (if not already present) */
+    len = _tcslen(dest);
+    if (len == 0)
+        return NULL;              /* empty start directory is not allowed */
+    if (dest[len - 1] != __T(DIRSEP_CHAR) && dest[len - 1] != __T('/') && len + 1 < size)
+    {
+        dest[len] = __T(DIRSEP_CHAR);
+        dest[len + 1] = __T('\0');
+    } /* if */
+    assert(_tcslen(dest) < size);
+
+    /* for DOS/Windows and Unix/Linux, skip everyting up to a comma, because
+     * this is used to indicate a protocol (e.g. file://C:/myfile.txt)
+     */
+#if DIRSEP_CHAR != ':'
+    if ((ptr = _tcsrchr(src, __T(':'))) != NULL)
+    {
+        src = ptr + 1;              /* skip protocol/drive and colon */
+        /* a "drive" specifier is sometimes ended with a vertical bar instead
+         * of a colon in URL specifications
+         */
+        if ((ptr = _tcschr(src, __T('|'))) != NULL)
+            src = ptr + 1;            /* skip drive and vertical bar */
+        while (src[0] == __T(DIRSEP_CHAR) || src[0] == __T('/'))
+            src++;                /* skip slashes behind the protocol/drive letter */
+    } /* if */
+#endif
+
+    /* skip an initial backslash or a drive specifier in the source */
+    if ((src[0] == __T(DIRSEP_CHAR) || src[0] == __T('/')) && (src[1] == __T(DIRSEP_CHAR) || src[1] == __T('/')))
+    {
+        /* UNC path */
+        char separators[] = {__T(DIRSEP_CHAR), __T('/'), __T('\0')};
+        src += 2;
+        ptr = _tcspbrk(src, separators);
+        if (ptr != NULL)
+            src = ptr + 1;
+    } else if (src[0] == __T(DIRSEP_CHAR) || src[0] == __T('/'))
+    {
+        /* simple path starting from the root directory */
+        src++;
+    } /* if */
+
+    /* disallow any "../" specifications in the source path
+     * (the check below should be stricter, but directory names with
+     * trailing periods are rare anyway)
+     */
+    for (ptr = src; *ptr != __T('\0'); ptr++)
+        if (ptr[0] == __T('.') && (ptr[1] == __T(DIRSEP_CHAR) || ptr[1] == __T('/')))
+            return NULL;            /* path name is not allowed */
+
+    /* concatenate the drive letter to the destination path */
+    if (_tcslen(dest) + _tcslen(src) >= size)
+        return NULL;
+    _tcscat(dest, src);
+
+    /* change forward slashes into proper directory separators */
+#if DIRSEP_CHAR != '/'
+    while ((ptr=_tcschr(dest,__T('/')))!=NULL)
+      *ptr=__T(DIRSEP_CHAR);
+#endif
+    return dest;
+
+#else
+    if (_tcslen(src)>=size)
+      return NULL;
+    _tcscpy(dest,src);
+    /* change forward slashes into proper directory separators */
+#if DIRSEP_CHAR!='/'
+      while ((ptr=_tcschr(dest,__T('/')))!=NULL)
+        *ptr=__T(DIRSEP_CHAR);
+#endif
+    return dest;
+#endif
+}
+
+/* File: fopen(const name[], filemode: mode) */
+static cell AMX_NATIVE_CALL n_fopen(AMX *amx, const cell *params)
+{
+    TCHAR *attrib, *altattrib;
+    TCHAR *name, fullname[_MAX_PATH];
+    FILE *f = NULL;
+
+    (void) amx;
+    altattrib = NULL;
+    switch (params[2] & 0x7fff)
+    {
+        case io_read:
+            attrib = __T("rb");
+            break;
+        case io_write:
+            attrib = __T("wb");
+            break;
+        case io_readwrite:
+            attrib = __T("r+b");
+            altattrib = __T("w+b");
+            break;
+        case io_append:
+            attrib = __T("ab");
+            break;
+        default:
+            return 0;
+    } /* switch */
+
+    /* get the filename */
+    amx_StrParam(amx, params[1], name);
+    if (name != NULL && completename(fullname, name, sizearray(fullname)) != NULL)
+    {
+        f = _tfopen(fullname, attrib);
+        if (f == NULL && altattrib != NULL)
+            f = _tfopen(fullname, altattrib);
+    } /* if */
+
+    return (cell) f;
+}
+
+/* fclose(File: handle) */
+static cell AMX_NATIVE_CALL n_fclose(AMX *amx, const cell *params)
+{
+    (void) amx;
+    return fclose((FILE *) params[1]) == 0;
+}
+
+/* fwrite(File: handle, const string[]) */
+static cell AMX_NATIVE_CALL n_fwrite(AMX *amx, const cell *params)
+{
+    size_t r = 0;
+    cell *cptr;
+    char *str;
+    int len;
+
+    (void) amx;
+    cptr = amx_Address(amx, params[2]);
+    amx_StrLen(cptr, &len);
+    if (len == 0)
+        return 0;
+
+    if ((ucell) *cptr > UNPACKEDMAX)
+    {
+        /* the string is packed, write it as an ASCII/ANSI string */
+        if ((str = (char *) alloca(len + 1)) != NULL)
+        {
+            amx_GetString(str, cptr, 0, len);
+            r = fputs(str, (FILE *) params[1]);
+        } /* if */
+    } else
+    {
+        /* the string is unpacked, write it as UTF-8 */
+        r = fputs_cell((FILE *) params[1], cptr, 1);
+    } /* if */
+    return (cell) r;
+}
+
+/* fread(File: handle, string[], size=sizeof string, bool:pack=false) */
+static cell AMX_NATIVE_CALL n_fread(AMX *amx, const cell *params)
+{
+    size_t chars;
+    int max;
+    char *str;
+    cell *cptr;
+
+    max = (int) params[3];
+    if (max <= 0)
+        return 0;
+    if (params[4])
+        max *= sizeof(cell);
+
+    cptr = amx_Address(amx, params[2]);
+    str = (char *) alloca(max);
+    if (str == NULL || cptr == NULL)
+    {
+        amx_RaiseError(amx, AMX_ERR_NATIVE);
+        return 0;
+    } /* if */
+
+    if (params[4])
+    {
+        /* store as packed string, read an ASCII/ANSI string */
+        chars = fgets_char((FILE *) params[1], str, max);
+        assert(chars < max);
+        amx_SetString(cptr, str, 1, 0, max);
+    } else
+    {
+        /* store and unpacked string, interpret UTF-8 */
+        chars = fgets_cell((FILE *) params[1], cptr, max, 1);
+    } /* if */
+
+    assert((int) chars < max);
+    return (cell) chars;
+}
+
+/* fputchar(File: handle, value, bool:utf8 = true) */
+static cell AMX_NATIVE_CALL n_fputchar(AMX *amx, const cell *params)
+{
+    size_t result = 0;
+
+    (void) amx;
+    if (params[3])
+    {
+        cell str[2];
+        str[0] = params[2];
+        str[1] = 0;
+        result = fputs_cell((FILE *) params[1], str, 1);
+    } else
+    {
+        fputc((int) params[2], (FILE *) params[1]);
+    } /* if */
+    assert(result == 0 || result == 1);
+    return (cell) result;
+}
+
+/* fgetchar(File: handle, bool:utf8 = true) */
+static cell AMX_NATIVE_CALL n_fgetchar(AMX *amx, const cell *params)
+{
+    cell str[2];
+    size_t result;
+
+    (void) amx;
+    if (params[2])
+    {
+        result = fgets_cell((FILE *) params[1], str, 2, 1);
+    } else
+    {
+        str[0] = fgetc((FILE *) params[1]);
+        result = (str[0] != EOF);
+    } /* if */
+    assert(result == 0 || result == 1);
+    if (result == 0)
+        return EOF;
+    else
+        return str[0];
+}
+
+#if PAWN_CELL_SIZE == 16
+#define aligncell amx_Align16
+#elif PAWN_CELL_SIZE == 32
+#define aligncell amx_Align32
+#elif PAWN_CELL_SIZE == 64 && (defined _I64_MAX || defined HAVE_I64)
+#define aligncell amx_Align64
+#else
+#error Unsupported cell size
+#endif
+
+/* fblockwrite(File: handle, buffer[], size=sizeof buffer) */
+static cell AMX_NATIVE_CALL n_fblockwrite(AMX *amx, const cell *params)
+{
+    cell *cptr;
+    cell count = 0;
+
+    (void) amx;
+    cptr = amx_Address(amx, params[2]);
+    if (cptr != NULL)
+    {
+        cell max = params[3];
+        ucell v;
+        for (count = 0; count < max; count++)
+        {
+            v = (ucell) *cptr++;
+            if (fwrite(aligncell(&v), sizeof(cell), 1, (FILE *) params[1]) != 1)
+                break;          /* write error */
+        } /* for */
+    } /* if */
+    return count;
+}
+
+/* fblockread(File: handle, buffer[], size=sizeof buffer) */
+static cell AMX_NATIVE_CALL n_fblockread(AMX *amx, const cell *params)
+{
+    cell *cptr;
+    cell count = 0;
+
+    (void) amx;
+    cptr = amx_Address(amx, params[2]);
+    if (cptr != NULL)
+    {
+        cell max = params[3];
+        ucell v;
+        for (count = 0; count < max; count++)
+        {
+            if (fread(&v, sizeof(cell), 1, (FILE *) params[1]) != 1)
+                break;          /* write error */
+            *cptr++ = (cell) *aligncell(&v);
+        } /* for */
+    } /* if */
+    return count;
+}
+
+/* File: ftemp() */
+static cell AMX_NATIVE_CALL n_ftemp(AMX *amx, const cell *params)
+{
+    (void) amx;
+    (void) params;
+    return (cell) tmpfile();
+}
+
+/* fseek(File: handle, position, seek_whence: whence=seek_start) */
+static cell AMX_NATIVE_CALL n_fseek(AMX *amx, const cell *params)
+{
+    int whence;
+    (void) amx;
+    switch (params[3])
+    {
+        case seek_start:
+            whence = SEEK_SET;
+            break;
+        case seek_current:
+            whence = SEEK_CUR;
+            break;
+        case seek_end:
+            whence = SEEK_END;
+            //if (params[2]>0)
+            //  params[2]=-params[2];
+            break;
+        default:
+            return 0;
+    } /* switch */
+    return lseek(fileno((FILE *) params[1]), params[2], whence);
+}
+
+/* bool: fremove(const name[]) */
+static cell AMX_NATIVE_CALL n_fremove(AMX *amx, const cell *params)
+{
+    int r = 1;
+    TCHAR *name, fullname[_MAX_PATH];
+
+    (void) amx;
+    amx_StrParam(amx, params[1], name);
+    if (name != NULL && completename(fullname, name, sizearray(fullname)) != NULL)
+    {
+        /* if this is a directory, try _trmdir() */
+        struct stat stbuf;
+        _tstat(fullname, &stbuf);
+        if (S_ISDIR(stbuf.st_mode))
+            r = _trmdir(fullname);
+        else
+            r = _tremove(fullname);
+    } /* if */
+    return r == 0;
+}
+
+/* bool: fcopy(const source[], const target[]) */
+static cell AMX_NATIVE_CALL n_fcopy(AMX *amx, const cell *params)
+{
+    int r = 1;
+    TCHAR *name, oldname[_MAX_PATH], newname[_MAX_PATH];
+
+    (void) amx;
+    amx_StrParam(amx, params[1], name);
+    if (name != NULL && completename(oldname, name, sizearray(oldname)) != NULL)
+    {
+        amx_StrParam(amx, params[2], name);
+        if (name != NULL && completename(newname, name, sizearray(newname)) != NULL)
+        {
+#if defined __WIN32__
+            r= CopyFile(oldname,newname,FALSE)==FALSE;
+#else
+            TCHAR cmd[2 * _MAX_PATH + 10];
+            sprintf(cmd, "cp %s %s", oldname, newname);
+            r = system(cmd) < 0;
+#endif
+        } /* if */
+    } /* if */
+    return r == 0;
+}
+
+/* bool: frename(const oldname[], const newname[]) */
+static cell AMX_NATIVE_CALL n_frename(AMX *amx, const cell *params)
+{
+    int r = 1;
+    TCHAR *name, oldname[_MAX_PATH], newname[_MAX_PATH];
+
+    (void) amx;
+    amx_StrParam(amx, params[1], name);
+    if (name != NULL && completename(oldname, name, sizearray(oldname)) != NULL)
+    {
+        amx_StrParam(amx, params[2], name);
+        if (name != NULL && completename(newname, name, sizearray(newname)) != NULL)
+            r = _trename(oldname, newname);
+    } /* if */
+    return r == 0;
+}
+
+/* flength(File: handle) */
+static cell AMX_NATIVE_CALL n_flength(AMX *amx, const cell *params)
+{
+    long l, c;
+    int fn = fileno((FILE *) params[1]);
+    c = lseek(fn, 0, SEEK_CUR); /* save the current position */
+    l = lseek(fn, 0, SEEK_END); /* return the file position at its end */
+    lseek(fn, c, SEEK_SET);   /* restore the file pointer */
+    (void) amx;
+    return l;
+}
+
+static int match_optcopy(TCHAR *out, int outlen, const TCHAR *in, int skip)
+{
+    if (out == NULL || skip != 0 || outlen <= 0)
+        return 0;
+    _tcsncpy(out, in, outlen);
+    out[outlen - 1] = '\0';
+    return 1;
+}
+
+static int matchfiles(const TCHAR *path, int skip, TCHAR *out, int outlen)
+{
+    int count = 0;
+    const TCHAR *basename;
+#if DIRSEP_CHAR != '/'
+    TCHAR *ptr;
+#endif
+#if defined __WIN32__
+    HANDLE hfind;
+    WIN32_FIND_DATA fd;
+#else
+    /* assume LINUX, FreeBSD, OpenBSD, or some other variant */
+    DIR *dir;
+    struct dirent *entry;
+    TCHAR dirname[_MAX_PATH];
+#endif
+
+    basename = _tcsrchr(path, DIRSEP_CHAR);
+    basename = (basename == NULL) ? path : basename + 1;
+#if DIRSEP_CHAR != '/'
+    ptr=_tcsrchr(basename,DIRSEP_CHAR);
+    basename=(ptr==NULL) ? basename : ptr+1;
+#endif
+
+#if defined __WIN32__
+    if ((hfind=FindFirstFile(path,&fd))!=INVALID_HANDLE_VALUE) {
+      do {
+        if (fpattern_match(basename,fd.cFileName,-1,FALSE)) {
+          count++;
+          if (match_optcopy(out,outlen,fd.cFileName,skip--))
+            break;
+        } /* if */
+      } while (FindNextFile(hfind,&fd));
+      FindClose(hfind);
+    } /* if */
+#else
+    /* copy directory part only (zero-terminate) */
+    if (basename == path)
+    {
+        _tcscpy(dirname, ".");
+    } else
+    {
+        _tcsncpy(dirname, path, (int) (basename - path));
+        dirname[(int) (basename - path)] = __T('\0');
+    } /* if */
+    if ((dir = opendir(dirname)) != NULL)
+    {
+        while ((entry = readdir(dir)) != NULL)
+        {
+            if (fpattern_match(basename, entry->d_name, -1, TRUE))
+            {
+                count++;
+                if (match_optcopy(out, outlen, entry->d_name, skip--))
+                    break;
+            } /* if */
+        } /* while */
+        closedir(dir);
+    } /* if */
+#endif
+    return count;
+}
+
+/* fexist(const pattern[]) */
+static cell AMX_NATIVE_CALL n_fexist(AMX *amx, const cell *params)
+{
+    int r = 0;
+    TCHAR *name, fullname[_MAX_PATH];
+
+    (void) amx;
+    amx_StrParam(amx, params[1], name);
+    if (name != NULL && completename(fullname, name, sizearray(fullname)) != NULL)
+        r = matchfiles(fullname, 0, NULL, 0);
+    return r;
+}
+
+/* bool: fmatch(filename[], const pattern[], index=0, maxlength=sizeof filename) */
+static cell AMX_NATIVE_CALL n_fmatch(AMX *amx, const cell *params)
+{
+    TCHAR *name, fullname[_MAX_PATH] = "";
+    cell *cptr;
+
+    (void) amx;
+    amx_StrParam(amx, params[2], name);
+    if (name != NULL && completename(fullname, name, sizearray(fullname)) != NULL)
+    {
+        if (!matchfiles(fullname, params[3], fullname, sizearray(fullname)))
+        {
+            fullname[0] = '\0';
+        } else
+        {
+            /* copy the string into the destination */
+            cptr = amx_Address(amx, params[1]);
+            amx_SetString(cptr, fullname, 1, 0, params[4]);
+        } /* if */
+    } /* if */
+    return fullname[0] != '\0';
+}
+
+/* bool: fstat(const name[], &size = 0, &timestamp = 0, &attrib = 0, &inode = 0) */
+static cell AMX_NATIVE_CALL n_fstat(AMX *amx, const cell *params)
+{
+    TCHAR *name, fullname[_MAX_PATH] = "";
+    cell *cptr;
+    int result = 0;
+
+    (void) amx;
+    amx_StrParam(amx, params[1], name);
+    if (name != NULL && completename(fullname, name, sizearray(fullname)) != NULL)
+    {
+        struct stat stbuf;
+        if (_tstat(name, &stbuf) == 0)
+        {
+            cptr = amx_Address(amx, params[2]);
+            *cptr = stbuf.st_size;
+            cptr = amx_Address(amx, params[3]);
+            *cptr = (cell) stbuf.st_mtime;
+            cptr = amx_Address(amx, params[4]);
+            *cptr = stbuf.st_mode;  /* mode/protection bits */
+            cptr = amx_Address(amx, params[5]);
+            *cptr = stbuf.st_ino;   /* inode number, unique id for a file */
+            result = 1;
+        } /* if */
+    } /* if */
+    return result;
+}
+
+/* bool: fattrib(const name[], timestamp=0, attrib=0x0f) */
+static cell AMX_NATIVE_CALL n_fattrib(AMX *amx, const cell *params)
+{
+#if !(defined __WIN32__ || defined _WIN32 || defined WIN32)
+#define _utime(n, t)  utime(n,t)
+#define _utimbuf     utimbuf
+#endif
+    TCHAR *name, fullname[_MAX_PATH] = "";
+    int result = 0;
+
+    (void) amx;
+    amx_StrParam(amx, params[1], name);
+    if (name != NULL && completename(fullname, name, sizearray(fullname)) != NULL)
+    {
+        result = 1;
+        if (params[2] != 0)
+        {
+            struct _utimbuf times;
+            times.actime = (unsigned long) params[2];
+            times.modtime = (unsigned long) params[2];
+            result = result && (_tutime(name, &times) == 0);
+        } /* if */
+        if (params[3] != 0x0f)
+            result = result && (_tchmod(name, (int) params[3]) == 0);
+    } /* if */
+    return result;
+}
+
+/* bool: fcreatedir(const name[]) */
+static cell AMX_NATIVE_CALL n_fcreatedir(AMX *amx, const cell *params)
+{
+    TCHAR *name, fullname[_MAX_PATH] = "";
+    int r = 1;
+
+    (void) amx;
+    amx_StrParam(amx, params[1], name);
+    if (name != NULL && completename(fullname, name, sizearray(fullname)) != NULL)
+    {
+#if defined __WIN32__ || defined __DOS__
+        r=_tmkdir(fullname);
+#else
+        r = _tmkdir(fullname, 0755);
+#endif
+    } /* if */
+    return r == 0;
+}
+
+/* CRC32 functions are adapted from source code from www.networkdls.com
+ * The table generation routines are replaced by a hard-coded table, which
+ * can be stored in Flash ROM.
+ */
+const unsigned long ulCRCTable[256] = // CRC Lookup Table Array
+        {
+                0x00000000Lu, 0x77073096Lu, 0xee0e612cLu, 0x990951baLu,
+                0x076dc419Lu, 0x706af48fLu, 0xe963a535Lu, 0x9e6495a3Lu,
+                0x0edb8832Lu, 0x79dcb8a4Lu, 0xe0d5e91eLu, 0x97d2d988Lu,
+                0x09b64c2bLu, 0x7eb17cbdLu, 0xe7b82d07Lu, 0x90bf1d91Lu,
+                0x1db71064Lu, 0x6ab020f2Lu, 0xf3b97148Lu, 0x84be41deLu,
+                0x1adad47dLu, 0x6ddde4ebLu, 0xf4d4b551Lu, 0x83d385c7Lu,
+                0x136c9856Lu, 0x646ba8c0Lu, 0xfd62f97aLu, 0x8a65c9ecLu,
+                0x14015c4fLu, 0x63066cd9Lu, 0xfa0f3d63Lu, 0x8d080df5Lu,
+                0x3b6e20c8Lu, 0x4c69105eLu, 0xd56041e4Lu, 0xa2677172Lu,
+                0x3c03e4d1Lu, 0x4b04d447Lu, 0xd20d85fdLu, 0xa50ab56bLu,
+                0x35b5a8faLu, 0x42b2986cLu, 0xdbbbc9d6Lu, 0xacbcf940Lu,
+                0x32d86ce3Lu, 0x45df5c75Lu, 0xdcd60dcfLu, 0xabd13d59Lu,
+                0x26d930acLu, 0x51de003aLu, 0xc8d75180Lu, 0xbfd06116Lu,
+                0x21b4f4b5Lu, 0x56b3c423Lu, 0xcfba9599Lu, 0xb8bda50fLu,
+                0x2802b89eLu, 0x5f058808Lu, 0xc60cd9b2Lu, 0xb10be924Lu,
+                0x2f6f7c87Lu, 0x58684c11Lu, 0xc1611dabLu, 0xb6662d3dLu,
+                0x76dc4190Lu, 0x01db7106Lu, 0x98d220bcLu, 0xefd5102aLu,
+                0x71b18589Lu, 0x06b6b51fLu, 0x9fbfe4a5Lu, 0xe8b8d433Lu,
+                0x7807c9a2Lu, 0x0f00f934Lu, 0x9609a88eLu, 0xe10e9818Lu,
+                0x7f6a0dbbLu, 0x086d3d2dLu, 0x91646c97Lu, 0xe6635c01Lu,
+                0x6b6b51f4Lu, 0x1c6c6162Lu, 0x856530d8Lu, 0xf262004eLu,
+                0x6c0695edLu, 0x1b01a57bLu, 0x8208f4c1Lu, 0xf50fc457Lu,
+                0x65b0d9c6Lu, 0x12b7e950Lu, 0x8bbeb8eaLu, 0xfcb9887cLu,
+                0x62dd1ddfLu, 0x15da2d49Lu, 0x8cd37cf3Lu, 0xfbd44c65Lu,
+                0x4db26158Lu, 0x3ab551ceLu, 0xa3bc0074Lu, 0xd4bb30e2Lu,
+                0x4adfa541Lu, 0x3dd895d7Lu, 0xa4d1c46dLu, 0xd3d6f4fbLu,
+                0x4369e96aLu, 0x346ed9fcLu, 0xad678846Lu, 0xda60b8d0Lu,
+                0x44042d73Lu, 0x33031de5Lu, 0xaa0a4c5fLu, 0xdd0d7cc9Lu,
+                0x5005713cLu, 0x270241aaLu, 0xbe0b1010Lu, 0xc90c2086Lu,
+                0x5768b525Lu, 0x206f85b3Lu, 0xb966d409Lu, 0xce61e49fLu,
+                0x5edef90eLu, 0x29d9c998Lu, 0xb0d09822Lu, 0xc7d7a8b4Lu,
+                0x59b33d17Lu, 0x2eb40d81Lu, 0xb7bd5c3bLu, 0xc0ba6cadLu,
+                0xedb88320Lu, 0x9abfb3b6Lu, 0x03b6e20cLu, 0x74b1d29aLu,
+                0xead54739Lu, 0x9dd277afLu, 0x04db2615Lu, 0x73dc1683Lu,
+                0xe3630b12Lu, 0x94643b84Lu, 0x0d6d6a3eLu, 0x7a6a5aa8Lu,
+                0xe40ecf0bLu, 0x9309ff9dLu, 0x0a00ae27Lu, 0x7d079eb1Lu,
+                0xf00f9344Lu, 0x8708a3d2Lu, 0x1e01f268Lu, 0x6906c2feLu,
+                0xf762575dLu, 0x806567cbLu, 0x196c3671Lu, 0x6e6b06e7Lu,
+                0xfed41b76Lu, 0x89d32be0Lu, 0x10da7a5aLu, 0x67dd4accLu,
+                0xf9b9df6fLu, 0x8ebeeff9Lu, 0x17b7be43Lu, 0x60b08ed5Lu,
+                0xd6d6a3e8Lu, 0xa1d1937eLu, 0x38d8c2c4Lu, 0x4fdff252Lu,
+                0xd1bb67f1Lu, 0xa6bc5767Lu, 0x3fb506ddLu, 0x48b2364bLu,
+                0xd80d2bdaLu, 0xaf0a1b4cLu, 0x36034af6Lu, 0x41047a60Lu,
+                0xdf60efc3Lu, 0xa867df55Lu, 0x316e8eefLu, 0x4669be79Lu,
+                0xcb61b38cLu, 0xbc66831aLu, 0x256fd2a0Lu, 0x5268e236Lu,
+                0xcc0c7795Lu, 0xbb0b4703Lu, 0x220216b9Lu, 0x5505262fLu,
+                0xc5ba3bbeLu, 0xb2bd0b28Lu, 0x2bb45a92Lu, 0x5cb36a04Lu,
+                0xc2d7ffa7Lu, 0xb5d0cf31Lu, 0x2cd99e8bLu, 0x5bdeae1dLu,
+                0x9b64c2b0Lu, 0xec63f226Lu, 0x756aa39cLu, 0x026d930aLu,
+                0x9c0906a9Lu, 0xeb0e363fLu, 0x72076785Lu, 0x05005713Lu,
+                0x95bf4a82Lu, 0xe2b87a14Lu, 0x7bb12baeLu, 0x0cb61b38Lu,
+                0x92d28e9bLu, 0xe5d5be0dLu, 0x7cdcefb7Lu, 0x0bdbdf21Lu,
+                0x86d3d2d4Lu, 0xf1d4e242Lu, 0x68ddb3f8Lu, 0x1fda836eLu,
+                0x81be16cdLu, 0xf6b9265bLu, 0x6fb077e1Lu, 0x18b74777Lu,
+                0x88085ae6Lu, 0xff0f6a70Lu, 0x66063bcaLu, 0x11010b5cLu,
+                0x8f659effLu, 0xf862ae69Lu, 0x616bffd3Lu, 0x166ccf45Lu,
+                0xa00ae278Lu, 0xd70dd2eeLu, 0x4e048354Lu, 0x3903b3c2Lu,
+                0xa7672661Lu, 0xd06016f7Lu, 0x4969474dLu, 0x3e6e77dbLu,
+                0xaed16a4aLu, 0xd9d65adcLu, 0x40df0b66Lu, 0x37d83bf0Lu,
+                0xa9bcae53Lu, 0xdebb9ec5Lu, 0x47b2cf7fLu, 0x30b5ffe9Lu,
+                0xbdbdf21cLu, 0xcabac28aLu, 0x53b39330Lu, 0x24b4a3a6Lu,
+                0xbad03605Lu, 0xcdd70693Lu, 0x54de5729Lu, 0x23d967bfLu,
+                0xb3667a2eLu, 0xc4614ab8Lu, 0x5d681b02Lu, 0x2a6f2b94Lu,
+                0xb40bbe37Lu, 0xc30c8ea1Lu, 0x5a05df1bLu, 0x2d02ef8dLu
+        };
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// This function uses the ulCRCTable lookup table to generate a CRC for xData
+
+static unsigned long PartialCRC(unsigned long ulCRC, unsigned char *sBuf, unsigned long lBufSz)
+{
+    while (lBufSz--)
+        ulCRC = (ulCRC >> 8) ^ ulCRCTable[(ulCRC & 0xFF) ^ *sBuf++];
+
+    return ulCRC;
+}
+
+/* filecrc(const name[]) */
+static cell AMX_NATIVE_CALL n_filecrc(AMX *amx, const cell *params)
+{
+    TCHAR *name, fullname[_MAX_PATH] = "";
+    FILE *fp;
+    unsigned char buffer[256];
+    unsigned long ulCRC = 0xffffffff;
+    size_t numread;
+
+    (void) amx;
+    amx_StrParam(amx, params[1], name);
+    if (name != NULL && completename(fullname, name, sizearray(fullname)) != NULL
+        && (fp = _tfopen(fullname, "rb")) != NULL)
+    {
+        do
+        {
+            numread = fread(buffer, sizeof(unsigned char), sizeof buffer, fp);
+            ulCRC = PartialCRC(ulCRC, buffer, (unsigned long) numread);
+        } while (numread == sizeof buffer);
+        fclose(fp);
+    } /* if */
+    return (ulCRC ^ 0xffffffff);
+}
+
+
+const TCHAR default_ini_name[] = "config.ini";
+
+/* readcfg(const filename[]="", const section[]="", const key[], value[], size=sizeof value, const defvalue[]="", bool:packed=false) */
+static cell AMX_NATIVE_CALL n_readcfg(AMX *amx, const cell *params)
+{
+    TCHAR *name, fullname[_MAX_PATH] = "";
+    TCHAR *section, *key, *defvalue;
+    TCHAR *buffer;
+    int size, result = 0;
+    cell *cptr;
+
+    size = (int) params[5];
+    if (size <= 0)
+        return 0;
+    if (params[7])
+        size *= sizeof(cell);
+
+    amx_StrParam(amx, params[1], name);
+    if (name != NULL && *name == '\0')
+        name = (TCHAR *) default_ini_name;
+    if (name != NULL && completename(fullname, name, sizearray(fullname)) != NULL)
+    {
+        amx_StrParam(amx, params[2], section);
+        amx_StrParam(amx, params[3], key);
+        amx_StrParam(amx, params[6], defvalue);
+
+        cptr = amx_Address(amx, params[4]);
+        buffer = (char *) alloca(size);
+        if (buffer == NULL || cptr == NULL)
+        {
+            amx_RaiseError(amx, AMX_ERR_NATIVE);
+            return 0;
+        } /* if */
+        result = ini_gets(section, key, defvalue, buffer, size, fullname);
+        amx_SetString(cptr, buffer, params[7], 0, size);
+    } /* if */
+    return result;
+}
+
+/* readcfgvalue(const filename[]="", const section[]="", const key[], defvalue=0) */
+static cell AMX_NATIVE_CALL n_readcfgvalue(AMX *amx, const cell *params)
+{
+    TCHAR *name, fullname[_MAX_PATH] = "";
+    TCHAR *section, *key;
+    long result = 0;
+
+    (void) amx;
+    amx_StrParam(amx, params[1], name);
+    if (name != NULL && *name == '\0')
+        name = (TCHAR *) default_ini_name;
+    if (name != NULL && completename(fullname, name, sizearray(fullname)) != NULL)
+    {
+        amx_StrParam(amx, params[2], section);
+        amx_StrParam(amx, params[3], key);
+        result = ini_getl(section, key, (long) params[4], fullname);
+    } /* if */
+    return result;
+}
+
+/* writecfg(const filename[]="", const section[]="", const key[], const value[]) */
+static cell AMX_NATIVE_CALL n_writecfg(AMX *amx, const cell *params)
+{
+    TCHAR *name, fullname[_MAX_PATH] = "";
+    TCHAR *section, *key, *value;
+    int result = 0;
+
+    (void) amx;
+    amx_StrParam(amx, params[1], name);
+    if (name != NULL && *name == '\0')
+        name = (TCHAR *) default_ini_name;
+    if (name != NULL && completename(fullname, name, sizearray(fullname)) != NULL)
+    {
+        amx_StrParam(amx, params[2], section);
+        amx_StrParam(amx, params[3], key);
+        amx_StrParam(amx, params[4], value);
+        result = ini_puts(section, key, value, fullname);
+    } /* if */
+    return result;
+}
+
+/* writecfgvalue(const filename[]="", const section[]="", const key[], value) */
+static cell AMX_NATIVE_CALL n_writecfgvalue(AMX *amx, const cell *params)
+{
+    TCHAR *name, fullname[_MAX_PATH] = "";
+    TCHAR *section, *key;
+    int result = 0;
+
+    (void) amx;
+    amx_StrParam(amx, params[1], name);
+    if (name != NULL && *name == '\0')
+        name = (TCHAR *) default_ini_name;
+    if (name != NULL && completename(fullname, name, sizearray(fullname)) != NULL)
+    {
+        amx_StrParam(amx, params[2], section);
+        amx_StrParam(amx, params[3], key);
+        result = ini_putl(section, key, (long) params[4], fullname);
+    } /* if */
+    return result;
+}
+
+/* deletecfg(const filename[]="", const section[]="", const key[]="") */
+static cell AMX_NATIVE_CALL n_deletecfg(AMX *amx, const cell *params)
+{
+    TCHAR *name, fullname[_MAX_PATH] = "";
+    TCHAR *section, *key;
+    int result = 0;
+
+    (void) amx;
+    amx_StrParam(amx, params[1], name);
+    if (name != NULL && *name == '\0')
+        name = (TCHAR *) default_ini_name;
+    if (name != NULL && completename(fullname, name, sizearray(fullname)) != NULL)
+    {
+        amx_StrParam(amx, params[2], section);
+        if (*section == '\0')
+            section = NULL;
+        amx_StrParam(amx, params[3], key);
+        if (*key == '\0')
+            key = NULL;
+        result = ini_puts(section, key, NULL, fullname);
+    } /* if */
+    return result;
+}
+
+#if defined __cplusplus
+extern "C"
+#endif
+AMX_NATIVE_INFO file_Natives[] = {
+        {"fopen",         n_fopen},
+        {"fclose",        n_fclose},
+        {"fwrite",        n_fwrite},
+        {"fread",         n_fread},
+        {"fputchar",      n_fputchar},
+        {"fgetchar",      n_fgetchar},
+        {"fblockwrite",   n_fblockwrite},
+        {"fblockread",    n_fblockread},
+        {"ftemp",         n_ftemp},
+        {"fseek",         n_fseek},
+        {"flength",       n_flength},
+        {"fremove",       n_fremove},
+        {"fcopy",         n_fcopy},
+        {"frename",       n_frename},
+        {"fexist",        n_fexist},
+        {"fmatch",        n_fmatch},
+        {"fstat",         n_fstat},
+        {"fattrib",       n_fattrib},
+        {"filecrc",       n_filecrc},
+        {"fcreatedir",    n_fcreatedir},
+        {"readcfg",       n_readcfg},
+        {"readcfgvalue",  n_readcfgvalue},
+        {"writecfg",      n_writecfg},
+        {"writecfgvalue", n_writecfgvalue},
+        {"deletecfg",     n_deletecfg},
+        {NULL, NULL}        /* terminator */
+};
+
+int AMXEXPORT AMXAPI amx_FileInit(AMX *amx)
+{
+    return amx_Register(amx, file_Natives, -1);
+}
+
+int AMXEXPORT AMXAPI amx_FileCleanup(AMX *amx)
+{
+    (void) amx;
+    return AMX_ERR_NONE;
+}
diff --git a/apps/openmw-mp/amx/amxfloat.c b/apps/openmw-mp/amx/amxfloat.c
new file mode 100644
index 000000000..48aa21b19
--- /dev/null
+++ b/apps/openmw-mp/amx/amxfloat.c
@@ -0,0 +1,379 @@
+/*  Float arithmetic for the Pawn Abstract Machine
+ *
+ *  Copyright (c) Artran, Inc. 1999
+ *  Written by Greg Garner (gmg@artran.com)
+ *  This file may be freely used. No warranties of any kind.
+ *
+ * CHANGES -
+ * 2002-08-27: Basic conversion of source from C++ to C by Adam D. Moss
+ *             <adam@gimp.org> <aspirin@icculus.org>
+ * 2003-08-29: Removal of the dynamic memory allocation and replacing two
+ *             type conversion functions by macros, by Thiadmer Riemersma
+ * 2003-09-22: Moved the type conversion macros to AMX.H, and simplifications
+ *             of some routines, by Thiadmer Riemersma
+ * 2003-11-24: A few more native functions (geometry), plus minor modifications,
+ *             mostly to be compatible with dynamically loadable extension
+ *             modules, by Thiadmer Riemersma
+ * 2004-01-09: Adaptions for 64-bit cells (using "double precision"), by
+ *             Thiadmer Riemersma
+ */
+#include <stdlib.h>     /* for atof() */
+#include <stdio.h>      /* for NULL */
+#include <assert.h>
+#include <math.h>
+#include "amx.h"
+
+/*
+  #if defined __BORLANDC__
+    #pragma resource "amxFloat.res"
+  #endif
+*/
+
+#if PAWN_CELL_SIZE==32
+  #define REAL          float
+#elif PAWN_CELL_SIZE==64
+  #define REAL          double
+#else
+  #error Unsupported cell size
+#endif
+
+#define PI  3.1415926535897932384626433832795
+
+/******************************************************************/
+static cell AMX_NATIVE_CALL n_float(AMX *amx,const cell *params)
+{
+    /*
+    *   params[0] = number of bytes
+    *   params[1] = integer value to convert to a float
+    */
+    REAL fValue;
+
+    (void)amx;
+    /* Convert to a float. Calls the compilers long to float conversion. */
+    fValue = (REAL) params[1];
+
+    /* Return the cell. */
+    return amx_ftoc(fValue);
+}
+
+/******************************************************************/
+static cell AMX_NATIVE_CALL n_strfloat(AMX *amx,const cell *params)
+{
+    /*
+    *   params[0] = number of bytes
+    *   params[1] = virtual string address to convert to a float
+    */
+    char szSource[60];
+    cell *pString;
+    REAL fNum;
+    int nLen;
+
+    (void)amx;
+    /* They should have sent us 1 cell. */
+    assert(params[0]/sizeof(cell)==1);
+
+    /* Get the real address of the string. */
+    pString=amx_Address(amx,params[1]);
+
+    /* Find out how long the string is in characters. */
+    amx_StrLen(pString, &nLen);
+    if (nLen == 0 || nLen >= sizeof szSource)
+        return 0;
+
+    /* Now convert the Pawn string into a C type null terminated string */
+    amx_GetString(szSource, pString, 0, sizeof szSource);
+
+    /* Now convert this to a float. */
+    fNum = (REAL)atof(szSource);
+
+    return amx_ftoc(fNum);
+}
+
+/******************************************************************/
+static cell AMX_NATIVE_CALL n_floatmul(AMX *amx,const cell *params)
+{
+    /*
+    *   params[0] = number of bytes
+    *   params[1] = float operand 1
+    *   params[2] = float operand 2
+    */
+    REAL fRes = amx_ctof(params[1]) * amx_ctof(params[2]);
+    (void)amx;
+    return amx_ftoc(fRes);
+}
+
+/******************************************************************/
+static cell AMX_NATIVE_CALL n_floatdiv(AMX *amx,const cell *params)
+{
+    /*
+    *   params[0] = number of bytes
+    *   params[1] = float dividend (top)
+    *   params[2] = float divisor (bottom)
+    */
+    REAL fRes = amx_ctof(params[1]) / amx_ctof(params[2]);
+    (void)amx;
+    return amx_ftoc(fRes);
+}
+
+/******************************************************************/
+static cell AMX_NATIVE_CALL n_floatadd(AMX *amx,const cell *params)
+{
+    /*
+    *   params[0] = number of bytes
+    *   params[1] = float operand 1
+    *   params[2] = float operand 2
+    */
+    REAL fRes = amx_ctof(params[1]) + amx_ctof(params[2]);
+    (void)amx;
+    return amx_ftoc(fRes);
+}
+
+/******************************************************************/
+static cell AMX_NATIVE_CALL n_floatsub(AMX *amx,const cell *params)
+{
+    /*
+    *   params[0] = number of bytes
+    *   params[1] = float operand 1
+    *   params[2] = float operand 2
+    */
+    REAL fRes = amx_ctof(params[1]) - amx_ctof(params[2]);
+    (void)amx;
+    return amx_ftoc(fRes);
+}
+
+/******************************************************************/
+/* Return fractional part of float */
+static cell AMX_NATIVE_CALL n_floatfract(AMX *amx,const cell *params)
+{
+    /*
+    *   params[0] = number of bytes
+    *   params[1] = float operand
+    */
+    REAL fA = amx_ctof(params[1]);
+    fA = fA - (REAL)(floor((double)fA));
+    (void)amx;
+    return amx_ftoc(fA);
+}
+
+/******************************************************************/
+/* Return integer part of float, rounded */
+static cell AMX_NATIVE_CALL n_floatround(AMX *amx,const cell *params)
+{
+    /*
+    *   params[0] = number of bytes
+    *   params[1] = float operand
+    *   params[2] = Type of rounding (integer)
+    */
+    REAL fA = amx_ctof(params[1]);
+
+    (void)amx;
+    switch (params[2])
+    {
+        case 1:       /* round downwards */
+            fA = (REAL)(floor((double)fA));
+            break;
+        case 2:       /* round upwards */
+            fA = (REAL)(ceil((double)fA));
+            break;
+        case 3:       /* round towards zero (truncate) */
+            if ( fA>=0.0 )
+                fA = (REAL)(floor((double)fA));
+            else
+                fA = (REAL)(ceil((double)fA));
+            break;
+        default:      /* standard, round to nearest */
+            fA = (REAL)(floor((double)fA+.5));
+            break;
+    }
+
+    return (cell)fA;
+}
+
+/******************************************************************/
+static cell AMX_NATIVE_CALL n_floatcmp(AMX *amx,const cell *params)
+{
+    /*
+    *   params[0] = number of bytes
+    *   params[1] = float operand 1
+    *   params[2] = float operand 2
+    */
+    REAL fA, fB;
+
+    (void)amx;
+    fA = amx_ctof(params[1]);
+    fB = amx_ctof(params[2]);
+    if (fA == fB)
+        return 0;
+    else if (fA>fB)
+        return 1;
+    else
+        return -1;
+
+}
+
+/******************************************************************/
+static cell AMX_NATIVE_CALL n_floatsqroot(AMX *amx,const cell *params)
+{
+    /*
+    *   params[0] = number of bytes
+    *   params[1] = float operand
+    */
+    REAL fA = amx_ctof(params[1]);
+    fA = (REAL)sqrt(fA);
+    if (fA < 0)
+        return amx_RaiseError(amx, AMX_ERR_DOMAIN);
+    return amx_ftoc(fA);
+}
+
+/******************************************************************/
+static cell AMX_NATIVE_CALL n_floatpower(AMX *amx,const cell *params)
+{
+    /*
+    *   params[0] = number of bytes
+    *   params[1] = float operand 1 (base)
+    *   params[2] = float operand 2 (exponent)
+    */
+    REAL fA = amx_ctof(params[1]);
+    REAL fB = amx_ctof(params[2]);
+    fA = (REAL)pow(fA, fB);
+    (void)amx;
+    return amx_ftoc(fA);
+}
+
+/******************************************************************/
+static cell AMX_NATIVE_CALL n_floatlog(AMX *amx,const cell *params)
+{
+    /*
+    *   params[0] = number of bytes
+    *   params[1] = float operand 1 (value)
+    *   params[2] = float operand 2 (base)
+    */
+    REAL fValue = amx_ctof(params[1]);
+    REAL fBase = amx_ctof(params[2]);
+    (void)amx;
+    if (fValue <= 0.0 || fBase <= 0)
+        return amx_RaiseError(amx, AMX_ERR_DOMAIN);
+    if (fBase == 10.0) // ??? epsilon
+        fValue = (REAL)log10(fValue);
+    else
+        fValue = (REAL)(log(fValue) / log(fBase));
+    return amx_ftoc(fValue);
+}
+
+static REAL ToRadians(REAL angle, int radix)
+{
+    switch (radix)
+    {
+        case 1:         /* degrees, sexagesimal system (technically: degrees/minutes/seconds) */
+            return (REAL)(angle * PI / 180.0);
+        case 2:         /* grades, centesimal system */
+            return (REAL)(angle * PI / 200.0);
+        default:        /* assume already radian */
+            return angle;
+    } /* switch */
+}
+
+/******************************************************************/
+static cell AMX_NATIVE_CALL n_floatsin(AMX *amx,const cell *params)
+{
+    /*
+    *   params[0] = number of bytes
+    *   params[1] = float operand 1 (angle)
+    *   params[2] = float operand 2 (radix)
+    */
+    REAL fA = amx_ctof(params[1]);
+    fA = ToRadians(fA, params[2]);
+    fA = (float)sin(fA);
+    (void)amx;
+    return amx_ftoc(fA);
+}
+
+/******************************************************************/
+static cell AMX_NATIVE_CALL n_floatcos(AMX *amx,const cell *params)
+{
+    /*
+    *   params[0] = number of bytes
+    *   params[1] = float operand 1 (angle)
+    *   params[2] = float operand 2 (radix)
+    */
+    REAL fA = amx_ctof(params[1]);
+    fA = ToRadians(fA, params[2]);
+    fA = (float)cos(fA);
+    (void)amx;
+    return amx_ftoc(fA);
+}
+
+/******************************************************************/
+static cell AMX_NATIVE_CALL n_floattan(AMX *amx,const cell *params)
+{
+    /*
+    *   params[0] = number of bytes
+    *   params[1] = float operand 1 (angle)
+    *   params[2] = float operand 2 (radix)
+    */
+    REAL fA = amx_ctof(params[1]);
+    fA = ToRadians(fA, params[2]);
+    fA = (float)tan(fA);
+    (void)amx;
+    return amx_ftoc(fA);
+}
+
+/******************************************************************/
+static cell AMX_NATIVE_CALL n_floatabs(AMX *amx,const cell *params)
+{
+    REAL fA = amx_ctof(params[1]);
+    fA = (fA >= 0) ? fA : -fA;
+    (void)amx;
+    return amx_ftoc(fA);
+}
+
+/******************************************************************/
+/* return the integer part of a real value, truncated
+/* Return integer part of float, truncated (same as floatround
+ * with mode 3)
+ */
+static cell AMX_NATIVE_CALL n_floatint(AMX *amx,const cell *params)
+{
+    REAL fA = amx_ctof(params[1]);
+    if ( fA>=0.0 )
+        fA = (REAL)(floor((double)fA));
+    else
+        fA = (REAL)(ceil((double)fA));
+    (void)amx;
+    return (cell)fA;
+}
+
+#if defined __cplusplus
+  extern "C"
+#endif
+const AMX_NATIVE_INFO float_Natives[] = {
+  { "float",       n_float      },
+  { "strfloat",    n_strfloat   },
+  { "floatmul",    n_floatmul   },
+  { "floatdiv",    n_floatdiv   },
+  { "floatadd",    n_floatadd   },
+  { "floatsub",    n_floatsub   },
+  { "floatfract",  n_floatfract },
+  { "floatround",  n_floatround },
+  { "floatcmp",    n_floatcmp   },
+  { "floatsqroot", n_floatsqroot},
+  { "floatpower",  n_floatpower },
+  { "floatlog",    n_floatlog   },
+  { "floatsin",    n_floatsin   },
+  { "floatcos",    n_floatcos   },
+  { "floattan",    n_floattan   },
+  { "floatabs",    n_floatabs   },
+  { "floatint",    n_floatint   },  // also add user-defined operator "="
+  { NULL, NULL }        /* terminator */
+};
+
+int AMXEXPORT AMXAPI amx_FloatInit(AMX *amx)
+{
+  return amx_Register(amx,float_Natives,-1);
+}
+
+int AMXEXPORT AMXAPI amx_FloatCleanup(AMX *amx)
+{
+  (void)amx;
+  return AMX_ERR_NONE;
+}
diff --git a/apps/openmw-mp/amx/amxstring.c b/apps/openmw-mp/amx/amxstring.c
new file mode 100644
index 000000000..300ec3b80
--- /dev/null
+++ b/apps/openmw-mp/amx/amxstring.c
@@ -0,0 +1,1012 @@
+/*  String functions for the Pawn Abstract Machine
+ *
+ *  Copyright (c) ITB CompuPhase, 2005-2015
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ *  use this file except in compliance with the License. You may obtain a copy
+ *  of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ *  License for the specific language governing permissions and limitations
+ *  under the License.
+ *
+ *  Version: $Id: amxstring.c 5181 2015-01-21 09:44:28Z thiadmer $
+ */
+#include <limits.h>
+#include <string.h>
+#include <assert.h>
+#if defined __WIN32__ || defined _WIN32 || defined WIN32 || defined __MSDOS__
+  #include <malloc.h>
+#endif
+#include "osdefs.h"
+#include "amx.h"
+#if defined __WIN32__ || defined _WIN32 || defined WIN32 || defined _Windows
+  #include <windows.h>
+#endif
+
+#define MAX_FORMATSTR   256
+
+#define CHARBITS        (8*sizeof(char))
+
+#if defined _UNICODE
+# include <tchar.h>
+#elif !defined __T
+  typedef char          TCHAR;
+# define __T(string)    string
+# define _tcscat        strcat
+# define _tcschr        strchr
+# define _tcscpy        strcpy
+# define _tcslen        strlen
+#endif
+#include "amxcons.h"
+
+#if !defined isdigit
+# define isdigit(c)     ((unsigned)((c)-'0')<10u)
+#endif
+#if !defined sizearray
+# define sizearray(a)   (sizeof(a) / sizeof((a)[0]))
+#endif
+
+
+/* dest     the destination buffer; the buffer must point to the start of a cell
+ * source   the source buffer, this must be aligned to a cell edge
+ * len      the number of characters (bytes) to copy
+ * offs     the offset in dest, in characters (bytes)
+ */
+static int amx_StrPack(cell *dest,cell *source,int len,int offs)
+{
+  int i;
+
+  if ((ucell)*source>UNPACKEDMAX && offs%sizeof(cell)==0) {
+    /* source string is already packed and the destination is cell-aligned */
+    unsigned char* pdest=(unsigned char*)dest+offs;
+    i=(len+sizeof(cell)-1)/sizeof(cell);
+    memmove(pdest,source,i*sizeof(cell));
+    /* zero-terminate */
+    #if BYTE_ORDER==BIG_ENDIAN
+      pdest+=len;
+      for (i=len; i==len || i%sizeof(cell)!=0; i++)
+        *pdest++='\0';
+    #else
+      i=(len/sizeof(cell))*sizeof(cell);
+      pdest+=i;
+      len=(len==i) ? sizeof(cell) : sizeof(cell)-(len-i);
+      assert(len>0 && len<=sizeof(cell));
+      for (i=0; i<len; i++)
+        *pdest++='\0';
+    #endif
+  } else if ((ucell)*source>UNPACKEDMAX) {
+    /* source string is packed, destination is not aligned */
+    cell mask,c;
+    dest+=offs/sizeof(cell);    /* increment whole number of cells */
+    offs%=sizeof(cell);         /* get remainder */
+    mask=(~(ucell)0) >> (offs*CHARBITS);
+    c=*dest & ~mask;
+    for (i=0; i<len+offs+1; i+=sizeof(cell)) {
+      *dest=c | ((*source >> (offs*CHARBITS)) & mask);
+      c=(*source << ((sizeof(cell)-offs)*CHARBITS)) & ~mask;
+      dest++;
+      source++;
+    } /* for */
+    /* set the zero byte in the last cell */
+    mask=(~(ucell)0) >> (((offs+len)%sizeof(cell))*CHARBITS);
+    *(dest-1) &= ~mask;
+  } else {
+    /* source string is unpacked: pack string, from top-down */
+    cell c=0;
+    if (offs!=0) {
+      /* get the last cell in "dest" and mask of the characters that must be changed */
+      cell mask;
+      dest+=offs/sizeof(cell);  /* increment whole number of cells */
+      offs%=sizeof(cell);       /* get remainder */
+      mask=(~(ucell)0) >> (offs*CHARBITS);
+      c=(*dest & ~mask) >> ((sizeof(cell)-offs)*CHARBITS);
+    } /* if */
+    /* for proper alignement, add the offset to both the starting and the ending
+     * criterion (so that the number of iterations stays the same)
+     */
+    assert(offs>=0 && offs<sizeof(cell));
+    for (i=offs; i<len+offs; i++) {
+      c=(c<<CHARBITS) | (*source++ & 0xff);
+      if (i%sizeof(cell)==sizeof(cell)-1) {
+        *dest++=c;
+        c=0;
+      } /* if */
+    } /* for */
+    if (i%sizeof(cell) != 0)    /* store remaining packed characters */
+      *dest=c << (sizeof(cell)-i%sizeof(cell))*CHARBITS;
+    else
+      *dest=0;                  /* store full cell of zeros */
+  } /* if */
+  return AMX_ERR_NONE;
+}
+
+static int amx_StrUnpack(cell *dest,cell *source,int len)
+{
+  /* len excludes the terminating '\0' byte */
+  if ((ucell)*source>UNPACKEDMAX) {
+    /* unpack string, from bottom up (so string can be unpacked in place) */
+    cell c;
+    int i;
+    for (i=len-1; i>=0; i--) {
+      c=source[i/sizeof(cell)] >> (sizeof(cell)-i%sizeof(cell)-1)*CHARBITS;
+      dest[i]=c & UCHAR_MAX;
+    } /* for */
+    dest[len]=0;        /* zero-terminate */
+  } else {
+    /* source string is already unpacked */
+    while (len-->0)
+      *dest++=*source++;
+    *dest=0;
+  } /* if */
+  return AMX_ERR_NONE;
+}
+
+static unsigned char *packedptr(cell *string,int index)
+{
+  unsigned char *ptr=(unsigned char *)(string+index/sizeof(cell));
+  #if BYTE_ORDER==BIG_ENDIAN
+    ptr+=index & (sizeof(cell)-1);
+  #else
+    ptr+=(sizeof(cell)-1) - (index & (sizeof(cell)-1));
+  #endif
+  return ptr;
+}
+
+static cell extractchar(cell *string,int index,int mklower)
+{
+  cell c;
+
+  if ((ucell)*string>UNPACKEDMAX)
+    c=*packedptr(string,index);
+  else
+    c=string[index];
+  if (mklower) {
+    #if defined __WIN32__ || defined _WIN32 || defined WIN32
+      c=(cell)CharLower((LPTSTR)c);
+    #elif defined _Windows
+      c=(cell)AnsiLower((LPSTR)c);
+    #else
+      if ((unsigned int)(c-'A')<26u)
+        c+='a'-'A';
+    #endif
+  } /* if */
+  return c;
+}
+
+/* strlen(const string[])
+ */
+static cell AMX_NATIVE_CALL n_strlen(AMX *amx,const cell *params)
+{
+  cell *cptr;
+  int len = 0;
+
+  (void)(amx);
+  cptr=amx_Address(amx,params[1]);
+  amx_StrLen(cptr,&len);
+  return len;
+}
+
+/* strpack(dest[], const source[], maxlength=sizeof dest)
+ */
+static cell AMX_NATIVE_CALL n_strpack(AMX *amx,const cell *params)
+{
+  cell *cdest,*csrc;
+  int len,err;
+
+  csrc=amx_Address(amx,params[2]);
+  amx_StrLen(csrc,&len);
+  if ((unsigned)len>params[3]*sizeof(cell)-1)
+    len=params[3]*sizeof(cell)-1;
+
+  cdest=amx_Address(amx,params[1]);
+  err=amx_StrPack(cdest,csrc,len,0);
+  if (err!=AMX_ERR_NONE)
+    return amx_RaiseError(amx,err);
+
+  return len;
+}
+
+/* strunpack(dest[], const source[], maxlength=sizeof dest)
+ */
+static cell AMX_NATIVE_CALL n_strunpack(AMX *amx,const cell *params)
+{
+  cell *cdest,*csrc;
+  int len,err;
+
+  csrc=amx_Address(amx,params[2]);
+  amx_StrLen(csrc,&len);
+  assert(len>=0);
+  if (len>=params[3])
+    len=params[3]-1;
+
+  cdest=amx_Address(amx,params[1]);
+  err=amx_StrUnpack(cdest,csrc,len);
+  if (err!=AMX_ERR_NONE)
+    return amx_RaiseError(amx,err);
+
+  return len;
+}
+
+/* strcat(dest[], const source[], maxlength=sizeof dest)
+ * packed/unpacked attribute is taken from dest[], or from source[] if dest[]
+ * is an empty string.
+ */
+static cell AMX_NATIVE_CALL n_strcat(AMX *amx,const cell *params)
+{
+  cell *cdest,*csrc;
+  int len,len2;
+  int packed,err;
+
+  /* calculate number of cells needed for (packed) destination */
+  csrc=amx_Address(amx,params[2]);
+  cdest=amx_Address(amx,params[1]);
+  amx_StrLen(csrc,&len);
+  amx_StrLen(cdest,&len2);
+  packed=(*cdest==0) ? ((ucell)*csrc>UNPACKEDMAX) : ((ucell)*cdest>UNPACKEDMAX);
+  if (packed) {
+    if ((unsigned)(len+len2)>params[3]*sizeof(cell)-1)
+      len=params[3]*sizeof(cell)-len2-1;
+  } else {
+    if (len+len2>params[3]-1)
+      len=params[3]-len2-1;
+  } /* if */
+
+  if (packed) {
+    err=amx_StrPack(cdest,csrc,len,len2);
+  } else {
+    /* destination string must either be unpacked, or empty */
+    assert((ucell)*cdest<=UNPACKEDMAX || len2==0);
+    err=amx_StrUnpack(cdest+len2,csrc,len);
+  } /* if */
+  if (err!=AMX_ERR_NONE)
+    return amx_RaiseError(amx,err);
+
+  return len;
+}
+
+/* strcopy(dest[], const source[], maxlength=sizeof dest)
+ * packed/unpacked attribute from source[]
+ */
+static cell AMX_NATIVE_CALL n_strcopy(AMX *amx,const cell *params)
+{
+  cell *cdest,*csrc;
+  int len,packed,err;
+
+  /* calculate number of cells needed for (packed) destination */
+  csrc=amx_Address(amx,params[2]);
+  cdest=amx_Address(amx,params[1]);
+  amx_StrLen(csrc,&len);
+  packed=(ucell)*csrc>UNPACKEDMAX;
+  if (packed) {
+    if ((unsigned)len>params[3]*sizeof(cell)-1)
+      len=params[3]*sizeof(cell)-1;
+  } else {
+    if (len>params[3]-1)
+      len=params[3]-1;
+  } /* if */
+
+  if (packed)
+    err=amx_StrPack(cdest,csrc,len,0);
+  else
+    err=amx_StrUnpack(cdest,csrc,len);
+  if (err!=AMX_ERR_NONE)
+    return amx_RaiseError(amx,err);
+
+  return len;
+}
+
+static int compare(cell *cstr1,cell *cstr2,int ignorecase,int length,int offs1)
+{
+  int index;
+  cell c1=0,c2=0;
+
+  for (index=0; index<length; index++) {
+    c1=extractchar(cstr1,index+offs1,ignorecase);
+    c2=extractchar(cstr2,index,ignorecase);
+    assert(c1!=0 && c2!=0); /* string lengths are already checked, so zero-bytes should not occur */
+    if (c1!=c2)
+      break;
+  } /* for */
+
+  if (c1<c2)
+    return -1;
+  if (c1>c2)
+    return 1;
+  return 0;
+}
+
+/* strcmp(const string1[], const string2[], bool:ignorecase=false, length=cellmax)
+ */
+static cell AMX_NATIVE_CALL n_strcmp(AMX *amx,const cell *params)
+{
+  cell *cstr1,*cstr2;
+  int len1,len2,len;
+  cell result;
+
+  (void)(amx);
+  cstr1=amx_Address(amx,params[1]);
+  cstr2=amx_Address(amx,params[2]);
+
+  /* get the maximum length to compare */
+  amx_StrLen(cstr1,&len1);
+  amx_StrLen(cstr2,&len2);
+  len=len1;
+  if (len>len2)
+    len=len2;
+  if (len>params[4])
+    len=params[4];
+  if (len==0)
+    return (params[4]==0) ? 0 : len1-len2;
+
+  result=compare(cstr1,cstr2,params[3],len,0);
+  if (result==0 && len!=params[4])
+    result=len1-len2;
+  return result;
+}
+
+/* strfind(const string[], const sub[], bool:ignorecase=false, offset=0)
+ */
+static cell AMX_NATIVE_CALL n_strfind(AMX *amx,const cell *params)
+{
+  cell *cstr,*csub;
+  int lenstr,lensub,offs;
+  cell c,f;
+
+  (void)(amx);
+  cstr=amx_Address(amx,params[1]);
+  csub=amx_Address(amx,params[2]);
+
+  /* get the maximum length to compare */
+  amx_StrLen(cstr,&lenstr);
+  amx_StrLen(csub,&lensub);
+  if (lensub==0)
+    return -1;
+
+  /* get the start character of the substring, for quicker searching */
+  f=extractchar(csub,0,params[3]);
+  assert(f!=0);         /* string length is already checked */
+
+  for (offs=(int)params[4]; offs+lensub<=lenstr; offs++) {
+    /* find the initial character */
+    c=extractchar(csub,0,params[3]);
+    assert(c!=0);      /* string length is already checked */
+    if (c!=f)
+      continue;
+    if (compare(cstr,csub,params[3],lensub,offs)==0)
+      return offs;
+  } /* for */
+  return -1;
+}
+
+/* strmid(dest[], const source[], start, end, maxlength=sizeof dest)
+ * packed/unpacked attribute is taken from source[]
+ */
+static cell AMX_NATIVE_CALL n_strmid(AMX *amx,const cell *params)
+{
+  cell *cdest,*csrc;
+  int len,err;
+  int soffs,doffs;
+  unsigned char *ptr;
+  unsigned char c;
+  int start=params[3];
+  int end=params[4];
+
+  /* calculate number of cells needed for (packed) destination */
+  csrc=amx_Address(amx,params[2]);
+  cdest=amx_Address(amx,params[1]);
+  amx_StrLen(csrc,&len);
+
+  /* clamp the start/end parameters */
+  if (start<0)
+    start=0;
+  else if (start>len)
+    start=len;
+  if (end<start)
+    end=start;
+  else if (end>len)
+    end=len;
+
+  len=end-start;
+  if ((ucell)*csrc>UNPACKEDMAX) {
+    if ((unsigned)len>params[5]*sizeof(cell)-1)
+      len=params[5]*sizeof(cell)-1;
+  } else {
+    if (len>params[5]-1)
+      len=params[5]-1;
+  } /* if */
+
+  if ((ucell)*csrc>UNPACKEDMAX) {
+    /* first align the source to a cell boundary */
+    for (doffs=0,soffs=start; (soffs & (sizeof(cell)-1))!=0 && len>0; soffs++,doffs++,len--) {
+      ptr=packedptr(csrc,soffs);
+      c=*ptr;
+      ptr=packedptr(cdest,doffs);
+      *ptr=c;
+    } /* for */
+    if (len==0) {
+      /* nothing left to do, zero-terminate */
+      ptr=packedptr(cdest,doffs);
+      *ptr='\0';
+      err=AMX_ERR_NONE;
+    } else {
+      err=amx_StrPack(cdest,csrc+soffs/sizeof(cell),len,doffs);
+    } /* if */
+  } else {
+    err=amx_StrUnpack(cdest,csrc+start,len);
+  } /* if */
+  if (err!=AMX_ERR_NONE)
+    return amx_RaiseError(amx,err);
+
+  return len;
+}
+
+/* strdel(string[], start, end)
+ */
+static cell AMX_NATIVE_CALL n_strdel(AMX *amx,const cell *params)
+{
+  cell *cstr;
+  int index,offs,length;
+  unsigned char *ptr;
+  unsigned char c;
+
+  (void)(amx);
+  /* calculate number of cells needed for (packed) destination */
+  cstr=amx_Address(amx,params[1]);
+  amx_StrLen(cstr,&length);
+  index=(int)params[2];
+  offs=(int)params[3]-index;
+  if (index>=length || offs<=0)
+    return 0;
+  if (index+offs>length)
+    offs=length-index;
+
+  index--;  /* prepare for increment in the top of the loop */
+  if (((ucell)*cstr>UNPACKEDMAX)) {
+    do {
+      index++;
+      ptr=packedptr(cstr,index+offs);
+      c=*ptr;
+      ptr=packedptr(cstr,index);
+      *ptr=c;
+    } while (c!='\0');
+    if (index==0)
+      *cstr=0;
+  } else {
+    do {
+      index++;
+      cstr[index]=cstr[index+offs];
+    } while (cstr[index]!=0);
+  } /* if */
+
+  return 1;
+}
+
+/* strins(string[], const substr[], offset, maxlength=sizeof string)
+ */
+static cell AMX_NATIVE_CALL n_strins(AMX *amx,const cell *params)
+{
+  cell *cstr,*csub;
+  int index,lenstr,lensub,count;
+  unsigned char *ptr;
+  cell c;
+
+  /* calculate number of cells needed for (packed) destination */
+  cstr=amx_Address(amx,params[1]);
+  csub=amx_Address(amx,params[2]);
+  amx_StrLen(cstr,&lenstr);
+  amx_StrLen(csub,&lensub);
+  index=(int)params[3];
+  if (index>lenstr)
+    return amx_RaiseError(amx,AMX_ERR_NATIVE);
+
+  if (*cstr==0) {
+    /* current string is empty (and the insertion point is zero), just make a copy */
+    assert(index==0);
+    if ((ucell)*csub>UNPACKEDMAX)
+      amx_StrPack(cstr,csub,lensub,0);
+    else
+      amx_StrUnpack(cstr,csub,lensub);
+    return 1;
+  } /* if */
+
+  if (((ucell)*cstr>UNPACKEDMAX)) {
+    /* make room for the new characters */
+    for (count=lenstr+lensub; count>index; count--) {
+      ptr=packedptr(cstr,count-lensub);
+      c=*ptr;
+      ptr=packedptr(cstr,count);
+      *ptr=(unsigned char)c;
+    } /* for */
+    /* copy in the new characters */
+    for (count=0; count<lensub; count++) {
+      c=extractchar(csub,count,0);
+      ptr=packedptr(cstr,index+count);
+      *ptr=(unsigned char)c;
+    } /* for */
+  } else {
+    /* make room for the new characters */
+    for (count=lenstr+lensub; count>index; count--)
+      cstr[count]=cstr[count-lensub];
+    /* copy in the new characters */
+    for (count=0; count<lensub; count++) {
+      c=extractchar(csub,count,0);
+      cstr[index+count]=c;
+    } /* for */
+  } /* if */
+
+  return 1;
+}
+
+/* strval(const string[], index=0)
+ */
+static cell AMX_NATIVE_CALL n_strval(AMX *amx,const cell *params)
+{
+  TCHAR str[50],*ptr;
+  cell *cstr,result;
+  int len,negate=0;
+  int offset=0;
+
+  (void)(amx);
+  /* get parameters */
+  cstr=amx_Address(amx,params[1]);
+  amx_StrLen(cstr,&len);
+  if ((unsigned)params[0]>=2*sizeof(cell))
+    offset=params[2];
+  if (offset<0)
+    offset=0;
+  else if (offset>=len)
+    offset=len-1;
+
+  /* skip a number of cells */
+  if ((ucell)*cstr>UNPACKEDMAX) {
+    /* packed string */
+    while (offset>=(int)sizeof(cell)) {
+      cstr++;
+      offset-=sizeof(cell);
+      len-=sizeof(cell);
+    } /* while */
+  } else {
+    /* unpacked string, one character per cell */
+    while (offset>0) {
+      cstr++;
+      offset--;
+      len--;
+    } /* while */
+  } /* if */
+
+  amx_GetString(str,cstr,sizeof(TCHAR)>1,sizeof str);
+  assert(offset<(int)sizeof(cell) && offset>=0);
+  ptr=str+offset;
+  result=0;
+  while (*ptr!='\0' && *ptr<=' ')
+    ptr++;              /* skip whitespace */
+  if (*ptr=='-') {      /* handle sign */
+    negate=1;
+    ptr++;
+  } else if (*ptr=='+') {
+    ptr++;
+  } /* if */
+  while (isdigit(*ptr)) {
+    result=result*10 + (*ptr-'0');
+    ptr++;
+  } /* while */
+  if (negate)
+    result=-result;
+  return result;
+}
+
+/* valstr(dest[], value, bool:pack=false) */
+static cell AMX_NATIVE_CALL n_valstr(AMX *amx,const cell *params)
+{
+  TCHAR str[50];
+  cell value,temp;
+  cell *cstr;
+  int len,result,negate=0;
+
+  (void)(amx);
+  /* find out how many digits are needed */
+  len=1;
+  value=params[2];
+  if (value<0) {
+    negate=1;
+    len++;
+    value=-value;
+  } /* if */
+  for (temp=value; temp>=10; temp/=10)
+    len++;
+  assert(len<=sizearray(str));
+
+  /* put in the string */
+  result=len;
+  str[len--]='\0';
+  while (len>=negate) {
+    str[len--]=(char)((value % 10)+'0');
+    value/=10;
+  } /* while */
+  if (negate)
+    str[0]='-';
+  cstr=amx_Address(amx,params[1]);
+  amx_SetString(cstr,str,params[3],sizeof(TCHAR)>1,sizearray(str));
+  return result;
+}
+
+/* ispacked(const string[]) */
+static cell AMX_NATIVE_CALL n_ispacked(AMX *amx,const cell *params)
+{
+  cell *cstr=amx_Address(amx,params[1]);
+  (void)(amx);
+  return *cstr>=UNPACKEDMAX;
+}
+
+
+/* single character decode and encode */
+#define BITMASK 0x3f
+#define DEC(c)  (((c) - ' ') & BITMASK)
+#define ENC(c)  (char)(((c) & BITMASK) == 0 ? 0x60 : ((c) & BITMASK) + ' ')
+
+static int uudecode(unsigned char *target, char *source)
+{
+  int len, retval;
+
+  len = DEC(*source++);
+  retval = len;
+  while (len > 0) {
+    if (len-- > 0)
+      *target++ = (unsigned char)(( DEC(source[0]) << 2 ) | ( DEC(source[1]) >> 4 ));
+    if (len-- > 0)
+      *target++ = (unsigned char)(( DEC(source[1]) << 4 ) | ( DEC(source[2]) >> 2 ));
+    if (len-- > 0)
+      *target++ = (unsigned char)(( DEC(source[2]) << 6 ) | DEC(source[3]) );
+    source += 4;
+  } /* while */
+  return retval;
+}
+
+static int uuencode(char *target, unsigned char *source, int length)
+{
+  int split[4]={0,0,0,0};
+
+  if (length > BITMASK)
+    return 0;                           /* can encode up to 64 bytes */
+
+  *target++ = ENC(length);
+  while (length > 0) {
+    split[0] = source[0] >> 2;          /* split first byte to char. 0 & 1 */
+    split[1] = source[0] << 4;
+    if (length > 1) {
+      split[1] |= source[1] >> 4;       /* split 2nd byte to char. 1 & 2 */
+      split[2] = source[1] << 2;
+      if (length > 2) {
+        split[2] |= source[2] >> 6;     /* split 3th byte to char. 2 & 3 */
+        split[3] = source[2];
+      } /* if */
+    } /* if */
+
+    *target++ = ENC(split[0]);
+    *target++ = ENC(split[1]);
+    if (length > 1)
+      *target++ = ENC(split[2]);
+    if (length > 2)
+      *target++ = ENC(split[3]);
+    source += 3;
+    length -= 3;
+  } /* while */
+
+  *target = '\0';                       /* end string */
+  return 1;
+}
+
+/* uudecode(dest[], const source[], maxlength=sizeof dest)
+ * Returns the number of bytes (not cells) decoded; if the dest buffer is
+ * too small, not all bytes are stored.
+ * Always creates a (packed) array (not a string; the array is not
+ * zero-terminated).
+ * A buffer may be decoded "in-place"; the destination size is always smaller
+ * than the source size.
+ * Endian issues (for multi-byte values in the data stream) are not handled.
+ */
+static cell AMX_NATIVE_CALL n_uudecode(AMX *amx,const cell *params)
+{
+  cell *cstr;
+  unsigned char dst[BITMASK+2];
+  char src[BITMASK+BITMASK/3+2];
+  int len;
+  size_t size;
+
+  (void)(amx);
+  /* get the source */
+  cstr=amx_Address(amx,params[2]);
+  amx_GetString(src,cstr,0,sizeof src);
+  /* decode */
+  len=uudecode(dst,src);
+  /* store */
+  cstr=amx_Address(amx,params[1]);
+  size=len;
+  if (size>params[3]*sizeof(cell))
+    size=params[3]*sizeof(cell);
+  memcpy(cstr,dst,size);
+  return len;
+}
+
+/* uuencode(dest[], const source[], numbytes, maxlength=sizeof dest)
+ * Returns the number of characters encoded, excluding the zero string
+ * terminator; if the dest buffer is too small, not all bytes are stored.
+ * Always creates a packed string. This string has a newline character at the
+ * end. A buffer may be encoded "in-place" if the destination is large enough.
+ * Endian issues (for multi-byte values in the data stream) are not handled.
+ */
+static cell AMX_NATIVE_CALL n_uuencode(AMX *amx,const cell *params)
+{
+  cell *cstr;
+  unsigned char src[BITMASK+2];
+  char dst[BITMASK+BITMASK/3+2];
+
+  (void)(amx);
+  /* get the source */
+  cstr=amx_Address(amx,params[2]);
+  amx_GetString((char *)src,cstr,0,sizeof src);
+  /* encode (and check for errors) */
+  if (uuencode(dst,src,params[3])) {
+    if (params[4]>0) {
+      cstr=amx_Address(amx,params[1]);
+      *cstr=0;
+    } /* if */
+    return 0;
+  } /* if */
+  /* always add a \n */
+  assert(strlen(dst)+1<sizeof dst);
+  strcat(dst,"\n");
+  /* store */
+  cstr=amx_Address(amx,params[1]);
+  amx_SetString(cstr,dst,1,0,params[4]);
+  return (((params[3]+2)/3) << 2)+2;
+}
+
+/* urldecode(dest[], const source[], maxlength=sizeof dest, bool:pack=false)
+ * Returns the number of characters decoded; if the dest buffer is
+ * too small, not all bytes are stored.
+ * A buffer may be decoded "in-place"; the destination size is always
+ * smaller than the source size.
+ */
+static cell AMX_NATIVE_CALL n_urldecode(AMX *amx,const cell *params)
+{
+  cell *cstr;
+  TCHAR *str;
+  int idx_src=0,idx_dst=0;
+
+  /* get the source */
+  (void)(amx);
+  amx_StrParam(amx,params[2],str);
+
+  /* decode */
+  while (idx_src!='\0') {
+    assert(idx_dst<=idx_src);
+    if (str[idx_src]=='%') {
+      int p,q;
+      if (str[idx_src+1]>='0' && str[idx_src+1]<='9')
+        p=str[idx_src+1]-'0';
+      else if (str[idx_src+1]>='A' && str[idx_src+1]<='F')
+        p=str[idx_src+1]-'A'+10;
+      else if (str[idx_src+1]>='a' && str[idx_src+1]<='f')
+        p=str[idx_src+1]-'a'+10;
+      else
+        p=-1;
+      if (p>=0) {
+        if (str[idx_src+2]>='0' && str[idx_src+2]<='9')
+          q=str[idx_src+2]-'0';
+        else if (str[idx_src+2]>='A' && str[idx_src+2]<='F')
+          q=str[idx_src+2]-'A'+10;
+        else if (str[idx_src+2]>='a' && str[idx_src+2]<='f')
+          q=str[idx_src+2]-'a'+10;
+        else
+          q=-1;
+      } /* if */
+      if (p>=0 && q >=0) {
+        assert(p<=15 && q<=15);
+        str[idx_dst]=(TCHAR)((p<<4) | q);
+        idx_src+=3;
+      } else {
+        /* invalid '%xx' syntax, copy literal '%' */
+        str[idx_dst]=str[idx_src++];
+      } /* if */
+    } else {
+      str[idx_dst]=str[idx_src++];
+    } /* if */
+    idx_dst++;
+  } /* while */
+  str[idx_dst]='\0';
+
+  /* store */
+  cstr=amx_Address(amx,params[1]);
+  amx_SetString(cstr,str,1,0,params[4]); /* store as packed ot unpacked */
+
+  return idx_dst;
+}
+
+#define INVALIDURI(c) ((c)<','               \
+                       || (c)>'9' && (c)<'A' \
+                       || (c)>'Z' && (c)<'_' \
+                       || (c)>'_' && (c)<'a' \
+                       || (c)>'z' && (unsigned)(c)<0xa1)
+
+#define TOHEX(c)      (TCHAR)((c)<10 ? '0'+(c) : 'A'-10+(c))
+
+/* urlencode(dest[], const source[], maxlength=sizeof dest, bool:pack=false)
+ * Returns the number of characters encoded, excluding the zero string
+ * terminator; if the dest buffer is too small, not all bytes are stored.
+ * Always creates a packed string. This string has a newline character at the
+ * end. A buffer may be encoded "in-place" if the destination is large enough.
+ * Endian issues (for multi-byte values in the data stream) are not handled.
+ */
+static cell AMX_NATIVE_CALL n_urlencode(AMX *amx,const cell *params)
+{
+  cell *cstr;
+  int length,destlen,count,lastwidth;
+  TCHAR *str;
+
+  /* allocate memory and get the source */
+  (void)(amx);
+  if ((length=(int)params[3])==0)
+    return 0;
+  if ((str = (TCHAR*)alloca(length * sizeof(TCHAR)))==NULL)
+    return 0;
+  cstr=amx_Address(amx,params[2]);
+  amx_GetString((char*)str, cstr, sizeof(TCHAR)>1, length);
+
+  /* run through the string and determine the new length */
+  destlen=1;  /* space for the '\0' terminator */
+  lastwidth=0;
+  for (count=0; str[count]!='\0' && destlen<length; count++) {
+    if (INVALIDURI(str[count]))
+      lastwidth=3;
+    else
+      lastwidth=1;
+    destlen+=lastwidth;
+  } /* for */
+  if (destlen>length) {   /* correct for overrun */
+    destlen-=lastwidth;
+    count--;
+  } /* if */
+  assert(destlen<=length);
+  assert(count>=0);
+
+  /* store string terminator */
+  assert(destlen>0);
+  str[--destlen]='\0';
+  /* convert string from end to start */
+  while (--count>=0) {
+    assert(destlen>count);
+    if (INVALIDURI(str[count])) {
+      str[--destlen]=TOHEX(str[count] & 0x0f);
+      str[--destlen]=TOHEX((str[count] >> 4) & 0x0f);
+      str[--destlen]='%';
+    } else {
+      str[--destlen]=str[count];
+    } /* if */
+  } /* while */
+  assert(destlen==0);
+
+  /* store the result */
+  cstr=amx_Address(amx,params[1]);
+  amx_SetString(cstr,str,1,0,params[4]); /* store as packed ot unpacked */
+
+  return (cell)strlen(str);
+}
+
+/* memcpy(dest[], const source[], index=0, numbytes, maxlength=sizeof dest)
+ * This function can align byte strings in cell arrays, or concatenate two
+ * byte strings in two arrays. The parameter "index" is a byte offset; "numbytes"
+ * is the number of bytes to copy. Parameter "maxlength", however, is in cells.
+ * This function allows copying in-place, for aligning memory buffers.
+ * Endian issues (for multi-byte values in the data stream) are not handled.
+ */
+static cell AMX_NATIVE_CALL n_memcpy(AMX *amx,const cell *params)
+{
+  cell *cdest,*csrc;
+  unsigned char *pdest,*psrc;
+
+  (void)(amx);
+  if (params[3]<0 || params[4]<0 || (params[3]+params[4])>params[5]*(int)sizeof(cell))
+    return 0;
+  cdest=amx_Address(amx,params[1]);
+  csrc=amx_Address(amx,params[2]);
+  pdest=(unsigned char*)cdest+params[3];
+  psrc=(unsigned char*)csrc;
+  memmove(pdest,psrc,params[4]);
+  return 1;
+}
+
+#if !defined AMX_NOSTRFMT
+  static int str_putstr(void *dest,const TCHAR *str)
+  {
+    if (_tcslen((TCHAR*)dest)+_tcslen(str)<MAX_FORMATSTR)
+      _tcscat((TCHAR*)dest,str);
+    return 0;
+  }
+
+  static int str_putchar(void *dest,TCHAR ch)
+  {
+    int len=(int)_tcslen((TCHAR*)dest);
+    if (len<MAX_FORMATSTR-1) {
+      ((TCHAR*)dest)[len]=ch;
+      ((TCHAR*)dest)[len+1]='\0';
+    } /* if */
+    return 0;
+  }
+#endif
+
+/* strformat(dest[], size=sizeof dest, bool:pack=false, const format[], {Fixed,_}:...)
+ */
+static cell AMX_NATIVE_CALL n_strformat(AMX *amx,const cell *params)
+{
+  #if defined AMX_NOSTRFMT
+    (void)amx;
+    (void)params;
+    return 0;
+  #else
+    cell *cstr;
+    AMX_FMTINFO info;
+    TCHAR output[MAX_FORMATSTR];
+
+    memset(&info,0,sizeof info);
+    info.params=params+5;
+    info.numparams=(int)(params[0]/sizeof(cell))-4;
+    info.skip=0;
+    info.length=MAX_FORMATSTR;  /* max. length of the string */
+    info.f_putstr=str_putstr;
+    info.f_putchar=str_putchar;
+    info.user=output;
+    output[0] = __T('\0');
+
+    cstr=amx_Address(amx,params[4]);
+    amx_printstring(amx,cstr,&info);
+
+    /* store the output string */
+    cstr=amx_Address(amx,params[1]);
+    amx_SetString(cstr,(char*)output,(int)params[3],sizeof(TCHAR)>1,(int)params[2]);
+    return 1;
+  #endif
+}
+
+
+#if defined __cplusplus
+  extern "C"
+#endif
+const AMX_NATIVE_INFO string_Natives[] = {
+  { "ispacked",  n_ispacked },
+  { "memcpy",    n_memcpy },
+  { "strcat",    n_strcat },
+  { "strcmp",    n_strcmp },
+  { "strcopy",   n_strcopy },
+  { "strdel",    n_strdel },
+  { "strfind",   n_strfind },
+  { "strformat", n_strformat },
+  { "strins",    n_strins },
+  { "strlen",    n_strlen },
+  { "strmid",    n_strmid },
+  { "strpack",   n_strpack },
+  { "strunpack", n_strunpack },
+  { "strval",    n_strval },
+  { "uudecode",  n_uudecode },
+  { "uuencode",  n_uuencode },
+  { "urldecode", n_urldecode },
+  { "urlencode", n_urlencode },
+  { "valstr",    n_valstr },
+  { NULL, NULL }        /* terminator */
+};
+
+int AMXEXPORT AMXAPI amx_StringInit(AMX *amx)
+{
+  return amx_Register(amx, string_Natives, -1);
+}
+
+int AMXEXPORT AMXAPI amx_StringCleanup(AMX *amx)
+{
+  (void)amx;
+  return AMX_ERR_NONE;
+}
diff --git a/apps/openmw-mp/amx/amxtime.c b/apps/openmw-mp/amx/amxtime.c
new file mode 100644
index 000000000..3704e2e8d
--- /dev/null
+++ b/apps/openmw-mp/amx/amxtime.c
@@ -0,0 +1,480 @@
+/*  Date/time module for the Pawn Abstract Machine
+ *
+ *  Copyright (c) ITB CompuPhase, 2001-2013
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ *  use this file except in compliance with the License. You may obtain a copy
+ *  of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ *  License for the specific language governing permissions and limitations
+ *  under the License.
+ *
+ *  Version: $Id: amxtime.c 4983 2013-10-21 07:32:57Z  $
+ */
+#include <time.h>
+#include <assert.h>
+#include "amx.h"
+#if defined __WIN32__ || defined _WIN32 || defined _Windows
+  #include <windows.h>
+  #include <mmsystem.h>
+#endif
+
+#define CELLMIN   (-1 << (8*sizeof(cell) - 1))
+
+#define SECONDS_PER_MINUTE	60
+#define SECONDS_PER_HOUR	3600
+#define SECONDS_PER_DAY		86400
+#define SECONDS_PER_YEAR	31556952	/* based on 365.2425 days per year */
+
+#if !defined CLOCKS_PER_SEC
+  #define CLOCKS_PER_SEC CLK_TCK
+#endif
+#if defined __WIN32__ || defined _WIN32 || defined WIN32
+  static int timerset = 0;
+  /* timeGetTime() is more accurate on WindowsNT if timeBeginPeriod(1) is set */
+  #define INIT_TIMER()    \
+    if (!timerset) {      \
+      timeBeginPeriod(1); \
+      timerset=1;         \
+    }
+#else
+  #define INIT_TIMER()
+#endif
+static unsigned long timestamp;
+static unsigned long timelimit;
+static int timerepeat;
+
+static const unsigned char monthdays[12] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
+
+static int wrap(int value, int min, int max)
+{
+  if (value<min)
+    value=max;
+  else if (value>max)
+    value=min;
+  return value;
+}
+
+static unsigned long gettimestamp(void)
+{
+  unsigned long value;
+
+  #if defined __WIN32__ || defined _WIN32 || defined WIN32
+    value=timeGetTime();        /* this value is already in milliseconds */
+  #elif defined __linux || defined __linux__ || defined __LINUX__ || defined __APPLE__
+    struct timeval tv;
+    gettimeofday(&tv, NULL);
+    value = ((tv.tv_sec * 1000) + (tv.tv_usec / 1000));
+  #else
+    value=clock();
+    #if CLOCKS_PER_SEC<1000
+      /* convert to milliseconds */
+      value=(cell)((1000L * value) / CLOCKS_PER_SEC);
+    #elif CLOCKS_PER_SEC>1000
+      /* convert to milliseconds */
+      value=(cell)(value/(CLOCKS_PER_SEC/1000));
+    #endif
+  #endif
+  return value;
+}
+
+void stamp2datetime(unsigned long sec1970,
+                    int *year, int *month, int *day,
+                    int *hour, int *minute, int *second)
+{
+  int days, seconds;
+
+  /* find the year */
+  assert(year!=NULL);
+  for (*year = 1970; ; *year += 1) {
+    days = 365 + ((*year & 0x03) == 0); /* clumsy "leap-year" routine, fails for 2100 */
+    seconds = days * SECONDS_PER_DAY;
+    if ((unsigned long)seconds > sec1970)
+      break;
+    sec1970 -= seconds;
+  } /* if */
+
+  /* find the month */
+  assert(month!=NULL);
+  for (*month = 1; ; *month += 1) {
+    days = monthdays[*month - 1];
+    seconds = days * SECONDS_PER_DAY;
+    if ((unsigned long)seconds > sec1970)
+      break;
+    sec1970 -= seconds;
+  } /* if */
+
+  /* find the day */
+  assert(day!=NULL);
+  for (*day = 1; sec1970 >= SECONDS_PER_DAY; *day += 1)
+    sec1970 -= SECONDS_PER_DAY;
+
+  /* find the hour */
+  assert(hour!=NULL);
+  for (*hour = 0; sec1970 >= SECONDS_PER_HOUR; *hour += 1)
+    sec1970 -= SECONDS_PER_HOUR;
+
+  /* find the minute */
+  assert(minute!=NULL);
+  for (*minute = 0; sec1970 >= SECONDS_PER_MINUTE; *minute += 1)
+    sec1970 -= SECONDS_PER_MINUTE;
+
+  /* remainder is the number of seconds */
+  assert(second!=NULL);
+  *second = (int)sec1970;
+}
+
+static void settime(cell hour,cell minute,cell second)
+{
+  #if defined __WIN32__ || defined _WIN32 || defined WIN32
+    SYSTEMTIME systim;
+
+    GetLocalTime(&systim);
+    if (hour!=CELLMIN)
+      systim.wHour=(WORD)wrap((int)hour,0,23);
+    if (minute!=CELLMIN)
+      systim.wMinute=(WORD)wrap((int)minute,0,59);
+    if (second!=CELLMIN)
+      systim.wSecond=(WORD)wrap((int)second,0,59);
+    SetLocalTime(&systim);
+  #else
+    /* Linux/Unix (and some DOS compilers) have stime(); on Linux/Unix, you
+     * must have "root" permission to call stime(); many POSIX systems will
+     * have settimeofday() instead
+     */
+    time_t sec1970;
+    struct tm gtm;
+    #if defined __APPLE__ /* also valid for other POSIX systems */
+      struct timeval tv;
+    #endif
+
+    time(&sec1970);
+    gtm=*localtime(&sec1970);
+    if (hour!=CELLMIN)
+      gtm.tm_hour=wrap((int)hour,0,23);
+    if (minute!=CELLMIN)
+      gtm.tm_min=wrap((int)minute,0,59);
+    if (second!=CELLMIN)
+      gtm.tm_sec=wrap((int)second,0,59);
+    sec1970=mktime(&gtm);
+    #if defined __APPLE__ /* also valid for other POSIX systems */
+      tv.tv_sec = sec1970;
+      tv.tv_usec = 0;
+      settimeofday(&tv, 0);
+    #else
+      stime(&sec1970);
+    #endif
+  #endif
+}
+
+static void setdate(cell year,cell month,cell day)
+{
+  int maxday;
+
+  #if defined __WIN32__ || defined _WIN32 || defined WIN32
+    SYSTEMTIME systim;
+
+    GetLocalTime(&systim);
+    if (year!=CELLMIN)
+      systim.wYear=(WORD)wrap((int)year,1970,2099);
+    if (month!=CELLMIN)
+      systim.wMonth=(WORD)wrap((int)month,1,12);
+    maxday=monthdays[systim.wMonth - 1];
+    if (systim.wMonth==2 && ((systim.wYear % 4)==0 && ((systim.wYear % 100)!=0 || (systim.wYear % 400)==0)))
+      maxday++;
+    if (day!=CELLMIN)
+      systim.wDay=(WORD)wrap((int)day,1,maxday);
+    SetLocalTime(&systim);
+  #else
+    /* Linux/Unix (and some DOS compilers) have stime(); on Linux/Unix, you
+     * must have "root" permission to call stime(); many POSIX systems will
+     * have settimeofday() instead
+     */
+    time_t sec1970;
+    struct tm gtm;
+    #if defined __APPLE__ /* also valid for other POSIX systems */
+      struct timeval tv;
+    #endif
+
+    time(&sec1970);
+    gtm=*localtime(&sec1970);
+    if (year!=CELLMIN)
+      gtm.tm_year=year-1900;
+    if (month!=CELLMIN)
+      gtm.tm_mon=month-1;
+    if (day!=CELLMIN)
+      gtm.tm_mday=day;
+    sec1970=mktime(&gtm);
+    #if defined __APPLE__ /* also valid for other POSIX systems */
+      tv.tv_sec = sec1970;
+      tv.tv_usec = 0;
+      settimeofday(&tv, 0);
+    #else
+      stime(&sec1970);
+    #endif
+  #endif
+}
+
+
+/* settime(hour, minute, second)
+ * Always returns 0
+ */
+static cell AMX_NATIVE_CALL n_settime(AMX *amx, const cell *params)
+{
+  (void)amx;
+  settime(params[1],params[2],params[3]);
+  return 0;
+}
+
+/* gettime(&hour, &minute, &second)
+ * The return value is the number of seconds since 1 January 1970 (Unix system
+ * time).
+ */
+static cell AMX_NATIVE_CALL n_gettime(AMX *amx, const cell *params)
+{
+  time_t sec1970;
+  struct tm gtm;
+  cell *cptr;
+
+  assert(params[0]==(int)(3*sizeof(cell)));
+
+  time(&sec1970);
+
+  /* on DOS/Windows, the timezone is usually not set for the C run-time
+   * library; in that case gmtime() and localtime() return the same value
+   */
+  gtm=*localtime(&sec1970);
+  cptr=amx_Address(amx,params[1]);
+  *cptr=gtm.tm_hour;
+  cptr=amx_Address(amx,params[2]);
+  *cptr=gtm.tm_min;
+  cptr=amx_Address(amx,params[3]);
+  *cptr=gtm.tm_sec;
+
+  /* the time() function returns the number of seconds since January 1 1970
+   * in Universal Coordinated Time (the successor to Greenwich Mean Time)
+   */
+  return (cell)sec1970;
+}
+
+/* setdate(year, month, day)
+ * Always returns 0
+ */
+static cell AMX_NATIVE_CALL n_setdate(AMX *amx, const cell *params)
+{
+  (void)amx;
+  setdate(params[1],params[2],params[3]);
+  return 0;
+}
+
+/* getdate(&year, &month, &day)
+ * The return value is the number of days since the start of the year. January
+ * 1 is day 1 of the year.
+ */
+static cell AMX_NATIVE_CALL n_getdate(AMX *amx, const cell *params)
+{
+  time_t sec1970;
+  struct tm gtm;
+  cell *cptr;
+
+  assert(params[0]==(int)(3*sizeof(cell)));
+
+  time(&sec1970);
+
+  gtm=*localtime(&sec1970);
+  cptr=amx_Address(amx,params[1]);
+  *cptr=gtm.tm_year+1900;
+  cptr=amx_Address(amx,params[2]);
+  *cptr=gtm.tm_mon+1;
+  cptr=amx_Address(amx,params[3]);
+  *cptr=gtm.tm_mday;
+
+  return gtm.tm_yday+1;
+}
+
+/* tickcount(&granularity)
+ * Returns the number of milliseconds since start-up. For a 32-bit cell, this
+ * count overflows after approximately 24 days of continuous operation.
+ */
+static cell AMX_NATIVE_CALL n_tickcount(AMX *amx, const cell *params)
+{
+  cell *cptr;
+
+  assert(params[0]==(int)sizeof(cell));
+
+  INIT_TIMER();
+  cptr=amx_Address(amx,params[1]);
+  #if defined __WIN32__ || defined _WIN32 || defined WIN32
+    *cptr=1000;               	/* granularity = 1 ms */
+  #else
+    *cptr=(cell)CLOCKS_PER_SEC;	/* in Unix/Linux, this is often 100 */
+  #endif
+  return gettimestamp() & 0x7fffffff;
+}
+
+/* delay(milliseconds)
+ * Pauses for (at least) the requested number of milliseconds.
+ */
+static cell AMX_NATIVE_CALL n_delay(AMX *amx, const cell *params)
+{
+  unsigned long stamp;
+
+  (void)amx;
+  assert(params[0]==(int)sizeof(cell));
+
+  INIT_TIMER();
+  stamp=gettimestamp();
+  while (gettimestamp()-stamp < (unsigned long)params[1])
+    /* nothing */;
+  return 0;
+}
+
+/* settimer(milliseconds, bool: singleshot = false)
+ * Sets the delay until the @timer() callback is called. The timer may either
+ * be single-shot or repetitive.
+ */
+static cell AMX_NATIVE_CALL n_settimer(AMX *amx, const cell *params)
+{
+  (void)amx;
+  assert(params[0]==(int)(2*sizeof(cell)));
+  timestamp=gettimestamp();
+  timelimit=params[1];
+  timerepeat=(int)(params[2]==0);
+  return 0;
+}
+
+/* bool: gettimer(&milliseconds, bool: &singleshot = false)
+ * Retrieves the timer set with settimer(); returns true if a timer
+ * was set up, or false otherwise.
+ */
+static cell AMX_NATIVE_CALL n_gettimer(AMX *amx, const cell *params)
+{
+  cell *cptr;
+
+  assert(params[0]==(int)(2*sizeof(cell)));
+  cptr=amx_Address(amx,params[1]);
+  *cptr=timelimit;
+  cptr=amx_Address(amx,params[2]);
+  *cptr=timerepeat;
+  return timelimit>0;
+}
+
+/* settimestamp(seconds1970) sets the date and time from a single parameter: the
+ * number of seconds since 1 January 1970.
+ */
+static cell AMX_NATIVE_CALL n_settimestamp(AMX *amx, const cell *params)
+{
+  #if defined __WIN32__ || defined _WIN32 || defined WIN32
+    int year, month, day, hour, minute, second;
+
+    stamp2datetime(params[1],
+                   &year, &month, &day,
+                   &hour, &minute, &second);
+    setdate(year, month, day);
+    settime(hour, minute, second);
+  #else
+    /* Linux/Unix (and some DOS compilers) have stime(); on Linux/Unix, you
+     * must have "root" permission to call stime(); many POSIX systems will
+     * have settimeofday() instead
+     */
+    #if defined __APPLE__ /* also valid for other POSIX systems */
+      struct timeval tv;
+      tv.tv_sec = params[1];
+      tv.tv_usec = 0;
+      settimeofday(&tv, 0);
+    #else
+      time_t sec1970=(time_t)params[1];
+      stime(&sec1970);
+    #endif
+  #endif
+  (void)amx;
+
+  return 0;
+}
+
+/* cvttimestamp(seconds1970, &year, &month, &day, &hour, &minute, &second)
+ */
+static cell AMX_NATIVE_CALL n_cvttimestamp(AMX *amx, const cell *params)
+{
+  int year, month, day, hour, minute, second;
+
+  (void)amx;
+  stamp2datetime(params[1],
+                 &year, &month, &day,
+                 &hour, &minute, &second);
+  return 0;
+}
+
+
+#if !defined AMXTIME_NOIDLE
+static AMX_IDLE PrevIdle = NULL;
+static int idxTimer = -1;
+
+static int AMXAPI amx_TimeIdle(AMX *amx, int AMXAPI Exec(AMX *, cell *, int))
+{
+  int err=0;
+
+  assert(idxTimer >= 0);
+
+  if (PrevIdle != NULL)
+    PrevIdle(amx, Exec);
+
+  if (timelimit>0 && (gettimestamp()-timestamp)>=timelimit) {
+    if (timerepeat)
+      timestamp+=timelimit;
+    else
+      timelimit=0;      /* do not repeat single-shot timer */
+    err = Exec(amx, NULL, idxTimer);
+    while (err == AMX_ERR_SLEEP)
+      err = Exec(amx, NULL, AMX_EXEC_CONT);
+  } /* if */
+
+  return err;
+}
+#endif
+
+
+#if defined __cplusplus
+  extern "C"
+#endif
+const AMX_NATIVE_INFO time_Natives[] = {
+  { "gettime",      n_gettime },
+  { "settime",      n_settime },
+  { "getdate",      n_getdate },
+  { "setdate",      n_setdate },
+  { "tickcount",    n_tickcount },
+  { "settimer",     n_settimer },
+  { "gettimer",     n_gettimer },
+  { "delay",        n_delay },
+  { "settimestamp", n_settimestamp },
+  { "cvttimestamp", n_cvttimestamp },
+  { NULL, NULL }        /* terminator */
+};
+
+int AMXEXPORT AMXAPI amx_TimeInit(AMX *amx)
+{
+  #if !defined AMXTIME_NOIDLE
+    /* see whether there is a @timer() function */
+    if (amx_FindPublic(amx,"@timer",&idxTimer) == AMX_ERR_NONE) {
+      if (amx_GetUserData(amx, AMX_USERTAG('I','d','l','e'), (void**)&PrevIdle) != AMX_ERR_NONE)
+        PrevIdle = NULL;
+      amx_SetUserData(amx, AMX_USERTAG('I','d','l','e'), amx_TimeIdle);
+    } /* if */
+  #endif
+
+  return amx_Register(amx, time_Natives, -1);
+}
+
+int AMXEXPORT AMXAPI amx_TimeCleanup(AMX *amx)
+{
+  (void)amx;
+  #if !defined AMXTIME_NOIDLE
+    PrevIdle = NULL;
+  #endif
+  return AMX_ERR_NONE;
+}
diff --git a/apps/openmw-mp/amx/fpattern.c b/apps/openmw-mp/amx/fpattern.c
new file mode 100644
index 000000000..ea313050d
--- /dev/null
+++ b/apps/openmw-mp/amx/fpattern.c
@@ -0,0 +1,1334 @@
+/*
+ from http://home.flash.net/~dtribble/text/fpattern.htm
+ 2000/12/12
+ by Perry
+ License statement is in comments below
+*/
+
+/******************************************************************************
+* fpattern.c
+*   Functions for matching filename patterns to filenames.
+*
+* Usage
+*   (See "fpattern.h".)
+*
+* Notes
+*   These pattern matching capabilities are modeled after those found in
+*   the UNIX command shells.
+*
+*   'FPAT_DELIM' must be #define'd if pathname separators are to be handled
+*   explicitly.
+*
+* History
+*   1.00 1997-01-03 David Tribble.
+*       First cut.
+*   1.01 1997-01-03 David Tribble.
+*       Added SUB pattern character.
+*       Added fpattern_matchn().
+*   1.02 1997-01-12 David Tribble.
+*       Fixed missing lowercase matching cases.
+*   1.03 1997-01-13 David Tribble.
+*       Pathname separator code is now controlled by FPAT_DELIM macro.
+*   1.04 1997-01-14 David Tribble.
+*       Added QUOTE macro.
+*   1.05 1997-01-15 David Tribble.
+*       Handles special case of empty pattern and empty filename.
+*   1.06 1997-01-26 David Tribble.
+*       Changed range negation character from '^' to '!', ala Unix.
+*   1.07 1997-08-02 David Tribble.
+*       Uses the 'FPAT_XXX' constants.
+*   1.08 1998-06-28 David Tribble.
+*       Minor fixed for MS-VC++ (5.0).
+*
+*   Modifications by Thiadmer Riemersma (optional case-sensitive matching,
+*   optional explicit array length, repeated set syntax), 2005-11-27.
+*
+* Limitations
+*   This code is copyrighted by the author, but permission is hereby
+*   granted for its unlimited use provided that the original copyright
+*   and authorship notices are retained intact.
+*
+*   Other queries can be sent to:
+*       dtribble@technologist.com
+*       david.tribble@beasys.com
+*       dtribble@flash.net
+*
+* Copyright 1997-1998 by David R. Tribble, all rights reserved.
+* Copyright (c) 2005-2015, ITB CompuPhase, all rights reserved.
+* www.compuphase.com
+*
+* Version: $Id: fpattern.c 5181 2015-01-21 09:44:28Z thiadmer $
+*/
+
+
+
+/* System includes */
+#if defined TEST
+	#include <assert.h>
+#elif !defined assert
+	#define assert(e)
+#endif
+#include <string.h>
+
+#include "fpattern.h"
+
+
+/* Local constants */
+
+#ifndef NULL
+# define NULL       ((void *) 0)
+#endif
+
+#ifndef FALSE
+# define FALSE      0
+#endif
+
+#ifndef TRUE
+# define TRUE       1
+#endif
+
+#ifdef FPAT_SUBCLOS
+# if TEST
+#   undef           FPAT_CLOSP
+#   define FPAT_CLOSP  '~'
+# endif
+#endif
+
+
+#define ishexdigit(c)   ( ((c)>='0' && (c)<='9') || ((c)>='a' && (c)<='f') || ((c)>='A' && (c)<='F') )
+#define hexdigit(c)     ( ((c)>='0' && (c)<='9') ? (c) - '0' : 10 + \
+                        ( ((c)>='a' && (c)<='f') ? (c) - 'a' : (c) - 'A' ) )
+#if !defined tolower
+# define tolower(c)     ( (c)>='A' && (c)<='Z' ? (c) - 'A' + 'a' : (c) )
+#endif
+
+#define BITSET(set,idx) ( (set)[(idx)/8] |= (unsigned char)(1 << ((idx) & 7)) )
+#define BITGET(set,idx) ( (set)[(idx)/8] & (1 << ((idx) & 7)) )
+
+/*-----------------------------------------------------------------------------
+* fpattern_isvalid()
+*   Checks that filename pattern 'pat' is a well-formed pattern.
+*
+* Returns
+*   0 (FPAT_INVALID) if 'pat' is an INVALID pattern, 1 or 2 for VALID patterns
+*   (FPAT_CLOSED and FPAT_OPEN respectively).
+*   A valid pattern may be "closed" (with a non-repeating terminator) or
+*   "open-ended" (where the last character in the pattern may be repeated 0 or
+*   more times).
+*
+* Caveats
+*   If 'pat' is NULL, 0 (FPAT_INVALID) is returned.
+*
+*   If 'pat' is empty (""), 1 (FPAT_CLOSED) is returned, and it is considered a
+*   valid (but degenerate) pattern (the only filename it matches is the
+*   empty ("") string).
+*/
+
+int fpattern_isvalid(const char *pat)
+{
+    static const char specialchars[] = { FPAT_QUOTE, FPAT_SET_THRU, FPAT_SET_L,
+                                         FPAT_SET_R, FPAT_MSET_L, FPAT_MSET_R,
+                                         FPAT_ANY, FPAT_NOT, FPAT_CLOS, FPAT_CLOSP,
+                                         '\0' };
+    int     len, open;
+    char    close, pch, pch2;
+    unsigned char mask[256/sizeof(unsigned char)];
+
+    /* Check args */
+    if (pat == NULL)
+        return (FPAT_INVALID);
+
+    open = FALSE;   /* pattern is not open-ended */
+
+    /* Verify that the pattern is valid */
+    for (len = 0;  pat[len] != '\0';  len++)
+    {
+        switch (pat[len])
+        {
+        case FPAT_SET_L:
+#if defined FPAT_MSET_ENABLED
+        case FPAT_MSET_L:
+#endif
+            /* Char set */
+            if (pat[len] == FPAT_SET_L)
+            {
+                open = FALSE;
+                close = FPAT_SET_R;
+            }
+            else
+            {
+                open = TRUE;
+                close = FPAT_MSET_R;
+            }
+            len++;
+            if (pat[len] == FPAT_NOT)
+                len++;          /* Set negation */
+
+            memset(mask,0,sizeof mask);
+            while (pat[len] != close)
+            {
+                pch = pat[len];
+                if (pat[len] == FPAT_QUOTE) {
+                    len++;      /* Quoted char */
+                    pch = pat[len];
+                    if (ishexdigit(pch)) {
+                        len++;  /* Hex digits should come in pairs */
+                        if (!ishexdigit(pat[len]))
+                            return (FPAT_INVALID);
+                        pch2 = pat[len];
+                        pch = (hexdigit(pch) << 4) | hexdigit(pch2);
+                    } else if (strchr(specialchars,pat[len])==NULL) {
+                        return (FPAT_INVALID); /* escaped char should be special char */
+                    } /* if */
+                } /* if */
+                if (pat[len] == '\0')
+                    return (FPAT_INVALID); /* Missing closing bracket */
+                if (BITGET(mask,pch))
+                    return (FPAT_INVALID);
+                BITSET(mask,pch);
+                len++;
+
+                if (pat[len] == FPAT_SET_THRU && (pat[len+1] != FPAT_SET_THRU || pch == FPAT_SET_THRU))
+                {
+                    /* Char range */
+                    len++;
+                    if (pat[len] == FPAT_QUOTE) {
+                        len++;      /* Quoted char */
+                        if (ishexdigit(pat[len])) {
+                            len++;  /* Hex digits should come in pairs */
+                            if (!ishexdigit(pat[len]))
+                                return (FPAT_INVALID);
+                        } else if (strchr(specialchars,pat[len])==NULL) {
+                            return (FPAT_INVALID); /* escaped char should be special char */
+                        } /* if */
+                    } /* if */
+
+                    if (pat[len] == '\0')
+                        return (FPAT_INVALID); /* Missing closing bracket */
+                    if (len<2 || (unsigned char)pat[len-2]>(unsigned char)pat[len]
+                        || (pat[len-2]==pat[len] && pat[len]!=FPAT_SET_THRU))
+                        return (FPAT_INVALID);  /* invalid range (decrementing) */
+                    //??? also set bits of characters in range?
+                    len++;
+                }
+
+                if (pat[len] == '\0')
+                    return (FPAT_INVALID); /* Missing closing bracket */
+            }
+            break;
+
+        case FPAT_QUOTE:
+            /* Quoted char */
+            len++;
+            open = FALSE;
+            if (ishexdigit(pat[len])) {
+                len++;                    /* Hex digits should come in pairs */
+                if (!ishexdigit(pat[len]))
+                    return (FPAT_INVALID);
+            } else if (strchr(specialchars,pat[len])==NULL) {
+                return (FPAT_INVALID);    /* escaped char should be special char */
+            } /* if */
+            if (pat[len] == '\0')
+                return (FPAT_INVALID);    /* Missing quoted char */
+            break;
+
+#if defined FPAT_NOT_ENABLED
+        case FPAT_NOT:
+            /* Negated pattern */
+            len++;
+            open = FALSE;
+            if (pat[len] == '\0')
+                return (FPAT_INVALID);     /* Missing subpattern */
+            break;
+#endif
+
+        case FPAT_CLOS:
+            open = TRUE;
+            break;
+
+        default:
+            /* Valid character */
+            open = FALSE;
+            break;
+        }
+    }
+
+    return (open ? FPAT_OPEN : FPAT_CLOSED);
+}
+
+
+/* NOTA BENE
+ * =========
+ * To modify the pattern matcher, modify the case-insensitive version and
+ * copy it to the case-sensitive version. In steps:
+ * - modify the function fpatter_submatch_tolower(), here below
+ * - make a copy of the entire function
+ * - erase all references to "tolower" in the copy
+ */
+
+/*-----------------------------------------------------------------------------
+* fpattern_submatch_tolower()
+*   Attempts to match subpattern 'pat' to subfilename 'fname'.
+*
+* Returns
+*   1 (true) if the subfilename matches, otherwise 0 (false).
+*
+* Caveats
+*   This does not assume that 'pat' is well-formed.
+*
+*   If 'pat' is empty (""), the only filename it matches is the empty ("")
+*   string.
+*
+*   Some non-empty patterns (e.g., "") will match an empty filename ("").
+*/
+
+static int fpattern_submatch_tolower(const char *pat, const char *fname, int flength)
+{
+    int     fch;
+    int     pch, pch2;
+    int     i;
+    int     yes, match;
+    int     lo, hi;
+
+    /* Attempt to match subpattern against subfilename */
+    while (*pat != '\0')
+    {
+        fch = (unsigned char)*fname;
+        pch = (unsigned char)*pat;
+        pat++;
+
+        switch (pch)
+        {
+        case FPAT_ANY:
+            /* Match a single char */
+        #if defined FPAT_DELIM
+            if (fch == FPAT_DEL  ||  fch == FPAT_DEL2  ||  fch == '\0')
+                return (FALSE);
+        #else
+            if (flength == 0)
+                return (FALSE);
+        #endif
+            fname++;
+            flength--;
+            break;
+
+        case FPAT_CLOS:
+            /* Match zero or more chars */
+        #if defined FPAT_DELIM
+            i = 0;
+            while (fname[i] != '\0'  &&
+                    fname[i] != FPAT_DEL  &&  fname[i] != FPAT_DEL2)
+                i++;
+        #else
+            i = flength;
+        #endif
+            while (i >= 0)
+            {
+                if (fpattern_submatch_tolower(pat, fname+i, flength-i))
+                    return (TRUE);
+                i--;
+            }
+            return (FALSE);
+
+    #ifdef FPAT_SUBCLOS
+        case FPAT_CLOSP:
+            /* Match zero or more chars */
+            i = 0;
+            while (i < flength  &&
+        #if defined FPAT_DELIM
+                    fname[i] != FPAT_DEL  &&  fname[i] != FPAT_DEL2  &&
+        #endif
+                    fname[i] != '.')
+                i++;
+            while (i >= 0)
+            {
+                if (fpattern_submatch_tolower(pat, fname+i, flength-i))
+                    return (TRUE);
+                i--;
+            }
+            return (FALSE);
+    #endif
+
+        case FPAT_QUOTE:
+            /* Match a quoted char */
+            assert(*pat != '\0');
+            pch = (unsigned char)*pat;
+            if (ishexdigit(pch)) {
+                pch2 = *++pat;
+                pch = (hexdigit(pch) << 4) | hexdigit(pch2);
+            } /* if */
+            if (tolower(fch) != tolower(pch))
+                return (FALSE);
+            fname++;
+            flength--;
+            pat++;
+            break;
+
+        case FPAT_SET_L:
+            /* Match char set/range */
+            yes = TRUE;
+            if (*pat == FPAT_NOT) {
+               pat++;
+               yes = FALSE; /* Set negation */
+            } /* if */
+
+            /* Look for [s], [-], [abc], [a-c] */
+            match = !yes;
+            while (*pat != FPAT_SET_R) {
+                assert(*pat != '\0');
+                pch = (unsigned char)*pat++;
+                if (pch == FPAT_QUOTE) {
+                    assert(*pat != '\0');
+                    pch = (unsigned char)*pat++;
+                    if (ishexdigit(pch)) {
+                        pch2 = *pat++;
+                        lo = (hexdigit(pch) << 4) | hexdigit(pch2);
+                    } else {
+                        lo = pch;
+                    } /* if */
+                } else {
+                    lo = pch;
+                } /* if */
+
+                if (*pat == FPAT_SET_THRU) {
+                    /* Range */
+                    pat++;
+                    pch = (unsigned char)*pat++;
+
+                    if (pch == FPAT_QUOTE) {
+                        assert(*pat != '\0');
+                        pch = (unsigned char)*pat++;
+                        if (ishexdigit(pch)) {
+                            pch2 = *pat++;
+                            hi = (hexdigit(pch) << 4) | hexdigit(pch2);
+                        } else {
+                            hi = pch;
+                        } /* if */
+                    } else {
+                      hi = pch;
+                    } /* if */
+
+                    /* Compare character to set range */
+                    if (tolower(fch) >= tolower(lo) && tolower(fch) <= tolower(hi)) {
+                        match = yes;
+                        /* skip to the end of the set in the pattern (no need to
+                         * search further once a match is found)
+                         */
+                        while (*pat != FPAT_SET_R) {
+                            assert(*pat != '\0');
+                            pat++;
+                        } /* while */
+                        break;
+                    } /* if */
+                } else {
+                    /* Compare character to single char from set */
+                    if (tolower(fch) == tolower(lo)) {
+                        match = yes;
+                        /* skip to the end of the set in the pattern (no need to
+                         * search further once a match is found)
+                         */
+                        while (*pat != FPAT_SET_R) {
+                            assert(*pat != '\0');
+                            pat++;
+                        } /* while */
+                        break;
+                    } /* if */
+                } /* if */
+
+                assert(*pat != '\0');
+            } /* while */
+
+            if (!match)
+                return (FALSE);
+
+            fname++;
+            flength--;
+            assert(*pat == FPAT_SET_R);
+            pat++;
+            break;
+
+#if defined FPAT_MSET_ENABLED
+        case FPAT_MSET_L:
+            /* Match zero or more characters in a char set/range */
+            yes = TRUE;
+            if (*pat == FPAT_NOT) {
+               pat++;
+               yes = FALSE; /* Set negation */
+            } /* if */
+
+            do {
+                const char *org_pat = pat;
+                /* Look for [s], [-], [abc], [a-c] */
+                match = !yes;
+                while (*pat != FPAT_MSET_R) {
+                    assert(*pat != '\0');
+                    pch = (unsigned char)*pat++;
+                    if (pch == FPAT_QUOTE) {
+                        assert(*pat != '\0');
+                        pch = (unsigned char)*pat++;
+                        if (ishexdigit(pch)) {
+                            pch2 = *pat++;
+                            lo = (hexdigit(pch) << 4) | hexdigit(pch2);
+                        } else {
+                            lo = pch;
+                        } /* if */
+                    } else {
+                        lo = pch;
+                    } /* if */
+
+                    if (*pat == FPAT_SET_THRU) {
+                        /* Range */
+                        pat++;
+                        pch = (unsigned char)*pat++;
+
+                        if (pch == FPAT_QUOTE) {
+                            assert(*pat != '\0');
+                            pch = (unsigned char)*pat++;
+                            if (ishexdigit(pch)) {
+                                pch2 = *pat++;
+                                hi = (hexdigit(pch) << 4) | hexdigit(pch2);
+                            } else {
+                                hi = pch;
+                            } /* if */
+                        } else {
+                            hi = pch;
+                        } /* if */
+
+                        /* Compare character to set range */
+                        if (tolower(fch) >= tolower(lo) && tolower(fch) <= tolower(hi)) {
+                            match = yes;
+                            /* skip to the end of the set in the pattern (no
+                             * need to search further once a match is found)
+                             */
+                            while (*pat != FPAT_MSET_R) {
+                                assert(*pat != '\0');
+                                pat++;
+                            } /* while */
+                            break;
+                        } /* if */
+                    } else {
+                        /* Compare character to single char from the set */
+                        if (tolower(fch) == tolower(lo)) {
+                            match = yes;
+                            /* skip to the end of the set in the pattern (no
+                             * need to search further once a match is found)
+                             */
+                            while (*pat != FPAT_MSET_R) {
+                                assert(*pat != '\0');
+                                pat++;
+                            } /* while */
+                            break;
+                        } /* if */
+                    } /* if */
+
+                    assert(*pat != '\0');
+                } /* while */
+
+                assert(*pat == FPAT_MSET_R);
+
+                if (match) {
+                    fname++;
+                    flength--;
+                    fch = *fname;
+                    if (flength > 0)
+                        pat = org_pat;
+                } /* if */
+
+            } while (match && flength > 0);
+
+            pat++;
+            break;
+#endif /* FPAT_MSET_ENABLED */
+
+#if defined FPAT_NOT_ENABLED
+        case FPAT_NOT:
+            /* Match only if rest of pattern does not match */
+            assert(*pat != '\0');
+            i = fpattern_submatch_tolower(pat, fname, flength);
+            return !i;
+#endif
+
+#if defined FPAT_DELIM
+        case FPAT_DEL:
+    #if FPAT_DEL2 != FPAT_DEL
+        case FPAT_DEL2:
+    #endif
+            /* Match path delimiter char */
+            if (fch != FPAT_DEL  &&  fch != FPAT_DEL2)
+                return (FALSE);
+            fname++;
+            flength--;
+            break;
+#endif
+
+        default:
+            /* Match a (non-null) char exactly */
+            if (tolower(fch) != tolower(pch))
+                return (FALSE);
+            fname++;
+            flength--;
+            break;
+        }
+    }
+
+    /* Check for complete match */
+    if (flength != 0)
+        return (FALSE);
+
+    /* Successful match */
+    return (TRUE);
+}
+
+/*
+* fpattern_submatch()
+*   See fpattern_submatch_tolower()
+*/
+
+static int fpattern_submatch(const char *pat, const char *fname, int flength)
+{
+    int     fch;
+    int     pch, pch2;
+    int     i;
+    int     yes, match;
+    int     lo, hi;
+
+    /* Attempt to match subpattern against subfilename */
+    while (*pat != '\0')
+    {
+        fch = (unsigned char)*fname;
+        pch = (unsigned char)*pat;
+        pat++;
+
+        switch (pch)
+        {
+        case FPAT_ANY:
+            /* Match a single char */
+        #if defined FPAT_DELIM
+            if (fch == FPAT_DEL  ||  fch == FPAT_DEL2  ||  fch == '\0')
+                return (FALSE);
+        #else
+            if (flength == 0)
+                return (FALSE);
+        #endif
+            fname++;
+            flength--;
+            break;
+
+        case FPAT_CLOS:
+            /* Match zero or more chars */
+        #if defined FPAT_DELIM
+            i = 0;
+            while (fname[i] != '\0'  &&
+                    fname[i] != FPAT_DEL  &&  fname[i] != FPAT_DEL2)
+                i++;
+        #else
+            i = flength;
+        #endif
+            while (i >= 0)
+            {
+                if (fpattern_submatch(pat, fname+i, flength-i))
+                    return (TRUE);
+                i--;
+            }
+            return (FALSE);
+
+    #ifdef FPAT_SUBCLOS
+        case FPAT_CLOSP:
+            /* Match zero or more chars */
+            i = 0;
+            while (i < flength  &&
+        #if defined FPAT_DELIM
+                    fname[i] != FPAT_DEL  &&  fname[i] != FPAT_DEL2  &&
+        #endif
+                    fname[i] != '.')
+                i++;
+            while (i >= 0)
+            {
+                if (fpattern_submatch(pat, fname+i, flength-i))
+                    return (TRUE);
+                i--;
+            }
+            return (FALSE);
+    #endif
+
+        case FPAT_QUOTE:
+            /* Match a quoted char */
+            assert(*pat != '\0');
+            pch = (unsigned char)*pat;
+            if (ishexdigit(pch)) {
+                pch2 = *++pat;
+                pch = (hexdigit(pch) << 4) | hexdigit(pch2);
+            } /* if */
+            if ((fch) != (pch))
+                return (FALSE);
+            fname++;
+            flength--;
+            pat++;
+            break;
+
+        case FPAT_SET_L:
+            /* Match char set/range */
+            yes = TRUE;
+            if (*pat == FPAT_NOT) {
+               pat++;
+               yes = FALSE; /* Set negation */
+            } /* if */
+
+            /* Look for [s], [-], [abc], [a-c] */
+            match = !yes;
+            while (*pat != FPAT_SET_R) {
+                assert(*pat != '\0');
+                pch = (unsigned char)*pat++;
+                if (pch == FPAT_QUOTE) {
+                    assert(*pat != '\0');
+                    pch = (unsigned char)*pat++;
+                    if (ishexdigit(pch)) {
+                        pch2 = *pat++;
+                        lo = (hexdigit(pch) << 4) | hexdigit(pch2);
+                    } else {
+                        lo = pch;
+                    } /* if */
+                } else {
+                    lo = pch;
+                } /* if */
+
+                if (*pat == FPAT_SET_THRU) {
+                    /* Range */
+                    pat++;
+                    pch = (unsigned char)*pat++;
+
+                    if (pch == FPAT_QUOTE) {
+                        assert(*pat != '\0');
+                        pch = (unsigned char)*pat++;
+                        if (ishexdigit(pch)) {
+                            pch2 = *pat++;
+                            hi = (hexdigit(pch) << 4) | hexdigit(pch2);
+                        } else {
+                            hi = pch;
+                        } /* if */
+                    } else {
+                      hi = pch;
+                    } /* if */
+
+                    /* Compare character to set range */
+                    if ((fch) >= (lo) && (fch) <= (hi)) {
+                        match = yes;
+                        /* skip to the end of the set in the pattern (no need to
+                         * search further once a match is found)
+                         */
+                        while (*pat != FPAT_SET_R) {
+                            assert(*pat != '\0');
+                            pat++;
+                        } /* while */
+                        break;
+                    } /* if */
+                } else {
+                    /* Compare character to single char from set */
+                    if ((fch) == (lo)) {
+                        match = yes;
+                        /* skip to the end of the set in the pattern (no need to
+                         * search further once a match is found)
+                         */
+                        while (*pat != FPAT_SET_R) {
+                            assert(*pat != '\0');
+                            pat++;
+                        } /* while */
+                        break;
+                    } /* if */
+                } /* if */
+
+                assert(*pat != '\0');
+            } /* while */
+
+            if (!match)
+                return (FALSE);
+
+            fname++;
+            flength--;
+            assert(*pat == FPAT_SET_R);
+            pat++;
+            break;
+
+#if defined FPAT_MSET_ENABLED
+        case FPAT_MSET_L:
+            /* Match zero or more characters in a char set/range */
+            yes = TRUE;
+            if (*pat == FPAT_NOT) {
+               pat++;
+               yes = FALSE; /* Set negation */
+            } /* if */
+
+            do {
+                const char *org_pat = pat;
+                /* Look for [s], [-], [abc], [a-c] */
+                match = !yes;
+                while (*pat != FPAT_MSET_R) {
+                    assert(*pat != '\0');
+                    pch = (unsigned char)*pat++;
+                    if (pch == FPAT_QUOTE) {
+                        assert(*pat != '\0');
+                        pch = (unsigned char)*pat++;
+                        if (ishexdigit(pch)) {
+                            pch2 = *pat++;
+                            lo = (hexdigit(pch) << 4) | hexdigit(pch2);
+                        } else {
+                            lo = pch;
+                        } /* if */
+                    } else {
+                        lo = pch;
+                    } /* if */
+
+                    if (*pat == FPAT_SET_THRU) {
+                        /* Range */
+                        pat++;
+                        pch = (unsigned char)*pat++;
+
+                        if (pch == FPAT_QUOTE) {
+                            assert(*pat != '\0');
+                            pch = (unsigned char)*pat++;
+                            if (ishexdigit(pch)) {
+                                pch2 = *pat++;
+                                hi = (hexdigit(pch) << 4) | hexdigit(pch2);
+                            } else {
+                                hi = pch;
+                            } /* if */
+                        } else {
+                            hi = pch;
+                        } /* if */
+
+                        /* Compare character to set range */
+                        if ((fch) >= (lo) && (fch) <= (hi)) {
+                            match = yes;
+                            /* skip to the end of the set in the pattern (no
+                             * need to search further once a match is found)
+                             */
+                            while (*pat != FPAT_MSET_R) {
+                                assert(*pat != '\0');
+                                pat++;
+                            } /* while */
+                            break;
+                        } /* if */
+                    } else {
+                        /* Compare character to single char from the set */
+                        if ((fch) == (lo)) {
+                            match = yes;
+                            /* skip to the end of the set in the pattern (no
+                             * need to search further once a match is found)
+                             */
+                            while (*pat != FPAT_MSET_R) {
+                                assert(*pat != '\0');
+                                pat++;
+                            } /* while */
+                            break;
+                        } /* if */
+                    } /* if */
+
+                    assert(*pat != '\0');
+                } /* while */
+
+                assert(*pat == FPAT_MSET_R);
+
+                if (match) {
+                    fname++;
+                    flength--;
+                    fch = *fname;
+                    if (flength > 0)
+                        pat = org_pat;
+                } /* if */
+
+            } while (match && flength > 0);
+
+            pat++;
+            break;
+#endif  /* FPAT_MSET_ENABLED */
+
+#if defined FPAT_NOT_ENABLED
+        case FPAT_NOT:
+            /* Match only if rest of pattern does not match */
+            assert(*pat != '\0');
+            i = fpattern_submatch(pat, fname, flength);
+            return !i;
+#endif
+
+#if defined FPAT_DELIM
+        case FPAT_DEL:
+    #if FPAT_DEL2 != FPAT_DEL
+        case FPAT_DEL2:
+    #endif
+            /* Match path delimiter char */
+            if (fch != FPAT_DEL  &&  fch != FPAT_DEL2)
+                return (FALSE);
+            fname++;
+            flength--;
+            break;
+#endif
+
+        default:
+            /* Match a (non-null) char exactly */
+            if ((fch) != (pch))
+                return (FALSE);
+            fname++;
+            flength--;
+            break;
+        }
+    }
+
+    /* Check for complete match */
+    if (flength != 0)
+        return (FALSE);
+
+    /* Successful match */
+    return (TRUE);
+}
+
+
+/*-----------------------------------------------------------------------------
+* fpattern_match()
+*   Attempts to match pattern 'pat' to filename 'fname'. The comparison is case
+* sensitive if 'keepcase' is true, and case insensitive otherwise. The 'flength'
+* parameter allows to check partial strings, or to check strings with embedded
+* zero bytes. When 'flength' is -1, it is set to the string length.
+*
+* Returns
+*   1 (true) if the filename matches, otherwise 0 (false).
+*
+* Caveats
+*   If 'fname' is null, zero (false) is returned.
+*
+*   If 'pat' is null, zero (false) is returned.
+*
+*   If 'pat' is empty (""), the only filename it matches is the empty
+*   string ("").
+*
+*   If 'fname' is empty, the only pattern that will match it is the empty
+*   string ("").
+*
+*   If 'pat' is not a well-formed pattern, zero (false) is returned.
+*
+*   Upper and lower case letters are treated the same; alphabetic
+*   characters are converted to lower case before matching occurs.
+*   Conversion to lower case is dependent upon the current locale setting.
+*/
+
+int fpattern_match(const char *pat, const char *fname, int flength, int keepcase)
+{
+    int     rc;
+
+    /* Check args */
+    if (fname == NULL)
+        return (FALSE);
+
+    if (pat == NULL)
+        return (FALSE);
+
+    /* Verify that the pattern is valid, and get its length */
+    if (!fpattern_isvalid(pat))
+        return (FALSE);
+
+    /* Attempt to match pattern against filename */
+    if (flength < 0)
+        flength = (int)strlen(fname);
+    if (flength == 0)
+        return (pat[0] == '\0');    /* Special case */
+    if (keepcase)
+        rc = fpattern_submatch(pat, fname, flength);
+    else
+        rc = fpattern_submatch_tolower(pat, fname, flength);
+
+    return (rc);
+}
+
+
+/*-----------------------------------------------------------------------------
+* fpattern_matchn()
+*   Attempts to match pattern 'pat' to filename 'fname'.
+*   This operates like fpattern_match() except that it does not verify that
+*   pattern 'pat' is well-formed, assuming that it has been checked by a
+*   prior call to fpattern_isvalid().
+*
+*   NOTA BENE: this function may crash on invalid patterns!
+*   =======================================================
+*
+* Returns
+*   1 (true) if the filename matches, otherwise 0 (false).
+*
+* Caveats
+*   If 'fname' is null, zero (false) is returned.
+*
+*   If 'pat' is null, zero (false) is returned.
+*
+*   If 'pat' is empty (""), the only filename it matches is the empty ("")
+*   string.
+*
+*   If 'pat' is not a well-formed pattern, unpredictable results may occur.
+*
+*   Upper and lower case letters are treated the same; alphabetic
+*   characters are converted to lower case before matching occurs.
+*   Conversion to lower case is dependent upon the current locale setting.
+*
+* See also
+*   fpattern_match().
+*/
+
+int fpattern_matchn(const char *pat, const char *fname, int flength, int keepcase)
+{
+    int     rc;
+
+    /* Check args */
+    if (fname == NULL)
+        return (FALSE);
+
+    if (pat == NULL)
+        return (FALSE);
+
+    /* Assume that pattern is well-formed
+     * NOTA BENE: this function may crash on invalid patterns!
+     */
+    assert(fpattern_isvalid(pat));
+
+    /* Attempt to match pattern against filename */
+    if (flength < 0)
+        flength = (int)strlen(fname);
+    if (keepcase)
+        rc = fpattern_submatch(pat, fname, flength);
+    else
+        rc = fpattern_submatch_tolower(pat, fname, flength);
+
+    return (rc);
+}
+
+/* returns the largest packet that matches the pattern */
+int fpattern_matchcount(const char *pat, const char *fname, int flength, int minlength, int keepcase)
+{
+    int len;
+
+    if (fname == NULL)
+        return (FALSE);
+
+    if (pat == NULL)
+        return (FALSE);
+
+    /* Assume that pattern is well-formed */
+
+    /* Attempt to match pattern against filename */
+    if (flength < 0)
+        flength = (int)strlen(fname);
+
+    if (keepcase) {
+        for (len = flength; len > minlength; len--)
+            if (fpattern_submatch(pat, fname, len))
+                break;
+    } else {
+        for (len = flength; len > minlength; len--)
+            if (fpattern_submatch_tolower(pat, fname, len))
+                break;
+    } /* if */
+
+    return (len > minlength) ? len : 0;
+}
+
+
+/*---------------------------------------------------------------------------*/
+/*---------------------------------------------------------------------------*/
+/*---------------------------------------------------------------------------*/
+
+#ifdef TEST
+
+#include <locale.h>
+#include <stdio.h>
+#if defined _WIN32 || defined __WIN32__ || defined WIN32
+# include <stdlib.h>
+# define sleep(q) Sleep(q*1000)
+# include <windows.h>
+#endif
+
+/* Local variables */
+
+static int  count = 0;
+static int  fails = 0;
+static int  stop_on_fail = FALSE;
+
+
+/*-----------------------------------------------------------------------------
+* test()
+*/
+
+static void test(int expect, const char *fname, const char *pat)
+{
+    int     failed;
+    int     result;
+    char    fbuf[80+1];
+    char    pbuf[80+1];
+
+    count++;
+    printf("%3d. ", count);
+
+    if (fname == NULL)
+    {
+        printf("<null>\n");
+    }
+    else
+    {
+        strcpy(fbuf, fname);
+        printf("\"%s\"\n", fbuf);
+    }
+
+    if (pat == NULL)
+    {
+        printf("     <null>\n");
+    }
+    else
+    {
+        strcpy(pbuf, pat);
+        printf("     \"%s\"\n", pbuf);
+    }
+
+    result = fpattern_match(pat == NULL ? NULL : pbuf,
+                            fname == NULL ? NULL : fbuf,
+                            -1, FALSE);
+
+    failed = (result != expect);
+    printf("    -> %c, expected %c: %s\n",
+        "FT"[!!result], "FT"[!!expect], failed ? "FAIL ***" : "pass");
+
+    if (failed)
+    {
+        fails++;
+
+        if (stop_on_fail)
+            exit(1);
+        sleep(1);
+    }
+
+    printf("\n");
+}
+
+
+/*-----------------------------------------------------------------------------
+* main()
+*   Test driver.
+*/
+
+int main(int argc, char **argv)
+{
+    (void) argc;    /* Shut up lint */
+    (void) argv;    /* Shut up lint */
+
+#if DEBUG
+    dbg_f = stdout;
+#endif
+
+    printf("==========================================\n");
+
+    setlocale(LC_CTYPE, "");
+
+#if 1   /* Set to nonzero to stop on first failure */
+    stop_on_fail = TRUE;
+#endif
+
+    test(0, NULL,   NULL);
+    test(0, NULL,   "");
+    test(0, NULL,   "abc");
+    test(0, "", NULL);
+    test(0, "abc",  NULL);
+
+    test(1, "abc",      "abc");
+    test(0, "ab",       "abc");
+    test(0, "abcd",     "abc");
+    test(0, "Foo.txt",  "Foo.x");
+    test(1, "Foo.txt",  "Foo.txt");
+    test(1, "Foo.txt",  "foo.txt");
+    test(1, "FOO.txt",  "foo.TXT");
+
+    test(1, "a",        "?");
+    test(1, "foo.txt",  "f??.txt");
+    test(1, "foo.txt",  "???????");
+    test(0, "foo.txt",  "??????");
+    test(0, "foo.txt",  "????????");
+
+    test(1, "*",        "`*");
+    test(1, "A[",       "a`[");
+    test(1, "a`x",      "a``x");
+    test(1, "*`?",      "`*```?");
+    test(1, "a*x",      "a`*x");
+    test(1, "a�",       "a`80");
+    test(0, "a�",       "a`8");
+
+#if defined FPAT_DELIM
+    test(0, "",         "/");
+    test(0, "",         "\\");
+    test(1, "/",        "/");
+    test(1, "/",        "\\");
+    test(1, "\\",       "/");
+    test(1, "\\",       "\\");
+
+    test(1, "a/b",      "a/b");
+    test(1, "a/b",      "a\\b");
+
+    test(1, "/",        "*/*");
+    test(1, "foo/a.c",  "f*/*.?");
+    test(1, "foo/a.c",  "*/*");
+    test(0, "foo/a.c",  "/*/*");
+    test(0, "foo/a.c",  "*/*/");
+
+    test(1, "/",        "~/~");
+    test(1, "foo/a.c",  "f~/~.?");
+    test(0, "foo/a.c",  "~/~");
+    test(1, "foo/abc",  "~/~");
+    test(0, "foo/a.c",  "/~/~");
+    test(0, "foo/a.c",  "~/~/");
+#endif
+
+    test(0, "",         "*");
+    test(1, "a",        "*");
+    test(1, "ab",       "*");
+    test(1, "abc",      "**");
+    test(1, "ab.c",     "*.?");
+    test(1, "ab.c",     "*.*");
+    test(1, "ab.c",     "*?");
+    test(1, "ab.c",     "?*");
+    test(1, "ab.c",     "?*?");
+    test(1, "ab.c",     "?*?*");
+    test(1, "ac",       "a*c");
+    test(1, "axc",      "a*c");
+    test(1, "ax-yyy.c", "a*c");
+    test(1, "ax-yyy.c", "a*x-yyy.c");
+    test(1, "axx/yyy.c",    "a*x/*c");
+
+#ifdef FPAT_SUBCLOS
+    test(0, "",         "~");
+    test(1, "a",        "~");
+    test(1, "ab",       "~");
+    test(1, "abc",      "~~");
+    test(1, "ab.c",     "~.?");
+    test(1, "ab.c",     "~.~");
+    test(0, "ab.c",     "~?");
+    test(0, "ab.c",     "?~");
+    test(0, "ab.c",     "?~?");
+    test(1, "ab.c",     "?~.?");
+    test(1, "ab.c",     "?~?~");
+    test(1, "ac",       "a~c");
+    test(1, "axc",      "a~c");
+    test(0, "ax-yyy.c", "a~c");
+    test(1, "ax-yyyvc", "a~c");
+    test(1, "ax-yyy.c", "a~x-yyy.c");
+    test(0, "axx/yyy.c","a~x/~c");
+    test(1, "axx/yyyvc","a~x/~c");
+#endif
+
+#if defined FPAT_NOT_ENABLED
+    test(0, "a",        "!");
+    test(0, "a",        "!a");
+    test(1, "a",        "!b");
+    test(1, "abc",      "!abb");
+    test(0, "a",        "!*");
+    test(1, "abc",      "!*.?");
+    test(1, "abc",      "!*.*");
+    test(0, "",         "!*");      /*!*/
+    test(0, "",         "!*?");     /*!*/
+    test(0, "a",        "!*?");
+    test(0, "a",        "a!*");
+    test(1, "a",        "a!?");
+    test(1, "a",        "a!*?");
+    test(1, "ab",       "*!?");
+    test(1, "abc",      "*!?");
+    test(0, "ab",       "?!?");
+    test(1, "abc",      "?!?");
+    test(0, "a-b",      "!a[-]b");
+    test(0, "a-b",      "!a[x-]b");
+    test(0, "a=b",      "!a[x-]b");
+    test(0, "a-b",      "!a[x`-]b");
+    test(1, "a=b",      "!a[x`-]b");
+    test(0, "a-b",      "!a[x---]b");
+    test(1, "a=b",      "!a[x---]b");
+#endif
+
+    test(1, "abc",      "a[b]c");
+    test(1, "aBc",      "a[b]c");
+    test(1, "abc",      "a[bB]c");
+    test(1, "abc",      "a[bcz]c");
+    test(1, "azc",      "a[bcz]c");
+    test(0, "ab",       "a[b]c");
+    test(0, "ac",       "a[b]c");
+    test(0, "axc",      "a[b]c");
+
+    test(0, "abc",      "a[!b]c");
+    test(0, "abc",      "a[!bcz]c");
+    test(0, "azc",      "a[!bcz]c");
+    test(0, "ab",       "a[!b]c");
+    test(0, "ac",       "a[!b]c");
+    test(1, "axc",      "a[!b]c");
+    test(1, "axc",      "a[!bcz]c");
+
+    test(1, "a1z",      "a[0-9]z");
+    test(0, "a1",       "a[0-9]z");
+    test(0, "az",       "a[0-9]z");
+    test(0, "axz",      "a[0-9]z");
+    test(1, "a2z",      "a[-0-9]z");
+    test(1, "a-z",      "a[-0-9]z");
+    test(1, "a-b",      "a[-]b");
+    test(0, "a-b",      "a[x-]b");
+    test(0, "a=b",      "a[x-]b");
+    test(1, "a-b",      "a[x`-]b");
+    test(0, "a=b",      "a[x`-]b");
+    test(1, "a-b",      "a[x---]b");
+    test(0, "a=b",      "a[x---]b");
+
+    test(0, "a0z",      "a[!0-9]z");
+    test(1, "aoz",      "a[!0-9]z");
+    test(0, "a1",       "a[!0-9]z");
+    test(0, "az",       "a[!0-9]z");
+    test(0, "a9Z",      "a[!0-9]z");
+    test(1, "acz",      "a[!-0-9]z");
+    test(0, "a7z",      "a[!-0-9]z");
+    test(0, "a-z",      "a[!-0-9]z");
+    test(0, "a-b",      "a[!-]b");
+    test(0, "a-b",      "a[!x-]b");
+    test(0, "a=b",      "a[!x-]b");
+    test(0, "a-b",      "a[!x`-]b");
+    test(1, "a=b",      "a[!x`-]b");
+    test(0, "a-b",      "a[!x---]b");
+    test(1, "a=b",      "a[!x---]b");
+
+    test(1, "a!z",      "a[`!0-9]z");
+    test(1, "a3Z",      "a[`!0-9]z");
+    test(0, "A3Z",      "a[`!0`-9]z");
+    test(1, "a9z",      "a[`!0`-9]z");
+    test(1, "a-z",      "a[`!0`-9]z");
+
+    test(1, "ac",       "a{b}c");
+    test(1, "abc",      "a{b}c");
+    test(1, "abbc",     "a{b}c");
+    test(1, "aBbBc",    "a{b}c");
+    test(1, "abc",      "a{bB}c");
+    test(1, "abc",      "a{bpz}c");
+    test(1, "azc",      "a{bcz}");
+    test(0, "ab",       "a{b}c");
+    test(0, "axc",      "a{b}c");
+
+    assert(fpattern_isvalid("a[`[`]]") == 1);
+    assert(fpattern_isvalid("a{`{`}}") == 2);
+    assert(fpattern_isvalid("a[b-z]") == 1);
+    assert(fpattern_isvalid("a?") == 1);
+    assert(fpattern_isvalid("a{b-z}") == 2);
+    assert(fpattern_isvalid("a*") == 2);
+    assert(fpattern_isvalid("a[aba]") == FPAT_INVALID);
+    assert(fpattern_isvalid("a[z-b]") == FPAT_INVALID);
+    assert(fpattern_isvalid("a[b c ]") == FPAT_INVALID);
+    assert(fpattern_isvalid("a[`a]") == FPAT_INVALID);
+
+    assert(fpattern_isvalid("[`80-`ff]") == FPAT_CLOSED);
+    assert(fpattern_isvalid("[`80-`ff]{`00-`7f}") == FPAT_OPEN);
+    assert(fpattern_isvalid("???") == FPAT_CLOSED);
+    test(1, "\x90\x40\x4f", "[`80-`ff]{`00-`7f}");
+    test(0, "\x90\x40\x4f\x90", "[`80-`ff]{`00-`7f}");
+    test(1, "\x90\x40\x4f", "[`80`90]*");
+
+    printf("%d tests, %d failures\n", count, fails);
+    return (fails == 0 ? 0 : 1);
+}
+
+
+#endif /* TEST */
+
+/* End fpattern.c */
diff --git a/apps/openmw-mp/amx/fpattern.h b/apps/openmw-mp/amx/fpattern.h
new file mode 100644
index 000000000..d4219920e
--- /dev/null
+++ b/apps/openmw-mp/amx/fpattern.h
@@ -0,0 +1,184 @@
+/******************************************************************************
+* fpattern.h
+*	Functions for matching filename patterns to filenames.
+*
+* Usage
+*	Filename patterns are composed of regular (printable) characters which
+*	may comprise a filename as well as special pattern matching characters:
+*
+*	    .		Matches a period (.).
+*			Note that a period in a filename is not treated any
+*			differently than any other character.
+*
+*	    ?		Any.
+*			Matches any single character except '/' or '\'.
+*
+*	    *		Closure.
+*			Matches zero or more occurences of any characters other
+*			than '/' or '\'.
+*			Leading '*' characters are allowed.
+*
+*	    SUB		Substitute (^Z); optionally supported.
+*			Similar to '*', this matches zero or more occurences of
+*			any characters other than '/', '\', or '.'.
+*			Leading '^Z' characters are allowed.
+*
+*	    [ab]	Set.
+*			Matches the single character 'a' or 'b'.
+*			If the dash '-' character is to be included, it must
+*			immediately follow the opening bracket '['.
+*			If the closing bracket ']' character is to be included,
+*			it must be preceded by a quote '`'.
+*
+*	    [a-z]	Range.
+*			Matches a single character in the range 'a' to 'z'.
+*			Ranges and sets may be combined within the same set of
+*			brackets.
+*
+*	    [!R]	Exclusive range.
+*			Matches a single character not in the range 'R'.
+*			If range 'R' includes the dash '-' character, the dash
+*			must immediately follow the caret '!'.
+*
+*	    !		Not; optionally supported.
+*			Makes the following pattern (up to the next '/') match
+*			any filename except those what it would normally match.
+*
+*	    /		Path separator (UNIX and DOS).
+*			Matches a '/' or '\' pathname (directory) separator.
+*			Multiple separators are treated like a single
+*			separator.
+*			A leading separator indicates an absolute pathname.
+*
+*	    \		Path separator (DOS).
+*			Same as the '/' character.
+*			Note that this character must be escaped if used within
+*			string constants ("\\").
+*
+*	    \		Quote (UNIX).
+*			Makes the next character a regular (nonspecial)
+*			character.
+*			Note that to match the quote character itself, it must
+*			be quoted.
+*			Note that this character must be escaped if used within
+*			string constants ("\\").
+*
+*	    `		Quote (DOS).
+*			Makes the next character a regular (nonspecial)
+*			character.
+*			Note that to match the quote character itself, it must
+*			be quoted.
+*
+*	Upper and lower case alphabetic characters are considered identical,
+*	i.e., 'a' and 'A' match each other.
+*	(What constitutes a lowercase letter depends on the current locale
+*	settings.)
+*
+*	Spaces and control characters are treated as normal characters.
+*
+* Examples
+*	The following patterns in the left column will match the filenames in
+*	the middle column and will not match filenames in the right column:
+*
+*	    Pattern	Will Match			Will Not Match
+*	    -------	----------			--------------
+*	    a		a (only)			(anything else)
+*	    a.		a. (only)			(anything else)
+*	    a?c		abc, acc, arc, a.c		a, ac, abbc
+*	    a*c		ac, abc, abbc, acc, a.c		a, ab, acb, bac
+*	    a*		a, ab, abb, a., a.b		b, ba
+*	    *		a, ab, abb, a., .foo, a.foo	(nothing)
+*	    *.		a., ab., abb., a.foo.		a, ab, a.foo, .foo
+*	    *.*		a., a.b, ah.bc.foo		a
+*	    ^Z		a, ab, abb			a., .foo, a.foo
+*	    ^Z.		a., ab., abb.			a, .foo, a.foo
+*	    ^Z.*	a, a., .foo, a.foo		ab, abb
+*	    *2.c	2.c, 12.c, foo2.c, foo.12.c	2x.c
+*	    a[b-z]c	abc, acc, azc (only)		(anything else)
+*	    [ab0-9]x	ax, bx, 0x, 9x			zx
+*	    a[-.]b	a-b, a.b (only)			(anything else)
+*	    a[!a-z]b	a0b, a.b, a@b			aab, azb, aa0b
+*	    a[!-b]x	a0x, a+x, acx			a-x, abx, axxx
+*	    a[-!b]x	a-x, a!x, abx (only)		(anything else)
+*	    a[`]]x	a]x (only)			(anything else)
+*	    a``x	a`x (only)			(anything else)
+*	    oh`!	oh! (only)			(anything else)
+*	    is`?it	is?it (only)			(anything else)
+*	    !a?c	a, ac, ab, abb, acb, a.foo      abc, a.c, azc
+*
+* History
+*	1.00 1997-01-03 David Tribble.
+*		First cut.
+*	1.01 1997-01-03 David Tribble.
+*		Added '^Z' pattern character.
+*		Added fpattern_matchn().
+*	1.02 1997-01-26 David Tribble.
+*		Changed range negation character from '^' to '!', ala Unix.
+*	1.03 1997-08-02 David Tribble.
+*		Added 'FPAT_XXX' macro constants.
+*
+* Limitations
+*	This code is copyrighted by the author, but permission is hereby
+*	granted for its unlimited use provided that the original copyright
+*	and authorship notices are retained intact.
+*
+*	Other queries can be sent to:
+*	    dtribble@technologist.com
+*	    david.tribble@beasys.com
+*	    dtribble@flash.net
+*
+* Copyright �1997 by David R. Tribble, all rights reserved.
+*/
+
+
+#ifndef fpattern_h
+#define fpattern_h	1
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+
+/* Options */
+
+//#define FPAT_DELIM        /* handle path delimiters in a special way */
+//#define FPAT_SUBCLOS      /* support alternative closure */
+//#define FPAT_NOT_ENABLED  /* !pattern is enabled */
+#define FPAT_MSET_ENABLED   /* multi-set/range is enabled */
+
+
+/* Manifest constants */
+
+#define FPAT_QUOTE	'`'		/* Quotes a special char	*/
+#define FPAT_DEL	'/'		/* Path delimiter (used only when FPAT_DELIM is true) */
+#define FPAT_DEL2	'\\'	/* Path delimiter (used only when FPAT_DELIM is true) */
+#define FPAT_DOT	'.'		/* Dot char */
+#define FPAT_NOT	'!'		/* Exclusion (also used for sets) */
+#define FPAT_ANY	'?'		/* Any one char */
+#define FPAT_CLOS	'*'		/* Zero or more chars */
+#define FPAT_CLOSP	'\x1A'	/* Zero or more nondelimiters (used only when FPAT_SUBCLOS is true) */
+#define FPAT_SET_L	'[' 	/* Set/range open bracket	*/
+#define FPAT_SET_R	']' 	/* Set/range close bracket	*/
+#define FPAT_MSET_L	'{' 	/* Multi-set/range open bracket	*/
+#define FPAT_MSET_R	'}' 	/* Multi-set/range close bracket*/
+#define FPAT_SET_THRU	'-'	/* Set range of chars		*/
+
+
+#define FPAT_INVALID	0	/* invalid pattern */
+#define FPAT_CLOSED		1	/* valid pattern */
+#define FPAT_OPEN		2	/* valid pattern */
+
+
+/* Public functions */
+
+extern int	fpattern_isvalid(const char *pat);
+extern int	fpattern_match(const char *pat, const char *fname, int flength, int keepcase);
+extern int	fpattern_matchn(const char *pat, const char *fname, int flength, int keepcase);
+extern int	fpattern_matchcount(const char *pat, const char *fname, int flength, int minlength, int keepcase);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* fpattern_h */
diff --git a/apps/openmw-mp/amx/linux/binreloc.c b/apps/openmw-mp/amx/linux/binreloc.c
new file mode 100644
index 000000000..c6dc0ae70
--- /dev/null
+++ b/apps/openmw-mp/amx/linux/binreloc.c
@@ -0,0 +1,766 @@
+/*
+ * BinReloc - a library for creating relocatable executables
+ * Written by: Hongli Lai <h.lai@chello.nl>
+ * http://autopackage.org/
+ *
+ * This source code is public domain. You can relicense this code
+ * under whatever license you want.
+ *
+ * See http://autopackage.org/docs/binreloc/ for
+ * more information and how to use this.
+ */
+
+#ifndef __BINRELOC_C__
+#define __BINRELOC_C__
+
+#ifdef ENABLE_BINRELOC
+	#include <sys/types.h>
+	#include <sys/stat.h>
+	#include <unistd.h>
+#endif /* ENABLE_BINRELOC */
+#include <stdio.h>
+#include <stdlib.h>
+#include <limits.h>
+#include <string.h>
+#include "binreloc.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+
+/** @internal
+ * Find the canonical filename of the executable. Returns the filename
+ * (which must be freed) or NULL on error. If the parameter 'error' is
+ * not NULL, the error code will be stored there, if an error occured.
+ */
+static char *
+_br_find_exe (BrInitError *error)
+{
+#ifndef ENABLE_BINRELOC
+	if (error)
+		*error = BR_INIT_ERROR_DISABLED;
+	return NULL;
+#else
+	char *path, *path2, *line, *result;
+	size_t buf_size;
+	ssize_t size;
+	struct stat stat_buf;
+	FILE *f;
+
+	/* Read from /proc/self/exe (symlink) */
+	if (sizeof (path) > SSIZE_MAX)
+		buf_size = SSIZE_MAX - 1;
+	else
+		buf_size = PATH_MAX - 1;
+	path = (char *) malloc (buf_size);
+	if (path == NULL) {
+		/* Cannot allocate memory. */
+		if (error)
+			*error = BR_INIT_ERROR_NOMEM;
+		return NULL;
+	}
+	path2 = (char *) malloc (buf_size);
+	if (path2 == NULL) {
+		/* Cannot allocate memory. */
+		if (error)
+			*error = BR_INIT_ERROR_NOMEM;
+		free (path);
+		return NULL;
+	}
+
+	strncpy (path2, "/proc/self/exe", buf_size - 1);
+
+	while (1) {
+		int i;
+
+		size = readlink (path2, path, buf_size - 1);
+		if (size == -1) {
+			/* Error. */
+			free (path2);
+			break;
+		}
+
+		/* readlink() success. */
+		path[size] = '\0';
+
+		/* Check whether the symlink's target is also a symlink.
+		 * We want to get the final target. */
+		i = stat (path, &stat_buf);
+		if (i == -1) {
+			/* Error. */
+			free (path2);
+			break;
+		}
+
+		/* stat() success. */
+		if (!S_ISLNK (stat_buf.st_mode)) {
+			/* path is not a symlink. Done. */
+			free (path2);
+			return path;
+		}
+
+		/* path is a symlink. Continue loop and resolve this. */
+		strncpy (path, path2, buf_size - 1);
+	}
+
+
+	/* readlink() or stat() failed; this can happen when the program is
+	 * running in Valgrind 2.2. Read from /proc/self/maps as fallback. */
+
+	buf_size = PATH_MAX + 128;
+	line = (char *) realloc (path, buf_size);
+	if (line == NULL) {
+		/* Cannot allocate memory. */
+		free (path);
+		if (error)
+			*error = BR_INIT_ERROR_NOMEM;
+		return NULL;
+	}
+
+	f = fopen ("/proc/self/maps", "r");
+	if (f == NULL) {
+		free (line);
+		if (error)
+			*error = BR_INIT_ERROR_OPEN_MAPS;
+		return NULL;
+	}
+
+	/* The first entry should be the executable name. */
+	result = fgets (line, (int) buf_size, f);
+	if (result == NULL) {
+		fclose (f);
+		free (line);
+		if (error)
+			*error = BR_INIT_ERROR_READ_MAPS;
+		return NULL;
+	}
+
+	/* Get rid of newline character. */
+	buf_size = strlen (line);
+	if (buf_size <= 0) {
+		/* Huh? An empty string? */
+		fclose (f);
+		free (line);
+		if (error)
+			*error = BR_INIT_ERROR_INVALID_MAPS;
+		return NULL;
+	}
+	if (line[buf_size - 1] == 10)
+		line[buf_size - 1] = 0;
+
+	/* Extract the filename; it is always an absolute path. */
+	path = strchr (line, '/');
+
+	/* Sanity check. */
+	if (strstr (line, " r-xp ") == NULL || path == NULL) {
+		fclose (f);
+		free (line);
+		if (error)
+			*error = BR_INIT_ERROR_INVALID_MAPS;
+		return NULL;
+	}
+
+	path = strdup (path);
+	free (line);
+	fclose (f);
+	return path;
+#endif /* ENABLE_BINRELOC */
+}
+
+
+/** @internal
+ * Find the canonical filename of the executable which owns symbol.
+ * Returns a filename which must be freed, or NULL on error.
+ */
+static char *
+_br_find_exe_for_symbol (const void *symbol, BrInitError *error)
+{
+#ifndef ENABLE_BINRELOC
+	if (error)
+		*error = BR_INIT_ERROR_DISABLED;
+	return (char *) NULL;
+#else
+	#define SIZE PATH_MAX + 100
+	FILE *f;
+	size_t address_string_len;
+	char *address_string, line[SIZE], *found;
+
+	if (symbol == NULL)
+		return (char *) NULL;
+
+	f = fopen ("/proc/self/maps", "r");
+	if (f == NULL)
+		return (char *) NULL;
+
+	address_string_len = 4;
+	address_string = (char *) malloc (address_string_len);
+	found = (char *) NULL;
+
+	while (!feof (f)) {
+		char *start_addr, *end_addr, *end_addr_end, *file;
+		void *start_addr_p, *end_addr_p;
+		size_t len;
+
+		if (fgets (line, SIZE, f) == NULL)
+			break;
+
+		/* Sanity check. */
+		if (strstr (line, " r-xp ") == NULL || strchr (line, '/') == NULL)
+			continue;
+
+		/* Parse line. */
+		start_addr = line;
+		end_addr = strchr (line, '-');
+		file = strchr (line, '/');
+
+		/* More sanity check. */
+		if (!(file > end_addr && end_addr != NULL && end_addr[0] == '-'))
+			continue;
+
+		end_addr[0] = '\0';
+		end_addr++;
+		end_addr_end = strchr (end_addr, ' ');
+		if (end_addr_end == NULL)
+			continue;
+
+		end_addr_end[0] = '\0';
+		len = strlen (file);
+		if (len == 0)
+			continue;
+		if (file[len - 1] == '\n')
+			file[len - 1] = '\0';
+
+		/* Get rid of "(deleted)" from the filename. */
+		len = strlen (file);
+		if (len > 10 && strcmp (file + len - 10, " (deleted)") == 0)
+			file[len - 10] = '\0';
+
+		/* I don't know whether this can happen but better safe than sorry. */
+		len = strlen (start_addr);
+		if (len != strlen (end_addr))
+			continue;
+
+
+		/* Transform the addresses into a string in the form of 0xdeadbeef,
+		 * then transform that into a pointer. */
+		if (address_string_len < len + 3) {
+			address_string_len = len + 3;
+			address_string = (char *) realloc (address_string, address_string_len);
+		}
+
+		memcpy (address_string, "0x", 2);
+		memcpy (address_string + 2, start_addr, len);
+		address_string[2 + len] = '\0';
+		sscanf (address_string, "%p", &start_addr_p);
+
+		memcpy (address_string, "0x", 2);
+		memcpy (address_string + 2, end_addr, len);
+		address_string[2 + len] = '\0';
+		sscanf (address_string, "%p", &end_addr_p);
+
+
+		if (symbol >= start_addr_p && symbol < end_addr_p) {
+			found = file;
+			break;
+		}
+	}
+
+	free (address_string);
+	fclose (f);
+
+	if (found == NULL)
+		return (char *) NULL;
+	else
+		return strdup (found);
+#endif /* ENABLE_BINRELOC */
+}
+
+
+#ifndef BINRELOC_RUNNING_DOXYGEN
+	#undef NULL
+	#define NULL ((void *) 0) /* typecasted as char* for C++ type safeness */
+#endif
+
+static char *exe = (char *) NULL;
+
+
+/** Initialize the BinReloc library (for applications).
+ *
+ * This function must be called before using any other BinReloc functions.
+ * It attempts to locate the application's canonical filename.
+ *
+ * @note If you want to use BinReloc for a library, then you should call
+ *       br_init_lib() instead.
+ *
+ * @param error  If BinReloc failed to initialize, then the error code will
+ *               be stored in this variable. Set to NULL if you want to
+ *               ignore this. See #BrInitError for a list of error codes.
+ *
+ * @returns 1 on success, 0 if BinReloc failed to initialize.
+ */
+int
+br_init (BrInitError *error)
+{
+	exe = _br_find_exe (error);
+	return exe != NULL;
+}
+
+
+/** Initialize the BinReloc library (for libraries).
+ *
+ * This function must be called before using any other BinReloc functions.
+ * It attempts to locate the calling library's canonical filename.
+ *
+ * @note The BinReloc source code MUST be included in your library, or this
+ *       function won't work correctly.
+ *
+ * @param error  If BinReloc failed to initialize, then the error code will
+ *               be stored in this variable. Set to NULL if you want to
+ *               ignore this. See #BrInitError for a list of error codes.
+ *
+ * @returns 1 on success, 0 if a filename cannot be found.
+ */
+int
+br_init_lib (BrInitError *error)
+{
+	exe = _br_find_exe_for_symbol ((const void *) "", error);
+	return exe != NULL;
+}
+
+
+/** Find the canonical filename of the current application.
+ *
+ * @param default_exe  A default filename which will be used as fallback.
+ * @returns A string containing the application's canonical filename,
+ *          which must be freed when no longer necessary. If BinReloc is
+ *          not initialized, or if br_init() failed, then a copy of
+ *          default_exe will be returned. If default_exe is NULL, then
+ *          NULL will be returned.
+ */
+char *
+br_find_exe (const char *default_exe)
+{
+	if (exe == (char *) NULL) {
+		/* BinReloc is not initialized. */
+		if (default_exe != (const char *) NULL)
+			return strdup (default_exe);
+		else
+			return (char *) NULL;
+	}
+	return strdup (exe);
+}
+
+
+/** Locate the directory in which the current application is installed.
+ *
+ * The prefix is generated by the following pseudo-code evaluation:
+ * \code
+ * dirname(exename)
+ * \endcode
+ *
+ * @param default_dir  A default directory which will used as fallback.
+ * @return A string containing the directory, which must be freed when no
+ *         longer necessary. If BinReloc is not initialized, or if the
+ *         initialization function failed, then a copy of default_dir
+ *         will be returned. If default_dir is NULL, then NULL will be
+ *         returned.
+ */
+char *
+br_find_exe_dir (const char *default_dir)
+{
+	if (exe == NULL) {
+		/* BinReloc not initialized. */
+		if (default_dir != NULL)
+			return strdup (default_dir);
+		else
+			return NULL;
+	}
+
+	return br_dirname (exe);
+}
+
+
+/** Locate the prefix in which the current application is installed.
+ *
+ * The prefix is generated by the following pseudo-code evaluation:
+ * \code
+ * dirname(dirname(exename))
+ * \endcode
+ *
+ * @param default_prefix  A default prefix which will used as fallback.
+ * @return A string containing the prefix, which must be freed when no
+ *         longer necessary. If BinReloc is not initialized, or if
+ *         the initialization function failed, then a copy of default_prefix
+ *         will be returned. If default_prefix is NULL, then NULL will be returned.
+ */
+char *
+br_find_prefix (const char *default_prefix)
+{
+	char *dir1, *dir2;
+
+	if (exe == (char *) NULL) {
+		/* BinReloc not initialized. */
+		if (default_prefix != (const char *) NULL)
+			return strdup (default_prefix);
+		else
+			return (char *) NULL;
+	}
+
+	dir1 = br_dirname (exe);
+	dir2 = br_dirname (dir1);
+	free (dir1);
+	return dir2;
+}
+
+
+/** Locate the application's binary folder.
+ *
+ * The path is generated by the following pseudo-code evaluation:
+ * \code
+ * prefix + "/bin"
+ * \endcode
+ *
+ * @param default_bin_dir  A default path which will used as fallback.
+ * @return A string containing the bin folder's path, which must be freed when
+ *         no longer necessary. If BinReloc is not initialized, or if
+ *         the initialization function failed, then a copy of default_bin_dir will
+ *         be returned. If default_bin_dir is NULL, then NULL will be returned.
+ */
+char *
+br_find_bin_dir (const char *default_bin_dir)
+{
+	char *prefix, *dir;
+
+	prefix = br_find_prefix ((const char *) NULL);
+	if (prefix == (char *) NULL) {
+		/* BinReloc not initialized. */
+		if (default_bin_dir != (const char *) NULL)
+			return strdup (default_bin_dir);
+		else
+			return (char *) NULL;
+	}
+
+	dir = br_build_path (prefix, "bin");
+	free (prefix);
+	return dir;
+}
+
+
+/** Locate the application's superuser binary folder.
+ *
+ * The path is generated by the following pseudo-code evaluation:
+ * \code
+ * prefix + "/sbin"
+ * \endcode
+ *
+ * @param default_sbin_dir  A default path which will used as fallback.
+ * @return A string containing the sbin folder's path, which must be freed when
+ *         no longer necessary. If BinReloc is not initialized, or if the
+ *         initialization function failed, then a copy of default_sbin_dir will
+ *         be returned. If default_bin_dir is NULL, then NULL will be returned.
+ */
+char *
+br_find_sbin_dir (const char *default_sbin_dir)
+{
+	char *prefix, *dir;
+
+	prefix = br_find_prefix ((const char *) NULL);
+	if (prefix == (char *) NULL) {
+		/* BinReloc not initialized. */
+		if (default_sbin_dir != (const char *) NULL)
+			return strdup (default_sbin_dir);
+		else
+			return (char *) NULL;
+	}
+
+	dir = br_build_path (prefix, "sbin");
+	free (prefix);
+	return dir;
+}
+
+
+/** Locate the application's data folder.
+ *
+ * The path is generated by the following pseudo-code evaluation:
+ * \code
+ * prefix + "/share"
+ * \endcode
+ *
+ * @param default_data_dir  A default path which will used as fallback.
+ * @return A string containing the data folder's path, which must be freed when
+ *         no longer necessary. If BinReloc is not initialized, or if the
+ *         initialization function failed, then a copy of default_data_dir
+ *         will be returned. If default_data_dir is NULL, then NULL will be
+ *         returned.
+ */
+char *
+br_find_data_dir (const char *default_data_dir)
+{
+	char *prefix, *dir;
+
+	prefix = br_find_prefix ((const char *) NULL);
+	if (prefix == (char *) NULL) {
+		/* BinReloc not initialized. */
+		if (default_data_dir != (const char *) NULL)
+			return strdup (default_data_dir);
+		else
+			return (char *) NULL;
+	}
+
+	dir = br_build_path (prefix, "share");
+	free (prefix);
+	return dir;
+}
+
+
+/** Locate the application's localization folder.
+ *
+ * The path is generated by the following pseudo-code evaluation:
+ * \code
+ * prefix + "/share/locale"
+ * \endcode
+ *
+ * @param default_locale_dir  A default path which will used as fallback.
+ * @return A string containing the localization folder's path, which must be freed when
+ *         no longer necessary. If BinReloc is not initialized, or if the
+ *         initialization function failed, then a copy of default_locale_dir will be returned.
+ *         If default_locale_dir is NULL, then NULL will be returned.
+ */
+char *
+br_find_locale_dir (const char *default_locale_dir)
+{
+	char *data_dir, *dir;
+
+	data_dir = br_find_data_dir ((const char *) NULL);
+	if (data_dir == (char *) NULL) {
+		/* BinReloc not initialized. */
+		if (default_locale_dir != (const char *) NULL)
+			return strdup (default_locale_dir);
+		else
+			return (char *) NULL;
+	}
+
+	dir = br_build_path (data_dir, "locale");
+	free (data_dir);
+	return dir;
+}
+
+
+/** Locate the application's library folder.
+ *
+ * The path is generated by the following pseudo-code evaluation:
+ * \code
+ * prefix + "/lib"
+ * \endcode
+ *
+ * @param default_lib_dir  A default path which will used as fallback.
+ * @return A string containing the library folder's path, which must be freed when
+ *         no longer necessary. If BinReloc is not initialized, or if the initialization
+ *         function failed, then a copy of default_lib_dir will be returned.
+ *         If default_lib_dir is NULL, then NULL will be returned.
+ */
+char *
+br_find_lib_dir (const char *default_lib_dir)
+{
+	char *prefix, *dir;
+
+	prefix = br_find_prefix ((const char *) NULL);
+	if (prefix == (char *) NULL) {
+		/* BinReloc not initialized. */
+		if (default_lib_dir != (const char *) NULL)
+			return strdup (default_lib_dir);
+		else
+			return (char *) NULL;
+	}
+
+	dir = br_build_path (prefix, "lib");
+	free (prefix);
+	return dir;
+}
+
+
+/** Locate the application's libexec folder.
+ *
+ * The path is generated by the following pseudo-code evaluation:
+ * \code
+ * prefix + "/libexec"
+ * \endcode
+ *
+ * @param default_libexec_dir  A default path which will used as fallback.
+ * @return A string containing the libexec folder's path, which must be freed when
+ *         no longer necessary. If BinReloc is not initialized, or if the initialization
+ *         function failed, then a copy of default_libexec_dir will be returned.
+ *         If default_libexec_dir is NULL, then NULL will be returned.
+ */
+char *
+br_find_libexec_dir (const char *default_libexec_dir)
+{
+	char *prefix, *dir;
+
+	prefix = br_find_prefix ((const char *) NULL);
+	if (prefix == (char *) NULL) {
+		/* BinReloc not initialized. */
+		if (default_libexec_dir != (const char *) NULL)
+			return strdup (default_libexec_dir);
+		else
+			return (char *) NULL;
+	}
+
+	dir = br_build_path (prefix, "libexec");
+	free (prefix);
+	return dir;
+}
+
+
+/** Locate the application's configuration files folder.
+ *
+ * The path is generated by the following pseudo-code evaluation:
+ * \code
+ * prefix + "/etc"
+ * \endcode
+ *
+ * @param default_etc_dir  A default path which will used as fallback.
+ * @return A string containing the etc folder's path, which must be freed when
+ *         no longer necessary. If BinReloc is not initialized, or if the initialization
+ *         function failed, then a copy of default_etc_dir will be returned.
+ *         If default_etc_dir is NULL, then NULL will be returned.
+ */
+char *
+br_find_etc_dir (const char *default_etc_dir)
+{
+	char *prefix, *dir;
+
+	prefix = br_find_prefix ((const char *) NULL);
+	if (prefix == (char *) NULL) {
+		/* BinReloc not initialized. */
+		if (default_etc_dir != (const char *) NULL)
+			return strdup (default_etc_dir);
+		else
+			return (char *) NULL;
+	}
+
+	dir = br_build_path (prefix, "etc");
+	free (prefix);
+	return dir;
+}
+
+
+/***********************
+ * Utility functions
+ ***********************/
+
+/** Concatenate str1 and str2 to a newly allocated string.
+ *
+ * @param str1 A string.
+ * @param str2 Another string.
+ * @returns A newly-allocated string. This string should be freed when no longer needed.
+ */
+char *
+br_strcat (const char *str1, const char *str2)
+{
+	char *result;
+	size_t len1, len2;
+
+	if (str1 == NULL)
+		str1 = "";
+	if (str2 == NULL)
+		str2 = "";
+
+	len1 = strlen (str1);
+	len2 = strlen (str2);
+
+	result = (char *) malloc (len1 + len2 + 1);
+	memcpy (result, str1, len1);
+	memcpy (result + len1, str2, len2);
+	result[len1 + len2] = '\0';
+
+	return result;
+}
+
+
+char *
+br_build_path (const char *dir, const char *file)
+{
+	char *dir2, *result;
+	size_t len;
+	int must_free = 0;
+
+	len = strlen (dir);
+	if (len > 0 && dir[len - 1] != '/') {
+		dir2 = br_strcat (dir, "/");
+		must_free = 1;
+	} else
+		dir2 = (char *) dir;
+
+	result = br_strcat (dir2, file);
+	if (must_free)
+		free (dir2);
+	return result;
+}
+
+
+/* Emulates glibc's strndup() */
+static char *
+br_strndup (const char *str, size_t size)
+{
+	char *result = (char *) NULL;
+	size_t len;
+
+	if (str == (const char *) NULL)
+		return (char *) NULL;
+
+	len = strlen (str);
+	if (len == 0)
+		return strdup ("");
+	if (size > len)
+		size = len;
+
+	result = (char *) malloc (len + 1);
+	memcpy (result, str, size);
+	result[size] = '\0';
+	return result;
+}
+
+
+/** Extracts the directory component of a path.
+ *
+ * Similar to g_dirname() or the dirname commandline application.
+ *
+ * Example:
+ * \code
+ * br_dirname ("/usr/local/foobar");  --> Returns: "/usr/local"
+ * \endcode
+ *
+ * @param path  A path.
+ * @returns     A directory name. This string should be freed when no longer needed.
+ */
+char *
+br_dirname (const char *path)
+{
+	char *end, *result;
+
+	if (path == (const char *) NULL)
+		return (char *) NULL;
+
+	end = strrchr (path, '/');
+	if (end == (const char *) NULL)
+		return strdup (".");
+
+	while (end > path && *end == '/')
+		end--;
+	result = br_strndup (path, end - path + 1);
+	if (result[0] == 0) {
+		free (result);
+		return strdup ("/");
+	} else
+		return result;
+}
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __BINRELOC_C__ */
diff --git a/apps/openmw-mp/amx/linux/binreloc.h b/apps/openmw-mp/amx/linux/binreloc.h
new file mode 100644
index 000000000..4ee25c298
--- /dev/null
+++ b/apps/openmw-mp/amx/linux/binreloc.h
@@ -0,0 +1,80 @@
+/*
+ * BinReloc - a library for creating relocatable executables
+ * Written by: Hongli Lai <h.lai@chello.nl>
+ * http://autopackage.org/
+ *
+ * This source code is public domain. You can relicense this code
+ * under whatever license you want.
+ *
+ * See http://autopackage.org/docs/binreloc/ for
+ * more information and how to use this.
+ */
+
+#ifndef __BINRELOC_H__
+#define __BINRELOC_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+/** These error codes can be returned by br_init(), br_init_lib(), gbr_init() or gbr_init_lib(). */
+typedef enum {
+	/** Cannot allocate memory. */
+	BR_INIT_ERROR_NOMEM,
+	/** Unable to open /proc/self/maps; see errno for details. */
+	BR_INIT_ERROR_OPEN_MAPS,
+	/** Unable to read from /proc/self/maps; see errno for details. */
+	BR_INIT_ERROR_READ_MAPS,
+	/** The file format of /proc/self/maps is invalid; kernel bug? */
+	BR_INIT_ERROR_INVALID_MAPS,
+	/** BinReloc is disabled (the ENABLE_BINRELOC macro is not defined). */
+	BR_INIT_ERROR_DISABLED
+} BrInitError;
+
+
+#ifndef BINRELOC_RUNNING_DOXYGEN
+/* Mangle symbol names to avoid symbol collisions with other ELF objects. */
+	#define br_init             SbCJ22537442193159_br_init
+	#define br_init_lib         SbCJ22537442193159_br_init_lib
+	#define br_find_exe         SbCJ22537442193159_br_find_exe
+	#define br_find_exe_dir     SbCJ22537442193159_br_find_exe_dir
+	#define br_find_prefix      SbCJ22537442193159_br_find_prefix
+	#define br_find_bin_dir     SbCJ22537442193159_br_find_bin_dir
+	#define br_find_sbin_dir    SbCJ22537442193159_br_find_sbin_dir
+	#define br_find_data_dir    SbCJ22537442193159_br_find_data_dir
+	#define br_find_locale_dir  SbCJ22537442193159_br_find_locale_dir
+	#define br_find_lib_dir     SbCJ22537442193159_br_find_lib_dir
+	#define br_find_libexec_dir SbCJ22537442193159_br_find_libexec_dir
+	#define br_find_etc_dir     SbCJ22537442193159_br_find_etc_dir
+	#define br_strcat           SbCJ22537442193159_br_strcat
+	#define br_build_path       SbCJ22537442193159_br_build_path
+	#define br_dirname          SbCJ22537442193159_br_dirname
+
+
+#endif
+int   br_init             (BrInitError *error);
+int   br_init_lib         (BrInitError *error);
+
+char *br_find_exe         (const char *default_exe);
+char *br_find_exe_dir     (const char *default_dir);
+char *br_find_prefix      (const char *default_prefix);
+char *br_find_bin_dir     (const char *default_bin_dir);
+char *br_find_sbin_dir    (const char *default_sbin_dir);
+char *br_find_data_dir    (const char *default_data_dir);
+char *br_find_locale_dir  (const char *default_locale_dir);
+char *br_find_lib_dir     (const char *default_lib_dir);
+char *br_find_libexec_dir (const char *default_libexec_dir);
+char *br_find_etc_dir     (const char *default_etc_dir);
+
+/* Utility functions */
+char *br_strcat  (const char *str1, const char *str2);
+char *br_build_path (const char *dir, const char *file);
+char *br_dirname (const char *path);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __BINRELOC_H__ */
diff --git a/apps/openmw-mp/amx/linux/getch.c b/apps/openmw-mp/amx/linux/getch.c
new file mode 100644
index 000000000..6dd3959c2
--- /dev/null
+++ b/apps/openmw-mp/amx/linux/getch.c
@@ -0,0 +1,104 @@
+/* Extremely inefficient but portable POSIX getch() */
+
+#include <stdio.h>
+#include <string.h>
+#include <termios.h>    /* for tcgetattr() and tcsetattr() */
+#include <unistd.h>     /* for read() */
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include "getch.h"
+
+#ifndef STDIN_FILENO
+# define STDIN_FILENO 0
+#endif
+
+int
+getch (void)
+{
+  struct termios save_termios;
+  struct termios ios;
+  unsigned char b;
+  int c = 0;
+
+  if (!isatty (STDIN_FILENO))
+    return EOF;
+
+  if (tcgetattr (STDIN_FILENO, &save_termios) < 0)
+    return EOF;
+
+  ios = save_termios;
+  ios.c_lflag &= ~(ICANON | ECHO | ISIG);
+  ios.c_cc[VMIN] = 1;           /* read() will return with one char */
+  ios.c_cc[VTIME] = 0;          /* read() blocks forever */
+
+  if (tcsetattr (STDIN_FILENO, TCSANOW, &ios) < 0)
+    return EOF;
+
+  if (read (STDIN_FILENO, &b, 1) == 1)
+    c = (int)(0xff & b);
+  else
+    c = EOF;
+
+  tcsetattr (STDIN_FILENO, TCSANOW, &save_termios);
+
+  return c;
+}
+
+int
+kbhit (void)
+{
+  struct termios save_termios;
+  struct termios ios;
+  fd_set inp;
+  struct timeval timeout = {0, 0};
+  int result;
+
+  if (!isatty (STDIN_FILENO))
+    return 0;
+
+  if (tcgetattr (STDIN_FILENO, &save_termios) < 0)
+    return 0;
+
+  ios = save_termios;
+  ios.c_lflag &= ~(ICANON | ECHO | ISIG);
+  ios.c_cc[VMIN] = 1;           /* read() will return with one char */
+  ios.c_cc[VTIME] = 0;          /* read() blocks forever */
+
+  if (tcsetattr (STDIN_FILENO, TCSANOW, &ios) < 0)
+    return 0;
+
+  /* set up select() args */
+  FD_ZERO(&inp);
+  FD_SET(STDIN_FILENO, &inp);
+
+  result = select (STDIN_FILENO+1, &inp, NULL, NULL, &timeout) == 1;
+
+  tcsetattr (STDIN_FILENO, TCSANOW, &save_termios);
+
+  return result;
+}
+
+#if defined TEST_GETCH
+int
+main ()
+{
+  int i;
+  char c[4];
+
+  printf("Enter %d keys to continue: ", sizeof c - 1);
+  fflush (stdout);
+
+  memset(c, 0, sizeof c);
+  for (i=0; i<sizeof c - 1; i++)
+    c[i] = getch ();
+
+  printf("Your input: [%s]\n", c);
+
+  printf("Now hit any key to abort: ");
+  while (!kbhit())
+    printf(".");
+
+  return 0;
+}
+#endif
diff --git a/apps/openmw-mp/amx/linux/getch.h b/apps/openmw-mp/amx/linux/getch.h
new file mode 100644
index 000000000..71cdd83b9
--- /dev/null
+++ b/apps/openmw-mp/amx/linux/getch.h
@@ -0,0 +1,15 @@
+/* Extremely inefficient but portable POSIX getch(), see getch.c */
+#ifndef GETCH_H
+#define GETCH_H
+
+#if defined __cplusplus
+  extern "C" {
+#endif
+int getch(void);
+int kbhit(void);
+
+#if defined __cplusplus
+}
+#endif
+
+#endif /* GETCH_H */
diff --git a/apps/openmw-mp/amx/linux/sclinux.h b/apps/openmw-mp/amx/linux/sclinux.h
new file mode 100644
index 000000000..6c0f9d5ba
--- /dev/null
+++ b/apps/openmw-mp/amx/linux/sclinux.h
@@ -0,0 +1,49 @@
+/*
+ * Things needed to compile under linux.
+ *
+ * Should be reworked totally to use GNU's 'configure'
+ */
+#ifndef SCLINUX_H
+#define SCLINUX_H
+
+/* getchar() is not a 'cool' replacement for MSDOS getch: Linux/unix depends on the features activated or not about the
+ * controlling terminal's tty. This means that ioctl(2) calls must be performed, for instance to have the controlling
+ * terminal tty's in 'raw' mode, if we want to be able to fetch a single character. This also means that everything must
+ * be put back correctly when the function ends. See GETCH.C for an implementation.
+ *
+ * For interactive use of PawnRun/PawnDbg if would be much better to use GNU's readline package: the user would be able to
+ * have a complete emacs/vi like line editing system.
+ */
+#if !defined getch && !defined kbhit
+  #include "getch.h"
+#endif
+
+#define	stricmp(a,b)    strcasecmp(a,b)
+#define	strnicmp(a,b,c) strncasecmp(a,b,c)
+
+/*
+ * WinWorld wants '\'. Unices do not.
+ */
+#define	DIRECTORY_SEP_CHAR      '/'
+#define	DIRECTORY_SEP_STR       "/"
+
+/*
+ * SC assumes that a computer is Little Endian unless told otherwise. It uses
+ * (and defines) the macros BYTE_ORDER and BIG_ENDIAN.
+ * For Linux, we must overrule these settings with those defined in glibc.
+ */
+#if !defined __BYTE_ORDER
+# include <stdlib.h>
+#endif
+
+#if defined __OpenBSD__ || defined __FreeBSD__ || defined __APPLE__
+# define __BYTE_ORDER    BYTE_ORDER
+# define __LITTLE_ENDIAN LITTLE_ENDIAN
+# define __BIG_ENDIAN    BIG_ENDIAN
+#endif
+
+#if !defined __BYTE_ORDER
+# error	"Can't figure computer byte order (__BYTE_ORDER macro not found)"
+#endif
+
+#endif /* SCLINUX_H */
diff --git a/apps/openmw-mp/amx/minGlue.h b/apps/openmw-mp/amx/minGlue.h
new file mode 100644
index 000000000..2d47d90e0
--- /dev/null
+++ b/apps/openmw-mp/amx/minGlue.h
@@ -0,0 +1,31 @@
+/*  Glue functions for the minIni library, based on the C/C++ stdio library
+ *
+ *  Or better said: this file contains macros that maps the function interface
+ *  used by minIni to the standard C/C++ file I/O functions.
+ *
+ *  By CompuPhase, 2008-2014
+ *  This "glue file" is in the public domain. It is distributed without
+ *  warranties or conditions of any kind, either express or implied.
+ */
+
+/* map required file I/O types and functions to the standard C library */
+#include <stdio.h>
+
+#define INI_FILETYPE                    FILE*
+#define ini_openread(filename,file)     ((*(file) = fopen((filename),"rb")) != NULL)
+#define ini_openwrite(filename,file)    ((*(file) = fopen((filename),"wb")) != NULL)
+#define ini_openrewrite(filename,file)  ((*(file) = fopen((filename),"r+b")) != NULL)
+#define ini_close(file)                 (fclose(*(file)) == 0)
+#define ini_read(buffer,size,file)      (fgets((buffer),(size),*(file)) != NULL)
+#define ini_write(buffer,file)          (fputs((buffer),*(file)) >= 0)
+#define ini_rename(source,dest)         (rename((source), (dest)) == 0)
+#define ini_remove(filename)            (remove(filename) == 0)
+
+#define INI_FILEPOS                     long int
+#define ini_tell(file,pos)              (*(pos) = ftell(*(file)))
+#define ini_seek(file,pos)              (fseek(*(file), *(pos), SEEK_SET) == 0)
+
+/* for floating-point support, define additional types and functions */
+#define INI_REAL                        float
+#define ini_ftoa(string,value)          sprintf((string),"%f",(value))
+#define ini_atof(string)                (INI_REAL)strtod((string),NULL)
diff --git a/apps/openmw-mp/amx/minIni.c b/apps/openmw-mp/amx/minIni.c
new file mode 100644
index 000000000..5383f4d8b
--- /dev/null
+++ b/apps/openmw-mp/amx/minIni.c
@@ -0,0 +1,877 @@
+/*  minIni - Multi-Platform INI file parser, suitable for embedded systems
+ *
+ *  These routines are in part based on the article "Multiplatform .INI Files"
+ *  by Joseph J. Graf in the March 1994 issue of Dr. Dobb's Journal.
+ *
+ *  Copyright (c) CompuPhase, 2008-2015
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ *  use this file except in compliance with the License. You may obtain a copy
+ *  of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ *  License for the specific language governing permissions and limitations
+ *  under the License.
+ *
+ *  Version: $Id: minIni.c 5181 2015-01-21 09:44:28Z thiadmer $
+ */
+
+#if (defined _UNICODE || defined __UNICODE__ || defined UNICODE) && !defined INI_ANSIONLY
+# if !defined UNICODE   /* for Windows */
+#   define UNICODE
+# endif
+# if !defined _UNICODE  /* for C library */
+#   define _UNICODE
+# endif
+#endif
+
+#define MININI_IMPLEMENTATION
+#include "minIni.h"
+#if defined NDEBUG
+  #define assert(e)
+#else
+  #include <assert.h>
+#endif
+
+#if !defined __T || defined INI_ANSIONLY
+  #include <ctype.h>
+  #include <string.h>
+  #include <stdlib.h>
+  #define TCHAR     char
+  #define __T(s)    s
+  #define _tcscat   strcat
+  #define _tcschr   strchr
+  #define _tcscmp   strcmp
+  #define _tcscpy   strcpy
+  #define _tcsicmp  stricmp
+  #define _tcslen   strlen
+  #define _tcsncmp  strncmp
+  #define _tcsnicmp strnicmp
+  #define _tcsrchr  strrchr
+  #define _tcstol   strtol
+  #define _tcstod   strtod
+  #define _totupper toupper
+  #define _stprintf sprintf
+  #define _tfgets   fgets
+  #define _tfputs   fputs
+  #define _tfopen   fopen
+  #define _tremove  remove
+  #define _trename  rename
+#endif
+
+#if defined __linux || defined __linux__
+  #define __LINUX__
+#elif defined FREEBSD && !defined __FreeBSD__
+  #define __FreeBSD__
+#elif defined(_MSC_VER)
+  #pragma warning(disable: 4996)	/* for Microsoft Visual C/C++ */
+#endif
+#if !defined strnicmp && !defined PORTABLE_STRNICMP
+  #if defined __LINUX__ || defined __FreeBSD__ || defined __OpenBSD__ || defined __APPLE__
+    #define strnicmp  strncasecmp
+  #endif
+#endif
+#if !defined _totupper
+  #define _totupper toupper
+#endif
+
+#if !defined INI_LINETERM
+  #if defined __LINUX__ || defined __FreeBSD__ || defined __OpenBSD__ || defined __APPLE__
+    #define INI_LINETERM    __T("\n")
+  #else
+    #define INI_LINETERM    __T("\r\n")
+  #endif
+#endif
+#if !defined INI_FILETYPE
+  #error Missing definition for INI_FILETYPE.
+#endif
+
+#if !defined sizearray
+  #define sizearray(a)    (sizeof(a) / sizeof((a)[0]))
+#endif
+
+enum quote_option {
+  QUOTE_NONE,
+  QUOTE_ENQUOTE,
+  QUOTE_DEQUOTE,
+};
+
+#if defined PORTABLE_STRNICMP
+int strnicmp(const TCHAR *s1, const TCHAR *s2, size_t n)
+{
+  register int c1, c2;
+
+  while (n-- != 0 && (*s1 || *s2)) {
+    c1 = *s1++;
+    if ('a' <= c1 && c1 <= 'z')
+      c1 += ('A' - 'a');
+    c2 = *s2++;
+    if ('a' <= c2 && c2 <= 'z')
+      c2 += ('A' - 'a');
+    if (c1 != c2)
+      return c1 - c2;
+  } /* while */
+  return 0;
+}
+#endif /* PORTABLE_STRNICMP */
+
+static TCHAR *skipleading(const TCHAR *str)
+{
+  assert(str != NULL);
+  while ('\0' < *str && *str <= ' ')
+    str++;
+  return (TCHAR *)str;
+}
+
+static TCHAR *skiptrailing(const TCHAR *str, const TCHAR *base)
+{
+  assert(str != NULL);
+  assert(base != NULL);
+  while (str > base && '\0' < *(str-1) && *(str-1) <= ' ')
+    str--;
+  return (TCHAR *)str;
+}
+
+static TCHAR *striptrailing(TCHAR *str)
+{
+  TCHAR *ptr = skiptrailing(_tcschr(str, '\0'), str);
+  assert(ptr != NULL);
+  *ptr = '\0';
+  return str;
+}
+
+static TCHAR *save_strncpy(TCHAR *dest, const TCHAR *source, size_t maxlen, enum quote_option option)
+{
+  size_t d, s;
+
+  assert(maxlen>0);
+  assert(dest <= source || dest >= source + maxlen);
+  if (option == QUOTE_ENQUOTE && maxlen < 3)
+    option = QUOTE_NONE;  /* cannot store two quotes and a terminating zero in less than 3 characters */
+
+  switch (option) {
+  case QUOTE_NONE:
+    for (d = 0; d < maxlen - 1 && source[d] != '\0'; d++)
+      dest[d] = source[d];
+    assert(d < maxlen);
+    dest[d] = '\0';
+    break;
+  case QUOTE_ENQUOTE:
+    d = 0;
+    dest[d++] = '"';
+    for (s = 0; source[s] != '\0' && d < maxlen - 2; s++, d++) {
+      if (source[s] == '"') {
+        if (d >= maxlen - 3)
+          break;  /* no space to store the escape character plus the one that follows it */
+        dest[d++] = '\\';
+      } /* if */
+      dest[d] = source[s];
+    } /* for */
+    dest[d++] = '"';
+    dest[d] = '\0';
+    break;
+  case QUOTE_DEQUOTE:
+    for (d = s = 0; source[s] != '\0' && d < maxlen - 1; s++, d++) {
+      if ((source[s] == '"' || source[s] == '\\') && source[s + 1] == '"')
+        s++;
+      dest[d] = source[s];
+    } /* for */
+    dest[d] = '\0';
+    break;
+  default:
+    assert(0);
+  } /* switch */
+
+  return dest;
+}
+
+static TCHAR *cleanstring(TCHAR *string, enum quote_option *quotes)
+{
+  int isstring;
+  TCHAR *ep;
+
+  assert(string != NULL);
+  assert(quotes != NULL);
+
+  /* Remove a trailing comment */
+  isstring = 0;
+  for (ep = string; *ep != '\0' && ((*ep != ';' && *ep != '#') || isstring); ep++) {
+    if (*ep == '"') {
+      if (*(ep + 1) == '"')
+        ep++;                 /* skip "" (both quotes) */
+      else
+        isstring = !isstring; /* single quote, toggle isstring */
+    } else if (*ep == '\\' && *(ep + 1) == '"') {
+      ep++;                   /* skip \" (both quotes */
+    } /* if */
+  } /* for */
+  assert(ep != NULL && (*ep == '\0' || *ep == ';' || *ep == '#'));
+  *ep = '\0';                 /* terminate at a comment */
+  striptrailing(string);
+  /* Remove double quotes surrounding a value */
+  *quotes = QUOTE_NONE;
+  if (*string == '"' && (ep = _tcschr(string, '\0')) != NULL && *(ep - 1) == '"') {
+    string++;
+    *--ep = '\0';
+    *quotes = QUOTE_DEQUOTE;  /* this is a string, so remove escaped characters */
+  } /* if */
+  return string;
+}
+
+static int getkeystring(INI_FILETYPE *fp, const TCHAR *Section, const TCHAR *Key,
+                        int idxSection, int idxKey, TCHAR *Buffer, int BufferSize,
+                        INI_FILEPOS *mark)
+{
+  TCHAR *sp, *ep;
+  int len, idx;
+  enum quote_option quotes;
+  TCHAR LocalBuffer[INI_BUFFERSIZE];
+
+  assert(fp != NULL);
+  /* Move through file 1 line at a time until a section is matched or EOF. If
+   * parameter Section is NULL, only look at keys above the first section. If
+   * idxSection is postive, copy the relevant section name.
+   */
+  len = (Section != NULL) ? (int)_tcslen(Section) : 0;
+  if (len > 0 || idxSection >= 0) {
+    idx = -1;
+    do {
+      if (!ini_read(LocalBuffer, INI_BUFFERSIZE, fp))
+        return 0;
+      sp = skipleading(LocalBuffer);
+      ep = _tcschr(sp, ']');
+    } while (*sp != '[' || ep == NULL || (((int)(ep-sp-1) != len || _tcsnicmp(sp+1,Section,len) != 0) && ++idx != idxSection));
+    if (idxSection >= 0) {
+      if (idx == idxSection) {
+        assert(ep != NULL);
+        assert(*ep == ']');
+        *ep = '\0';
+        save_strncpy(Buffer, sp + 1, BufferSize, QUOTE_NONE);
+        return 1;
+      } /* if */
+      return 0; /* no more section found */
+    } /* if */
+  } /* if */
+
+  /* Now that the section has been found, find the entry.
+   * Stop searching upon leaving the section's area.
+   */
+  assert(Key != NULL || idxKey >= 0);
+  len = (Key != NULL) ? (int)_tcslen(Key) : 0;
+  idx = -1;
+  do {
+    if (mark != NULL)
+      ini_tell(fp, mark);   /* optionally keep the mark to the start of the line */
+    if (!ini_read(LocalBuffer,INI_BUFFERSIZE,fp) || *(sp = skipleading(LocalBuffer)) == '[')
+      return 0;
+    sp = skipleading(LocalBuffer);
+    ep = _tcschr(sp, '=');  /* Parse out the equal sign */
+    if (ep == NULL)
+      ep = _tcschr(sp, ':');
+  } while (*sp == ';' || *sp == '#' || ep == NULL
+           || ((len == 0 || (int)(skiptrailing(ep,sp)-sp) != len || _tcsnicmp(sp,Key,len) != 0) && ++idx != idxKey));
+  if (idxKey >= 0) {
+    if (idx == idxKey) {
+      assert(ep != NULL);
+      assert(*ep == '=' || *ep == ':');
+      *ep = '\0';
+      striptrailing(sp);
+      save_strncpy(Buffer, sp, BufferSize, QUOTE_NONE);
+      return 1;
+    } /* if */
+    return 0;   /* no more key found (in this section) */
+  } /* if */
+
+  /* Copy up to BufferSize chars to buffer */
+  assert(ep != NULL);
+  assert(*ep == '=' || *ep == ':');
+  sp = skipleading(ep + 1);
+  sp = cleanstring(sp, &quotes);  /* Remove a trailing comment */
+  save_strncpy(Buffer, sp, BufferSize, quotes);
+  return 1;
+}
+
+/** ini_gets()
+ * \param Section     the name of the section to search for
+ * \param Key         the name of the entry to find the value of
+ * \param DefValue    default string in the event of a failed read
+ * \param Buffer      a pointer to the buffer to copy into
+ * \param BufferSize  the maximum number of characters to copy
+ * \param Filename    the name and full path of the .ini file to read from
+ *
+ * \return            the number of characters copied into the supplied buffer
+ */
+int ini_gets(const TCHAR *Section, const TCHAR *Key, const TCHAR *DefValue,
+             TCHAR *Buffer, int BufferSize, const TCHAR *Filename)
+{
+  INI_FILETYPE fp;
+  int ok = 0;
+
+  if (Buffer == NULL || BufferSize <= 0 || Key == NULL)
+    return 0;
+  if (ini_openread(Filename, &fp)) {
+    ok = getkeystring(&fp, Section, Key, -1, -1, Buffer, BufferSize, NULL);
+    (void)ini_close(&fp);
+  } /* if */
+  if (!ok)
+    save_strncpy(Buffer, (DefValue != NULL) ? DefValue : __T(""), BufferSize, QUOTE_NONE);
+  return (int)_tcslen(Buffer);
+}
+
+/** ini_getl()
+ * \param Section     the name of the section to search for
+ * \param Key         the name of the entry to find the value of
+ * \param DefValue    the default value in the event of a failed read
+ * \param Filename    the name of the .ini file to read from
+ *
+ * \return            the value located at Key
+ */
+long ini_getl(const TCHAR *Section, const TCHAR *Key, long DefValue, const TCHAR *Filename)
+{
+  TCHAR LocalBuffer[64];
+  int len = ini_gets(Section, Key, __T(""), LocalBuffer, sizearray(LocalBuffer), Filename);
+  return (len == 0) ? DefValue
+                    : ((len >= 2 && _totupper((int)LocalBuffer[1]) == 'X') ? _tcstol(LocalBuffer, NULL, 16)
+                                                                           : _tcstol(LocalBuffer, NULL, 10));
+}
+
+#if defined INI_REAL
+/** ini_getf()
+ * \param Section     the name of the section to search for
+ * \param Key         the name of the entry to find the value of
+ * \param DefValue    the default value in the event of a failed read
+ * \param Filename    the name of the .ini file to read from
+ *
+ * \return            the value located at Key
+ */
+INI_REAL ini_getf(const TCHAR *Section, const TCHAR *Key, INI_REAL DefValue, const TCHAR *Filename)
+{
+  TCHAR LocalBuffer[64];
+  int len = ini_gets(Section, Key, __T(""), LocalBuffer, sizearray(LocalBuffer), Filename);
+  return (len == 0) ? DefValue : ini_atof(LocalBuffer);
+}
+#endif
+
+/** ini_getbool()
+ * \param Section     the name of the section to search for
+ * \param Key         the name of the entry to find the value of
+ * \param DefValue    default value in the event of a failed read; it should
+ *                    zero (0) or one (1).
+ * \param Buffer      a pointer to the buffer to copy into
+ * \param BufferSize  the maximum number of characters to copy
+ * \param Filename    the name and full path of the .ini file to read from
+ *
+ * A true boolean is found if one of the following is matched:
+ * - A string starting with 'y' or 'Y'
+ * - A string starting with 't' or 'T'
+ * - A string starting with '1'
+ *
+ * A false boolean is found if one of the following is matched:
+ * - A string starting with 'n' or 'N'
+ * - A string starting with 'f' or 'F'
+ * - A string starting with '0'
+ *
+ * \return            the true/false flag as interpreted at Key
+ */
+int ini_getbool(const TCHAR *Section, const TCHAR *Key, int DefValue, const TCHAR *Filename)
+{
+  TCHAR LocalBuffer[2] = __T("");
+  int ret;
+
+  ini_gets(Section, Key, __T(""), LocalBuffer, sizearray(LocalBuffer), Filename);
+  LocalBuffer[0] = (TCHAR)_totupper((int)LocalBuffer[0]);
+  if (LocalBuffer[0] == 'Y' || LocalBuffer[0] == '1' || LocalBuffer[0] == 'T')
+    ret = 1;
+  else if (LocalBuffer[0] == 'N' || LocalBuffer[0] == '0' || LocalBuffer[0] == 'F')
+    ret = 0;
+  else
+    ret = DefValue;
+
+  return(ret);
+}
+
+/** ini_getsection()
+ * \param idx         the zero-based sequence number of the section to return
+ * \param Buffer      a pointer to the buffer to copy into
+ * \param BufferSize  the maximum number of characters to copy
+ * \param Filename    the name and full path of the .ini file to read from
+ *
+ * \return            the number of characters copied into the supplied buffer
+ */
+int  ini_getsection(int idx, TCHAR *Buffer, int BufferSize, const TCHAR *Filename)
+{
+  INI_FILETYPE fp;
+  int ok = 0;
+
+  if (Buffer == NULL || BufferSize <= 0 || idx < 0)
+    return 0;
+  if (ini_openread(Filename, &fp)) {
+    ok = getkeystring(&fp, NULL, NULL, idx, -1, Buffer, BufferSize, NULL);
+    (void)ini_close(&fp);
+  } /* if */
+  if (!ok)
+    *Buffer = '\0';
+  return (int)_tcslen(Buffer);
+}
+
+/** ini_getkey()
+ * \param Section     the name of the section to browse through, or NULL to
+ *                    browse through the keys outside any section
+ * \param idx         the zero-based sequence number of the key to return
+ * \param Buffer      a pointer to the buffer to copy into
+ * \param BufferSize  the maximum number of characters to copy
+ * \param Filename    the name and full path of the .ini file to read from
+ *
+ * \return            the number of characters copied into the supplied buffer
+ */
+int  ini_getkey(const TCHAR *Section, int idx, TCHAR *Buffer, int BufferSize, const TCHAR *Filename)
+{
+  INI_FILETYPE fp;
+  int ok = 0;
+
+  if (Buffer == NULL || BufferSize <= 0 || idx < 0)
+    return 0;
+  if (ini_openread(Filename, &fp)) {
+    ok = getkeystring(&fp, Section, NULL, -1, idx, Buffer, BufferSize, NULL);
+    (void)ini_close(&fp);
+  } /* if */
+  if (!ok)
+    *Buffer = '\0';
+  return (int)_tcslen(Buffer);
+}
+
+
+#if !defined INI_NOBROWSE
+/** ini_browse()
+ * \param Callback    a pointer to a function that will be called for every
+ *                    setting in the INI file.
+ * \param UserData    arbitrary data, which the function passes on the the
+ *                    \c Callback function
+ * \param Filename    the name and full path of the .ini file to read from
+ *
+ * \return            1 on success, 0 on failure (INI file not found)
+ *
+ * \note              The \c Callback function must return 1 to continue
+ *                    browsing through the INI file, or 0 to stop. Even when the
+ *                    callback stops the browsing, this function will return 1
+ *                    (for success).
+ */
+int  ini_browse(INI_CALLBACK Callback, const void *UserData, const TCHAR *Filename)
+{
+  TCHAR LocalBuffer[INI_BUFFERSIZE];
+  int lenSec, lenKey;
+  enum quote_option quotes;
+  INI_FILETYPE fp;
+
+  if (Callback == NULL)
+    return 0;
+  if (!ini_openread(Filename, &fp))
+    return 0;
+
+  LocalBuffer[0] = '\0';   /* copy an empty section in the buffer */
+  lenSec = (int)_tcslen(LocalBuffer) + 1;
+  for ( ;; ) {
+    TCHAR *sp, *ep;
+    if (!ini_read(LocalBuffer + lenSec, INI_BUFFERSIZE - lenSec, &fp))
+      break;
+    sp = skipleading(LocalBuffer + lenSec);
+    /* ignore empty strings and comments */
+    if (*sp == '\0' || *sp == ';' || *sp == '#')
+      continue;
+    /* see whether we reached a new section */
+    ep = _tcschr(sp, ']');
+    if (*sp == '[' && ep != NULL) {
+      *ep = '\0';
+      save_strncpy(LocalBuffer, sp + 1, INI_BUFFERSIZE, QUOTE_NONE);
+      lenSec = (int)_tcslen(LocalBuffer) + 1;
+      continue;
+    } /* if */
+    /* not a new section, test for a key/value pair */
+    ep = _tcschr(sp, '=');    /* test for the equal sign or colon */
+    if (ep == NULL)
+      ep = _tcschr(sp, ':');
+    if (ep == NULL)
+      continue;               /* invalid line, ignore */
+    *ep++ = '\0';             /* split the key from the value */
+    striptrailing(sp);
+    save_strncpy(LocalBuffer + lenSec, sp, INI_BUFFERSIZE - lenSec, QUOTE_NONE);
+    lenKey = (int)_tcslen(LocalBuffer + lenSec) + 1;
+    /* clean up the value */
+    sp = skipleading(ep);
+    sp = cleanstring(sp, &quotes);  /* Remove a trailing comment */
+    save_strncpy(LocalBuffer + lenSec + lenKey, sp, INI_BUFFERSIZE - lenSec - lenKey, quotes);
+    /* call the callback */
+    if (!Callback(LocalBuffer, LocalBuffer + lenSec, LocalBuffer + lenSec + lenKey, UserData))
+      break;
+  } /* for */
+
+  (void)ini_close(&fp);
+  return 1;
+}
+#endif /* INI_NOBROWSE */
+
+#if ! defined INI_READONLY
+static void ini_tempname(TCHAR *dest, const TCHAR *source, int maxlength)
+{
+  TCHAR *p;
+
+  save_strncpy(dest, source, maxlength, QUOTE_NONE);
+  p = _tcsrchr(dest, '\0');
+  assert(p != NULL);
+  *(p - 1) = '~';
+}
+
+static enum quote_option check_enquote(const TCHAR *Value)
+{
+  const TCHAR *p;
+
+  /* run through the value, if it has trailing spaces, or '"', ';' or '#'
+   * characters, enquote it
+   */
+  assert(Value != NULL);
+  for (p = Value; *p != '\0' && *p != '"' && *p != ';' && *p != '#'; p++)
+    /* nothing */;
+  return (*p != '\0' || (p > Value && *(p - 1) == ' ')) ? QUOTE_ENQUOTE : QUOTE_NONE;
+}
+
+static void writesection(TCHAR *LocalBuffer, const TCHAR *Section, INI_FILETYPE *fp)
+{
+  if (Section != NULL && _tcslen(Section) > 0) {
+    TCHAR *p;
+    LocalBuffer[0] = '[';
+    save_strncpy(LocalBuffer + 1, Section, INI_BUFFERSIZE - 4, QUOTE_NONE);  /* -1 for '[', -1 for ']', -2 for '\r\n' */
+    p = _tcsrchr(LocalBuffer, '\0');
+    assert(p != NULL);
+    *p++ = ']';
+    _tcscpy(p, INI_LINETERM); /* copy line terminator (typically "\n") */
+    if (fp != NULL)
+      (void)ini_write(LocalBuffer, fp);
+  } /* if */
+}
+
+static void writekey(TCHAR *LocalBuffer, const TCHAR *Key, const TCHAR *Value, INI_FILETYPE *fp)
+{
+  TCHAR *p;
+  enum quote_option option = check_enquote(Value);
+  save_strncpy(LocalBuffer, Key, INI_BUFFERSIZE - 3, QUOTE_NONE);  /* -1 for '=', -2 for '\r\n' */
+  p = _tcsrchr(LocalBuffer, '\0');
+  assert(p != NULL);
+  *p++ = '=';
+  save_strncpy(p, Value, INI_BUFFERSIZE - (p - LocalBuffer) - 2, option); /* -2 for '\r\n' */
+  p = _tcsrchr(LocalBuffer, '\0');
+  assert(p != NULL);
+  _tcscpy(p, INI_LINETERM); /* copy line terminator (typically "\n") */
+  if (fp != NULL)
+    (void)ini_write(LocalBuffer, fp);
+}
+
+static int cache_accum(const TCHAR *string, int *size, int max)
+{
+  int len = (int)_tcslen(string);
+  if (*size + len >= max)
+    return 0;
+  *size += len;
+  return 1;
+}
+
+static int cache_flush(TCHAR *buffer, int *size,
+                      INI_FILETYPE *rfp, INI_FILETYPE *wfp, INI_FILEPOS *mark)
+{
+  int terminator_len = (int)_tcslen(INI_LINETERM);
+  int pos = 0;
+
+  (void)ini_seek(rfp, mark);
+  assert(buffer != NULL);
+  buffer[0] = '\0';
+  assert(size != NULL);
+  assert(*size <= INI_BUFFERSIZE);
+  while (pos < *size) {
+    (void)ini_read(buffer + pos, INI_BUFFERSIZE - pos, rfp);
+    while (pos < *size && buffer[pos] != '\0')
+      pos++;            /* cannot use _tcslen() because buffer may not be zero-terminated */
+  } /* while */
+  if (buffer[0] != '\0') {
+    assert(pos > 0 && pos <= INI_BUFFERSIZE);
+    if (pos == INI_BUFFERSIZE)
+      pos--;
+    buffer[pos] = '\0'; /* force zero-termination (may be left unterminated in the above while loop) */
+    (void)ini_write(buffer, wfp);
+  }
+  ini_tell(rfp, mark);  /* update mark */
+  *size = 0;
+  /* return whether the buffer ended with a line termination */
+  return (pos > terminator_len) && (_tcscmp(buffer + pos - terminator_len, INI_LINETERM) == 0);
+}
+
+static int close_rename(INI_FILETYPE *rfp, INI_FILETYPE *wfp, const TCHAR *filename, TCHAR *buffer)
+{
+  (void)ini_close(rfp);
+  (void)ini_close(wfp);
+  (void)ini_remove(filename);
+  (void)ini_tempname(buffer, filename, INI_BUFFERSIZE);
+  (void)ini_rename(buffer, filename);
+  return 1;
+}
+
+/** ini_puts()
+ * \param Section     the name of the section to write the string in
+ * \param Key         the name of the entry to write, or NULL to erase all keys in the section
+ * \param Value       a pointer to the buffer the string, or NULL to erase the key
+ * \param Filename    the name and full path of the .ini file to write to
+ *
+ * \return            1 if successful, otherwise 0
+ */
+int ini_puts(const TCHAR *Section, const TCHAR *Key, const TCHAR *Value, const TCHAR *Filename)
+{
+  INI_FILETYPE rfp;
+  INI_FILETYPE wfp;
+  INI_FILEPOS mark;
+  INI_FILEPOS head, tail;
+  TCHAR *sp, *ep;
+  TCHAR LocalBuffer[INI_BUFFERSIZE];
+  int len, match, flag, cachelen;
+
+  assert(Filename != NULL);
+  if (!ini_openread(Filename, &rfp)) {
+    /* If the .ini file doesn't exist, make a new file */
+    if (Key != NULL && Value != NULL) {
+      if (!ini_openwrite(Filename, &wfp))
+        return 0;
+      writesection(LocalBuffer, Section, &wfp);
+      writekey(LocalBuffer, Key, Value, &wfp);
+      (void)ini_close(&wfp);
+    } /* if */
+    return 1;
+  } /* if */
+
+  /* If parameters Key and Value are valid (so this is not an "erase" request)
+   * and the setting already exists, there are two short-cuts to avoid rewriting
+   * the INI file.
+   */
+  if (Key != NULL && Value != NULL) {
+    ini_tell(&rfp, &mark);
+    match = getkeystring(&rfp, Section, Key, -1, -1, LocalBuffer, sizearray(LocalBuffer), &head);
+    if (match) {
+      /* if the current setting is identical to the one to write, there is
+       * nothing to do.
+       */
+      if (_tcscmp(LocalBuffer,Value) == 0) {
+        (void)ini_close(&rfp);
+        return 1;
+      } /* if */
+      /* if the new setting has the same length as the current setting, and the
+       * glue file permits file read/write access, we can modify in place.
+       */
+      #if defined ini_openrewrite
+        /* we already have the start of the (raw) line, get the end too */
+        ini_tell(&rfp, &tail);
+        /* create new buffer (without writing it to file) */
+        writekey(LocalBuffer, Key, Value, NULL);
+        if (_tcslen(LocalBuffer) == (size_t)(tail - head)) {
+          /* length matches, close the file & re-open for read/write, then
+           * write at the correct position
+           */
+          (void)ini_close(&rfp);
+          if (!ini_openrewrite(Filename, &wfp))
+            return 0;
+          (void)ini_seek(&wfp, &head);
+          (void)ini_write(LocalBuffer, &wfp);
+          (void)ini_close(&wfp);
+          return 1;
+        } /* if */
+      #endif
+    } /* if */
+    /* key not found, or different value & length -> proceed (but rewind the
+     * input file first)
+     */
+    (void)ini_seek(&rfp, &mark);
+  } /* if */
+
+  /* Get a temporary file name to copy to. Use the existing name, but with
+   * the last character set to a '~'.
+   */
+  ini_tempname(LocalBuffer, Filename, INI_BUFFERSIZE);
+  if (!ini_openwrite(LocalBuffer, &wfp)) {
+    (void)ini_close(&rfp);
+    return 0;
+  } /* if */
+  ini_tell(&rfp, &mark);
+  cachelen = 0;
+
+  /* Move through the file one line at a time until a section is
+   * matched or until EOF. Copy to temp file as it is read.
+   */
+  len = (Section != NULL) ? (int)_tcslen(Section) : 0;
+  if (len > 0) {
+    do {
+      if (!ini_read(LocalBuffer, INI_BUFFERSIZE, &rfp)) {
+        /* Failed to find section, so add one to the end */
+        flag = cache_flush(LocalBuffer, &cachelen, &rfp, &wfp, &mark);
+        if (Key!=NULL && Value!=NULL) {
+          if (!flag)
+            (void)ini_write(INI_LINETERM, &wfp);  /* force a new line behind the last line of the INI file */
+          writesection(LocalBuffer, Section, &wfp);
+          writekey(LocalBuffer, Key, Value, &wfp);
+        } /* if */
+        return close_rename(&rfp, &wfp, Filename, LocalBuffer);  /* clean up and rename */
+      } /* if */
+      /* Copy the line from source to dest, but not if this is the section that
+       * we are looking for and this section must be removed
+       */
+      sp = skipleading(LocalBuffer);
+      ep = _tcschr(sp, ']');
+      match = (*sp == '[' && ep != NULL && (int)(ep-sp-1) == len && _tcsnicmp(sp + 1,Section,len) == 0);
+      if (!match || Key != NULL) {
+        if (!cache_accum(LocalBuffer, &cachelen, INI_BUFFERSIZE)) {
+          cache_flush(LocalBuffer, &cachelen, &rfp, &wfp, &mark);
+          (void)ini_read(LocalBuffer, INI_BUFFERSIZE, &rfp);
+          cache_accum(LocalBuffer, &cachelen, INI_BUFFERSIZE);
+        } /* if */
+      } /* if */
+    } while (!match);
+  } /* if */
+  cache_flush(LocalBuffer, &cachelen, &rfp, &wfp, &mark);
+  /* when deleting a section, the section head that was just found has not been
+   * copied to the output file, but because this line was not "accumulated" in
+   * the cache, the position in the input file was reset to the point just
+   * before the section; this must now be skipped (again)
+   */
+  if (Key == NULL) {
+    (void)ini_read(LocalBuffer, INI_BUFFERSIZE, &rfp);
+    ini_tell(&rfp, &mark);
+  } /* if */
+
+  /* Now that the section has been found, find the entry. Stop searching
+   * upon leaving the section's area. Copy the file as it is read
+   * and create an entry if one is not found.
+   */
+  len = (Key != NULL) ? (int)_tcslen(Key) : 0;
+  for( ;; ) {
+    if (!ini_read(LocalBuffer, INI_BUFFERSIZE, &rfp)) {
+      /* EOF without an entry so make one */
+      flag = cache_flush(LocalBuffer, &cachelen, &rfp, &wfp, &mark);
+      if (Key!=NULL && Value!=NULL) {
+        if (!flag)
+          (void)ini_write(INI_LINETERM, &wfp);  /* force a new line behind the last line of the INI file */
+        writekey(LocalBuffer, Key, Value, &wfp);
+      } /* if */
+      return close_rename(&rfp, &wfp, Filename, LocalBuffer);  /* clean up and rename */
+    } /* if */
+    sp = skipleading(LocalBuffer);
+    ep = _tcschr(sp, '='); /* Parse out the equal sign */
+    if (ep == NULL)
+      ep = _tcschr(sp, ':');
+    match = (ep != NULL && len > 0 && (int)(skiptrailing(ep,sp)-sp) == len && _tcsnicmp(sp,Key,len) == 0);
+    if ((Key != NULL && match) || *sp == '[')
+      break;  /* found the key, or found a new section */
+    /* copy other keys in the section */
+    if (Key == NULL) {
+      ini_tell(&rfp, &mark);  /* we are deleting the entire section, so update the read position */
+    } else {
+      if (!cache_accum(LocalBuffer, &cachelen, INI_BUFFERSIZE)) {
+        cache_flush(LocalBuffer, &cachelen, &rfp, &wfp, &mark);
+        (void)ini_read(LocalBuffer, INI_BUFFERSIZE, &rfp);
+        cache_accum(LocalBuffer, &cachelen, INI_BUFFERSIZE);
+      } /* if */
+    } /* if */
+  } /* for */
+  /* the key was found, or we just dropped on the next section (meaning that it
+   * wasn't found); in both cases we need to write the key, but in the latter
+   * case, we also need to write the line starting the new section after writing
+   * the key
+   */
+  flag = (*sp == '[');
+  cache_flush(LocalBuffer, &cachelen, &rfp, &wfp, &mark);
+  if (Key != NULL && Value != NULL)
+    writekey(LocalBuffer, Key, Value, &wfp);
+  /* cache_flush() reset the "read pointer" to the start of the line with the
+   * previous key or the new section; read it again (because writekey() destroyed
+   * the buffer)
+   */
+  (void)ini_read(LocalBuffer, INI_BUFFERSIZE, &rfp);
+  if (flag) {
+    /* the new section heading needs to be copied to the output file */
+    cache_accum(LocalBuffer, &cachelen, INI_BUFFERSIZE);
+  } else {
+    /* forget the old key line */
+    ini_tell(&rfp, &mark);
+  } /* if */
+  /* Copy the rest of the INI file */
+  while (ini_read(LocalBuffer, INI_BUFFERSIZE, &rfp)) {
+    if (!cache_accum(LocalBuffer, &cachelen, INI_BUFFERSIZE)) {
+      cache_flush(LocalBuffer, &cachelen, &rfp, &wfp, &mark);
+      (void)ini_read(LocalBuffer, INI_BUFFERSIZE, &rfp);
+      cache_accum(LocalBuffer, &cachelen, INI_BUFFERSIZE);
+    } /* if */
+  } /* while */
+  cache_flush(LocalBuffer, &cachelen, &rfp, &wfp, &mark);
+  return close_rename(&rfp, &wfp, Filename, LocalBuffer);  /* clean up and rename */
+}
+
+/* Ansi C "itoa" based on Kernighan & Ritchie's "Ansi C" book. */
+#define ABS(v)  ((v) < 0 ? -(v) : (v))
+
+static void strreverse(TCHAR *str)
+{
+  int i, j;
+  for (i = 0, j = (int)_tcslen(str) - 1; i < j; i++, j--) {
+    TCHAR t = str[i];
+    str[i] = str[j];
+    str[j] = t;
+  } /* for */
+}
+
+static void long2str(long value, TCHAR *str)
+{
+  int i = 0;
+  long sign = value;
+  int n;
+
+  /* generate digits in reverse order */
+  do {
+    n = (int)(value % 10);              /* get next lowest digit */
+    str[i++] = (TCHAR)(ABS(n) + '0');   /* handle case of negative digit */
+  } while (value /= 10);                /* delete the lowest digit */
+  if (sign < 0)
+    str[i++] = '-';
+  str[i] = '\0';
+
+  strreverse(str);
+}
+
+/** ini_putl()
+ * \param Section     the name of the section to write the value in
+ * \param Key         the name of the entry to write
+ * \param Value       the value to write
+ * \param Filename    the name and full path of the .ini file to write to
+ *
+ * \return            1 if successful, otherwise 0
+ */
+int ini_putl(const TCHAR *Section, const TCHAR *Key, long Value, const TCHAR *Filename)
+{
+  TCHAR LocalBuffer[32];
+  long2str(Value, LocalBuffer);
+  return ini_puts(Section, Key, LocalBuffer, Filename);
+}
+
+#if defined INI_REAL
+/** ini_putf()
+ * \param Section     the name of the section to write the value in
+ * \param Key         the name of the entry to write
+ * \param Value       the value to write
+ * \param Filename    the name and full path of the .ini file to write to
+ *
+ * \return            1 if successful, otherwise 0
+ */
+int ini_putf(const TCHAR *Section, const TCHAR *Key, INI_REAL Value, const TCHAR *Filename)
+{
+  TCHAR LocalBuffer[64];
+  ini_ftoa(LocalBuffer, Value);
+  return ini_puts(Section, Key, LocalBuffer, Filename);
+}
+#endif /* INI_REAL */
+#endif /* !INI_READONLY */
diff --git a/apps/openmw-mp/amx/minIni.h b/apps/openmw-mp/amx/minIni.h
new file mode 100644
index 000000000..0345c40f2
--- /dev/null
+++ b/apps/openmw-mp/amx/minIni.h
@@ -0,0 +1,152 @@
+/*  minIni - Multi-Platform INI file parser, suitable for embedded systems
+ *
+ *  Copyright (c) CompuPhase, 2008-2012
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ *  use this file except in compliance with the License. You may obtain a copy
+ *  of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ *  License for the specific language governing permissions and limitations
+ *  under the License.
+ *
+ *  Version: $Id: minIni.h 5181 2015-01-21 09:44:28Z thiadmer $
+ */
+#ifndef MININI_H
+#define MININI_H
+
+#include "minGlue.h"
+
+#if (defined _UNICODE || defined __UNICODE__ || defined UNICODE) && !defined INI_ANSIONLY
+  #include <tchar.h>
+  #define mTCHAR TCHAR
+#else
+  /* force TCHAR to be "char", but only for minIni */
+  #define mTCHAR char
+#endif
+
+#if !defined INI_BUFFERSIZE
+  #define INI_BUFFERSIZE  512
+#endif
+
+#if defined __cplusplus
+  extern "C" {
+#endif
+
+int   ini_getbool(const mTCHAR *Section, const mTCHAR *Key, int DefValue, const mTCHAR *Filename);
+long  ini_getl(const mTCHAR *Section, const mTCHAR *Key, long DefValue, const mTCHAR *Filename);
+int   ini_gets(const mTCHAR *Section, const mTCHAR *Key, const mTCHAR *DefValue, mTCHAR *Buffer, int BufferSize, const mTCHAR *Filename);
+int   ini_getsection(int idx, mTCHAR *Buffer, int BufferSize, const mTCHAR *Filename);
+int   ini_getkey(const mTCHAR *Section, int idx, mTCHAR *Buffer, int BufferSize, const mTCHAR *Filename);
+
+#if defined INI_REAL
+INI_REAL ini_getf(const mTCHAR *Section, const mTCHAR *Key, INI_REAL DefValue, const mTCHAR *Filename);
+#endif
+
+#if !defined INI_READONLY
+int   ini_putl(const mTCHAR *Section, const mTCHAR *Key, long Value, const mTCHAR *Filename);
+int   ini_puts(const mTCHAR *Section, const mTCHAR *Key, const mTCHAR *Value, const mTCHAR *Filename);
+#if defined INI_REAL
+int   ini_putf(const mTCHAR *Section, const mTCHAR *Key, INI_REAL Value, const mTCHAR *Filename);
+#endif
+#endif /* INI_READONLY */
+
+#if !defined INI_NOBROWSE
+typedef int (*INI_CALLBACK)(const mTCHAR *Section, const mTCHAR *Key, const mTCHAR *Value, const void *UserData);
+int  ini_browse(INI_CALLBACK Callback, const void *UserData, const mTCHAR *Filename);
+#endif /* INI_NOBROWSE */
+
+#if defined __cplusplus
+  }
+#endif
+
+
+#if defined __cplusplus
+
+#if defined __WXWINDOWS__
+	#include "wxMinIni.h"
+#else
+  #include <string>
+
+  /* The C++ class in minIni.h was contributed by Steven Van Ingelgem. */
+  class minIni
+  {
+  public:
+    minIni(const std::string& filename) : iniFilename(filename)
+      { }
+
+    bool getbool(const std::string& Section, const std::string& Key, bool DefValue=false) const
+      { return ini_getbool(Section.c_str(), Key.c_str(), int(DefValue), iniFilename.c_str()) != 0; }
+
+    long getl(const std::string& Section, const std::string& Key, long DefValue=0) const
+      { return ini_getl(Section.c_str(), Key.c_str(), DefValue, iniFilename.c_str()); }
+
+    int geti(const std::string& Section, const std::string& Key, int DefValue=0) const
+      { return static_cast<int>(this->getl(Section, Key, long(DefValue))); }
+
+    std::string gets(const std::string& Section, const std::string& Key, const std::string& DefValue="") const
+      {
+        char buffer[INI_BUFFERSIZE];
+        ini_gets(Section.c_str(), Key.c_str(), DefValue.c_str(), buffer, INI_BUFFERSIZE, iniFilename.c_str());
+        return buffer;
+      }
+
+    std::string getsection(int idx) const
+      {
+        char buffer[INI_BUFFERSIZE];
+        ini_getsection(idx, buffer, INI_BUFFERSIZE, iniFilename.c_str());
+        return buffer;
+      }
+
+    std::string getkey(const std::string& Section, int idx) const
+      {
+        char buffer[INI_BUFFERSIZE];
+        ini_getkey(Section.c_str(), idx, buffer, INI_BUFFERSIZE, iniFilename.c_str());
+        return buffer;
+      }
+
+#if defined INI_REAL
+    INI_REAL getf(const std::string& Section, const std::string& Key, INI_REAL DefValue=0) const
+      { return ini_getf(Section.c_str(), Key.c_str(), DefValue, iniFilename.c_str()); }
+#endif
+
+#if ! defined INI_READONLY
+    bool put(const std::string& Section, const std::string& Key, long Value) const
+      { return ini_putl(Section.c_str(), Key.c_str(), Value, iniFilename.c_str()) != 0; }
+
+    bool put(const std::string& Section, const std::string& Key, int Value) const
+      { return ini_putl(Section.c_str(), Key.c_str(), (long)Value, iniFilename.c_str()) != 0; }
+
+    bool put(const std::string& Section, const std::string& Key, bool Value) const
+      { return ini_putl(Section.c_str(), Key.c_str(), (long)Value, iniFilename.c_str()) != 0; }
+
+    bool put(const std::string& Section, const std::string& Key, const std::string& Value) const
+      { return ini_puts(Section.c_str(), Key.c_str(), Value.c_str(), iniFilename.c_str()) != 0; }
+
+    bool put(const std::string& Section, const std::string& Key, const char* Value) const
+      { return ini_puts(Section.c_str(), Key.c_str(), Value, iniFilename.c_str()) != 0; }
+
+#if defined INI_REAL
+    bool put(const std::string& Section, const std::string& Key, INI_REAL Value) const
+      { return ini_putf(Section.c_str(), Key.c_str(), Value, iniFilename.c_str()) != 0; }
+#endif
+
+    bool del(const std::string& Section, const std::string& Key) const
+      { return ini_puts(Section.c_str(), Key.c_str(), 0, iniFilename.c_str()) != 0; }
+
+    bool del(const std::string& Section) const
+      { return ini_puts(Section.c_str(), 0, 0, iniFilename.c_str()) != 0; }
+#endif
+
+  private:
+    std::string iniFilename;
+  };
+
+#endif /* __WXWINDOWS__ */
+#endif /* __cplusplus */
+
+#endif /* MININI_H */
diff --git a/apps/openmw-mp/amx/osdefs.h b/apps/openmw-mp/amx/osdefs.h
new file mode 100644
index 000000000..5e07cd349
--- /dev/null
+++ b/apps/openmw-mp/amx/osdefs.h
@@ -0,0 +1,159 @@
+/*
+ * Platform
+ *   __MSDOS__    set when compiling for DOS (not Windows)
+ *   _Windows     set when compiling for any version of Microsoft Windows
+ *   __WIN32__    set when compiling for Windows95 or WindowsNT (32 bit mode)
+ *   __32BIT__    set when compiling in 32-bit "flat" mode (DOS, Windows, ARM)
+ *   __64BIT__    set when compiling in 64-bit mode
+ *   __ECOS__     set if Pawn was included with the eCos with configtool
+ *   __LINUX__    set when compiling for Linux
+ *
+ * Copyright 1998-2011, ITB CompuPhase, The Netherlands.
+ * No usage restrictions, no warranties.
+ */
+
+#ifndef _OSDEFS_H
+#define _OSDEFS_H
+
+/* Every compiler uses different "default" macros to indicate the mode
+ * it is in. Throughout the source, we use the Borland C++ macros, so
+ * the macros of Watcom C/C++ and Microsoft Visual C/C++ are mapped to
+ * those of Borland C++.
+ */
+#if defined(__WATCOMC__)
+  #if defined(__WINDOWS__) || defined(__NT__)
+    #define _Windows    1
+  #endif
+  #if defined(__386__) || defined(__NT__)
+    #define __32BIT__   1
+  #endif
+  #if defined(_Windows) && defined(__32BIT__)
+    #define __WIN32__   1
+  #endif
+#elif defined(_MSC_VER)
+  #if defined(_WINDOWS) || defined(_WIN32)
+    #define _Windows    1
+  #endif
+  #if defined(_WIN32)
+    #define __WIN32__   1
+    #define __32BIT__   1
+  #endif
+#elif defined __arm__
+  #define __32BIT__     1
+#elif defined __AVR__
+  #define __16BIT__     1
+#endif
+#if !defined __16BIT__ && !defined __32BIT__ && !defined __64BIT__
+  #define __32BIT__     1
+#endif
+
+
+#if (defined __linux || defined __linux__) && !defined __LINUX__
+  #define __LINUX__
+#endif
+/* To be able to eventually set __ECOS__, we have to find a symbol
+ * defined in a common place (so including the header file won't break
+ * anything for other platforms). <sys/types.h> includes
+ * <pkgconf/system.h> and in this later file we can find CYGPKG_PAWN
+ * if the Pawn package was included with configtool and so we know
+ * that we are compiling for eCos.
+ */
+#if defined CCSINFO
+  #include <sys/types.h>
+#endif
+#if defined CYGPKG_PAWN
+  #define __ECOS__      1
+  #define HAVE_ALLOCA_H 0
+#endif
+
+
+#if defined __FreeBSD__
+  #include <sys/endian.h>
+#elif defined __LINUX__
+  #include <endian.h>
+#elif defined __ECOS__
+  #include <cyg/hal/hal_endian.h>
+  #define BIG_ENDIAN    4321
+  #define LITTLE_ENDIAN 1234
+  #if (CYG_BYTEORDER == CYG_LSBFIRST)
+  #define BYTE_ORDER  LITTLE_ENDIAN
+  #else
+    #define BYTE_ORDER  BIG_ENDIAN
+  #endif
+   /*
+    * eCos option management.
+    */
+  #include <pkgconf/pawn.h>
+  #if CYGPKG_PAWN_AMX_ANSIONLY==1
+    #define AMX_ANSIONLY
+  #endif
+  #define PAWN_CELL_SIZE CYGPKG_PAWN_AMX_CELLSIZE
+  #if CYGPKG_PAWN_CORE_RANDOM==0
+    #define AMX_NORANDOM
+  #endif
+  #if CYGPKG_PAWN_CORE_PROPERTY==0
+    #define AMX_NOPROPLIST
+  #endif
+  #if CYGPKG_PAWN_AMX_CONS_FIXEDPOINT==1
+    #define FIXEDPOINT
+  #endif
+  #if CYGPKG_PAWN_AMX_CONS_FLOATPOINT==1
+    #define FLOATPOINT
+  #endif
+#endif
+
+/* Linux now has these */
+#if !defined BIG_ENDIAN
+  #define BIG_ENDIAN    4321
+#endif
+#if !defined LITTLE_ENDIAN
+  #define LITTLE_ENDIAN 1234
+#endif
+
+/* educated guess, BYTE_ORDER is undefined, i386 is common => little endian */
+#if !defined BYTE_ORDER
+  #if defined UCLINUX
+    #define BYTE_ORDER BIG_ENDIAN
+  #else
+    #define BYTE_ORDER LITTLE_ENDIAN
+  #endif
+#endif
+
+#if defined __MSDOS__ || defined __WIN32__ || defined _Windows
+  #define DIRSEP_CHAR '\\'
+#elif defined macintosh /* only the original Macintosh uses ':', OSX uses the '/' */
+  #define DIRSEP_CHAR ':'
+#else
+  #define DIRSEP_CHAR '/'
+#endif
+
+/* _MAX_PATH is sometimes called differently and it may be in limits.h or
+ * stdlib.h instead of stdio.h.
+ */
+#if !defined _MAX_PATH
+  /* not defined, perhaps stdio.h was not included */
+  #if !defined PATH_MAX
+    #include <stdio.h>
+  #endif
+  #if !defined _MAX_PATH && !defined PATH_MAX
+    /* no _MAX_PATH and no MAX_PATH, perhaps it is in limits.h */
+    #include <limits.h>
+  #endif
+  #if !defined _MAX_PATH && !defined PATH_MAX
+    /* no _MAX_PATH and no MAX_PATH, perhaps it is in stdlib.h */
+    #include <stdlib.h>
+  #endif
+  /* if _MAX_PATH is undefined, try common alternative names */
+  #if !defined _MAX_PATH
+    #if defined MAX_PATH
+      #define _MAX_PATH    MAX_PATH
+    #elif defined _POSIX_PATH_MAX
+      #define _MAX_PATH  _POSIX_PATH_MAX
+    #else
+      /* everything failed, actually we have a problem here... */
+      #define _MAX_PATH  1024
+    #endif
+  #endif
+#endif
+
+#endif  /* _OSDEFS_H */
diff --git a/apps/openmw-mp/main.cpp b/apps/openmw-mp/main.cpp
new file mode 100644
index 000000000..ba226c8b9
--- /dev/null
+++ b/apps/openmw-mp/main.cpp
@@ -0,0 +1,136 @@
+#include <RakPeerInterface.h>
+#include <BitStream.h>
+#include "Player.hpp"
+#include "Networking.hpp"
+#include <RakPeer.h>
+#include <MessageIdentifiers.h>
+#include <components/openmw-mp/NetworkMessages.hpp>
+#include <apps/openmw-mp/Script/Script.hpp>
+#include <iostream>
+#include <components/files/configurationmanager.hpp>
+#include <components/settings/settings.hpp>
+
+using namespace std;
+using namespace mwmp;
+
+void printVersion(string version, int protocol)
+{
+    cout << "TES3:MP dedicated server " << version;
+    cout << " (";
+#ifdef __WIN32__
+    cout << "Windows";
+#elif __linux
+    cout << "Linux";
+#elif __APPLE__
+    cout << "OS X";
+#else
+    cout << "Unknown OS";
+#endif
+    cout << " ";
+#ifdef __x86_64__
+    cout << "64-bit";
+#elif defined __i386__ || defined _M_I86
+    cout << "32-bit";
+#else
+    cout << "Unknown architecture";
+#endif
+    cout << ")" << endl;
+    cout << "Protocol version: " << protocol << endl;
+
+    cout << "------------------------------------------------------------" << endl;
+}
+
+std::string loadSettings (Settings::Manager & settings)
+{
+    Files::ConfigurationManager mCfgMgr;
+    // Create the settings manager and load default settings file
+    const std::string localdefault = (mCfgMgr.getLocalPath() / "tes3mp-server-default.cfg").string();
+    const std::string globaldefault = (mCfgMgr.getGlobalPath() / "tes3mp-server-default.cfg").string();
+
+    // prefer local
+    if (boost::filesystem::exists(localdefault))
+        settings.loadDefault(localdefault);
+    else if (boost::filesystem::exists(globaldefault))
+        settings.loadDefault(globaldefault);
+    else
+        throw std::runtime_error ("No default settings file found! Make sure the file \"tes3mp-server-default.cfg\" was properly installed.");
+
+    // load user settings if they exist
+    const std::string settingspath = (mCfgMgr.getUserConfigPath() / "tes3mp-server.cfg").string();
+    if (boost::filesystem::exists(settingspath))
+        settings.loadUser(settingspath);
+
+    return settingspath;
+}
+
+const vector<string> split(const string &str, int delimiter)
+{
+    string buffer;
+    vector<string> result;
+
+    for (auto symb:str)
+        if (symb != delimiter)
+            buffer += symb;
+        else if (!buffer.empty())
+        {
+            result.push_back(move(buffer));
+            buffer.clear();
+        }
+    if (!buffer.empty())
+        result.push_back(move(buffer));
+
+    return result;
+}
+
+
+
+int main(int argc, char *argv[])
+{
+    Settings::Manager mgr;
+
+    loadSettings(mgr);
+
+    //string plugin_home = "/home/koncord/ClionProjects/tes3mp-server/files";
+
+    int players = mgr.getInt("players", "General");
+    int port = mgr.getInt("port", "General");
+
+    std::string plugin_home = mgr.getString("home", "Plugins");
+    string moddir = plugin_home + "/files";
+
+    vector<string> plugins (split(mgr.getString("plugins", "Plugins"), ','));
+
+    cout << plugins[0] << endl;
+
+    printVersion("0.0.1b", 1);
+
+
+    setenv("AMXFILE", moddir.c_str(), 1);
+    setenv("MOD_DIR", moddir.c_str(), 1); // hack for lua
+
+    setenv("LUA_PATH", (plugin_home + "/scripts/?.lua" + ";" + plugin_home + "/scripts/?.t").c_str(), 1);
+
+    for(auto plugin : plugins)
+        Script::LoadScript(plugin.c_str(), plugin_home.c_str());
+
+    RakNet::RakPeerInterface *peer = RakNet::RakPeerInterface::GetInstance();
+
+    const char passw[8] = "1234567";
+    peer->SetIncomingPassword(passw, sizeof(passw));
+
+    RakNet::SocketDescriptor sd((unsigned short)port, 0);
+    if (peer->Startup((unsigned)players, &sd, 1) != RakNet::RAKNET_STARTED)
+        return 0;
+
+    peer->SetMaximumIncomingConnections((unsigned short)(players));
+
+    Networking networking(peer);
+
+    int code = networking.MainLoop();
+
+    RakNet::RakPeerInterface::DestroyInstance(peer);
+    if (code == 0)
+        printf("Quitting peacefully.\n");
+
+    return code;
+}
\ No newline at end of file
diff --git a/apps/openmw/CMakeLists.txt b/apps/openmw/CMakeLists.txt
index 73f88bdb5..6dec9b42e 100644
--- a/apps/openmw/CMakeLists.txt
+++ b/apps/openmw/CMakeLists.txt
@@ -96,6 +96,8 @@ add_openmw_dir (mwbase
     inputmanager windowmanager statemanager
     )
 
+add_openmw_dir (mwmp DedicatedPlayer LocalPlayer Networking Main GUIChat GUILogin)
+
 # Main executable
 
 if (NOT ANDROID)
@@ -137,6 +139,7 @@ target_link_libraries(openmw
     "osg-ffmpeg-videoplayer"
     "oics"
     components
+    ${RakNet_LIBRARY}
 )
 
 if (ANDROID)
diff --git a/apps/openmw/engine.cpp b/apps/openmw/engine.cpp
index 62457cae6..a49d801e1 100644
--- a/apps/openmw/engine.cpp
+++ b/apps/openmw/engine.cpp
@@ -55,6 +55,8 @@
 
 #include "mwstate/statemanagerimp.hpp"
 
+#include "mwmp/Main.hpp"
+
 namespace
 {
     void checkSDLError(int ret)
@@ -98,13 +100,15 @@ void OMW::Engine::frame(float frametime)
         if (mUseSound)
             mEnvironment.getSoundManager()->update(frametime);
 
+        mwmp::Main::Frame(frametime);
+
         // Main menu opened? Then scripts are also paused.
         bool paused = mEnvironment.getWindowManager()->containsMode(MWGui::GM_MainMenu);
 
         // update game state
         mEnvironment.getStateManager()->update (frametime);
 
-        bool guiActive = mEnvironment.getWindowManager()->isGuiMode();
+        bool guiActive = /*mEnvironment.getWindowManager()->isGuiMode()*/ false;
 
         osg::Timer_t beforeScriptTick = osg::Timer::instance()->tick();
         if (mEnvironment.getStateManager()->getState()==
@@ -145,9 +149,9 @@ void OMW::Engine::frame(float frametime)
         if (mEnvironment.getStateManager()->getState()==
             MWBase::StateManager::State_Running)
         {
-            MWWorld::Ptr player = mEnvironment.getWorld()->getPlayerPtr();
+            /*MWWorld::Ptr player = mEnvironment.getWorld()->getPlayerPtr();
             if(!guiActive && player.getClass().getCreatureStats(player).isDead())
-                mEnvironment.getStateManager()->endGame();
+                mEnvironment.getStateManager()->endGame();*/
         }
 
         // update world
@@ -640,7 +644,10 @@ void OMW::Engine::go()
     ToUTF8::Utf8Encoder encoder (mEncoding);
     mEncoder = &encoder;
 
+
     prepareEngine (settings);
+    mwmp::Main::Create();
+    mSkipMenu = true;
 
     if (!mSaveGameFile.empty())
     {
@@ -678,7 +685,7 @@ void OMW::Engine::go()
         frameTimer.setStartTick();
         dt = std::min(dt, 0.2);
 
-        bool guiActive = mEnvironment.getWindowManager()->isGuiMode();
+        bool guiActive = /*mEnvironment.getWindowManager()->isGuiMode()*/ false;
         if (!guiActive)
             simulationTime += dt;
 
@@ -712,6 +719,7 @@ void OMW::Engine::go()
     // Save user settings
     settings.saveUser(settingspath);
 
+    mwmp::Main::Destroy();
     std::cout << "Quitting peacefully." << std::endl;
 }
 
diff --git a/apps/openmw/mwclass/npc.cpp b/apps/openmw/mwclass/npc.cpp
index 52cd562d1..dc3b224f4 100644
--- a/apps/openmw/mwclass/npc.cpp
+++ b/apps/openmw/mwclass/npc.cpp
@@ -7,6 +7,9 @@
 #include <components/esm/loadmgef.hpp>
 #include <components/esm/loadnpc.hpp>
 #include <components/esm/npcstate.hpp>
+#include <apps/openmw/mwmp/DedicatedPlayer.hpp>
+#include <apps/openmw/mwmp/Networking.hpp>
+#include <apps/openmw/mwmp/Main.hpp>
 
 #include "../mwbase/environment.hpp"
 #include "../mwbase/world.hpp"
@@ -548,6 +551,9 @@ namespace MWClass
 
     void Npc::hit(const MWWorld::Ptr& ptr, float attackStrength, int type) const
     {
+        if(mwmp::Main::get().getNetworking()->isDedicatedPlayer(ptr))
+            return;
+
         MWBase::World *world = MWBase::Environment::get().getWorld();
 
         const MWWorld::Store<ESM::GameSetting> &store = world->getStore().get<ESM::GameSetting>();
@@ -556,30 +562,29 @@ namespace MWClass
         MWWorld::InventoryStore &inv = getInventoryStore(ptr);
         MWWorld::ContainerStoreIterator weaponslot = inv.getSlot(MWWorld::InventoryStore::Slot_CarriedRight);
         MWWorld::Ptr weapon = ((weaponslot != inv.end()) ? *weaponslot : MWWorld::Ptr());
-        if(!weapon.isEmpty() && weapon.getTypeName() != typeid(ESM::Weapon).name())
+        if (!weapon.isEmpty() && weapon.getTypeName() != typeid(ESM::Weapon).name())
             weapon = MWWorld::Ptr();
 
         MWMechanics::applyFatigueLoss(ptr, weapon, attackStrength);
 
         const float fCombatDistance = store.find("fCombatDistance")->getFloat();
         float dist = fCombatDistance * (!weapon.isEmpty() ?
-                               weapon.get<ESM::Weapon>()->mBase->mData.mReach :
-                               store.find("fHandToHandReach")->getFloat());
+                                        weapon.get<ESM::Weapon>()->mBase->mData.mReach :
+                                        store.find("fHandToHandReach")->getFloat());
 
         // TODO: Use second to work out the hit angle
         std::pair<MWWorld::Ptr, osg::Vec3f> result = world->getHitContact(ptr, dist);
         MWWorld::Ptr victim = result.first;
-        osg::Vec3f hitPosition (result.second);
-        if(victim.isEmpty()) // Didn't hit anything
+        osg::Vec3f hitPosition(result.second);
+        if (victim.isEmpty()) // Didn't hit anything
             return;
 
         const MWWorld::Class &othercls = victim.getClass();
-        if(!othercls.isActor()) // Can't hit non-actors
+        if (!othercls.isActor()) // Can't hit non-actors
             return;
         MWMechanics::CreatureStats &otherstats = othercls.getCreatureStats(victim);
-        if(otherstats.isDead()) // Can't hit dead actors
+        if (otherstats.isDead()) // Can't hit dead actors
             return;
-
         if(ptr == MWMechanics::getPlayer())
             MWBase::Environment::get().getWindowManager()->setEnemy(victim);
 
@@ -589,8 +594,21 @@ namespace MWClass
 
         float hitchance = MWMechanics::getHitChance(ptr, victim, ptr.getClass().getSkill(ptr, weapskill));
 
-        if (Misc::Rng::roll0to99() >= hitchance)
+        if(ptr == MWBase::Environment::get().getWorld()->getPlayerPtr())
+        {
+            mwmp::Main::get().getLocalPlayer()->GetAttack()->success = true;
+            if(mwmp::Main::get().getNetworking()->isDedicatedPlayer(victim))
+                mwmp::Main::get().getLocalPlayer()->GetAttack()->target =mwmp::Players::GetPlayer(victim)->guid;
+        }
+
+        if(Misc::Rng::roll0to99() >= hitchance)
         {
+            if(ptr == MWBase::Environment::get().getWorld()->getPlayerPtr())
+            {
+                mwmp::Main::get().getLocalPlayer()->GetAttack()->success = false;
+                mwmp::Main::get().getLocalPlayer()->SendAttack(0);
+            }
+
             othercls.onHit(victim, 0.0f, false, weapon, ptr, false);
             MWMechanics::reduceWeaponCondition(0.f, false, weapon, ptr);
             return;
@@ -717,10 +735,15 @@ namespace MWClass
             float agilityTerm = getCreatureStats(ptr).getAttribute(ESM::Attribute::Agility).getModified() * gmst.fKnockDownMult->getFloat();
             float knockdownTerm = getCreatureStats(ptr).getAttribute(ESM::Attribute::Agility).getModified()
                     * gmst.iKnockDownOddsMult->getInt() * 0.01f + gmst.iKnockDownOddsBase->getInt();
-            if (ishealth && agilityTerm <= damage && knockdownTerm <= Misc::Rng::roll0to99())
+
+            bool isDedicated = mwmp::Main::get().getNetworking()->isDedicatedPlayer(attacker);
+            bool _knockdown = false;
+            if(isDedicated)
+                _knockdown = mwmp::Players::GetPlayer(attacker)->GetAttack()->knockdown;
+
+            if ((!isDedicated && ishealth && agilityTerm <= damage && knockdownTerm <= Misc::Rng::roll0to99()) || _knockdown)
             {
                 getCreatureStats(ptr).setKnockedDown(true);
-
             }
             else
                 getCreatureStats(ptr).setHitRecovery(true); // Is this supposed to always occur?
@@ -819,11 +842,30 @@ namespace MWClass
 
             MWBase::Environment::get().getMechanicsManager()->actorKilled(ptr, attacker);
         }
+
+
+        if(attacker == MWMechanics::getPlayer() && mwmp::Main::get().getNetworking()->isDedicatedPlayer(ptr))
+        {
+            mwmp::Attack *_atk = mwmp::Main::get().getLocalPlayer()->GetAttack();
+            _atk->damage = damage;
+            _atk->attacker = mwmp::Main::get().getLocalPlayer()->guid;
+            _atk->target = mwmp::Players::GetPlayer(ptr)->guid;
+            _atk->knockdown = getCreatureStats(ptr).getKnockedDown();
+            mwmp::Main::get().getLocalPlayer()->SendAttack(0); // todo : нужна чуствительность к виду
+        }
+
+        if(ptr == MWMechanics::getPlayer())
+        {
+            mwmp::Main::get().getLocalPlayer()->updateBaseStats(true);
+            mwmp::Main::get().getLocalPlayer()->updatePosition(true); // fix position after get damage;
+        }
     }
 
     boost::shared_ptr<MWWorld::Action> Npc::activate (const MWWorld::Ptr& ptr,
         const MWWorld::Ptr& actor) const
     {
+        if(actor == MWMechanics::getPlayer() && mwmp::Main::get().getNetworking()->isDedicatedPlayer(ptr))
+            return boost::shared_ptr<MWWorld::Action>(new MWWorld::FailedAction("Not implemented."));
         // player got activated by another NPC
         if(ptr == MWMechanics::getPlayer())
             return boost::shared_ptr<MWWorld::Action>(new MWWorld::ActionTalk(actor));
diff --git a/apps/openmw/mwinput/inputmanagerimp.cpp b/apps/openmw/mwinput/inputmanagerimp.cpp
index 6c2e695e6..a4e0801fd 100644
--- a/apps/openmw/mwinput/inputmanagerimp.cpp
+++ b/apps/openmw/mwinput/inputmanagerimp.cpp
@@ -16,6 +16,7 @@
 
 #include <components/sdlutil/sdlinputwrapper.hpp>
 #include <components/sdlutil/sdlvideowrapper.hpp>
+#include <apps/openmw/mwmp/Main.hpp>
 
 #include "../mwbase/world.hpp"
 #include "../mwbase/windowmanager.hpp"
@@ -658,6 +659,7 @@ namespace MWInput
 
     void InputManager::keyPressed( const SDL_KeyboardEvent &arg )
     {
+        mwmp::Main::PressedKey(arg.keysym.sym);
         // HACK: to make Morrowind's default keybinding for the console work without printing an extra "^" upon closing
         // This assumes that SDL_TextInput events always come *after* the key event
         // (which is somewhat reasonable, and hopefully true for all SDL platforms)
diff --git a/apps/openmw/mwmechanics/actors.cpp b/apps/openmw/mwmechanics/actors.cpp
index d12dde424..1476e0b48 100644
--- a/apps/openmw/mwmechanics/actors.cpp
+++ b/apps/openmw/mwmechanics/actors.cpp
@@ -8,6 +8,9 @@
 #include <components/esm/loadnpc.hpp>
 
 #include <components/sceneutil/positionattitudetransform.hpp>
+#include <apps/openmw/mwmp/Main.hpp>
+#include <apps/openmw/mwmp/DedicatedPlayer.hpp>
+
 
 #include "../mwworld/esmstore.hpp"
 #include "../mwworld/class.hpp"
@@ -1030,7 +1033,15 @@ namespace MWMechanics
                 iter->second->getCharacterController()->setActive(inProcessingRange);
 
                 if (iter->first == player)
-                    iter->second->getCharacterController()->setAttackingOrSpell(MWBase::Environment::get().getWorld()->getPlayer().getAttackingOrSpell());
+                {
+                    bool state = MWBase::Environment::get().getWorld()->getPlayer().getAttackingOrSpell();
+                    iter->second->getCharacterController()->setAttackingOrSpell(state);
+                    mwmp::Main::get().getLocalPlayer()->PrepareAttack(2, state);
+                }
+
+                if(mwmp::Main::get().getNetworking()->isDedicatedPlayer(iter->first))
+                    iter->second->getCharacterController()->setAttackingOrSpell(mwmp::Main::get().getNetworking()->Attack(iter->first));
+
 
                 if (!iter->first.getClass().getCreatureStats(iter->first).isDead())
                 {
diff --git a/apps/openmw/mwmechanics/combat.cpp b/apps/openmw/mwmechanics/combat.cpp
index df2793bcb..1ed554b51 100644
--- a/apps/openmw/mwmechanics/combat.cpp
+++ b/apps/openmw/mwmechanics/combat.cpp
@@ -3,6 +3,9 @@
 #include <components/misc/rng.hpp>
 
 #include <components/sceneutil/positionattitudetransform.hpp>
+#include <apps/openmw/mwmp/Networking.hpp>
+#include <apps/openmw/mwmp/Main.hpp>
+#include <apps/openmw/mwmp/DedicatedPlayer.hpp>
 
 #include "../mwbase/environment.hpp"
 #include "../mwbase/world.hpp"
@@ -112,8 +115,17 @@ namespace MWMechanics
         int iBlockMinChance = gmst.find("iBlockMinChance")->getInt();
         x = std::min(iBlockMaxChance, std::max(iBlockMinChance, x));
 
-        if (Misc::Rng::roll0to99() < x)
+
+        bool isDedicated = mwmp::Main::get().getNetworking()->isDedicatedPlayer(blocker);
+        if(attacker == MWMechanics::getPlayer())
+            mwmp::Main::get().getLocalPlayer()->GetAttack()->block = false;
+
+        if((!isDedicated && Misc::Rng::roll0to99() < x) ||
+           (isDedicated && mwmp::Players::GetPlayer(blocker)->GetAttack()->block == 1))
         {
+            if(attacker == MWMechanics::getPlayer())
+                mwmp::Main::get().getLocalPlayer()->GetAttack()->block = true;
+
             // Reduce shield durability by incoming damage
             int shieldhealth = shield->getClass().getItemHealth(*shield);
 
@@ -168,6 +180,8 @@ namespace MWMechanics
     void projectileHit(const MWWorld::Ptr &attacker, const MWWorld::Ptr &victim, MWWorld::Ptr weapon, const MWWorld::Ptr &projectile,
                        const osg::Vec3f& hitPosition, float attackStrength)
     {
+        if(mwmp::Main::get().getNetworking()->isDedicatedPlayer(attacker))
+            return;
         MWBase::World *world = MWBase::Environment::get().getWorld();
         const MWWorld::Store<ESM::GameSetting> &gmst = world->getStore().get<ESM::GameSetting>();
 
@@ -188,8 +202,13 @@ namespace MWMechanics
         int skillValue = attacker.getClass().getSkill(attacker,
                                            weapon.getClass().getEquipmentSkill(weapon));
 
+        if(attacker == MWBase::Environment::get().getWorld()->getPlayerPtr())
+            mwmp::Main::get().getLocalPlayer()->GetAttack()->success = true;
+
         if (Misc::Rng::roll0to99() >= getHitChance(attacker, victim, skillValue))
         {
+            if(attacker == getPlayer())
+                mwmp::Main::get().getLocalPlayer()->GetAttack()->success = false;
             victim.getClass().onHit(victim, 0.0f, false, projectile, attacker, false);
             MWMechanics::reduceWeaponCondition(0.f, false, weapon, attacker);
             return;
diff --git a/apps/openmw/mwmechanics/spellcasting.cpp b/apps/openmw/mwmechanics/spellcasting.cpp
index 52815816e..5b09a9b02 100644
--- a/apps/openmw/mwmechanics/spellcasting.cpp
+++ b/apps/openmw/mwmechanics/spellcasting.cpp
@@ -6,6 +6,8 @@
 #include <boost/format.hpp>
 
 #include <components/misc/rng.hpp>
+#include <apps/openmw/mwmp/Main.hpp>
+#include <apps/openmw/mwmp/DedicatedPlayer.hpp>
 
 #include "../mwbase/windowmanager.hpp"
 #include "../mwbase/soundmanager.hpp"
@@ -809,13 +811,38 @@ namespace MWMechanics
 
             // Check success
             float successChance = getSpellSuccessChance(spell, mCaster);
-            if (Misc::Rng::roll0to99() >= successChance)
+
+            bool isDedicated = mwmp::Main::get().getNetworking()->isDedicatedPlayer(mCaster);
+
+            if(mCaster == getPlayer())
+            {
+                mwmp::Main::get().getLocalPlayer()->GetAttack()->success = true;
+                mwmp::Main::get().getLocalPlayer()->GetAttack()->pressed = true;
+            }
+
+            if(isDedicated)
+            {
+                mwmp::Players::GetPlayer(mCaster)->GetAttack()->pressed = false;
+            }
+
+            if ((!isDedicated && Misc::Rng::roll0to99() >= successChance) ||
+                (isDedicated && mwmp::Players::GetPlayer(mCaster)->GetAttack()->success == 0))
             {
                 if (mCaster == getPlayer())
+                {
+                    mwmp::Main::get().getLocalPlayer()->GetAttack()->success = false;
                     MWBase::Environment::get().getWindowManager()->messageBox("#{sMagicSkillFail}");
+                }
                 fail = true;
             }
 
+            if(mCaster == getPlayer())
+            {
+                mwmp::Main::get().getLocalPlayer()->SendAttack(1);
+                mwmp::Main::get().getLocalPlayer()->GetAttack()->pressed = false;
+                mwmp::Main::get().getLocalPlayer()->SendAttack(1);
+            }
+
             if (fail)
             {
                 // Failure sound
diff --git a/apps/openmw/mwmp/DedicatedPlayer.cpp b/apps/openmw/mwmp/DedicatedPlayer.cpp
new file mode 100644
index 000000000..28fdf2f72
--- /dev/null
+++ b/apps/openmw/mwmp/DedicatedPlayer.cpp
@@ -0,0 +1,404 @@
+//
+// Created by koncord on 02.01.16.
+//
+
+#include "DedicatedPlayer.hpp"
+#include <apps/openmw/mwmechanics/aitravel.hpp>
+#include "../mwbase/environment.hpp"
+#include "../mwstate/statemanagerimp.hpp"
+#include "../mwinput/inputmanagerimp.hpp"
+#include "../mwgui/windowmanagerimp.hpp"
+#include "../mwworld/worldimp.hpp"
+#include "../mwworld/player.hpp"
+#include "../mwworld/customdata.hpp"
+#include "../mwclass/npc.hpp"
+#include "../mwmechanics/creaturestats.hpp"
+#include "../mwmechanics/npcstats.hpp"
+#include "../mwmechanics/mechanicsmanagerimp.hpp"
+#include "../mwworld/cellstore.hpp"
+#include "../mwworld/action.hpp"
+#include <apps/openmw/mwworld/inventorystore.hpp>
+#include <boost/algorithm/clamp.hpp>
+using namespace mwmp;
+using namespace std;
+
+std::map<RakNet::RakNetGUID, DedicatedPlayer *> Players::players;
+
+DedicatedPlayer::DedicatedPlayer(RakNet::RakNetGUID guid) : BasePlayer(guid)
+{
+    GetAttack()->pressed = 0;
+    CreatureStats()->mDead = false;
+    movementFlags = 0;
+}
+DedicatedPlayer::~DedicatedPlayer()
+{
+
+}
+
+MWWorld::Ptr DedicatedPlayer::getPtr()
+{
+    return ptr;
+}
+
+void Players::CreatePlayer(RakNet::RakNetGUID id)
+{
+    MWBase::World *world = MWBase::Environment::get().getWorld();
+    MWWorld::Ptr player = world->getPlayerPtr();
+
+    ESM::NPC dedic_pl = *player.get<ESM::NPC>()->mBase;
+    DedicatedPlayer *_player = players[id];
+
+    dedic_pl.mRace = _player->Npc()->mRace;
+    dedic_pl.mHead = _player->Npc()->mHead;
+    dedic_pl.mHair = _player->Npc()->mHair;
+    dedic_pl.mName = _player->Npc()->mName;
+    dedic_pl.mFlags = _player->Npc()->mFlags;
+
+
+    if (_player->state == 0)
+    {
+        dedic_pl.mId = "Dedicated Player";
+
+        std::string recid = world->createRecord(dedic_pl)->mId;
+
+
+        _player->reference = new MWWorld::ManualRef(world->getStore(), recid, 1);
+
+        // temporary spawn character in ToddTest cell
+        ESM::Position _pos;
+        world->findInteriorPosition("ToddTest", _pos);
+        MWWorld::CellStore *store = world->getInterior("ToddTest");
+
+        MWWorld::Ptr tmp = world->safePlaceObject(_player->reference->getPtr(), store, _pos);
+
+        _player->ptr.mCell = tmp.mCell;
+        _player->ptr.mRef = tmp.mRef;
+
+    }
+    else
+    {
+        dedic_pl.mId = players[id]->ptr.get<ESM::NPC>()->mBase->mId;
+
+        MWWorld::ESMStore *store = const_cast<MWWorld::ESMStore *>(&world->getStore());
+        MWWorld::Store<ESM::NPC> *esm_store = const_cast<MWWorld::Store<ESM::NPC> *> (&store->get<ESM::NPC>());
+
+        esm_store->insert(dedic_pl);
+    }
+
+    _player->guid = id;
+    _player->state = 2;
+
+    _player->cell = *_player->ptr.getCell()->getCell();
+    _player->pos = _player->ptr.getRefData().getPosition();
+    world->enable(players[id]->ptr);
+}
+
+
+void Players::CleanUp()
+{
+    for(std::map <RakNet::RakNetGUID, DedicatedPlayer *>::iterator it = players.begin(); it != players.end(); it++)
+        delete it->second;
+}
+
+void Players::DisconnectPlayer(RakNet::RakNetGUID id)
+{
+    if (players[id]->state > 1)
+    {
+        players[id]->state = 1;
+        MWBase::World *world = MWBase::Environment::get().getWorld();
+        world->disable(players[id]->getPtr());
+
+        //move player to toddTest
+        ESM::Position _pos;
+        world->findInteriorPosition("ToddTest", _pos);
+        MWWorld::CellStore *store = world->getInterior("ToddTest");
+
+        world->moveObject(players[id]->getPtr(), store, _pos.pos[0], _pos.pos[1], _pos.pos[2]);
+    }
+}
+
+DedicatedPlayer *Players::GetPlayer(RakNet::RakNetGUID id)
+{
+    return players[id];
+}
+
+MWWorld::Ptr DedicatedPlayer::getLiveCellPtr()
+{
+    return reference->getPtr();
+}
+
+MWWorld::ManualRef *DedicatedPlayer::getRef()
+{
+    return reference;
+}
+
+ESM::Position Slerp(ESM::Position start, ESM::Position end, float percent)
+{
+    // dot product - the cosine of the angle between 2 vectors.
+    float dot = start.asVec3() * end.asVec3();
+    // clamp it to be in the range of Acos()
+    // This may be unnecessary, but floating point
+    // precision can be a fickle mistress.
+    dot = boost::algorithm::clamp(dot, -1.0f, 1.0f);
+    // acos(dot) returns the angle between start and end,
+    // And multiplying that by percent returns the angle between
+    // start and the final result.
+    float theta = acos(dot) * percent;
+    osg::Vec3f relativeVec = end.asVec3() - start.asVec3() * dot;
+    relativeVec.normalize(); // Orthonormal basis
+
+    // result
+    osg::Vec3f tmp ((start.asVec3() * cos(theta)) + (relativeVec * sin(theta)));
+    ESM::Position result;
+
+    result.pos[0] = tmp.x();
+    result.pos[1] = tmp.y();
+    result.pos[2] = tmp.z();
+
+    result.rot[0] = start.rot[0];
+    result.rot[1] = start.rot[1];
+    result.rot[2] = result.rot[2];
+    return result;
+}
+
+osg::Vec3f Lerp(osg::Vec3f start, osg::Vec3f end, float percent)
+{
+    osg::Vec3f p(percent, percent, percent);
+
+    return (start + osg::componentMultiply(p, (end - start)));
+}
+
+void DedicatedPlayer::Move(float dt)
+{
+    if (state != 2) return;
+
+    ESM::Position ref_pos = ptr.getRefData().getPosition();
+    MWBase::World *world = MWBase::Environment::get().getWorld();
+
+
+    {
+        osg::Vec3f lerp = Lerp(ref_pos.asVec3(), pos.asVec3(), dt * 15);
+        ref_pos.pos[0] = lerp.x();
+        ref_pos.pos[1] = lerp.y();
+        ref_pos.pos[2] = lerp.z();
+        ptr.getRefData().setPosition(ref_pos);
+    }
+
+    MWMechanics::Movement *move = &ptr.getClass().getMovementSettings(ptr);
+    move->mPosition[0] = dir.pos[0];
+    move->mPosition[1] = dir.pos[1];
+    move->mPosition[2] = dir.pos[2];
+
+    world->rotateObject(ptr, pos.rot[0], pos.rot[1], pos.rot[2]);
+}
+
+void Players::Update(float dt)
+{
+    for(std::map <RakNet::RakNetGUID, DedicatedPlayer *>::iterator it = players.begin(); it != players.end(); it++)
+    {
+        DedicatedPlayer *pl = it->second;
+        if(pl == 0) continue;
+
+        MWMechanics::NpcStats *npcStats = &pl->ptr.getClass().getNpcStats(pl->getPtr());
+
+        MWMechanics::DynamicStat<float> value;
+
+        if(pl->CreatureStats()->mDead)
+        {
+            value.readState(pl->CreatureStats()->mDynamic[0]);
+            npcStats->setHealth(value);
+            continue;
+        }
+
+        value.readState(pl->CreatureStats()->mDynamic[0]);
+        npcStats->setHealth(value);
+        value.readState(pl->CreatureStats()->mDynamic[1]);
+        npcStats->setMagicka(value);
+        value.readState(pl->CreatureStats()->mDynamic[2]);
+        npcStats->setFatigue(value);
+
+        if(npcStats->isDead())
+            npcStats->resurrect();
+
+
+        npcStats->setAttacked(false);
+
+        npcStats->getAiSequence().stopCombat();
+
+        npcStats->setAlarmed(false);
+        npcStats->setAiSetting(MWMechanics::CreatureStats::AI_Alarm, 0);
+        npcStats->setAiSetting(MWMechanics::CreatureStats::AI_Fight, 0);
+        npcStats->setAiSetting(MWMechanics::CreatureStats::AI_Flee, 0);
+        npcStats->setAiSetting(MWMechanics::CreatureStats::AI_Hello, 0);
+
+        npcStats->setBaseDisposition(255);
+        pl->Move(dt);
+        pl->UpdateDrawState();
+    }
+}
+
+void DedicatedPlayer::UpdatePtr(MWWorld::Ptr newPtr)
+{
+    ptr.mCell = newPtr.mCell;
+    ptr.mRef = newPtr.mRef;
+    ptr.mContainerStore = newPtr.mContainerStore;
+}
+
+
+DedicatedPlayer *Players::NewPlayer(RakNet::RakNetGUID guid)
+{
+    players[guid] = new DedicatedPlayer(guid);
+    players[guid]->state = 0;
+    return players[guid];
+}
+
+void DedicatedPlayer::UpdateInventory()
+{
+    MWWorld::InventoryStore& invStore = ptr.getClass().getInventoryStore(ptr);
+    for (int slot = 0; slot < MWWorld::InventoryStore::Slots; ++slot)
+    {
+        MWWorld::ContainerStoreIterator it = invStore.getSlot(slot);
+
+        const string &dedicItem = EquipedItem(slot)->refid;
+        std::string item = "";
+        bool equal = false;
+        if(it != invStore.end())
+        {
+            item = it->getCellRef().getRefId();
+            if(!Misc::StringUtils::ciEqual(item, dedicItem)) // if other item equiped
+            {
+                MWWorld::ContainerStore &store = ptr.getClass().getContainerStore(ptr);
+                store.remove(item, store.count(item), ptr);
+            }
+            else
+                equal = true;
+        }
+
+        if(dedicItem.empty() || equal)
+            continue;
+
+        const int count = EquipedItem(slot)->count;
+        ptr.getClass().getContainerStore(ptr).add(dedicItem, count, ptr);
+
+        for (MWWorld::ContainerStoreIterator it2 = invStore.begin(); it2 != invStore.end(); ++it2)
+        {
+            if (::Misc::StringUtils::ciEqual(it2->getCellRef().getRefId(), dedicItem)) // equip item
+            {
+                boost::shared_ptr<MWWorld::Action> action = it2->getClass().use(*it2);
+                action->execute(ptr);
+                break;
+            }
+        }
+    }
+}
+
+const std::string DedicatedPlayer::GetAnim()
+{
+    static string anim;
+    static string anim_dir;
+    static string anim_weap;
+
+    MWMechanics::NpcStats *npcStats = &ptr.getClass().getNpcStats(ptr);
+
+    if (movementFlags & MWMechanics::CreatureStats::Flag_Run)
+        anim = "run";
+    else if (movementFlags & MWMechanics::CreatureStats::Flag_Sneak)
+        anim = "sneak";
+    else
+        anim = "walk";
+
+    if(movementAnim != 0)
+    {
+
+        if (movementAnim == 3)
+            anim_dir = "forward";
+        else if (movementAnim == 4)
+            anim_dir = "back";
+        else if (movementAnim == 2)
+            anim_dir = "left";
+        else if (movementAnim == 1)
+            anim_dir = "right";
+    }
+    else
+    {
+        anim = "idle";
+        anim_dir = "";
+    }
+
+    if (npcStats->getDrawState() == MWMechanics::DrawState_Weapon)
+    {
+        MWWorld::InventoryStore& invStore = ptr.getClass().getInventoryStore(ptr);
+        MWWorld::ContainerStoreIterator weaponSlot = invStore.getSlot(MWWorld::InventoryStore::Slot_CarriedRight);
+
+        if (weaponSlot != invStore.end() && weaponSlot->getTypeName() == typeid(ESM::Weapon).name())
+        {
+            int type = weaponSlot->get<ESM::Weapon>()->mBase->mData.mType;
+            if (type == ESM::Weapon::ShortBladeOneHand ||
+                type == ESM::Weapon::LongBladeOneHand ||
+                type == ESM::Weapon::BluntOneHand ||
+                type == ESM::Weapon::AxeOneHand /*||
+                type == ESM::Weapon::MarksmanThrown ||
+                type == ESM::Weapon::MarksmanCrossbow ||
+                type == ESM::Weapon::MarksmanBow*/)
+                anim_weap = "1h";
+            else if(type == ESM::Weapon::LongBladeTwoHand ||
+                    type == ESM::Weapon::BluntTwoClose ||
+                    type == ESM::Weapon::AxeTwoHand)
+                anim_weap = "2c";
+            else if(type == ESM::Weapon::BluntTwoWide ||
+                    type == ESM::Weapon::SpearTwoWide)
+                anim_weap = "2w";
+        }
+        else
+            anim_weap = "hh";
+    }
+    else if (movementAnim == 0 && npcStats->getDrawState() == MWMechanics::DrawState_Spell)
+        anim_weap = "spell";
+    else
+        anim_weap = "";
+
+    return (anim + anim_dir + anim_weap);
+}
+
+DedicatedPlayer *Players::GetPlayer(const MWWorld::Ptr &ptr)
+{
+    std::map <RakNet::RakNetGUID, DedicatedPlayer *>::iterator it = players.begin();
+
+    for(; it != players.end(); it++)
+    {
+        if(it->second == 0 || it->second->getPtr().mRef == 0)
+            continue;
+        string refid = ptr.getCellRef().getRefId();
+        if(it->second->getPtr().getCellRef().getRefId() == refid)
+            return it->second;
+    }
+    return 0;
+}
+
+void DedicatedPlayer::UpdateDrawState()
+{
+    using namespace MWMechanics;
+    if (drawState == 0)
+        ptr.getClass().getNpcStats(ptr).setDrawState(DrawState_Nothing);
+    else if(drawState == 1)
+        ptr.getClass().getNpcStats(ptr).setDrawState(DrawState_Weapon);
+    else if(drawState == 2)
+        ptr.getClass().getNpcStats(ptr).setDrawState(DrawState_Spell);
+
+    MWMechanics::NpcStats *npcStats = &ptr.getClass().getNpcStats(ptr);
+    npcStats->setMovementFlag(CreatureStats::Flag_Run, (movementFlags & CreatureStats::Flag_Run) != 0);
+    npcStats->setMovementFlag(CreatureStats::Flag_Sneak, (movementFlags & CreatureStats::Flag_Sneak) != 0);
+    npcStats->setMovementFlag(CreatureStats::Flag_ForceJump, (movementFlags & CreatureStats::Flag_ForceJump) != 0);
+    npcStats->setMovementFlag(CreatureStats::Flag_ForceMoveJump, (movementFlags & CreatureStats::Flag_ForceMoveJump) != 0);
+}
+
+void DedicatedPlayer::updateCell()
+{
+    MWBase::World *world = MWBase::Environment::get().getWorld();
+    MWWorld::CellStore *cellStore;
+    if (cell.isExterior() == 1)
+        cellStore = world->getExterior(cell.mCellId.mIndex.mX, cell.mCellId.mIndex.mY);
+    else
+        cellStore = world->getInterior(cell.mName);
+    UpdatePtr(world->moveObject(ptr, cellStore, pos.pos[0], pos.pos[1], pos.pos[2]));
+}
diff --git a/apps/openmw/mwmp/DedicatedPlayer.hpp b/apps/openmw/mwmp/DedicatedPlayer.hpp
new file mode 100644
index 000000000..69ffeba3e
--- /dev/null
+++ b/apps/openmw/mwmp/DedicatedPlayer.hpp
@@ -0,0 +1,60 @@
+//
+// Created by koncord on 02.01.16.
+//
+
+#ifndef OPENMW_PLAYER_HPP
+#define OPENMW_PLAYER_HPP
+
+#include <components/esm/loadnpc.hpp>
+#include <apps/openmw/mwworld/manualref.hpp>
+#include <map>
+#include <apps/openmw/mwmechanics/aisequence.hpp>
+#include <RakNetTypes.h>
+
+#include <components/openmw-mp/Base/BasePlayer.hpp>
+
+
+namespace mwmp
+{
+    struct DedicatedPlayer;
+
+    class Players
+    {
+    public:
+        static DedicatedPlayer *NewPlayer(RakNet::RakNetGUID guid);
+        static void CreatePlayer(RakNet::RakNetGUID guid);
+        static void DisconnectPlayer(RakNet::RakNetGUID guid);
+        static void CleanUp();
+        static DedicatedPlayer *GetPlayer(RakNet::RakNetGUID guid);
+        static DedicatedPlayer *GetPlayer(const MWWorld::Ptr &ptr);
+        static void Update(float dt);
+    private:
+        static std::map<RakNet::RakNetGUID, DedicatedPlayer *> players;
+    };
+
+    class DedicatedPlayer : public BasePlayer
+    {
+        friend class Players;
+    public:
+
+        MWWorld::Ptr getPtr();
+        MWWorld::Ptr getLiveCellPtr();
+        MWWorld::ManualRef* getRef();
+        void Move(float dt);
+        void UpdateDrawState();
+        void UpdateInventory();
+
+        void updateCell();
+
+    private:
+        DedicatedPlayer(RakNet::RakNetGUID guid);
+        virtual ~DedicatedPlayer();
+        void UpdatePtr(MWWorld::Ptr newPtr);
+        const std::string GetAnim();
+        int state;
+        MWWorld::ManualRef* reference;
+
+        MWWorld::Ptr ptr;
+    };
+}
+#endif //OPENMW_PLAYER_HPP
diff --git a/apps/openmw/mwmp/GUIChat.cpp b/apps/openmw/mwmp/GUIChat.cpp
new file mode 100644
index 000000000..6c4c46199
--- /dev/null
+++ b/apps/openmw/mwmp/GUIChat.cpp
@@ -0,0 +1,238 @@
+//
+// Created by koncord on 04.03.16.
+//
+
+#include "GUIChat.hpp"
+
+#include <MyGUI_EditBox.h>
+#include <apps/openmw/mwbase/environment.hpp>
+#include <apps/openmw/mwgui/windowmanagerimp.hpp>
+#include <apps/openmw/mwinput/inputmanagerimp.hpp>
+#include <MyGUI_InputManager.h>
+
+#include "../mwbase/environment.hpp"
+#include "../mwbase/windowmanager.hpp"
+#include "../mwworld/worldimp.hpp"
+#include "../mwworld/player.hpp"
+#include "Networking.hpp"
+#include "Main.hpp"
+
+
+namespace mwmp
+{
+    GUIChat::GUIChat(int x, int y, int w, int h)
+            : WindowBase("openmw_console.layout")
+    {
+        setCoord(x, y, w, h);
+
+        getWidget(mCommandLine, "edit_Command");
+        getWidget(mHistory, "list_History");
+
+        // Set up the command line box
+        mCommandLine->eventEditSelectAccept +=
+                newDelegate(this, &GUIChat::acceptCommand);
+        mCommandLine->eventKeyButtonPressed +=
+                newDelegate(this, &GUIChat::keyPress);
+
+        setTitle("Chat");
+
+        mHistory->setOverflowToTheLeft(true);
+
+        windowState = 0;
+        mCommandLine->setVisible(0);
+        delay = 3; // 3 sec.
+    }
+
+    void GUIChat::open()
+    {
+        // Give keyboard focus to the combo box whenever the console is
+        // turned on
+        SetEditState(0);
+        windowState = CHAT_ENABLED;
+    }
+
+    void GUIChat::close()
+    {
+        // Apparently, hidden widgets can retain key focus
+        // Remove for MyGUI 3.2.2
+        windowState = CHAT_DISABLED;
+        SetEditState(0);
+    }
+
+    void GUIChat::exit()
+    {
+        //WindowBase::exit();
+    }
+
+    void GUIChat::resetReference()
+    {
+        ReferenceInterface::resetReference();
+        //setSelectedObject(MWWorld::Ptr());
+    }
+
+    void GUIChat::onReferenceUnavailable()
+    {
+        //setSelectedObject(MWWorld::Ptr());
+    }
+
+    void GUIChat::acceptCommand(MyGUI::EditBox *_sender)
+    {
+        const std::string &cm = mCommandLine->getOnlyText();
+        if(cm.empty()) return;
+
+        // Add the command to the history, and set the current pointer to
+        // the end of the list
+        if (mCommandHistory.empty() || mCommandHistory.back() != cm)
+            mCommandHistory.push_back(cm);
+        mCurrent = mCommandHistory.end();
+        mEditString.clear();
+
+        // Reset the command line before the command execution.
+        // It prevents the re-triggering of the acceptCommand() event for the same command
+        // during the actual command execution
+        mCommandLine->setCaption("");
+        SetEditState(0);
+        send (cm);
+    }
+
+    void GUIChat::onResChange(int width, int height)
+    {
+        setCoord(10,10, width-10, height/2);
+    }
+
+    void GUIChat::setFont(const std::string &fntName)
+    {
+        mHistory->setFontName(fntName);
+        mCommandLine->setFontName(fntName);
+    }
+
+    void GUIChat::print(const std::string &msg, const std::string &color)
+    {
+        if(windowState == 2 && !isVisible())
+        {
+            setVisible(true);
+        }
+        mHistory->addText(color + MyGUI::TextIterator::toTagsString(msg));
+    }
+
+    void GUIChat::printOK(const std::string &msg)
+    {
+        print(msg + "\n", "#FF00FF");
+    }
+
+    void GUIChat::printError(const std::string &msg)
+    {
+        print(msg + "\n", "#FF2222");
+    }
+
+    void GUIChat::send(const std::string &str)
+    {
+        LocalPlayer *localPlayer = Main::get().getLocalPlayer();
+
+        Networking *networking = Main::get().getNetworking();
+
+        *localPlayer->ChatMessage() = str;
+
+        RakNet::BitStream bs;
+        networking->GetPacket(ID_CHAT_MESSAGE)->Packet(&bs, localPlayer, true);
+        networking->SendData(&bs);
+    }
+
+    void GUIChat::clean()
+    {
+        mHistory->clearUserStrings();
+    }
+
+    void GUIChat::PressedChatMode()
+    {
+        windowState++;
+        if(windowState == 3) windowState = 0;
+
+        switch(windowState)
+        {
+            case CHAT_DISABLED:
+                this->mMainWidget->setVisible(false);
+                SetEditState(0);
+                break;
+            case CHAT_ENABLED:
+                this->mMainWidget->setVisible(true);
+                break;
+            default: //CHAT_HIDDENMODE
+                this->mMainWidget->setVisible(true);
+                curTime = 0;
+        }
+    }
+
+    void GUIChat::SetEditState(bool state)
+    {
+        editState = state;
+        mCommandLine->setVisible(editState);
+        MWBase::Environment::get().getWindowManager()->setKeyFocusWidget(editState ? mCommandLine : nullptr);
+    }
+
+    void GUIChat::PressedSay()
+    {
+        if (windowState == CHAT_DISABLED)
+            return;
+        else if(windowState == CHAT_HIDDENMODE)
+        {
+            setVisible(true);
+            curTime = 0;
+            editState = true;
+        }
+        else // CHAT_ENABLED
+            editState = true;
+        SetEditState(editState);
+    }
+
+    void GUIChat::keyPress(MyGUI::Widget *_sender, MyGUI::KeyCode key, MyGUI::Char _char)
+    {
+        if(mCommandHistory.empty()) return;
+
+        // Traverse history with up and down arrows
+        if(key == MyGUI::KeyCode::ArrowUp)
+        {
+            // If the user was editing a string, store it for later
+            if(mCurrent == mCommandHistory.end())
+                mEditString = mCommandLine->getOnlyText();
+
+            if(mCurrent != mCommandHistory.begin())
+            {
+                --mCurrent;
+                mCommandLine->setCaption(*mCurrent);
+            }
+        }
+        else if(key == MyGUI::KeyCode::ArrowDown)
+        {
+            if(mCurrent != mCommandHistory.end())
+            {
+                ++mCurrent;
+
+                if(mCurrent != mCommandHistory.end())
+                    mCommandLine->setCaption(*mCurrent);
+                else
+                    // Restore the edit string
+                    mCommandLine->setCaption(mEditString);
+            }
+        }
+
+    }
+
+    void GUIChat::Update(float dt)
+    {
+        if(windowState == CHAT_HIDDENMODE && !editState && isVisible())
+        {
+            curTime += dt;
+            if(curTime >= delay)
+            {
+                SetEditState(false);
+                this->mMainWidget->setVisible(false);
+            }
+        }
+    }
+
+    void GUIChat::SetDelay(float delay)
+    {
+        this->delay = delay;
+    }
+}
\ No newline at end of file
diff --git a/apps/openmw/mwmp/GUIChat.hpp b/apps/openmw/mwmp/GUIChat.hpp
new file mode 100644
index 000000000..ad583c067
--- /dev/null
+++ b/apps/openmw/mwmp/GUIChat.hpp
@@ -0,0 +1,101 @@
+//
+// Created by koncord on 04.03.16.
+//
+
+#ifndef OPENMW_GUICHAT_HPP
+#define OPENMW_GUICHAT_HPP
+
+#include <list>
+#include <string>
+#include <vector>
+
+#include <components/compiler/errorhandler.hpp>
+#include <components/compiler/lineparser.hpp>
+#include <components/compiler/scanner.hpp>
+#include <components/compiler/locals.hpp>
+#include <components/compiler/output.hpp>
+#include <components/compiler/extensions.hpp>
+#include <components/interpreter/interpreter.hpp>
+
+#include "../mwgui/referenceinterface.hpp"
+#include "../mwgui/windowbase.hpp"
+
+namespace mwmp
+{
+    class GUIChat : public MWGui::WindowBase, public MWGui::ReferenceInterface
+    {
+    public:
+        enum
+        {
+            CHAT_DISABLED = 0,
+            CHAT_ENABLED,
+            CHAT_HIDDENMODE
+        } CHAT_WIN_STATE;
+
+        MyGUI::EditBox* mCommandLine;
+        MyGUI::EditBox* mHistory;
+
+        typedef std::list<std::string> StringList;
+
+        // History of previous entered commands
+        StringList mCommandHistory;
+        StringList::iterator mCurrent;
+        std::string mEditString;
+
+        GUIChat(int x, int y, int w, int h);
+
+        void PressedChatMode(); //switch chat mode
+        void PressedSay(); // switch chat focus (if chat mode != CHAT_DISABLED)
+        void SetDelay(float delay);
+
+        void Update(float dt);
+
+
+        virtual void open();
+        virtual void close();
+
+        virtual void exit();
+
+        void setFont(const std::string &fntName);
+
+        void onResChange(int width, int height);
+
+        // Print a message to the console, in specified color.
+        void print(const std::string &msg, const std::string& color = "#FFFFFF");
+
+        // Clean chat
+        void clean();
+
+        // These are pre-colored versions that you should use.
+
+        /// Output from successful console command
+        void printOK(const std::string &msg);
+
+        /// Error message
+        void printError(const std::string &msg);
+
+        virtual void resetReference ();
+
+        void send(const std::string &str);
+
+    protected:
+
+        virtual void onReferenceUnavailable();
+
+    private:
+
+        void keyPress(MyGUI::Widget* _sender,
+                      MyGUI::KeyCode key,
+                      MyGUI::Char _char);
+
+        void acceptCommand(MyGUI::EditBox* _sender);
+
+        void SetEditState(bool state);
+
+        int windowState;
+        bool editState;
+        float delay;
+        float curTime;
+    };
+}
+#endif //OPENMW_GUICHAT_HPP
diff --git a/apps/openmw/mwmp/GUILogin.cpp b/apps/openmw/mwmp/GUILogin.cpp
new file mode 100644
index 000000000..9414a7e17
--- /dev/null
+++ b/apps/openmw/mwmp/GUILogin.cpp
@@ -0,0 +1,22 @@
+//
+// Created by koncord on 19.05.16.
+//
+
+#include "GUILogin.hpp"
+#include <MyGUI_EditBox.h>
+#include <MyGUI_Button.h>
+
+
+GUILogin::GUILogin() : WindowModal("tes3mp_login.layout")
+{
+    center(); // center window
+
+    setVisible(false);
+
+
+    getWidget(mLogin, "EditLogin");
+    getWidget(mServer, "EditServer");
+    getWidget(mPort, "EditPort");
+    getWidget(mConnect, "ButtonConnect");
+
+}
\ No newline at end of file
diff --git a/apps/openmw/mwmp/GUILogin.hpp b/apps/openmw/mwmp/GUILogin.hpp
new file mode 100644
index 000000000..cfb129649
--- /dev/null
+++ b/apps/openmw/mwmp/GUILogin.hpp
@@ -0,0 +1,23 @@
+//
+// Created by koncord on 19.05.16.
+//
+
+#ifndef OPENMW_GUILOGIN_HPP
+#define OPENMW_GUILOGIN_HPP
+
+#include "../mwgui/windowbase.hpp"
+
+class GUILogin : public MWGui::WindowModal
+{
+public:
+    GUILogin();
+
+    MyGUI::EditBox* mLogin;
+    MyGUI::EditBox* mServer;
+    MyGUI::EditBox* mPort;
+protected:
+    MyGUI::Button* mConnect;
+};
+
+
+#endif //OPENMW_GUILOGIN_HPP
diff --git a/apps/openmw/mwmp/LocalPlayer.cpp b/apps/openmw/mwmp/LocalPlayer.cpp
new file mode 100644
index 000000000..00b27cd9e
--- /dev/null
+++ b/apps/openmw/mwmp/LocalPlayer.cpp
@@ -0,0 +1,489 @@
+//
+// Created by koncord on 14.01.16.
+//
+
+#include <apps/openmw/mwworld/manualref.hpp>
+#include <apps/openmw/mwmechanics/aitravel.hpp>
+#include <components/esm/esmwriter.hpp>
+#include "../mwbase/environment.hpp"
+#include "../mwstate/statemanagerimp.hpp"
+#include "../mwinput/inputmanagerimp.hpp"
+#include "../mwscript/scriptmanagerimp.hpp"
+#include "../mwgui/windowmanagerimp.hpp"
+#include "../mwworld/worldimp.hpp"
+#include "../mwworld/player.hpp"
+#include "../mwworld/customdata.hpp"
+#include "../mwmechanics/creaturestats.hpp"
+#include "../mwclass/npc.hpp"
+#include "../mwclass/creature.hpp"
+#include "../mwmechanics/mechanicsmanagerimp.hpp"
+#include "../mwworld/cellstore.hpp"
+#include <apps/openmw/mwdialogue/dialoguemanagerimp.hpp>
+#include <apps/openmw/mwworld/inventorystore.hpp>
+#include <apps/openmw/mwmechanics/spellcasting.hpp>
+#include <apps/openmw/mwgui/inventorywindow.hpp>
+
+#include "LocalPlayer.hpp"
+#include "Main.hpp"
+
+using namespace mwmp;
+using namespace std;
+
+LocalPlayer::LocalPlayer()
+{
+    CharGenStage()->current = 0;
+    CharGenStage()->end = 1;
+}
+
+LocalPlayer::~LocalPlayer()
+{
+
+}
+
+void LocalPlayer::Update()
+{
+    updateCell();
+    updatePosition();
+    updateDrawStateAndFlags();
+    updateAttackState();
+    updateDeadState();
+    updateInventory();
+    updateBaseStats();
+}
+
+MWWorld::Ptr LocalPlayer::GetPlayerPtr()
+{
+    return MWBase::Environment::get().getWorld()->getPlayerPtr();
+}
+
+void LocalPlayer::updateBaseStats(bool forceUpdate)
+{
+    MWWorld::Ptr player = GetPlayerPtr();
+
+    MWMechanics::CreatureStats *creatureClass = &player.getClass().getCreatureStats(player);
+    MWMechanics::DynamicStat<float> health(creatureClass->getHealth());
+    MWMechanics::DynamicStat<float> magicka(creatureClass->getMagicka());
+    MWMechanics::DynamicStat<float> fatigue(creatureClass->getFatigue());
+
+    static MWMechanics::DynamicStat<float> oldHealth(creatureClass->getHealth());
+    static MWMechanics::DynamicStat<float> oldMagicka(creatureClass->getMagicka());
+    static MWMechanics::DynamicStat<float> oldFatigue(creatureClass->getFatigue());
+
+    static float timer = 0;
+    if(((oldHealth != health || oldMagicka != magicka || oldFatigue != fatigue) &&
+            (timer += MWBase::Environment::get().getFrameDuration()) >= 0.5 ) || forceUpdate)
+    {
+        oldHealth = health;
+        oldMagicka = magicka;
+        oldFatigue = fatigue;
+
+        health.writeState(CreatureStats()->mDynamic[0]);
+        magicka.writeState(CreatureStats()->mDynamic[1]);
+        fatigue.writeState(CreatureStats()->mDynamic[2]);
+
+        timer = 0;
+
+        GetNetworking()->GetPacket(ID_GAME_UPDATE_BASESTATS)->Send(this);
+
+    }
+}
+
+void LocalPlayer::updatePosition(bool forceUpdate)
+{
+    MWBase::World *world = MWBase::Environment::get().getWorld();
+    MWWorld::Ptr player = world->getPlayerPtr();
+
+    const MWMechanics::Movement &move = player.getClass().getMovementSettings(player);
+
+    static bool posChanged = false;
+
+    ESM::Position _pos = player.getRefData().getPosition();
+
+    const bool isChangedPos = (move.mPosition[0] != 0 || move.mPosition[1] != 0 || move.mPosition[2] != 0
+                               || move.mRotation[0] != 0 || move.mRotation[1] != 0 || move.mRotation[2] != 0);
+
+    if (isChangedPos || posChanged || forceUpdate)
+    {
+        posChanged = isChangedPos;
+
+
+        (*Position()) = _pos;
+
+        Dir()->pos[0] = move.mPosition[0];
+        Dir()->pos[1] = move.mPosition[1];
+        Dir()->pos[2] = move.mPosition[2];
+
+        GetNetworking()->GetPacket(ID_GAME_UPDATE_POS)->Send(this);
+    }
+}
+
+
+void LocalPlayer::setPosition()
+{
+    MWBase::World *world = MWBase::Environment::get().getWorld();
+    MWWorld::Ptr player = world->getPlayerPtr();
+
+    world->getPlayer().setTeleported(true);
+    world->moveObject(player, Position()->pos[0], Position()->pos[1], Position()->pos[2]);
+    world->rotateObject(player, Position()->rot[0], Position()->rot[1], Position()->rot[2]);
+}
+
+
+void LocalPlayer::updateInventory(bool forceUpdate)
+{
+    MWWorld::Ptr player = GetPlayerPtr();
+
+    static bool invChanged = false;
+
+    if (forceUpdate)
+        invChanged = true;
+
+
+    MWWorld::InventoryStore &invStore = player.getClass().getInventoryStore(player);
+    for (int slot = 0; slot < MWWorld::InventoryStore::Slots; ++slot)
+    {
+        MWWorld::ContainerStoreIterator it = invStore.getSlot(slot);
+        if(it != invStore.end() && !::Misc::StringUtils::ciEqual(it->getCellRef().getRefId(), EquipedItem(slot)->refid))
+        {
+            invChanged = true;
+
+            EquipedItem(slot)->refid = it->getCellRef().getRefId();
+            if(slot == MWWorld::InventoryStore::Slot_CarriedRight)
+            {
+                MWMechanics::WeaponType weaptype;
+                MWMechanics::getActiveWeapon(player.getClass().getCreatureStats(player), player.getClass().getInventoryStore(player), &weaptype);
+                if(weaptype != MWMechanics::WeapType_Thrown)
+                    EquipedItem(slot)->count = 1;
+            }
+            else
+                EquipedItem(slot)->count = invStore.count(it->getCellRef().getRefId());
+        }
+        else if (it == invStore.end() && !EquipedItem(slot)->refid.empty())
+        {
+            invChanged = true;
+            EquipedItem(slot)->refid = "";
+            EquipedItem(slot)->count = 0;
+        }
+    }
+
+    if (invChanged)
+    {
+        RakNet::BitStream bs;
+        bs.ResetWritePointer();
+        GetNetworking()->GetPacket((RakNet::MessageID) ID_GAME_UPDATE_EQUIPED)->Packet(&bs, this, true);
+        GetNetworking()->SendData(&bs);
+        invChanged = false;
+    }
+}
+
+void LocalPlayer::updateAttackState(bool forceUpdate)
+{
+    MWBase::World *world = MWBase::Environment::get().getWorld();
+    MWWorld::Ptr player = GetPlayerPtr();
+
+    using namespace MWMechanics;
+
+    static bool attackPressed = false; // prevent flood
+    MWMechanics::DrawState_ state = player.getClass().getNpcStats(player).getDrawState();
+    //player.getClass().hit(player, 1, ESM::Weapon::AT_Chop);
+    if(world->getPlayer().getAttackingOrSpell() && !attackPressed)
+    {
+        MWWorld::Ptr weapon = MWWorld::Ptr(); // hand-to-hand
+        //player.getClass().onHit(player, 0.5, true, weapon, 0, 1);
+        if(state == MWMechanics::DrawState_Spell)
+        {
+            //cout << "getAttackingOrSpell" << endl;
+            const string &spell = MWBase::Environment::get().getWindowManager()->getSelectedSpell();
+
+            GetAttack()->attacker = guid;
+            GetAttack()->type = 1;
+            GetAttack()->pressed = true;
+            GetAttack()->refid = spell;
+
+            /*RakNet::BitStream bs;
+            GetNetworking()->GetPacket((RakNet::MessageID) ID_GAME_ATTACK)->Packet(&bs, this, true);
+            GetNetworking()->SendData(&bs);*/
+        }
+        else if(state == MWMechanics::DrawState_Weapon)
+        {
+            //PrepareAttack(2);
+        }
+        attackPressed = true;
+    }
+    else if(!world->getPlayer().getAttackingOrSpell() && attackPressed)
+    {
+        if(/*state == MWMechanics::DrawState_Spell ||*/ state == MWMechanics::DrawState_Weapon)
+        {
+            //localNetPlayer->GetAttack()->success = false;
+            //SendAttack(0);
+        }
+        attackPressed = false;
+    }
+}
+
+void LocalPlayer::updateDeadState(bool forceUpdate)
+{
+    MWWorld::Ptr player = GetPlayerPtr();
+
+    MWMechanics::NpcStats *playerStats = &player.getClass().getNpcStats(player);
+    static bool isDead = false;
+
+    if(playerStats->isDead() && !isDead)
+    {
+        CreatureStats()->mDead = true;
+        RakNet::BitStream bs;
+        GetNetworking()->GetPacket((RakNet::MessageID)ID_GAME_DIE)->Packet(&bs, this, true);
+        GetNetworking()->SendData(&bs);
+        isDead = true;
+    }
+    else if(playerStats->getHealth().getCurrent() > 0 && isDead)
+        isDead = false;
+}
+
+void LocalPlayer::updateAttributesAndSkills(bool forceUpdate)
+{
+    MWWorld::Ptr player = GetPlayerPtr();
+
+    const MWMechanics::NpcStats &_npcStats = player.getClass().getNpcStats(player);
+
+    for(int i = 0; i < PacketAttributesAndStats::StatsCount; ++i)
+        _npcStats.getSkill(i).writeState( NpcStats()->mSkills[i]);
+
+    for(int i = 0; i < PacketAttributesAndStats::AttributesCount; ++i)
+        _npcStats.getAttribute(i).writeState(CreatureStats()->mAttributes[i]);
+}
+
+Networking *LocalPlayer::GetNetworking()
+{
+    return mwmp::Main::get().getNetworking();
+}
+
+
+
+void LocalPlayer::PrepareAttack(char type, bool state)
+{
+    if(GetAttack()->pressed == state)
+        return;
+
+    MWMechanics::DrawState_ dstate = GetPlayerPtr().getClass().getNpcStats(GetPlayerPtr()).getDrawState();
+
+    if(dstate == MWMechanics::DrawState_Spell)
+    {
+        const string &spell = MWBase::Environment::get().getWindowManager()->getSelectedSpell();
+
+        GetAttack()->refid = spell;
+    }
+    else
+    {
+
+    }
+
+    GetAttack()->pressed = state;
+    GetAttack()->type = type;
+    GetAttack()->knockdown = false;
+    GetAttack()->success = false;
+    GetAttack()->block = false;
+    GetAttack()->target = RakNet::RakNetGUID();
+    GetAttack()->attacker = guid;
+
+    RakNet::BitStream bs;
+    GetNetworking()->GetPacket((RakNet::MessageID) ID_GAME_ATTACK)->Packet(&bs, this, true);
+    GetNetworking()->SendData(&bs);
+}
+
+
+void LocalPlayer::SendAttack(char type)
+{
+    MWMechanics::DrawState_ state = GetPlayerPtr().getClass().getNpcStats(GetPlayerPtr()).getDrawState();
+
+    if(state == MWMechanics::DrawState_Spell)
+    {
+
+    }
+    else
+    {
+
+    }
+    GetAttack()->type = type;
+    GetAttack()->pressed = false;
+    RakNet::BitStream bs;
+    GetNetworking()->GetPacket((RakNet::MessageID) ID_GAME_ATTACK)->Packet(&bs, this, true);
+    GetNetworking()->SendData(&bs);
+}
+
+
+void LocalPlayer::updateCell(bool forceUpdate)
+{
+    const ESM::Cell *_cell = MWBase::Environment::get().getWorld()->getPlayerPtr().getCell()->getCell();
+    static bool isExterior = !_cell->isExterior();
+
+    bool shouldUpdate = false;
+
+    // Send a packet to server to update this LocalPlayer's cell if:
+    // 1) forceUpdate is true
+    // 2) The LocalPlayer's cell name does not equal the World Player's cell name
+    // 3) The LocalPlayer's exterior cell coordinates do not equal the World Player's
+    //    exterior cell coordinates
+    if (forceUpdate) {
+        shouldUpdate = true;
+    }
+    else if (!Misc::StringUtils::ciEqual(_cell->mName, GetCell()->mName)) {
+        shouldUpdate = true;
+    }
+    else if (_cell->isExterior()) {
+        
+        if (_cell->mCellId.mIndex.mX != GetCell()->mCellId.mIndex.mX) {
+            shouldUpdate = true;
+        }
+        else if (_cell->mCellId.mIndex.mY != GetCell()->mCellId.mIndex.mY) {
+            shouldUpdate = true;
+        }
+    }
+
+    if (shouldUpdate)
+    {
+        (*GetCell()) = *_cell;
+        isExterior = _cell->isExterior();
+        
+        RakNet::BitStream bs;
+        GetNetworking()->GetPacket((RakNet::MessageID) ID_GAME_CELL)->Packet(&bs, this, true);
+        GetNetworking()->SendData(&bs);
+    }
+}
+
+void LocalPlayer::updateDrawStateAndFlags(bool forceUpdate)
+{
+    MWBase::World *world = MWBase::Environment::get().getWorld();
+    MWWorld::Ptr player = world->getPlayerPtr();
+
+
+    MWMechanics::NpcStats npcStats = player.getClass().getNpcStats(player);
+    using namespace MWMechanics;
+
+    static bool oldRun = npcStats.getMovementFlag(CreatureStats::Flag_Run);
+    static bool oldSneak = npcStats.getMovementFlag(CreatureStats::Flag_Sneak);
+    static bool oldForceJump = npcStats.getMovementFlag(CreatureStats::Flag_ForceJump);
+    static bool oldForceMoveJump = npcStats.getMovementFlag(CreatureStats::Flag_ForceMoveJump);
+
+    bool run = npcStats.getMovementFlag(CreatureStats::Flag_Run);
+    bool sneak = npcStats.getMovementFlag(CreatureStats::Flag_Sneak);
+    bool forceJump = npcStats.getMovementFlag(CreatureStats::Flag_ForceJump);
+    bool forceMoveJump = npcStats.getMovementFlag(CreatureStats::Flag_ForceMoveJump);
+    bool jump = !world->isOnGround(player) && !world->isFlying(player);
+    static bool onJump = false;
+
+    MWMechanics::DrawState_ state = player.getClass().getNpcStats(player).getDrawState();
+    static MWMechanics::DrawState_ oldState = player.getClass().getNpcStats(player).getDrawState();
+    //static float timer = 0;
+    if(oldRun != run
+          || oldSneak != sneak || oldForceJump != forceJump
+          || oldForceMoveJump != forceMoveJump || oldState != state ||
+            ((jump || onJump)/* && (timer += MWBase::Environment::get().getFrameDuration() )> 0.5*/)
+          || forceUpdate)
+    {
+        oldSneak = sneak;
+        oldRun = run;
+        oldForceJump = forceJump;
+        oldForceMoveJump = forceMoveJump;
+        oldState = state;
+        onJump = jump;
+
+        movementFlags = 0;
+#define __SETFLAG(flag, value) (value) ? (movementFlags | flag) : (movementFlags & ~flag)
+
+        movementFlags = __SETFLAG(CreatureStats::Flag_Sneak, sneak);
+        movementFlags = __SETFLAG(CreatureStats::Flag_Run, run);
+        movementFlags = __SETFLAG(CreatureStats::Flag_ForceJump, forceJump);
+        movementFlags = __SETFLAG(CreatureStats::Flag_ForceJump, jump);
+        movementFlags = __SETFLAG(CreatureStats::Flag_ForceMoveJump, forceMoveJump);
+
+#undef __SETFLAG
+
+        if (state == MWMechanics::DrawState_Nothing)
+            (*DrawState()) = 0;
+        else if (state == MWMechanics::DrawState_Weapon)
+            (*DrawState()) = 1;
+        else if (state == MWMechanics::DrawState_Spell)
+            (*DrawState()) = 2;
+
+        if(jump)
+            mwmp::Main::get().getLocalPlayer()->updatePosition(true); // fix position after jump;
+
+        RakNet::BitStream bs;
+        GetNetworking()->GetPacket((RakNet::MessageID) ID_GAME_DRAWSTATE)->Packet(&bs, this, true);
+        GetNetworking()->SendData(&bs);
+        //timer = 0;
+    }
+}
+
+void LocalPlayer::CharGen(int stageFirst, int stageEnd)
+{
+    CharGenStage()->current = stageFirst;
+    CharGenStage()->end = stageEnd;
+}
+
+bool LocalPlayer::CharGenThread() // ToDo: need fix
+{
+    MWBase::WindowManager *windowManager = MWBase::Environment::get().getWindowManager();
+    if(windowManager->isGuiMode())
+        return false;
+
+    if(CharGenStage()->current >= CharGenStage()->end)
+    {
+
+        if (GetNetworking()->isConnected() && CharGenStage()->current == CharGenStage()->end &&
+            CharGenStage()->end != 0)
+        {
+            MWWorld::Ptr player = MWBase::Environment::get().getWorld()->getPlayerPtr();
+            (*Npc()) = *player.get<ESM::NPC>()->mBase;
+            GetNetworking()->GetPacket(ID_GAME_BASE_INFO)->Send(this);
+            if(CharGenStage()->end != 1)
+            {
+                updateBaseStats(true);
+                updateAttributesAndSkills(true);
+                GetNetworking()->GetPacket(ID_GAME_UPDATE_SKILLS)->Send(this);
+                GetNetworking()->GetPacket(ID_GAME_CHARGEN)->Send(this);
+            }
+            CharGenStage()->end = 0;
+            /*RakNet::BitStream bs;
+            GetNetworking()->GetPacket(ID_GAME_BASE_INFO)->Packet(&bs, this, true);
+            GetNetworking()->SendData(&bs);*/
+
+        }
+        return true;
+    }
+
+    switch (CharGenStage()->current)
+    {
+        case 0:
+            windowManager->pushGuiMode(MWGui::GM_Name);
+            break;
+        case 1:
+            windowManager->pushGuiMode(MWGui::GM_Race);
+            break;
+        case 2:
+            windowManager->pushGuiMode(MWGui::GM_Class);
+            break;
+        case 3:
+            windowManager->pushGuiMode(MWGui::GM_Birth);
+            break;
+        default:
+            windowManager->pushGuiMode(MWGui::GM_Review);
+            break;
+    }
+    GetNetworking()->GetPacket(ID_GAME_CHARGEN)->Send(this);
+    CharGenStage()->current++;
+
+    return false;
+}
+
+void LocalPlayer::updateChar()
+{
+    MWBase::Environment::get().getMechanicsManager()->setPlayerRace(
+            Npc()->mRace,
+            Npc()->isMale(),
+            Npc()->mHead,
+            Npc()->mHair
+    );
+    MWBase::Environment::get().getWindowManager()->getInventoryWindow()->rebuildAvatar();
+}
diff --git a/apps/openmw/mwmp/LocalPlayer.hpp b/apps/openmw/mwmp/LocalPlayer.hpp
new file mode 100644
index 000000000..0ff0c37a6
--- /dev/null
+++ b/apps/openmw/mwmp/LocalPlayer.hpp
@@ -0,0 +1,50 @@
+//
+// Created by koncord on 14.01.16.
+//
+
+#ifndef OPENMW_LOCALPLAYER_HPP
+#define OPENMW_LOCALPLAYER_HPP
+
+#include <components/openmw-mp/Base/BasePlayer.hpp>
+#include <RakNetTypes.h>
+#include <apps/openmw/mwmp/Networking.hpp>
+
+namespace mwmp
+{
+    class LocalPlayer : public BasePlayer
+    {
+    public:
+
+        LocalPlayer();
+        virtual ~LocalPlayer();
+
+        void Update();
+
+        void updateBaseStats(bool forceUpdate = false);
+        void updatePosition(bool forceUpdate = false);
+        void updateInventory(bool forceUpdate = false);
+        void updateAttackState(bool forceUpdate = false);
+        void updateDeadState(bool forceUpdate = false);
+        void updateAttributesAndSkills(bool forceUpdate = false);
+        void updateCell(bool forceUpdate = false);
+        void updateDrawStateAndFlags(bool forceUpdate = false);
+
+        void setPosition();
+
+        void CharGen(int stageFirst, int stageEnd);
+
+        bool CharGenThread(); // return true if CGStage::current == CGStage::end
+
+        void updateChar();
+
+        void SendAttack(char type);
+        void PrepareAttack(char type, bool state);
+
+    private:
+        MWWorld::Ptr GetPlayerPtr();
+        Networking *GetNetworking();
+
+    };
+}
+
+#endif //OPENMW_LOCALPLAYER_HPP
diff --git a/apps/openmw/mwmp/Main.cpp b/apps/openmw/mwmp/Main.cpp
new file mode 100644
index 000000000..f7de5d9c5
--- /dev/null
+++ b/apps/openmw/mwmp/Main.cpp
@@ -0,0 +1,203 @@
+//
+// Created by koncord on 01.01.16.
+//
+
+#include "Main.hpp"
+#include <apps/openmw/mwworld/manualref.hpp>
+#include <apps/openmw/mwmechanics/aitravel.hpp>
+#include <components/esm/esmwriter.hpp>
+#include "../mwbase/environment.hpp"
+#include "../mwstate/statemanagerimp.hpp"
+#include "../mwinput/inputmanagerimp.hpp"
+#include "../mwscript/scriptmanagerimp.hpp"
+#include "../mwgui/windowmanagerimp.hpp"
+#include "../mwworld/worldimp.hpp"
+#include "../mwworld/ptr.hpp"
+#include "../mwworld/player.hpp"
+#include "../mwworld/customdata.hpp"
+#include "../mwmechanics/creaturestats.hpp"
+#include "../mwclass/npc.hpp"
+#include "../mwclass/creature.hpp"
+#include "../mwmechanics/mechanicsmanagerimp.hpp"
+#include "../mwworld/cellstore.hpp"
+#include <apps/openmw/mwdialogue/dialoguemanagerimp.hpp>
+#include <apps/openmw/mwworld/inventorystore.hpp>
+#include <apps/openmw/mwmechanics/spellcasting.hpp>
+
+#include "DedicatedPlayer.hpp"
+#include "LocalPlayer.hpp"
+#include "GUIChat.hpp"
+
+using namespace mwmp;
+using namespace std;
+
+Main *Main::pMain = 0;
+
+std::string loadSettings (Settings::Manager & settings)
+{
+    Files::ConfigurationManager mCfgMgr;
+    // Create the settings manager and load default settings file
+    const std::string localdefault = (mCfgMgr.getLocalPath() / "tes3mp-client-default.cfg").string();
+    const std::string globaldefault = (mCfgMgr.getGlobalPath() / "tes3mp-client-default.cfg").string();
+
+    // prefer local
+    if (boost::filesystem::exists(localdefault))
+        settings.loadDefault(localdefault);
+    else if (boost::filesystem::exists(globaldefault))
+        settings.loadDefault(globaldefault);
+    else
+        throw std::runtime_error ("No default settings file found! Make sure the file \"tes3mp-client-default.cfg\" was properly installed.");
+
+    // load user settings if they exist
+    const std::string settingspath = (mCfgMgr.getUserConfigPath() / "tes3mp-client.cfg").string();
+    if (boost::filesystem::exists(settingspath))
+        settings.loadUser(settingspath);
+
+    return settingspath;
+}
+
+Main::Main()
+{
+    std::cout << "Main::Main" << std::endl;
+    mNetworking = new Networking();
+    mLocalPlayer = new LocalPlayer();
+    //mLocalPlayer->CharGen(0, 4);
+
+    server = "mp.tes3mp.com";
+    port = 25565;
+    keySay = SDLK_y;
+    keyChatMode = SDLK_F2;
+}
+
+Main::~Main()
+{
+    std::cout << "Main::~Main" << std::endl;
+    delete mNetworking;
+    delete mLocalPlayer;
+    Players::CleanUp();
+}
+
+void Main::Create()
+{
+    assert(!pMain);
+    pMain = new Main();
+
+    Settings::Manager mgr;
+    Settings::CategorySettingValueMap saveUserSettings = mgr.mUserSettings;
+    Settings::CategorySettingValueMap saveDefaultSettings = mgr.mDefaultSettings;
+    Settings::CategorySettingVector saveChangedSettings = mgr.mChangedSettings;
+    mgr.mUserSettings.clear();
+    mgr.mDefaultSettings.clear();
+    mgr.mChangedSettings.clear();
+    loadSettings(mgr);
+
+    pMain->server = mgr.getString("server", "General");
+    pMain->port = (unsigned short)mgr.getInt("port", "General");
+
+    float chatDelay = mgr.getFloat("delay", "Chat");
+    int chatY = mgr.getInt("y", "Chat");
+    int chatX = mgr.getInt("x", "Chat");
+    int chatW = mgr.getInt("w", "Chat");
+    int chatH = mgr.getInt("h", "Chat");
+    pMain->keySay =      SDL_GetKeyFromName(mgr.getString("keySay", "Chat").c_str());
+    pMain->keyChatMode = SDL_GetKeyFromName(mgr.getString("keyChatMode", "Chat").c_str());
+
+
+    pMain->mChat = new GUIChat(chatX, chatY, chatW, chatH);
+    pMain->getChatBox()->SetDelay(chatDelay);
+
+    mgr.mUserSettings = saveUserSettings;
+    mgr.mDefaultSettings = saveDefaultSettings;
+    mgr.mChangedSettings = saveChangedSettings;
+
+    //pMain->mGUILogin = new GUILogin();
+    const MWBase::Environment &environment = MWBase::Environment::get();
+    environment.getStateManager()->newGame(true);
+}
+
+void Main::Destroy()
+{
+    assert(pMain);
+
+    delete pMain->mChat;
+
+    delete pMain;
+    pMain = 0;
+}
+
+void Main::Frame(float dt)
+{
+    const MWBase::Environment &environment = MWBase::Environment::get();
+    if (environment.getWindowManager()->containsMode(MWGui::GM_MainMenu))
+    {
+        //environment.getWindowManager()->exitCurrentGuiMode();
+    }
+
+    get().getNetworking()->Update();
+
+    Players::Update(dt);
+    get().UpdateWorld(dt);
+
+    get().getChatBox()->Update(dt);
+
+}
+
+void Main::UpdateWorld(float dt) const
+{
+
+    if(!mLocalPlayer->CharGenThread())
+        return;
+
+    if(!mNetworking->isConnected())
+    {
+        MWWorld::Ptr player = MWBase::Environment::get().getWorld()->getPlayerPtr();
+        MWBase::Environment::get().getMechanicsManager()->toggleAI();
+
+        (*mLocalPlayer->Npc()) = *player.get<ESM::NPC>()->mBase;
+
+        mLocalPlayer->updateAttributesAndSkills();
+
+        mNetworking->Connect(server, port);
+        player.getClass().getCreatureStats(player).getSpells().add("fireball");
+        mLocalPlayer->updateBaseStats(true);
+        mChat->setVisible(true);
+    }
+    else
+        mLocalPlayer->Update();
+}
+
+const Main &Main::get()
+{
+    return *pMain;
+}
+
+Networking *Main::getNetworking() const
+{
+    return mNetworking;
+}
+
+LocalPlayer *Main::getLocalPlayer() const
+{
+    return mLocalPlayer;
+}
+
+GUIChat *Main::getChatBox() const
+{
+    return mChat;
+}
+
+GUILogin *Main::getGUILogin() const
+{
+    return mGUILogin;
+}
+
+
+void Main::PressedKey(int key)
+{
+
+    if(pMain == nullptr || get().getChatBox() == nullptr) return;
+    if(key == get().keyChatMode)
+        get().getChatBox()->PressedChatMode();
+    else if(key == get().keySay)
+        get().getChatBox()->PressedSay();
+}
\ No newline at end of file
diff --git a/apps/openmw/mwmp/Main.hpp b/apps/openmw/mwmp/Main.hpp
new file mode 100644
index 000000000..2be74cdba
--- /dev/null
+++ b/apps/openmw/mwmp/Main.hpp
@@ -0,0 +1,46 @@
+#include <apps/openmw/mwworld/ptr.hpp>
+#include "Networking.hpp"
+#include "LocalPlayer.hpp"
+#include "GUIChat.hpp"
+#include "GUILogin.hpp"
+
+namespace mwmp
+{
+    class Main
+    {
+    public:
+        Main();
+        ~Main();
+
+        static void Create();
+        static void Destroy();
+        static const Main &get();
+        static void Frame(float dt);
+        static void PressedKey(int key);
+
+        Networking *getNetworking() const;
+        LocalPlayer *getLocalPlayer() const;
+        GUIChat *getChatBox() const;
+        GUILogin *getGUILogin() const;
+
+        void UpdateWorld(float dt) const;
+
+    private:
+        Main (const Main&);
+        ///< not implemented
+        Main& operator= (const Main&);
+        ///< not implemented
+        static Main *pMain;
+        Networking *mNetworking;
+        LocalPlayer *mLocalPlayer;
+
+        GUIChat *mChat;
+        GUILogin *mGUILogin;
+
+        std::string server;
+        unsigned short port;
+
+        int keySay;
+        int keyChatMode;
+    };
+}
diff --git a/apps/openmw/mwmp/Networking.cpp b/apps/openmw/mwmp/Networking.cpp
new file mode 100644
index 000000000..31f1b8c68
--- /dev/null
+++ b/apps/openmw/mwmp/Networking.cpp
@@ -0,0 +1,570 @@
+//
+// Created by koncord on 04.01.16.
+//
+
+#include <stdexcept>
+#include <iostream>
+#include <string>
+#include <components/esm/cellid.hpp>
+#include <apps/openmw/mwbase/world.hpp>
+#include <apps/openmw/mwbase/environment.hpp>
+#include <apps/openmw/mwworld/cellstore.hpp>
+#include <apps/openmw/mwclass/npc.hpp>
+#include <apps/openmw/mwmechanics/npcstats.hpp>
+#include <apps/openmw/mwworld/inventorystore.hpp>
+#include <apps/openmw/mwmechanics/combat.hpp>
+#include "Networking.hpp"
+#include "../mwstate/statemanagerimp.hpp"
+#include "DedicatedPlayer.hpp"
+#include "Main.hpp"
+
+using namespace std;
+using namespace mwmp;
+
+Networking::Networking(): peer(RakNet::RakPeerInterface::GetInstance()), controller(peer)
+{
+
+    RakNet::SocketDescriptor sd;
+    sd.port=0;
+    RakNet::StartupResult b = peer->Startup(1,&sd, 1);
+    RakAssert(b==RAKNET_STARTED);
+
+    controller.SetStream(0, &bsOut);
+    connected = 0;
+}
+
+Networking::~Networking()
+{
+    peer->Shutdown(100);
+    peer->CloseConnection(peer->GetSystemAddressFromIndex(0), true, 0);
+    RakNet::RakPeerInterface::DestroyInstance(peer);
+}
+
+void Networking::Update()
+{
+    RakNet::Packet *packet;
+    for (packet=peer->Receive(); packet; peer->DeallocatePacket(packet), packet=peer->Receive())
+    {
+        switch (packet->data[0])
+        {
+            case ID_REMOTE_DISCONNECTION_NOTIFICATION:
+                printf("Another client has disconnected.\n");
+                break;
+            case ID_REMOTE_CONNECTION_LOST:
+                printf("Another client has lost the connection.\n");
+                break;
+            case ID_REMOTE_NEW_INCOMING_CONNECTION:
+                printf("Another client has connected.\n");
+                break;
+            case ID_CONNECTION_REQUEST_ACCEPTED:
+                printf("Our connection request has been accepted.\n");
+                break;
+            case ID_NEW_INCOMING_CONNECTION:
+                printf("A connection is incoming.\n");
+                break;
+            case ID_NO_FREE_INCOMING_CONNECTIONS:
+                printf("The server is full.\n");
+                MWBase::Environment::get().getStateManager()->requestQuit();
+                break;
+            case ID_DISCONNECTION_NOTIFICATION:
+                    printf("We have been disconnected.\n");
+                    MWBase::Environment::get().getStateManager()->requestQuit();
+                break;
+            case ID_CONNECTION_LOST:
+                    printf("Connection lost.\n");
+                    MWBase::Environment::get().getStateManager()->requestQuit();
+                break;
+            case ID_CUSTOM_MESSAGE:
+                ReciveMessage(packet);
+                break;
+            default:
+                printf("Message with identifier %i has arrived.\n", packet->data[0]);
+                break;
+        }
+    }
+}
+
+void Networking::SendData(RakNet::BitStream *bs)
+{
+    peer->Send(bs, HIGH_PRIORITY, RELIABLE_ORDERED, 0, serverAddr, false);
+}
+
+void Networking::Connect(const std::string &ip, unsigned short port)
+{
+    RakNet::SystemAddress master;
+    master.SetBinaryAddress(ip.c_str());
+    master.SetPortHostOrder(port);
+    const char passw[8] = "1234567";
+
+
+    if (peer->Connect(master.ToString(false), master.GetPort(), passw, sizeof(passw), 0, 0, 3, 500, 0) != RakNet::CONNECTION_ATTEMPT_STARTED)
+    {
+        cout << "Connection attempt failed." << endl;
+        MWBase::Environment::get().getStateManager()->requestQuit();
+    }
+
+    bool queue = true;
+    while(queue)
+    {
+        for (RakNet::Packet *packet = peer->Receive(); packet; peer->DeallocatePacket(
+                packet), packet = peer->Receive())
+        {
+            switch (packet->data[0])
+            {
+                case ID_CONNECTION_ATTEMPT_FAILED:
+                {
+                    cerr << "Connection failed." << endl;
+                    MWBase::Environment::get().getStateManager()->requestQuit();
+                    queue = false;
+                    break;
+                }
+                case ID_INVALID_PASSWORD:
+                {
+                    cerr << "Connection failed. Different versions of client or server." << endl
+                         << "Ask your server administrator for resolve this problem." << endl;
+                    MWBase::Environment::get().getStateManager()->requestQuit();
+                    queue = false;
+                    break;
+                }
+                case ID_CONNECTION_REQUEST_ACCEPTED:
+                {
+                    serverAddr = packet->systemAddress;
+                    connected = true;
+                    queue = false;
+
+                    GetPacket(ID_GAME_BASE_INFO)->Send(getLocalPlayer());
+
+                    break;
+                }
+                case ID_DISCONNECTION_NOTIFICATION:
+                    throw runtime_error("ID_DISCONNECTION_NOTIFICATION.\n");
+                case ID_CONNECTION_BANNED:
+                    throw runtime_error("ID_CONNECTION_BANNED.\n");
+                case ID_CONNECTION_LOST:
+                    throw runtime_error("ID_CONNECTION_LOST.\n");
+                default:
+                    printf("Connection message with identifier %i has arrived in initialization.\n", packet->data[0]);
+            }
+        }
+    }
+}
+
+void Networking::ReciveMessage(RakNet::Packet *packet)
+{
+    RakNet::RakNetGUID id;
+
+    if(packet->length < 3)
+        return;
+
+    RakNet::BitStream bsIn(&packet->data[2], packet->length, false);
+    bsIn.Read(id);
+
+    DedicatedPlayer *pl = 0;
+    static RakNet::RakNetGUID myid = getLocalPlayer()->guid;
+    if(id != myid)
+        pl = Players::GetPlayer(id);
+
+    BasePacket *myPacket = controller.GetPacket(packet->data[1]);
+
+    switch(packet->data[1])
+    {
+        case ID_HANDSHAKE:
+        {
+            (*getLocalPlayer()->GetPassw()) = "SuperPassword";
+            myPacket->Send(getLocalPlayer(), serverAddr);
+            break;
+        }
+        case ID_GAME_BASE_INFO:
+        {
+            if(id == myid)
+            {
+                cout << "TEST: " << packet->length << endl;
+                if(packet->length == myPacket->headerSize())
+                {
+                    cout << "ID_GAME_BASE_INFO request only" << endl;
+                    myPacket->Send(getLocalPlayer(), serverAddr);
+                }
+                else
+                {
+                    myPacket->Packet(&bsIn, getLocalPlayer(), false);
+                    cout << "ID_GAME_BASE_INFO" << endl;
+                    getLocalPlayer()->updateChar();
+                }
+            }
+            else
+            {
+                if(pl == 0)
+                    pl = Players::NewPlayer(id);
+
+                myPacket->Packet(&bsIn, pl, false);
+                Players::CreatePlayer(id);
+            }
+            break;
+        }
+        case ID_GAME_UPDATE_POS:
+        {
+            if(id == myid)
+            {
+                if (packet->length != myPacket->headerSize())
+                {
+                    cout << "ID_GAME_UPDATE_POS changed by server" << endl;
+                    myPacket->Packet(&bsIn, getLocalPlayer(), false);
+                    getLocalPlayer()->setPosition();
+                }
+                else
+                    getLocalPlayer()->updatePosition(true);
+            }
+            else if(pl != 0)
+                myPacket->Packet(&bsIn, pl, false);
+            break;
+        }
+        case ID_USER_MYID:
+        {
+            cout << "ID_USER_MYID" << endl;
+            myid = id;
+            getLocalPlayer()->guid = id;
+            break;
+        }
+        case ID_USER_DISCONNECTED:
+        {
+            if(id == myid)
+                MWBase::Environment::get().getStateManager()->requestQuit();
+            else if(pl != 0)
+                Players::DisconnectPlayer(id);
+
+        }
+        case ID_GAME_UPDATE_EQUIPED:
+        {
+            if(id == myid)
+            {
+                getLocalPlayer()->updateInventory(true);
+                myPacket->Send(getLocalPlayer(), serverAddr);
+            }
+            else if (pl != 0)
+            {
+                myPacket->Packet(&bsIn, pl, false);
+                pl->UpdateInventory();
+            }
+            break;
+        }
+        case ID_GAME_UPDATE_SKILLS:
+        {
+            if(id == myid)
+            {
+                getLocalPlayer()->updateAttributesAndSkills(true);
+                myPacket->Send(getLocalPlayer(), serverAddr);
+            }
+            else if (pl != 0)
+            {
+                myPacket->Packet(&bsIn, pl, false);
+
+                MWMechanics::SkillValue skillValue;
+                MWMechanics::AttributeValue attributeValue;
+                for (int i = 0; i < PacketAttributesAndStats::StatsCount; ++i)
+                {
+                    skillValue.readState(pl->NpcStats()->mSkills[i]);
+                    pl->getPtr().getClass().getNpcStats(pl->getPtr()).setSkill(i, skillValue);
+                }
+
+                for (int i = 0; i < PacketAttributesAndStats::AttributesCount; ++i)
+                {
+                    attributeValue.readState(pl->CreatureStats()->mAttributes[i]);
+                    pl->getPtr().getClass().getCreatureStats(pl->getPtr()).setAttribute(i, attributeValue);
+                }
+            }
+            break;
+        }
+        case ID_GAME_ATTACK:
+        {
+            if(pl != 0)
+            {
+                myPacket->Packet(&bsIn, pl, false);
+
+                cout << "Player: " << pl->Npc()->mName << " pressed: " << (pl->GetAttack()->pressed == 1) << endl;
+                if(pl->GetAttack()->pressed == 0)
+                {
+                    cout << "success: " << (pl->GetAttack()->success == 1);
+                    if(pl->GetAttack()->success == 1)
+                        cout << " damage: " << pl->GetAttack()->damage;
+                    cout << endl;
+                }
+
+                MWMechanics::CreatureStats &stats = pl->getPtr().getClass().getNpcStats(pl->getPtr());
+                stats.getSpells().setSelectedSpell(pl->GetAttack()->refid);
+
+                MWWorld::Ptr victim;
+                if(pl->GetAttack()->target == getLocalPlayer()->guid)
+                    victim = MWBase::Environment::get().getWorld()->getPlayerPtr();
+                else if(Players::GetPlayer(pl->GetAttack()->target) != 0)
+                    victim = Players::GetPlayer(pl->GetAttack()->target)->getPtr();
+
+                MWWorld::Ptr attacker;
+                attacker = pl->getPtr();
+
+                // Get the weapon used (if hand-to-hand, weapon = inv.end())
+                if(*pl->DrawState() == 1)
+                {
+                    MWWorld::InventoryStore &inv = attacker.getClass().getInventoryStore(attacker);
+                    MWWorld::ContainerStoreIterator weaponslot = inv.getSlot(
+                            MWWorld::InventoryStore::Slot_CarriedRight);
+                    MWWorld::Ptr weapon = ((weaponslot != inv.end()) ? *weaponslot : MWWorld::Ptr());
+                    if (!weapon.isEmpty() && weapon.getTypeName() != typeid(ESM::Weapon).name())
+                        weapon = MWWorld::Ptr();
+
+                    bool healthdmg;
+                    if (!weapon.isEmpty())
+                        healthdmg = true;
+                    else
+                    {
+                        MWMechanics::CreatureStats &otherstats = victim.getClass().getCreatureStats(victim);
+                        healthdmg = otherstats.isParalyzed() || otherstats.getKnockedDown();
+                    }
+
+                    if (victim.mRef != 0)
+                    {
+                        if (!weapon.isEmpty())
+                            MWMechanics::blockMeleeAttack(attacker, victim, weapon, pl->GetAttack()->damage, 1);
+                        pl->getPtr().getClass().onHit(victim, pl->GetAttack()->damage, healthdmg, weapon, attacker,
+                                                      pl->GetAttack()->success);
+                    }
+                }
+                else
+                {
+                    cout << "SpellId: " << pl->GetAttack()->refid << endl;
+                }
+            }
+            break;
+        }
+        case ID_GAME_UPDATE_BASESTATS:
+        {
+            if(id == myid)
+            {
+                getLocalPlayer()->updateBaseStats(true);
+                myPacket->Send(getLocalPlayer(), serverAddr);
+            }
+            else if (pl != 0)
+            {
+                myPacket->Packet(&bsIn, pl, false);
+                MWMechanics::DynamicStat<float> value;
+
+                value.readState(pl->CreatureStats()->mDynamic[0]);
+                pl->getPtr().getClass().getCreatureStats(pl->getPtr()).setHealth(value);
+                value.readState(pl->CreatureStats()->mDynamic[1]);
+                pl->getPtr().getClass().getCreatureStats(pl->getPtr()).setMagicka(value);
+                value.readState(pl->CreatureStats()->mDynamic[2]);
+                pl->getPtr().getClass().getCreatureStats(pl->getPtr()).setFatigue(value);
+            }
+            break;
+        }
+        case ID_GAME_DIE:
+        {
+            printf("ID_GAME_DIE\n");
+            if(id == myid)
+            {
+                MWWorld::Ptr player = MWBase::Environment::get().getWorld()->getPlayerPtr();
+                MWMechanics::DynamicStat<float> health = player.getClass().getCreatureStats(player).getHealth();
+                health.setCurrent(0);
+                player.getClass().getCreatureStats(player).setHealth(health);
+                myPacket->Send(getLocalPlayer(), serverAddr);
+            }
+            else if(pl != 0)
+            {
+                printf("attempt to kill %s\n", pl->Npc()->mName.c_str());
+                MWMechanics::DynamicStat<float> health;
+                pl->CreatureStats()->mDead = true;
+                health.readState(pl->CreatureStats()->mDynamic[0]);
+                health.setCurrent(0);
+                health.writeState(pl->CreatureStats()->mDynamic[0]);
+                pl->getPtr().getClass().getCreatureStats(pl->getPtr()).setHealth(health);
+            }
+            break;
+        }
+        case ID_GAME_RESURRECT:
+        {
+            if (id == myid)
+            {
+                MWWorld::Ptr player = MWBase::Environment::get().getWorld()->getPlayerPtr();
+                player.getClass().getCreatureStats(player).resurrect();
+                ESM::Position pos;
+                MWBase::Environment::get().getWorld()->findInteriorPosition("ToddTest", pos);
+                MWBase::Environment::get().getWorld()->changeToInteriorCell("ToddTest", pos);
+                (*getLocalPlayer()->Position()) = pos;
+                (*getLocalPlayer()->GetCell()) = *player.getCell()->getCell();
+                myPacket->Send(getLocalPlayer(), serverAddr);
+
+                getLocalPlayer()->updateBaseStats(true);
+                controller.GetPacket(ID_GAME_UPDATE_BASESTATS)->Send(getLocalPlayer(), serverAddr);
+            }
+            else if (pl != 0)
+            {
+                pl->CreatureStats()->mDead = false;
+                if (pl->CreatureStats()->mDynamic[0].mMod < 1)
+                    pl->CreatureStats()->mDynamic[0].mMod = 1;
+                pl->CreatureStats()->mDynamic[0].mCurrent = pl->CreatureStats()->mDynamic[0].mMod;
+
+                pl->getPtr().getClass().getCreatureStats(pl->getPtr()).resurrect();
+
+                MWMechanics::DynamicStat<float> health;
+                health.readState(pl->CreatureStats()->mDynamic[0]);
+                pl->getPtr().getClass().getCreatureStats(pl->getPtr()).setHealth(health);
+            }
+            break;
+        }
+            case ID_GAME_CELL:
+            {
+                if(id == myid)
+                {
+                    myPacket->Packet(&bsIn, getLocalPlayer(), false);
+
+                    if(!getLocalPlayer()->GetCell()->isExterior())
+                    {
+                        cout << "location: " << getLocalPlayer()->GetCell()->mName << endl;
+
+                        MWBase::World *world = MWBase::Environment::get().getWorld();
+                        ESM::Position pos;
+                        world->findInteriorPosition(getLocalPlayer()->GetCell()->mName, pos);
+                        world->changeToInteriorCell(getLocalPlayer()->GetCell()->mName, pos);
+                    }
+
+                    getLocalPlayer()->updateCell(true);
+                }
+                else if(pl != 0)
+                {
+                    myPacket->Packet(&bsIn, pl, false);
+                    pl->updateCell();
+                }
+                break;
+            }
+            case ID_GAME_DRAWSTATE:
+            {
+                if(id == myid)
+                    getLocalPlayer()->updateDrawStateAndFlags(true);
+                else if(pl != 0)
+                {
+                    myPacket->Packet(&bsIn, pl, false);
+                    pl->UpdateDrawState();
+                }
+                break;
+            }
+            case ID_CHAT_MESSAGE:
+            {
+                std::string message;
+                if(id == myid)
+                {
+                    myPacket->Packet(&bsIn, getLocalPlayer(), false);
+                    message =  *getLocalPlayer()->ChatMessage();
+                }
+                else if(pl != 0)
+                {
+                    myPacket->Packet(&bsIn, pl, false);
+                    message =  *pl->ChatMessage();
+                }
+                Main::get().getChatBox()->print(message);
+                break;
+            }
+            case ID_GAME_CHARGEN:
+            {
+                if(id == myid)
+                {
+                    myPacket->Packet(&bsIn, getLocalPlayer(), false);
+                }
+                break;
+            }
+
+            case ID_GAME_ATTRIBUTE:
+            {
+                BasePlayer *__pl = nullptr;
+                MWWorld::Ptr __pl_ptr;
+                if (id == myid)
+                {
+                    __pl = getLocalPlayer();
+                    __pl_ptr = MWBase::Environment::get().getWorld()->getPlayerPtr();
+                }
+                else if (pl != 0)
+                {
+                    __pl = pl;
+                    __pl_ptr = pl->getPtr();
+                }
+                else
+                    return;
+
+                MWMechanics::AttributeValue attributeValue;
+
+                myPacket->Packet(&bsIn, __pl, false);
+
+                for (int i = 0; i < PacketAttributesAndStats::AttributesCount; ++i)
+                {
+                    attributeValue.readState(__pl->CreatureStats()->mAttributes[i]);
+                    __pl_ptr.getClass().getCreatureStats(__pl_ptr).setAttribute(i, attributeValue);
+                }
+                break;
+            }
+
+            case ID_GAME_SKILL:
+            {
+                BasePlayer *__pl = nullptr;
+                MWWorld::Ptr __pl_ptr;
+                if (id == myid)
+                {
+                    __pl = getLocalPlayer();
+                    __pl_ptr = MWBase::Environment::get().getWorld()->getPlayerPtr();
+                }
+                else if (pl != 0)
+                {
+                    __pl = pl;
+                    __pl_ptr = pl->getPtr();
+                }
+                else
+                    return;
+
+                MWMechanics::SkillValue skillValue;
+
+                myPacket->Packet(&bsIn, __pl, false);
+
+                for (int i = 0; i < PacketAttributesAndStats::StatsCount; ++i)
+                {
+                    skillValue.readState(__pl->NpcStats()->mSkills[i]);
+                    __pl_ptr.getClass().getNpcStats(__pl_ptr).setSkill(i, skillValue);
+                    printf("skill %d, value %d\n", i, skillValue.getBase());
+                }
+
+                break;
+            }
+        default:
+            printf("Custom message with identifier %i has arrived in initialization.\n", packet->data[1]);
+    }
+}
+
+BasePacket *Networking::GetPacket(RakNet::MessageID id)
+{
+    return controller.GetPacket(id);
+}
+
+LocalPlayer *Networking::getLocalPlayer()
+{
+    return mwmp::Main::get().getLocalPlayer();
+}
+
+bool Networking::isDedicatedPlayer(const MWWorld::Ptr &ptr)
+{
+    if(ptr.mRef == 0)
+        return 0;
+    DedicatedPlayer *pl = Players::GetPlayer(ptr);
+
+    return pl != 0;
+}
+
+bool Networking::Attack(const MWWorld::Ptr &ptr)
+{
+    DedicatedPlayer *pl = Players::GetPlayer(ptr);
+
+    if(pl == 0)
+        return false;
+
+    return pl->GetAttack()->pressed;
+}
+
+bool Networking::isConnected()
+{
+    return connected;
+}
diff --git a/apps/openmw/mwmp/Networking.hpp b/apps/openmw/mwmp/Networking.hpp
new file mode 100644
index 000000000..c37b967dc
--- /dev/null
+++ b/apps/openmw/mwmp/Networking.hpp
@@ -0,0 +1,63 @@
+//
+// Created by koncord on 04.01.16.
+//
+
+#ifndef OPENMW_NETWORKING_HPP
+#define OPENMW_NETWORKING_HPP
+
+#include <RakPeerInterface.h>
+#include <BitStream.h>
+#include <string>
+
+#include <components/openmw-mp/NetworkMessages.hpp>
+#include <components/openmw-mp/Packets/PacketPosition.hpp>
+#include <components/openmw-mp/Packets/PacketBaseInfo.hpp>
+#include <components/openmw-mp/Packets/PacketEquiped.hpp>
+#include <components/openmw-mp/Packets/PacketAttributesAndStats.hpp>
+#include <components/openmw-mp/Packets/PacketAttack.hpp>
+#include <components/openmw-mp/Packets/PacketMainStats.hpp>
+#include <components/openmw-mp/Packets/PacketResurrect.hpp>
+#include <components/openmw-mp/Packets/PacketDie.hpp>
+#include <components/openmw-mp/Packets/PacketCell.hpp>
+#include <components/openmw-mp/Packets/PacketDrawState.hpp>
+#include <components/openmw-mp/PacketsController.hpp>
+
+namespace mwmp
+{
+    class LocalPlayer;
+
+    class Networking
+    {
+    public:
+        Networking();
+        ~Networking();
+        void Connect(const std::string& ip, unsigned short port);
+        void Update();
+        void SendData(RakNet::BitStream *bitStream);
+        BasePacket *GetPacket(RakNet::MessageID id);
+
+        bool isDedicatedPlayer(const MWWorld::Ptr &ptr);
+        bool Attack(const MWWorld::Ptr &ptr);
+
+        RakNet::SystemAddress serverAddress()
+        {
+            return serverAddr;
+        }
+
+        bool isConnected();
+
+    private:
+        bool connected;
+        RakNet::RakPeerInterface *peer;
+        RakNet::SystemAddress serverAddr;
+        RakNet::BitStream bsOut;
+
+        PacketsController controller;
+
+        void ReciveMessage(RakNet::Packet *packet);
+        LocalPlayer *getLocalPlayer();
+    };
+}
+
+
+#endif //OPENMW_NETWORKING_HPP
diff --git a/apps/openmw/mwworld/cellstore.cpp b/apps/openmw/mwworld/cellstore.cpp
index 1ca452efe..f1dfa1639 100644
--- a/apps/openmw/mwworld/cellstore.cpp
+++ b/apps/openmw/mwworld/cellstore.cpp
@@ -242,6 +242,10 @@ namespace MWWorld
 
         // Objects with no refnum can't be handled correctly in the merging process that happens
         // on a save/load, so do a simple copy & delete for these objects.
+
+        // The code below is disabled for TES3MP for as long as player objects lack refnums,
+        // because it will break exterior cell transitions for them
+        /*
         if (!object.getCellRef().getRefNum().hasContentFile())
         {
             MWWorld::Ptr copied = object.getClass().copyToCell(object, *cellToMoveTo, object.getRefData().getCount());
@@ -249,6 +253,7 @@ namespace MWWorld
             object.getRefData().setBaseNode(NULL);
             return copied;
         }
+        */
 
         MovedRefTracker::iterator found = mMovedHere.find(object.getBase());
         if (found != mMovedHere.end())
diff --git a/cmake/FindRakNet.cmake b/cmake/FindRakNet.cmake
new file mode 100644
index 000000000..f589b25b8
--- /dev/null
+++ b/cmake/FindRakNet.cmake
@@ -0,0 +1,66 @@
+# Comes form project edunetgames
+# - Try to find RakNet
+# Once done this will define
+#
+#  RakNet_FOUND - system has RakNet
+#  RakNet_INCLUDES - the RakNet include directory
+#  RakNet_LIBRARY - Link these to use RakNet
+
+FIND_LIBRARY (RakNet_LIBRARY_RELEASE NAMES RakNetLibStatic
+    PATHS
+    ENV LD_LIBRARY_PATH
+    ENV LIBRARY_PATH
+    /usr/lib64
+    /usr/lib
+    /usr/local/lib64
+    /usr/local/lib
+    /opt/local/lib
+    $ENV{RAKNET_ROOT}/lib
+    )
+	
+FIND_LIBRARY (RakNet_LIBRARY_DEBUG NAMES RakNetLibStatic
+    PATHS
+    ENV LD_LIBRARY_PATH
+    ENV LIBRARY_PATH
+    /usr/lib64
+    /usr/lib
+    /usr/local/lib64
+    /usr/local/lib
+    /opt/local/lib
+    $ENV{RAKNET_ROOT}/lib
+    )	
+	
+	
+
+FIND_PATH (RakNet_INCLUDES raknet/RakPeer.h
+    ENV CPATH
+    /usr/include
+    /usr/local/include
+    /opt/local/include
+	$ENV{RAKNET_ROOT}/include
+    )
+ 
+IF(RakNet_INCLUDES AND RakNet_LIBRARY_RELEASE)
+    SET(RakNet_FOUND TRUE)
+ENDIF(RakNet_INCLUDES AND RakNet_LIBRARY_RELEASE)
+
+IF(RakNet_FOUND)
+  SET(RakNet_INCLUDES ${RakNet_INCLUDES})
+  
+  
+   IF (CMAKE_CONFIGURATION_TYPES OR CMAKE_BUILD_TYPE)
+        SET(RakNet_LIBRARY optimized ${RakNet_LIBRARY_RELEASE} debug ${RakNet_LIBRARY_DEBUG})
+      ELSE()
+        # if there are no configuration types and CMAKE_BUILD_TYPE has no value
+        # then just use the release libraries
+        SET(RakNet_LIBRARY ${RakNet_LIBRARY_RELEASE} )
+      ENDIF()
+  IF(NOT RakNet_FIND_QUIETLY)
+    MESSAGE(STATUS "Found RakNet: ${RakNet_LIBRARIES}")
+  ENDIF(NOT RakNet_FIND_QUIETLY)
+ELSE(RakNet_FOUND)
+  IF(RakNet_FIND_REQUIRED)
+    MESSAGE(FATAL_ERROR "Could not find RakNet")
+  ENDIF(RakNet_FIND_REQUIRED)
+ENDIF(RakNet_FOUND)
+
diff --git a/cmake/FindTerra.cmake b/cmake/FindTerra.cmake
new file mode 100644
index 000000000..6b38306cf
--- /dev/null
+++ b/cmake/FindTerra.cmake
@@ -0,0 +1,70 @@
+# - Try to find Terra
+# Once done this will define
+#
+#  Terra_FOUND - system has Terra
+#  Terra_INCLUDES - the Terra include directory
+#  Terra_LIBRARY - Link these to use Terra
+
+FIND_LIBRARY (Terra_LIBRARY_RELEASE NAMES terra
+    PATHS
+    ENV LD_LIBRARY_PATH
+    ENV LIBRARY_PATH
+    /usr/lib64
+    /usr/lib
+    /usr/local/lib64
+    /usr/local/lib
+    /opt/local/lib
+    $ENV{Terra_ROOT}/lib
+    )
+	
+FIND_LIBRARY (Terra_LIBRARY_DEBUG NAMES terra
+    PATHS
+    ENV LD_LIBRARY_PATH
+    ENV LIBRARY_PATH
+    /usr/lib64
+    /usr/lib
+    /usr/local/lib64
+    /usr/local/lib
+    /opt/local/lib
+    $ENV{Terra_ROOT}/lib
+    )	
+	
+	
+
+FIND_PATH (Terra_INCLUDES terra/terra.h
+    ENV CPATH
+    /usr/include
+    /usr/local/include
+    /opt/local/include
+    $ENV{Terra_ROOT}/include
+    )
+ 
+IF(Terra_INCLUDES AND Terra_LIBRARY_RELEASE)
+    SET(Terra_FOUND TRUE)
+ENDIF(Terra_INCLUDES AND Terra_LIBRARY_RELEASE)
+
+IF(NOT Terra_LIBRARY_DEBUG)
+    SET(Terra_LIBRARY_DEBUG ${Terra_LIBRARY_RELEASE})
+ENDIF()
+
+IF(Terra_FOUND)
+  SET(Terra_INCLUDES ${Terra_INCLUDES})
+
+  find_package(ZLIB REQUIRED)
+  
+   IF (CMAKE_CONFIGURATION_TYPES OR CMAKE_BUILD_TYPE)
+        SET(Terra_LIBRARY optimized ${Terra_LIBRARY_RELEASE} debug ${Terra_LIBRARY_DEBUG} ${ZLIB_LIBRARIES} dl tinfo)
+      ELSE()
+        # if there are no configuration types and CMAKE_BUILD_TYPE has no value
+        # then just use the release libraries
+        SET(Terra_LIBRARY ${Terra_LIBRARY_RELEASE} ${ZLIB_LIBRARIES} dl tinfo)
+      ENDIF()
+  IF(NOT Terra_FIND_QUIETLY)
+    MESSAGE(STATUS "Found Terra: ${Terra_LIBRARIES}")
+  ENDIF(NOT Terra_FIND_QUIETLY)
+ELSE(Terra_FOUND)
+  IF(Terra_FIND_REQUIRED)
+    MESSAGE(FATAL_ERROR "Could not find Terra")
+  ENDIF(Terra_FIND_REQUIRED)
+ENDIF(Terra_FOUND)
+
diff --git a/components/CMakeLists.txt b/components/CMakeLists.txt
index 6d2436824..ee6f64788 100644
--- a/components/CMakeLists.txt
+++ b/components/CMakeLists.txt
@@ -141,10 +141,17 @@ add_component_dir (version
     version
     )
 
+add_component_dir (openmw-mp
+        PacketsController
+        Packets/BasePacket Packets/PacketBaseInfo Packets/PacketPosition Packets/PacketEquiped Packets/PacketAttributesAndStats
+        Packets/PacketAttack Packets/PacketMainStats Packets/PacketCell Packets/PacketDrawState Packets/PacketChatMessage
+        Packets/PacketCharGen Packets/PacketAttribute Packets/PacketSkill Packets/PacketHandshake)
+
 add_component_dir (fallback
     fallback validate
     )
 
+
 set (ESM_UI ${CMAKE_SOURCE_DIR}/files/ui/contentselector.ui
     )
 
diff --git a/components/openmw-mp/Base/BasePlayer.hpp b/components/openmw-mp/Base/BasePlayer.hpp
new file mode 100644
index 000000000..dfddf32fe
--- /dev/null
+++ b/components/openmw-mp/Base/BasePlayer.hpp
@@ -0,0 +1,148 @@
+//
+// Created by koncord on 07.01.16.
+//
+
+#ifndef OPENMW_BASEPLAYER_HPP
+#define OPENMW_BASEPLAYER_HPP
+
+#include <components/esm/npcstats.hpp>
+#include <components/esm/loadcell.hpp>
+#include <components/esm/loadnpc.hpp>
+#include <components/esm/creaturestats.hpp>
+#include <RakNetTypes.h>
+
+namespace mwmp
+{
+    class Attack
+    {
+    public:
+        RakNet::RakNetGUID target;
+        RakNet::RakNetGUID attacker;
+        char type; // 0 - melee, 1 - magic, 2 - throwable
+        std::string refid; // id of spell (e.g. "fireball")
+        char success;
+        char block;
+        float damage;
+        char pressed;
+        char knockdown;
+    };
+
+    struct Item
+    {
+        std::string refid;
+        int count;
+    };
+
+    class BasePlayer
+    {
+    public:
+
+        struct CGStage
+        {
+            int current, end;
+        };
+
+        BasePlayer(RakNet::RakNetGUID guid) : guid(guid)
+        {
+
+        }
+
+        BasePlayer()
+        {
+
+        }
+
+        virtual ESM::Position *Position()
+        {
+            return &pos;
+        }
+        virtual ESM::NPC *Npc()
+        {
+            return &npc;
+        }
+        virtual ESM::NpcStats *NpcStats()
+        {
+            return &npcStats;
+        }
+        virtual ESM::CreatureStats *CreatureStats()
+        {
+            return &creatureStats;
+        }
+
+        virtual unsigned int *MovementFlags()
+        {
+            return &movementFlags;
+        }
+        virtual ESM::Cell *GetCell()
+        {
+            return &cell;
+        }
+
+        virtual Item *EquipedItem(int id)
+        {
+            if(id >= 18) return &equipedItems[18];
+            return &equipedItems[id];
+        }
+
+        virtual char *MovementAnim()
+        {
+            return &movementAnim;
+        }
+
+        virtual char *DrawState()
+        {
+            return &drawState;
+        }
+
+        virtual ESM::Position *Dir()
+        {
+            return &dir;
+        }
+
+        virtual Attack *GetAttack()
+        {
+            return &attack;
+        }
+
+        virtual std::string *BirthSign()
+        {
+            return &birthSign;
+        }
+
+        virtual std::string *ChatMessage()
+        {
+            return &chatMessage;
+        }
+
+        virtual CGStage *CharGenStage()
+        {
+            return &stage;
+        }
+
+        virtual std::string *GetPassw()
+        {
+            return &passw;
+        }
+        RakNet::RakNetGUID guid;
+
+    protected:
+        ESM::Position pos;
+        ESM::Position dir;
+        ESM::Cell cell;
+        ESM::NPC npc;
+        ESM::NpcStats npcStats;
+        ESM::CreatureStats creatureStats;
+        Item equipedItems[19];
+        unsigned int movementFlags;
+        char movementAnim;
+        char drawState;
+        Attack attack;
+        std::string birthSign;
+        std::string chatMessage;
+        CGStage stage;
+        std::string passw;
+
+    };
+}
+
+#endif //OPENMW_BASEPLAYER_HPP
diff --git a/components/openmw-mp/NetworkMessages.hpp b/components/openmw-mp/NetworkMessages.hpp
new file mode 100644
index 000000000..80d6bccfc
--- /dev/null
+++ b/components/openmw-mp/NetworkMessages.hpp
@@ -0,0 +1,43 @@
+//
+// Created by koncord on 05.01.16.
+//
+
+#ifndef OPENMW_NETWORKMESSAGES_HPP
+#define OPENMW_NETWORKMESSAGES_HPP
+
+#include <MessageIdentifiers.h>
+
+enum GameMessages
+{
+    ID_CUSTOM_MESSAGE = ID_USER_PACKET_ENUM+1
+};
+
+enum MyGameMesages
+{
+    ID_GAME_BASE_INFO = 0,
+    ID_GAME_CHARGEN,
+    ID_GAME_UPDATE_POS,
+    ID_GAME_UPDATE_BASESTATS,
+    ID_GAME_UPDATE_SKILLS,
+    ID_GAME_ATTACK,
+    ID_USER_MYID,
+    ID_GAME_UPDATE_EQUIPED,
+    ID_USER_DISCONNECTED,
+    ID_GAME_CREATE_PROJECTILE,
+    ID_GAME_CAST,
+    ID_GAME_DIE,
+    ID_GAME_RESURRECT,
+    ID_CHAT_MESSAGE,
+    ID_GAME_CELL,
+    ID_GAME_DRAWSTATE,
+
+    ID_GAME_STATS,
+    ID_GAME_ATTRIBUTE,
+    ID_GAME_SKILL,
+    ID_GAME_CHARCLASS,
+    ID_GAME_SKILLPRIORITY,
+    ID_HANDSHAKE
+};
+
+
+#endif //OPENMW_NETWORKMESSAGES_HPP
diff --git a/components/openmw-mp/Packets/BasePacket.cpp b/components/openmw-mp/Packets/BasePacket.cpp
new file mode 100644
index 000000000..6becccd06
--- /dev/null
+++ b/components/openmw-mp/Packets/BasePacket.cpp
@@ -0,0 +1,82 @@
+//
+// Created by koncord on 05.01.16.
+//
+
+#include <components/openmw-mp/NetworkMessages.hpp>
+#include <PacketPriority.h>
+#include <RakPeer.h>
+#include "BasePacket.hpp"
+
+using namespace mwmp;
+
+void BasePacket::Packet(RakNet::BitStream *bs, BasePlayer *player, bool send)
+{
+    this->player = player;
+    this->bs = bs;
+
+    if(send)
+    {
+        bs->Write((RakNet::MessageID) ID_CUSTOM_MESSAGE);
+        bs->Write((RakNet::MessageID) packetID);
+        bs->Write(player->guid);
+    }
+}
+
+BasePacket::BasePacket(RakNet::RakPeerInterface *peer)
+{
+    packetID = 0;
+    priority = HIGH_PRIORITY;
+    reliability = RELIABLE_ORDERED;
+    this->peer = peer;
+}
+
+BasePacket::~BasePacket()
+{
+
+}
+
+void BasePacket::Send(BasePlayer *player, RakNet::AddressOrGUID destination)
+{
+    bsSend->ResetWritePointer();
+    Packet(bsSend, player, true);
+    peer->Send(bsSend, priority, reliability, 0, destination, false);
+}
+
+void BasePacket::Send(BasePlayer *player, bool toOther)
+{
+    bsSend->ResetWritePointer();
+    Packet(bsSend, player, true);
+    peer->Send(bsSend, priority, reliability, 0, player->guid, toOther);
+}
+
+void BasePacket::Read(BasePlayer *player)
+{
+    Packet(bsRead, player, false);
+}
+
+void BasePacket::SetReadStream(RakNet::BitStream *bitStream)
+{
+    bsRead = bitStream;
+}
+
+void BasePacket::SetSendStream(RakNet::BitStream *bitStream)
+{
+    bsSend = bitStream;
+}
+
+void BasePacket::RequestData(RakNet::RakNetGUID player)
+{
+    bsSend->ResetWritePointer();
+    bsSend->Write((RakNet::MessageID) ID_CUSTOM_MESSAGE);
+    bsSend->Write((RakNet::MessageID) packetID);
+    bsSend->Write(player);
+    peer->Send(bsSend, HIGH_PRIORITY, RELIABLE_ORDERED, 0, player, false);
+}
+
+void BasePacket::SetStreams(RakNet::BitStream *inStream, RakNet::BitStream *outStream)
+{
+    if(inStream != 0)
+        bsRead = inStream;
+    if(outStream != 0)
+        bsSend = outStream;
+}
\ No newline at end of file
diff --git a/components/openmw-mp/Packets/BasePacket.hpp b/components/openmw-mp/Packets/BasePacket.hpp
new file mode 100644
index 000000000..818b911e1
--- /dev/null
+++ b/components/openmw-mp/Packets/BasePacket.hpp
@@ -0,0 +1,101 @@
+//
+// Created by koncord on 05.01.16.
+//
+
+#ifndef OPENMW_BASEPACKET_HPP
+#define OPENMW_BASEPACKET_HPP
+
+#include <string>
+#include <RakNetTypes.h>
+#include <BitStream.h>
+#include <PacketPriority.h>
+#include <components/openmw-mp/Base/BasePlayer.hpp>
+
+
+namespace mwmp
+{
+    class BasePacket
+    {
+    public:
+        BasePacket(RakNet::RakPeerInterface *peer);
+
+        ~BasePacket();
+
+        virtual void Packet(RakNet::BitStream *bs, BasePlayer *player, bool send);
+
+        virtual void Send(BasePlayer *player, bool toOtherPlayers = true);
+        virtual void Send(BasePlayer *player, RakNet::AddressOrGUID destination);
+        virtual void Read(BasePlayer *player);
+
+        virtual void RequestData(RakNet::RakNetGUID player);
+
+        void SetReadStream(RakNet::BitStream *bitStream);
+        void SetSendStream(RakNet::BitStream *bitStream);
+        void SetStreams(RakNet::BitStream *inStream, RakNet::BitStream *outStream);
+
+        size_t headerSize()
+        {
+            return 10; // 10 == char + char + RakNetGUID (uint64_t)
+        }
+
+    protected:
+        template<class templateType>
+        void RW(templateType &data, unsigned int size, bool write)
+        {
+            if (write)
+                bs->Write(data, size);
+            else
+                bs->Read(data, size);
+        }
+
+        template<class templateType>
+        void RW(templateType &data, bool write)
+        {
+            if (write)
+                bs->Write(data);
+            else
+                bs->Read(data);
+        }
+
+        void RW(bool &data, bool write)
+        {
+            char _data;
+            if (write)
+            {
+                _data = data;
+                bs->Write(_data);
+            }
+            else
+            {
+                bs->Read(_data);
+                data = _data;
+            }
+        }
+
+
+        void RW(std::string &str, bool write)
+        {
+            if (write)
+                bs->Write(str.c_str());
+            else
+            {
+                char cstr[256];
+                bs->Read(cstr);
+                str = cstr;
+            }
+        }
+
+    protected:
+        BasePlayer *player;
+        unsigned char packetID;
+        PacketReliability reliability;
+        PacketPriority priority;
+
+    private:
+        RakNet::BitStream *bsRead, *bsSend, *bs;
+        RakNet::RakPeerInterface *peer;
+
+    };
+}
+
+#endif //OPENMW_BASEPACKET_HPP
diff --git a/components/openmw-mp/Packets/PacketAttack.cpp b/components/openmw-mp/Packets/PacketAttack.cpp
new file mode 100644
index 000000000..44c1326dd
--- /dev/null
+++ b/components/openmw-mp/Packets/PacketAttack.cpp
@@ -0,0 +1,29 @@
+//
+// Created by koncord on 13.01.16.
+//
+
+#include <components/openmw-mp/NetworkMessages.hpp>
+#include "PacketAttack.hpp"
+
+using namespace mwmp;
+
+PacketAttack::PacketAttack(RakNet::RakPeerInterface *peer) : BasePacket(peer)
+{
+    packetID = ID_GAME_ATTACK;
+}
+
+void PacketAttack::Packet(RakNet::BitStream *bs, mwmp::BasePlayer *player, bool send)
+{
+    BasePacket::Packet(bs, player, send);
+
+    RW(player->GetAttack()->attacker, send);
+    RW(player->GetAttack()->target, send);
+    RW(player->GetAttack()->refid, send);
+    RW(player->GetAttack()->type, send);
+    RW(player->GetAttack()->success, send);
+    RW(player->GetAttack()->damage, send);
+    //
+    RW(player->GetAttack()->pressed, send);
+    RW(player->GetAttack()->knockdown, send);
+    RW(player->GetAttack()->block, send);
+}
diff --git a/components/openmw-mp/Packets/PacketAttack.hpp b/components/openmw-mp/Packets/PacketAttack.hpp
new file mode 100644
index 000000000..2b2719024
--- /dev/null
+++ b/components/openmw-mp/Packets/PacketAttack.hpp
@@ -0,0 +1,22 @@
+//
+// Created by koncord on 13.01.16.
+//
+
+#ifndef OPENMW_PACKETATTACK_HPP
+#define OPENMW_PACKETATTACK_HPP
+
+
+#include <components/openmw-mp/Packets/BasePacket.hpp>
+
+namespace mwmp
+{
+    class PacketAttack : public BasePacket
+    {
+    public:
+        PacketAttack(RakNet::RakPeerInterface *peer);
+
+        virtual void Packet(RakNet::BitStream *bs, BasePlayer *player, bool send);
+    };
+}
+
+#endif //OPENMW_PACKETATTACK_HPP
diff --git a/components/openmw-mp/Packets/PacketAttribute.cpp b/components/openmw-mp/Packets/PacketAttribute.cpp
new file mode 100644
index 000000000..69627f2cc
--- /dev/null
+++ b/components/openmw-mp/Packets/PacketAttribute.cpp
@@ -0,0 +1,21 @@
+//
+// Created by koncord on 08.03.16.
+//
+
+#include "PacketAttribute.hpp"
+#include <components/openmw-mp/NetworkMessages.hpp>
+
+using namespace mwmp;
+
+PacketAttribute::PacketAttribute(RakNet::RakPeerInterface *peer) : BasePacket(peer)
+{
+    packetID = ID_GAME_ATTRIBUTE;
+}
+
+void PacketAttribute::Packet(RakNet::BitStream *bs, BasePlayer *player, bool send)
+{
+    BasePacket::Packet(bs, player, send);
+
+    for(int i = 0; i < AttributesCount; ++i)
+        RW(player->CreatureStats()->mAttributes[i], send);
+}
diff --git a/components/openmw-mp/Packets/PacketAttribute.hpp b/components/openmw-mp/Packets/PacketAttribute.hpp
new file mode 100644
index 000000000..407127b0f
--- /dev/null
+++ b/components/openmw-mp/Packets/PacketAttribute.hpp
@@ -0,0 +1,22 @@
+//
+// Created by koncord on 08.03.16.
+//
+
+#ifndef OPENMW_PACKETATTRIBUTE_HPP
+#define OPENMW_PACKETATTRIBUTE_HPP
+
+#include <components/openmw-mp/Packets/BasePacket.hpp>
+
+namespace mwmp
+{
+    class PacketAttribute : public BasePacket
+    {
+    public:
+        const static int AttributesCount = 8;
+        PacketAttribute(RakNet::RakPeerInterface *peer);
+
+        virtual void Packet(RakNet::BitStream *bs, BasePlayer *player, bool send);
+    };
+}
+
+#endif //OPENMW_PACKETATTRIBUTE_HPP
diff --git a/components/openmw-mp/Packets/PacketAttributesAndStats.cpp b/components/openmw-mp/Packets/PacketAttributesAndStats.cpp
new file mode 100644
index 000000000..fcfa601e1
--- /dev/null
+++ b/components/openmw-mp/Packets/PacketAttributesAndStats.cpp
@@ -0,0 +1,25 @@
+//
+// Created by koncord on 11.01.16.
+//
+
+#include <components/openmw-mp/NetworkMessages.hpp>
+#include <components/esm/creaturestats.hpp>
+#include "PacketAttributesAndStats.hpp"
+
+using namespace mwmp;
+
+PacketAttributesAndStats::PacketAttributesAndStats(RakNet::RakPeerInterface *peer) : BasePacket(peer)
+{
+    packetID = ID_GAME_UPDATE_SKILLS;
+}
+
+void PacketAttributesAndStats::Packet(RakNet::BitStream *bs, BasePlayer *player, bool send)
+{
+    BasePacket::Packet(bs, player, send);
+
+    for(int i = 0; i < AttributesCount; ++i)
+        RW(player->CreatureStats()->mAttributes[i], send);
+
+    for (int i = 0; i < StatsCount; ++i)
+        RW(player->NpcStats()->mSkills[i], send);
+}
diff --git a/components/openmw-mp/Packets/PacketAttributesAndStats.hpp b/components/openmw-mp/Packets/PacketAttributesAndStats.hpp
new file mode 100644
index 000000000..2392b1ba8
--- /dev/null
+++ b/components/openmw-mp/Packets/PacketAttributesAndStats.hpp
@@ -0,0 +1,23 @@
+//
+// Created by koncord on 11.01.16.
+//
+
+#ifndef OPENMW_PacketAttributesAndStats_HPP
+#define OPENMW_PacketAttributesAndStats_HPP
+
+#include <components/openmw-mp/Packets/BasePacket.hpp>
+
+namespace mwmp
+{
+    class PacketAttributesAndStats : public BasePacket
+    {
+    public:
+        const static int AttributesCount = 8;
+        const static int StatsCount = 27;
+        PacketAttributesAndStats(RakNet::RakPeerInterface *peer);
+
+        virtual void Packet(RakNet::BitStream *bs, BasePlayer *player, bool send);
+    };
+}
+
+#endif //OPENMW_PacketAttributesAndStats_HPP
diff --git a/components/openmw-mp/Packets/PacketBaseInfo.cpp b/components/openmw-mp/Packets/PacketBaseInfo.cpp
new file mode 100644
index 000000000..4d3cba59c
--- /dev/null
+++ b/components/openmw-mp/Packets/PacketBaseInfo.cpp
@@ -0,0 +1,29 @@
+//
+// Created by koncord on 07.01.16.
+//
+
+#include "PacketBaseInfo.hpp"
+#include <components/openmw-mp/NetworkMessages.hpp>
+
+using namespace mwmp;
+
+PacketBaseInfo::PacketBaseInfo(RakNet::RakPeerInterface *peer) : BasePacket(peer)
+{
+    packetID = ID_GAME_BASE_INFO;
+}
+
+void PacketBaseInfo::Packet(RakNet::BitStream *bs, BasePlayer *player, bool send)
+{
+    BasePacket::Packet(bs, player, send);
+
+    RW(player->Npc()->mName, send);
+    RW(player->Npc()->mModel, send);
+    RW(player->Npc()->mRace, send);
+    RW(player->Npc()->mClass, send);
+    RW(player->Npc()->mHair, send);
+    RW(player->Npc()->mHead, send);
+
+    RW(player->Npc()->mFlags, send);
+
+    RW(*player->BirthSign(), send);
+}
diff --git a/components/openmw-mp/Packets/PacketBaseInfo.hpp b/components/openmw-mp/Packets/PacketBaseInfo.hpp
new file mode 100644
index 000000000..cdddbebd6
--- /dev/null
+++ b/components/openmw-mp/Packets/PacketBaseInfo.hpp
@@ -0,0 +1,21 @@
+//
+// Created by koncord on 07.01.16.
+//
+
+#ifndef OPENMW_PACKETBASEINFO_HPP
+#define OPENMW_PACKETBASEINFO_HPP
+
+#include <components/openmw-mp/Packets/BasePacket.hpp>
+
+namespace mwmp
+{
+    class PacketBaseInfo : public BasePacket
+    {
+    public:
+        PacketBaseInfo(RakNet::RakPeerInterface *peer);
+
+        virtual void Packet(RakNet::BitStream *bs, BasePlayer *player, bool send);
+    };
+}
+
+#endif //OPENMW_PACKETBASEINFO_HPP
diff --git a/components/openmw-mp/Packets/PacketCell.cpp b/components/openmw-mp/Packets/PacketCell.cpp
new file mode 100644
index 000000000..9cf8bb1f6
--- /dev/null
+++ b/components/openmw-mp/Packets/PacketCell.cpp
@@ -0,0 +1,29 @@
+//
+// Created by koncord on 15.01.16.
+//
+
+#include <components/openmw-mp/NetworkMessages.hpp>
+#include "PacketCell.hpp"
+
+
+mwmp::PacketCell::PacketCell(RakNet::RakPeerInterface *peer) : BasePacket(peer)
+{
+    packetID = ID_GAME_CELL;
+    priority = IMMEDIATE_PRIORITY;
+    reliability = RELIABLE_ORDERED;
+}
+
+void mwmp::PacketCell::Packet(RakNet::BitStream *bs, mwmp::BasePlayer *player, bool send)
+{
+    BasePacket::Packet(bs, player, send);
+
+    RW(player->GetCell()->mData.mFlags, send);
+
+    if(player->GetCell()->isExterior())
+    {
+        RW(player->GetCell()->mCellId.mIndex.mX, send);
+        RW(player->GetCell()->mCellId.mIndex.mY, send);
+    }
+    else
+        RW(player->GetCell()->mName, send);
+}
diff --git a/components/openmw-mp/Packets/PacketCell.hpp b/components/openmw-mp/Packets/PacketCell.hpp
new file mode 100644
index 000000000..73ab333ea
--- /dev/null
+++ b/components/openmw-mp/Packets/PacketCell.hpp
@@ -0,0 +1,24 @@
+//
+// Created by koncord on 15.01.16.
+//
+
+#ifndef OPENMW_PACKETCELL_HPP
+#define OPENMW_PACKETCELL_HPP
+
+
+#include <components/openmw-mp/Packets/BasePacket.hpp>
+
+namespace mwmp
+{
+    class PacketCell : public BasePacket
+    {
+    public:
+        PacketCell(RakNet::RakPeerInterface *peer);
+
+        virtual void Packet(RakNet::BitStream *bs, BasePlayer *player, bool send);
+    };
+}
+
+
+
+#endif //OPENMW_PACKETCELL_HPP
diff --git a/components/openmw-mp/Packets/PacketCharGen.cpp b/components/openmw-mp/Packets/PacketCharGen.cpp
new file mode 100644
index 000000000..09ab231b2
--- /dev/null
+++ b/components/openmw-mp/Packets/PacketCharGen.cpp
@@ -0,0 +1,19 @@
+//
+// Created by koncord on 08.03.16.
+//
+
+#include <components/openmw-mp/NetworkMessages.hpp>
+#include "PacketCharGen.hpp"
+
+mwmp::PacketCharGen::PacketCharGen(RakNet::RakPeerInterface *peer) : BasePacket(peer)
+{
+    packetID = ID_GAME_CHARGEN;
+}
+
+void mwmp::PacketCharGen::Packet(RakNet::BitStream *bs, mwmp::BasePlayer *player, bool send)
+{
+    BasePacket::Packet(bs, player, send);
+
+    RW(*player->CharGenStage(), send);
+
+}
diff --git a/components/openmw-mp/Packets/PacketCharGen.hpp b/components/openmw-mp/Packets/PacketCharGen.hpp
new file mode 100644
index 000000000..899380224
--- /dev/null
+++ b/components/openmw-mp/Packets/PacketCharGen.hpp
@@ -0,0 +1,24 @@
+//
+// Created by koncord on 08.03.16.
+//
+
+#ifndef OPENMW_PACKETCHARGEN_HPP
+#define OPENMW_PACKETCHARGEN_HPP
+
+
+#include <components/openmw-mp/Packets/BasePacket.hpp>
+
+namespace mwmp
+{
+    class PacketCharGen : public BasePacket
+    {
+    public:
+        PacketCharGen(RakNet::RakPeerInterface *peer);
+
+        virtual void Packet(RakNet::BitStream *bs, BasePlayer *player, bool send);
+    };
+}
+
+
+
+#endif //OPENMW_PACKETCHARGEN_HPP
diff --git a/components/openmw-mp/Packets/PacketChatMessage.cpp b/components/openmw-mp/Packets/PacketChatMessage.cpp
new file mode 100644
index 000000000..94e494cf0
--- /dev/null
+++ b/components/openmw-mp/Packets/PacketChatMessage.cpp
@@ -0,0 +1,18 @@
+//
+// Created by koncord on 06.03.16.
+//
+
+#include <components/openmw-mp/NetworkMessages.hpp>
+#include "PacketChatMessage.hpp"
+
+mwmp::PacketChatMessage::PacketChatMessage(RakNet::RakPeerInterface *peer) : BasePacket(peer)
+{
+    packetID = ID_CHAT_MESSAGE;
+}
+
+void mwmp::PacketChatMessage::Packet(RakNet::BitStream *bs, mwmp::BasePlayer *player, bool send)
+{
+    BasePacket::Packet(bs, player, send);
+
+    RW(*player->ChatMessage(), send);
+}
diff --git a/components/openmw-mp/Packets/PacketChatMessage.hpp b/components/openmw-mp/Packets/PacketChatMessage.hpp
new file mode 100644
index 000000000..a4b67c624
--- /dev/null
+++ b/components/openmw-mp/Packets/PacketChatMessage.hpp
@@ -0,0 +1,21 @@
+//
+// Created by koncord on 06.03.16.
+//
+
+#ifndef OPENMW_PACKETCHATMESSAGE_HPP
+#define OPENMW_PACKETCHATMESSAGE_HPP
+
+#include <components/openmw-mp/Packets/BasePacket.hpp>
+
+namespace mwmp
+{
+    class PacketChatMessage : public BasePacket
+    {
+    public:
+        PacketChatMessage(RakNet::RakPeerInterface *peer);
+
+        virtual void Packet(RakNet::BitStream *bs, BasePlayer *player, bool send);
+    };
+}
+
+#endif //OPENMW_PACKETCHATMESSAGE_HPP
diff --git a/components/openmw-mp/Packets/PacketCreateProjectile.cpp b/components/openmw-mp/Packets/PacketCreateProjectile.cpp
new file mode 100644
index 000000000..810c82c14
--- /dev/null
+++ b/components/openmw-mp/Packets/PacketCreateProjectile.cpp
@@ -0,0 +1,18 @@
+//
+// Created by koncord on 13.01.16.
+//
+
+#include <components/openmw-mp/NetworkMessages.hpp>
+#include "PacketCreateProjectile.hpp"
+
+mwmp::PacketCreateProjectile::PacketCreateProjectile(RakNet::RakPeerInterface *peer)
+{
+    packetID = ID_GAME_CREATE_PROJECTILE;
+}
+
+void mwmp::PacketCreateProjectile::Packet(RakNet::BitStream *bs, mwmp::BasePlayer *player, bool send)
+{
+    BasePacket::Packet(bs, player, send);
+
+
+}
diff --git a/components/openmw-mp/Packets/PacketCreateProjectile.hpp b/components/openmw-mp/Packets/PacketCreateProjectile.hpp
new file mode 100644
index 000000000..97281b9a0
--- /dev/null
+++ b/components/openmw-mp/Packets/PacketCreateProjectile.hpp
@@ -0,0 +1,23 @@
+//
+// Created by koncord on 13.01.16.
+//
+
+#ifndef OPENMW_PACKETCREATEPROJECTILE_HPP
+#define OPENMW_PACKETCREATEPROJECTILE_HPP
+
+
+#include <components/openmw-mp/Packets/BasePacket.hpp>
+
+namespace mwmp
+{
+    class PacketCreateProjectile : public BasePacket
+    {
+    public:
+        PacketCreateProjectile(RakNet::RakPeerInterface *peer);
+
+        virtual void Packet(RakNet::BitStream *bs, BasePlayer *player, bool send);
+    };
+}
+
+
+#endif //OPENMW_PACKETCREATEPROJECTILE_HPP
diff --git a/components/openmw-mp/Packets/PacketDie.hpp b/components/openmw-mp/Packets/PacketDie.hpp
new file mode 100644
index 000000000..d48729203
--- /dev/null
+++ b/components/openmw-mp/Packets/PacketDie.hpp
@@ -0,0 +1,29 @@
+//
+// Created by koncord on 13.01.16.
+//
+
+#ifndef OPENMW_PACKETDIE_HPP
+#define OPENMW_PACKETDIE_HPP
+
+
+#include <components/openmw-mp/Packets/BasePacket.hpp>
+#include <components/openmw-mp/NetworkMessages.hpp>
+
+namespace mwmp
+{
+    class PacketDie: public BasePacket
+    {
+    public:
+        PacketDie(RakNet::RakPeerInterface *peer) : BasePacket(peer)
+        {
+            packetID = ID_GAME_DIE;
+        }
+        void Packet(RakNet::BitStream *bs, BasePlayer *player, bool send)
+        {
+            BasePacket::Packet(bs, player, send);
+            RW(player->CreatureStats()->mDead, send);
+        }
+    };
+}
+
+#endif //OPENMW_PACKETDIE_HPP
diff --git a/components/openmw-mp/Packets/PacketDisconnect.hpp b/components/openmw-mp/Packets/PacketDisconnect.hpp
new file mode 100644
index 000000000..28140176f
--- /dev/null
+++ b/components/openmw-mp/Packets/PacketDisconnect.hpp
@@ -0,0 +1,24 @@
+//
+// Created by koncord on 12.01.16.
+//
+
+#ifndef OPENMW_PACKETDISCONNECT_HPP
+#define OPENMW_PACKETDISCONNECT_HPP
+
+#include <components/openmw-mp/Packets/BasePacket.hpp>
+#include <components/openmw-mp/NetworkMessages.hpp>
+
+namespace mwmp
+{
+    class PacketDisconnect : public BasePacket
+    {
+    public:
+        PacketDisconnect(RakNet::RakPeerInterface *peer) : BasePacket(peer)
+        {
+            packetID = ID_USER_DISCONNECTED;
+        }
+    };
+}
+
+
+#endif //OPENMW_PACKETDISCONNECT_HPP
diff --git a/components/openmw-mp/Packets/PacketDrawState.cpp b/components/openmw-mp/Packets/PacketDrawState.cpp
new file mode 100644
index 000000000..4ea9403b0
--- /dev/null
+++ b/components/openmw-mp/Packets/PacketDrawState.cpp
@@ -0,0 +1,20 @@
+//
+// Created by koncord on 15.01.16.
+//
+
+#include <components/openmw-mp/NetworkMessages.hpp>
+#include "PacketDrawState.hpp"
+
+mwmp::PacketDrawState::PacketDrawState(RakNet::RakPeerInterface *peer) : BasePacket(peer)
+{
+    packetID = ID_GAME_DRAWSTATE;
+}
+
+void mwmp::PacketDrawState::Packet(RakNet::BitStream *bs, mwmp::BasePlayer *player, bool send)
+{
+    BasePacket::Packet(bs, player, send);
+
+    RW(*player->MovementFlags(), send);
+
+    RW(*player->DrawState(), send);
+}
diff --git a/components/openmw-mp/Packets/PacketDrawState.hpp b/components/openmw-mp/Packets/PacketDrawState.hpp
new file mode 100644
index 000000000..569a4a399
--- /dev/null
+++ b/components/openmw-mp/Packets/PacketDrawState.hpp
@@ -0,0 +1,23 @@
+//
+// Created by koncord on 15.01.16.
+//
+
+#ifndef OPENMW_PACKETDRAWSTATE_HPP
+#define OPENMW_PACKETDRAWSTATE_HPP
+
+
+#include <components/openmw-mp/Packets/BasePacket.hpp>
+
+namespace mwmp
+{
+    class PacketDrawState : public BasePacket
+    {
+    public:
+        PacketDrawState(RakNet::RakPeerInterface *peer);
+
+        virtual void Packet(RakNet::BitStream *bs, BasePlayer *player, bool send);
+    };
+}
+
+
+#endif //OPENMW_PACKETDRAWSTATE_HPP
diff --git a/components/openmw-mp/Packets/PacketEquiped.cpp b/components/openmw-mp/Packets/PacketEquiped.cpp
new file mode 100644
index 000000000..e2f89546e
--- /dev/null
+++ b/components/openmw-mp/Packets/PacketEquiped.cpp
@@ -0,0 +1,24 @@
+//
+// Created by koncord on 07.01.16.
+//
+
+#include "PacketEquiped.hpp"
+#include <components/openmw-mp/NetworkMessages.hpp>
+
+using namespace mwmp;
+
+PacketEquiped::PacketEquiped(RakNet::RakPeerInterface *peer) : BasePacket(peer)
+{
+    packetID = ID_GAME_UPDATE_EQUIPED;
+}
+
+void PacketEquiped::Packet(RakNet::BitStream *bs, BasePlayer *player, bool send)
+{
+    BasePacket::Packet(bs, player, send);
+
+    for(int i = 0; i < 19; i++)
+    {
+        RW(player->EquipedItem(i)->refid, send);
+        RW(player->EquipedItem(i)->count, send);
+    }
+}
diff --git a/components/openmw-mp/Packets/PacketEquiped.hpp b/components/openmw-mp/Packets/PacketEquiped.hpp
new file mode 100644
index 000000000..309b84ffb
--- /dev/null
+++ b/components/openmw-mp/Packets/PacketEquiped.hpp
@@ -0,0 +1,21 @@
+//
+// Created by koncord on 07.01.16.
+//
+
+#ifndef OPENMW_PACKETCONTAINER_HPP
+#define OPENMW_PACKETCONTAINER_HPP
+
+#include <components/openmw-mp/Packets/BasePacket.hpp>
+
+namespace mwmp
+{
+    class PacketEquiped : public BasePacket
+    {
+    public:
+        PacketEquiped(RakNet::RakPeerInterface *peer);
+
+        virtual void Packet(RakNet::BitStream *bs, BasePlayer *player, bool send);
+    };
+}
+
+#endif //OPENMW_PACKETCONTAINER_HPP
diff --git a/components/openmw-mp/Packets/PacketHandshake.cpp b/components/openmw-mp/Packets/PacketHandshake.cpp
new file mode 100644
index 000000000..ba30278ae
--- /dev/null
+++ b/components/openmw-mp/Packets/PacketHandshake.cpp
@@ -0,0 +1,20 @@
+//
+// Created by koncord on 28.04.16.
+//
+
+#include <components/openmw-mp/NetworkMessages.hpp>
+#include "PacketHandshake.hpp"
+
+using namespace mwmp;
+
+PacketHandshake::PacketHandshake(RakNet::RakPeerInterface *peer) : BasePacket(peer)
+{
+    packetID = ID_HANDSHAKE;
+}
+
+void PacketHandshake::Packet(RakNet::BitStream *bs, BasePlayer *player, bool send)
+{
+    BasePacket::Packet(bs, player, send);
+    RW(player->Npc()->mName, send);
+    RW(*player->GetPassw(), send);
+}
diff --git a/components/openmw-mp/Packets/PacketHandshake.hpp b/components/openmw-mp/Packets/PacketHandshake.hpp
new file mode 100644
index 000000000..195b714ff
--- /dev/null
+++ b/components/openmw-mp/Packets/PacketHandshake.hpp
@@ -0,0 +1,21 @@
+//
+// Created by koncord on 28.04.16.
+//
+
+#ifndef OPENMW_PACKETHANDSHAKE_HPP
+#define OPENMW_PACKETHANDSHAKE_HPP
+
+#include <components/openmw-mp/Packets/BasePacket.hpp>
+
+namespace mwmp
+{
+    class PacketHandshake : public BasePacket
+    {
+    public:
+        PacketHandshake(RakNet::RakPeerInterface *peer);
+
+        virtual void Packet(RakNet::BitStream *bs, BasePlayer *player, bool send);
+    };
+}
+
+#endif //OPENMW_PACKETHANDSHAKE_HPP
diff --git a/components/openmw-mp/Packets/PacketMainStats.cpp b/components/openmw-mp/Packets/PacketMainStats.cpp
new file mode 100644
index 000000000..3288a69fa
--- /dev/null
+++ b/components/openmw-mp/Packets/PacketMainStats.cpp
@@ -0,0 +1,21 @@
+//
+// Created by koncord on 13.01.16.
+//
+
+#include "PacketMainStats.hpp"
+#include <components/openmw-mp/NetworkMessages.hpp>
+
+using namespace mwmp;
+
+PacketMainStats::PacketMainStats(RakNet::RakPeerInterface *peer) : BasePacket(peer)
+{
+    packetID = ID_GAME_UPDATE_BASESTATS;
+}
+
+void PacketMainStats::Packet(RakNet::BitStream *bs, BasePlayer *player, bool send)
+{
+    BasePacket::Packet(bs, player, send);
+    RW(player->CreatureStats()->mDynamic[0], send); // health
+    RW(player->CreatureStats()->mDynamic[1], send); // magic
+    RW(player->CreatureStats()->mDynamic[2], send); // fatigue
+}
\ No newline at end of file
diff --git a/components/openmw-mp/Packets/PacketMainStats.hpp b/components/openmw-mp/Packets/PacketMainStats.hpp
new file mode 100644
index 000000000..841c243bb
--- /dev/null
+++ b/components/openmw-mp/Packets/PacketMainStats.hpp
@@ -0,0 +1,22 @@
+//
+// Created by koncord on 13.01.16.
+//
+
+#ifndef OPENMW_PACKAGEMAINSTATS_HPP
+#define OPENMW_PACKAGEMAINSTATS_HPP
+
+
+#include <components/openmw-mp/Packets/BasePacket.hpp>
+
+namespace mwmp
+{
+    class PacketMainStats : public BasePacket
+    {
+    public:
+        PacketMainStats(RakNet::RakPeerInterface *peer);
+
+        virtual void Packet(RakNet::BitStream *bs, BasePlayer *player, bool send);
+    };
+}
+
+#endif //OPENMW_PACKAGEMAINSTATS_HPP
diff --git a/components/openmw-mp/Packets/PacketPosition.cpp b/components/openmw-mp/Packets/PacketPosition.cpp
new file mode 100644
index 000000000..dd620bece
--- /dev/null
+++ b/components/openmw-mp/Packets/PacketPosition.cpp
@@ -0,0 +1,24 @@
+//
+// Created by koncord on 05.01.16.
+//
+
+#include "PacketPosition.hpp"
+#include <components/openmw-mp/NetworkMessages.hpp>
+
+using namespace std;
+using namespace mwmp;
+
+PacketPosition::PacketPosition(RakNet::RakPeerInterface *peer) : BasePacket(peer)
+{
+    packetID = ID_GAME_UPDATE_POS;
+    priority = MEDIUM_PRIORITY;
+    //reliability = UNRELIABLE_SEQUENCED;
+}
+
+void PacketPosition::Packet(RakNet::BitStream *bs, BasePlayer *player, bool send)
+{
+    BasePacket::Packet(bs, player, send);
+
+    RW(*player->Position(), send);
+    RW(*player->Dir(), send);
+}
\ No newline at end of file
diff --git a/components/openmw-mp/Packets/PacketPosition.hpp b/components/openmw-mp/Packets/PacketPosition.hpp
new file mode 100644
index 000000000..4eeeeea76
--- /dev/null
+++ b/components/openmw-mp/Packets/PacketPosition.hpp
@@ -0,0 +1,21 @@
+//
+// Created by koncord on 05.01.16.
+//
+
+#ifndef OPENMW_PACKETPOSITION_HPP
+#define OPENMW_PACKETPOSITION_HPP
+
+#include <components/openmw-mp/Packets/BasePacket.hpp>
+
+namespace mwmp
+{
+    class PacketPosition : public BasePacket
+    {
+    public:
+        PacketPosition(RakNet::RakPeerInterface *peer);
+
+        virtual void Packet(RakNet::BitStream *bs, BasePlayer *player, bool send);
+    };
+}
+
+#endif //OPENMW_PACKETPOSITION_HPP
diff --git a/components/openmw-mp/Packets/PacketResurrect.hpp b/components/openmw-mp/Packets/PacketResurrect.hpp
new file mode 100644
index 000000000..cd68ad3a3
--- /dev/null
+++ b/components/openmw-mp/Packets/PacketResurrect.hpp
@@ -0,0 +1,30 @@
+//
+// Created by koncord on 13.01.16.
+//
+
+#ifndef OPENMW_PACKETRESURRECT_HPP
+#define OPENMW_PACKETRESURRECT_HPP
+
+
+#include <components/openmw-mp/Packets/BasePacket.hpp>
+#include <components/openmw-mp/NetworkMessages.hpp>
+
+namespace mwmp
+{
+    class PacketResurrect: public BasePacket
+    {
+    public:
+        PacketResurrect(RakNet::RakPeerInterface *peer) : BasePacket(peer)
+        {
+            packetID = ID_GAME_RESURRECT;
+        }
+        void Packet(RakNet::BitStream *bs, BasePlayer *player, bool send)
+        {
+            BasePacket::Packet(bs, player, send);
+            RW(player->CreatureStats()->mDead, send);
+        }
+    };
+}
+
+
+#endif //OPENMW_PACKETRESURRECT_HPP
diff --git a/components/openmw-mp/Packets/PacketRotation.cpp b/components/openmw-mp/Packets/PacketRotation.cpp
new file mode 100644
index 000000000..ab1dfbe19
--- /dev/null
+++ b/components/openmw-mp/Packets/PacketRotation.cpp
@@ -0,0 +1,5 @@
+//
+// Created by koncord on 15.01.16.
+//
+
+#include "PacketRotation.hpp"
diff --git a/components/openmw-mp/Packets/PacketRotation.hpp b/components/openmw-mp/Packets/PacketRotation.hpp
new file mode 100644
index 000000000..ec895d923
--- /dev/null
+++ b/components/openmw-mp/Packets/PacketRotation.hpp
@@ -0,0 +1,15 @@
+//
+// Created by koncord on 15.01.16.
+//
+
+#ifndef OPENMW_PACKETROTATION_HPP
+#define OPENMW_PACKETROTATION_HPP
+
+
+class PacketRotation
+{
+
+};
+
+
+#endif //OPENMW_PACKETROTATION_HPP
diff --git a/components/openmw-mp/Packets/PacketSendMyID.hpp b/components/openmw-mp/Packets/PacketSendMyID.hpp
new file mode 100644
index 000000000..7ce4253fd
--- /dev/null
+++ b/components/openmw-mp/Packets/PacketSendMyID.hpp
@@ -0,0 +1,24 @@
+//
+// Created by koncord on 12.01.16.
+//
+
+#ifndef OPENMW_PACKETSENDMYID_HPP
+#define OPENMW_PACKETSENDMYID_HPP
+
+#include <components/openmw-mp/Packets/BasePacket.hpp>
+#include <components/openmw-mp/NetworkMessages.hpp>
+
+namespace mwmp
+{
+    class PacketSendMyID : public BasePacket
+    {
+    public:
+        PacketSendMyID(RakNet::RakPeerInterface *peer) : BasePacket(peer)
+        {
+            packetID = ID_USER_MYID;
+        }
+    };
+}
+
+
+#endif //OPENMW_PACKETSENDMYID_HPP
diff --git a/components/openmw-mp/Packets/PacketSkill.cpp b/components/openmw-mp/Packets/PacketSkill.cpp
new file mode 100644
index 000000000..b2c5a5249
--- /dev/null
+++ b/components/openmw-mp/Packets/PacketSkill.cpp
@@ -0,0 +1,24 @@
+//
+// Created by koncord on 17.03.16.
+//
+
+#include "PacketSkill.hpp"
+
+#include <components/openmw-mp/NetworkMessages.hpp>
+#include <components/esm/creaturestats.hpp>
+#include "PacketAttributesAndStats.hpp"
+
+using namespace mwmp;
+
+PacketSkill::PacketSkill(RakNet::RakPeerInterface *peer) : BasePacket(peer)
+{
+    packetID = ID_GAME_SKILL;
+}
+
+void PacketSkill::Packet(RakNet::BitStream *bs, BasePlayer *player, bool send)
+{
+    BasePacket::Packet(bs, player, send);
+
+    for (int i = 0; i < StatsCount; ++i)
+        RW(player->NpcStats()->mSkills[i], send);
+}
diff --git a/components/openmw-mp/Packets/PacketSkill.hpp b/components/openmw-mp/Packets/PacketSkill.hpp
new file mode 100644
index 000000000..6b7831580
--- /dev/null
+++ b/components/openmw-mp/Packets/PacketSkill.hpp
@@ -0,0 +1,25 @@
+//
+// Created by koncord on 17.03.16.
+//
+
+#ifndef OPENMW_PACKETSKILL_HPP
+#define OPENMW_PACKETSKILL_HPP
+
+
+#include <components/openmw-mp/Packets/BasePacket.hpp>
+
+namespace mwmp
+{
+    class PacketSkill : public BasePacket
+    {
+    public:
+        const static int StatsCount = 27;
+        PacketSkill(RakNet::RakPeerInterface *peer);
+
+        virtual void Packet(RakNet::BitStream *bs, BasePlayer *player, bool send);
+    };
+}
+
+
+
+#endif //OPENMW_PACKETSKILL_HPP
diff --git a/components/openmw-mp/PacketsController.cpp b/components/openmw-mp/PacketsController.cpp
new file mode 100644
index 000000000..c5b1d64cc
--- /dev/null
+++ b/components/openmw-mp/PacketsController.cpp
@@ -0,0 +1,137 @@
+//
+// Created by koncord on 15.01.16.
+//
+
+#include "Packets/PacketPosition.hpp"
+#include "Packets/PacketBaseInfo.hpp"
+#include "components/openmw-mp/Packets/PacketEquiped.hpp"
+#include "Packets/PacketAttributesAndStats.hpp"
+#include "Packets/PacketAttack.hpp"
+#include "Packets/PacketMainStats.hpp"
+#include "Packets/PacketResurrect.hpp"
+#include "Packets/PacketDie.hpp"
+#include "Packets/PacketCell.hpp"
+#include "Packets/PacketSendMyID.hpp"
+#include "Packets/PacketDisconnect.hpp"
+#include "Packets/PacketDrawState.hpp"
+#include "Packets/PacketChatMessage.hpp"
+#include "Packets/PacketCharGen.hpp"
+#include "Packets/PacketAttribute.hpp"
+#include "Packets/PacketSkill.hpp"
+#include "Packets/PacketHandshake.hpp"
+
+#include "PacketsController.hpp"
+
+
+mwmp::PacketsController::PacketsController(RakNet::RakPeerInterface *peer)
+{
+    packetPosition = new PacketPosition(peer);
+    packetCell = new PacketCell(peer);
+    packetBaseInfo = new PacketBaseInfo(peer);
+    packetEquiped = new PacketEquiped(peer);
+    attributesAndStats = new PacketAttributesAndStats(peer);
+    packetAttack = new PacketAttack(peer);
+    packetMainStats = new PacketMainStats(peer);
+    packetResurrect = new PacketResurrect(peer);
+    packetDie = new PacketDie(peer);
+    packetDrawState = new PacketDrawState(peer);
+
+    packetSendMyID = new PacketSendMyID(peer);
+    packetDisconnect = new PacketDisconnect(peer);
+
+    packetChatMessage = new PacketChatMessage(peer);
+    packetCharGen = new PacketCharGen(peer);
+
+    packetAttribute = new PacketAttribute(peer);
+    packetSkill = new PacketSkill(peer);
+
+    packetHandshake = new PacketHandshake(peer);
+}
+
+
+mwmp::BasePacket *mwmp::PacketsController::GetPacket(RakNet::MessageID id)
+{
+    BasePacket * packet;
+    switch(id)
+    {
+        case ID_GAME_UPDATE_POS:
+            packet = packetPosition;
+            break;
+        case ID_GAME_CELL:
+            packet = packetCell;
+            break;
+        case ID_GAME_BASE_INFO:
+            packet = packetBaseInfo;
+            break;
+        case ID_GAME_UPDATE_EQUIPED:
+            packet = packetEquiped;
+            break;
+        case ID_GAME_UPDATE_SKILLS:
+            packet = attributesAndStats;
+            break;
+        case ID_GAME_ATTACK:
+            packet = packetAttack;
+            break;
+        case ID_GAME_UPDATE_BASESTATS:
+            packet = packetMainStats;
+            break;
+        case ID_GAME_RESURRECT:
+            packet = packetResurrect;
+            break;
+        case ID_GAME_DIE:
+            packet = packetDie;
+            break;
+        case ID_GAME_DRAWSTATE:
+            packet = packetDrawState;
+            break;
+        case ID_USER_MYID:
+            packet = packetSendMyID;
+            break;
+        case ID_USER_DISCONNECTED:
+            packet = packetDisconnect;
+            break;
+        case ID_CHAT_MESSAGE:
+            packet = packetChatMessage;
+            break;
+        case ID_GAME_CHARGEN:
+            packet = packetCharGen;
+            break;
+        case ID_GAME_ATTRIBUTE:
+            packet = packetAttribute;
+            break;
+        case ID_GAME_SKILL:
+            packet = packetSkill;
+            break;
+        case ID_HANDSHAKE:
+            packet = packetHandshake;
+            break;
+        default:
+            packet = 0;
+    }
+    return packet;
+}
+
+void mwmp::PacketsController::SetStream(RakNet::BitStream *inStream, RakNet::BitStream *outStream)
+{
+    packetPosition->SetStreams(inStream, outStream);
+    packetCell->SetStreams(inStream, outStream);
+    packetBaseInfo->SetStreams(inStream, outStream);
+    packetEquiped->SetStreams(inStream, outStream);
+    attributesAndStats->SetStreams(inStream, outStream);
+    packetAttack->SetStreams(inStream, outStream);
+    packetMainStats->SetStreams(inStream, outStream);
+    packetResurrect->SetStreams(inStream, outStream);
+    packetDie->SetStreams(inStream, outStream);
+    packetDrawState->SetStreams(inStream, outStream);
+
+    packetSendMyID->SetStreams(inStream, outStream);
+    packetDisconnect->SetStreams(inStream, outStream);
+
+    packetChatMessage->SetStreams(inStream, outStream);
+    packetCharGen->SetStreams(inStream, outStream);
+
+    packetAttribute->SetStreams(inStream, outStream);
+    packetSkill->SetStreams(inStream, outStream);
+
+    packetHandshake->SetStreams(inStream, outStream);
+}
\ No newline at end of file
diff --git a/components/openmw-mp/PacketsController.hpp b/components/openmw-mp/PacketsController.hpp
new file mode 100644
index 000000000..71f15bd1f
--- /dev/null
+++ b/components/openmw-mp/PacketsController.hpp
@@ -0,0 +1,67 @@
+//
+// Created by koncord on 15.01.16.
+//
+
+#ifndef OPENMW_PACKETSCONTROLLER_HPP
+#define OPENMW_PACKETSCONTROLLER_HPP
+
+
+#include <RakPeerInterface.h>
+#include "Packets/BasePacket.hpp"
+
+namespace mwmp
+{
+    class PacketPosition;
+    class PacketCell;
+    class PacketBaseInfo;
+    class PacketEquiped;
+    class PacketAttributesAndStats;
+    class PacketAttack;
+    class PacketMainStats;
+    class PacketResurrect;
+    class PacketDie;
+    class PacketDrawState;
+
+    class PacketSendMyID;
+    class PacketDisconnect;
+
+    class PacketChatMessage;
+    class PacketCharGen;
+
+    class PacketAttribute;
+    class PacketSkill;
+    class PacketHandshake;
+
+    class PacketsController
+    {
+    public:
+        PacketsController(RakNet::RakPeerInterface *peer);
+
+        BasePacket *GetPacket(RakNet::MessageID id);
+
+        void SetStream(RakNet::BitStream *inStream, RakNet::BitStream *outStream);
+
+    private:
+        PacketPosition *packetPosition;
+        PacketCell *packetCell;
+        PacketBaseInfo *packetBaseInfo;
+        PacketEquiped *packetEquiped;
+        PacketAttributesAndStats *attributesAndStats;
+        PacketAttack *packetAttack;
+        PacketMainStats *packetMainStats;
+        PacketResurrect *packetResurrect;
+        PacketDie *packetDie;
+        PacketDrawState *packetDrawState;
+
+        PacketSendMyID *packetSendMyID;
+        PacketDisconnect *packetDisconnect;
+
+        PacketChatMessage *packetChatMessage;
+        PacketCharGen *packetCharGen;
+        PacketAttribute *packetAttribute;
+        PacketSkill *packetSkill;
+        PacketHandshake *packetHandshake;
+    };
+}
+
+#endif //OPENMW_PACKETSCONTROLLER_HPP
diff --git a/extern/LuaBridge/LuaBridge.h b/extern/LuaBridge/LuaBridge.h
new file mode 100644
index 000000000..1928e9a1f
--- /dev/null
+++ b/extern/LuaBridge/LuaBridge.h
@@ -0,0 +1,142 @@
+//------------------------------------------------------------------------------
+/*
+  https://github.com/vinniefalco/LuaBridge
+  
+  Copyright 2012, Vinnie Falco <vinnie.falco@gmail.com>
+  Copyright 2007, Nathan Reed
+
+  License: The MIT License (http://www.opensource.org/licenses/mit-license.php)
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+//==============================================================================
+
+#ifndef LUABRIDGE_LUABRIDGE_HEADER
+#define LUABRIDGE_LUABRIDGE_HEADER
+
+// All #include dependencies are listed here
+// instead of in the individual header files.
+//
+#include <cassert>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <typeinfo>
+
+#define LUABRIDGE_MAJOR_VERSION 2
+#define LUABRIDGE_MINOR_VERSION 0
+#define LUABRIDGE_VERSION 200
+
+namespace luabridge
+{
+
+// Forward declaration
+//
+template <class T>
+struct Stack;
+
+#include "detail/LuaHelpers.h"
+
+#include "detail/TypeTraits.h"
+#include "detail/TypeList.h"
+#include "detail/FuncTraits.h"
+#include "detail/Constructor.h"
+#include "detail/Stack.h"
+#include "detail/ClassInfo.h"
+
+class LuaRef;
+
+#include "detail/LuaException.h"
+#include "detail/LuaRef.h"
+#include "detail/Iterator.h"
+
+//------------------------------------------------------------------------------
+/**
+    security options.
+*/
+class Security
+{
+public:
+  static bool hideMetatables ()
+  {
+    return getSettings().hideMetatables;
+  }
+
+  static void setHideMetatables (bool shouldHide)
+  {
+    getSettings().hideMetatables = shouldHide;
+  }
+
+private:
+  struct Settings
+  {
+    Settings () : hideMetatables (true)
+    {
+    }
+
+    bool hideMetatables;
+  };
+
+  static Settings& getSettings ()
+  {
+    static Settings settings;
+    return settings;
+  }
+};
+
+#include "detail/Userdata.h"
+#include "detail/CFunctions.h"
+#include "detail/Namespace.h"
+
+//------------------------------------------------------------------------------
+/**
+    Push an object onto the Lua stack.
+*/
+template <class T>
+inline void push (lua_State* L, T t)
+{
+  Stack <T>::push (L, t);
+}
+
+//------------------------------------------------------------------------------
+/**
+  Set a global value in the lua_State.
+
+  @note This works on any type specialized by `Stack`, including `LuaRef` and
+        its table proxies.
+*/
+template <class T>
+inline void setGlobal (lua_State* L, T t, char const* name)
+{
+  push (L, t);
+  lua_setglobal (L, name);
+}
+
+//------------------------------------------------------------------------------
+/**
+  Change whether or not metatables are hidden (on by default).
+*/
+inline void setHideMetatables (bool shouldHide)
+{
+  Security::setHideMetatables (shouldHide);
+}
+
+}
+
+#endif
diff --git a/extern/LuaBridge/Manual.html b/extern/LuaBridge/Manual.html
new file mode 100644
index 000000000..e2a7d0dfd
--- /dev/null
+++ b/extern/LuaBridge/Manual.html
@@ -0,0 +1,1794 @@
+<!doctype html>
+<html>
+<head>
+<title>LuaBridge 2.0 Reference Manual</title>
+<META HTTP-EQUIV="content-type" CONTENT="text/html; charset=iso-8859-1">
+
+<!--=========================================================================-->
+<style TYPE="text/css">
+
+body {
+  color: #000000 ;
+  background-color: #FFFFFF ;
+  font-family: Helvetica, Arial, sans-serif ;
+  text-align: justify ;
+  margin-right: 30px ;
+  margin-left: 30px ;
+}
+
+h1, h2, h3, h4 {
+  font-family: Verdana, Geneva, sans-serif ;
+  font-weight: normal ;
+  font-style: normal ;
+}
+
+h1 {
+  padding-top: 0.4em ;
+  padding-bottom: 0.4em ;
+  padding-left: 24px ;
+  margin-left: -24px ;
+  background-color: #ffe668 ;
+  border-radius: 8px ;
+}
+
+h2 {
+  padding-top: 0.4em ;
+  padding-bottom: 0.4em ;
+  padding-left: 1em ;
+  padding-right: 1em ;
+  background-color: #ffe668 ;
+  border-radius: 8px ;
+}
+
+h3 {
+  padding-left: 0.5em ;
+  border-left: solid #ffe668 1em ;
+}
+
+a:link {
+  color: #8d5c00 ;
+  background-color: inherit ;
+  text-decoration: none ;
+}
+
+a:visited {
+  color: #b17b26;
+  background-color: inherit ;
+  text-decoration: none ;
+}
+
+a:link:hover, a:visited:hover {
+  color: #8d5c00 ;
+  background-color: #ffe668 ;
+}
+
+a:link:active, a:visited:active {
+  color: inherit;
+}
+
+hr {
+  border: 0 ;
+  height: 1px ;
+  color: #a0a0a0 ;
+  background-color: #a0a0a0 ;
+}
+
+:target {
+  background-color: #F8F8F8 ;
+  padding-top: 2px ;
+  padding-bottom: 2px ;
+  padding-left: 8px;
+  padding-right: 8px;
+  border: solid #a0a0a0 2px ;
+}
+
+.footer {
+  color: gray ;
+  font-size: small ;
+}
+
+ul {
+  list-style-type: none ;
+  list-style-position: outside ;
+}
+
+ul.bullets {
+  list-style-type: disc ;
+} 
+
+img {
+  border: 0;
+}
+
+table {
+  margin-left: 2em;
+}
+
+pre, code {
+  font-size: 12pt ;
+}
+
+pre {
+  margin-left: 2em;
+}
+
+pre.split {
+  padding-left: 2em;
+  display: table-cell ;
+  white-space: pre-wrap ;
+  vertical-align: text-top ;
+  padding-right: 2em;
+}
+
+pre.split + pre.split {
+  border-left: 1px solid #ccc;
+}
+
+</style>
+
+</head>
+
+<!--=========================================================================-->
+
+<body>
+
+<header>
+<hr>
+<h1>LuaBridge 2.0 Reference Manual</h1>
+<hr>
+</header>
+
+<small>
+Official repository is located at
+<a href="https://github.com/vinniefalco/LuaBridge">https://github.com/vinniefalco/LuaBridge</a>.
+<br>
+Copyright &copy; 2012 Vinnie Falco. Freely available under the terms of the
+<A HREF="http://www.opensource.org/licenses/mit-license.html">MIT License</A>.
+</small>
+
+<nav>
+<H2>Contents</H2>
+<UL id="toc" style="padding: 0">
+<LI><A href="#s1">1 - Introduction</A>
+<UL>
+  <LI><A href="#s1.1">1.1 - Design</A>
+  <LI><A href="#s1.2">1.2 - Repository</A>
+  <LI><A href="#s1.3">1.3 - License and Credits</A>
+</UL>
+<P>
+<LI><A href="#s2">2 - Accessing C++ from Lua</A>
+<UL>
+  <LI><A href="#s2.1">2.1 - Namespaces</A>
+  <LI><A href="#s2.2">2.2 - Data, Properties, Functions, and CFunctions</A>
+  <LI><A href="#s2.3">2.3 - Class Objects</A>
+  <LI><A href="#s2.4">2.4 - Property Member Proxies</A>
+  <LI><A href="#s2.5">2.5 - Constructors</A>
+  <LI><A href="#s2.6">2.6 - Lua Stack</A>
+  <LI><A href="#s2.7">2.7 - lua_State</A>
+</UL>
+<p>
+<LI><A href="#s3">3 - Passing Objects</A>
+<UL>
+  <LI><A href="#s3.1">3.1 - C++ Lifetime</A>
+  <LI><A href="#s3.2">3.2 - Lua Lifetime</A>
+  <LI><A href="#s3.3">3.3 - Pointers, References, and Pass by Value</A>
+  <LI><A href="#s3.4">3.4 - Shared Lifetime</A>
+  <UL>
+    <LI><A href="#s3.4.1">3.4.1 - Class RefCountedObjectPtr</A>
+    <LI><A href="#s3.4.2">3.4.2 - Class RefCountedPtr</A>
+    <LI><A href="#s3.4.3">3.4.3 - User-defined Containers</A>
+    <LI><A href="#s3.4.4">3.4.4 - Container Constructors</A>
+  </UL>
+  <LI><A href="#s3.5">3.5 - Mixing Lifetimes</A>
+  <LI><A href="#s3.6">3.6 - Convenience Functions</A>
+</UL>
+<P>
+<LI><A href="#s4">4 - Accessing Lua from C++</A>
+<UL>
+  <LI><A href="#s4.1">4.1 - Class LuaRef</A>
+  <UL>
+    <LI><A href="#s4.1.1">4.1.1 - Type Conversions</A>
+    <LI><A href="#s4.1.2">4.1.2 - Visual Studio 2010, 2012</A>
+  </UL>
+  <LI><A href="#s4.2">4.2 - Table Proxies</A>
+  <LI><A href="#s4.3">4.3 - Calling Lua</A>
+  <UL>
+    <LI><A href="#s4.3.1">4.3.1 - Class LuaException</A>
+  </UL>
+</uL>
+<P>
+<LI><A href="#s5">5 - Security</A>
+</UL>
+</nav>
+
+<!--========================================================================-->
+
+<section>
+
+<h1>1 - <span id="s1">Introduction</span></h1>
+
+<p>
+<a href="https://github.com/vinniefalco/LuaBridge">LuaBridge</a> is a
+lightweight and dependency-free library for mapping data, functions, and
+classes back and forth between C++ and <a href="http://wwww.lua.org">Lua</a>,
+a powerful, fast, lightweight, embeddable scripting language. LuaBridge has
+been tested and works with Lua revisions starting from 5.1.5, although it
+should work in any version of Lua from 5.1.0 and later. It also works
+transparently with <a href="http://luajit.org/">LuaJIT</a>.
+</p>
+
+<p>
+LuaBridge offers the following features:
+</p>
+
+<ul class="bullets" title="Features">
+<li><a href="http://www.opensource.org/licenses/mit-license.html">MIT Licensed</a>, no usage restrictions!</li>
+<li>Headers-only: No Makefile, no .cpp files, just one <code>#include</code>!</li>
+<li>Simple, light, and nothing else needed (like Boost).</li>
+<li>No macros, settings, or configuration scripts needed.</li>
+<li>Supports different object lifetime management models.</li>
+<li>Convenient, type-safe access to the Lua stack.</li>
+<li>Automatic function parameter type binding.</li>
+<li>Easy access to Lua objects like tables and functions.</li>
+<li>Written in a clear and easy to debug style.</li>
+<li>Does not require C++11.</li>
+</ul>
+
+<p>
+LuaBridge is distributed as a a collection of header files. You simply add
+one line, <code>#include "LuaBridge/LuaBridge.h"</code> where you want to
+pass functions, classes, and variables back and forth between C++ and Lua.
+There are no additional source files, no compilation settings, and no
+Makefiles or IDE-specific project files. LuaBridge is easy to integrate.
+</p>
+
+<p>
+C++ concepts like variables and classes are made available to Lua through a
+process called <em>registration</em>. Because Lua is weakly typed, the resulting
+structure is not rigid. The API is based on C++ template metaprogramming. It
+contains template code to automatically generate at compile-time the various
+Lua C API calls necessary to export your program's classes and functions to
+the Lua environment.
+</p>
+
+<p>
+To expose Lua objects to C++, a class called <code>LuaRef</code> is provided.
+The implementation allows C++ code to access Lua objects such as numbers
+or strings, but more importantly to access things like tables and their
+values. Using this class makes idioms like calling Lua functions simple
+and clean.
+</p>
+
+<!--========================================================================-->
+
+<section>
+
+<h2>1.1 - <span id="s1.1">Design</span></h2>
+
+<p>
+LuaBridge tries to be efficient as possible when creating the "glue" that
+exposes C++ data and functions to Lua. At the same time, the code was
+written with the intention that it is all as simple and clear as possible,
+without resorting to obscure C++ idioms, ugly preprocessor macros, or
+configuration settings. Furthermore, it is designed to be "header-only",
+making it very easy to integrate into your projects.
+</p>
+
+<p>
+Because LuaBridge was written with simplicity in mind there are some features
+that are not available. Although it comes close to the highest possible
+performance, LuaBridge is not quite the fastest,
+<a href="http://code.google.com/p/oolua/">OOLua</a> slightly outperforms
+LuaBridge in some tests. LuaBridge also does not try to implement every
+possible feature,
+<a href="http://www.rasterbar.com/products/luabind.html">LuaBind</a>
+explores every corner of the C++ language (but it requires Boost).
+</p>
+
+<p>
+LuaBridge does not support:
+</p>
+
+<ul class="bullets">
+<li>Enumerated constants
+<li>More than 8 parameters on a function or method (although this can be
+    increased by adding more <code>TypeListValues</code> specializations).
+<li>Overloaded functions, methods, or constructors.
+<li>Global variables (variables must be wrapped in a named scope).
+<li>Automatic conversion between STL container types and Lua tables.
+<li>Inheriting Lua classes from C++ classes.
+<li>Passing nil to a C++ function that expects a pointer or reference.
+<li>Standard containers like <code>std::shared_ptr</code>.
+</ul>
+
+</section>
+
+<!--========================================================================-->
+
+<section>
+
+<h2>1.2 - <span id="s1.2">Repository</span></h2>
+
+<p>
+The official repository is located at
+<a href="https://github.com/vinniefalco/LuaBridge">https://github.com/vinniefalco/LuaBridge</a>.
+The branches are organized as follows:
+</p>
+
+<table>
+<tr>
+  <td><b>master</b></td>
+  <td>Tagged, stable release versions.</td>
+</tr>
+<tr>
+  <td><b>release</b></td>
+  <td>A temporarily created branch that holds a release candidate for review.</td>
+</tr>
+<tr>
+  <td><b>develop</b></td>
+  <td>Contains work in progress, possibly unfinished or with bugs.</td>
+</tr>
+</table>
+
+<p>
+These repositories are also available:
+</p>
+
+<table>
+<tr>
+  <td><b><a href="https://github.com/vinniefalco/LuaBridgeUnitTests">LuaBridgeUnitTests</a></b></td>
+  <td>A stand alone command line application to exercise LuaBridge functionality.</td>
+</tr>
+<tr>
+  <td><b><a href="https://github.com/vinniefalco/LuaBridgeDemo">LuaBridgeUnitDemo</a></b></td>
+  <td>A stand alone GUI application that provides an interactive console.</td>
+</tr>
+</table>
+
+</section>
+
+<!--========================================================================-->
+
+<section>
+
+<h2>1.3 - <span id="s1.3">License and Credits</span></h2>
+
+<p>
+LuaBridge is published under the terms of the
+<a href="http://www.opensource.org/licenses/mit-license.html">MIT License</a>:
+</p>
+
+<pre>
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+</pre>
+
+<p>
+The original version of LuaBridge was written by Nathan Reed. The project
+has been taken over by Vinnie Falco, who added new functionality and wrote
+the new documentation. Vinnie also incorporated <code>LuaRef</code> and
+other Lua to C++ binding contributions from Nigel Atkinson.
+</p>
+
+<p>
+For questions, comments, or bug reports feel free to open a Github issue
+or contact Vinnie Falco directly at the email address indicated below.
+</p>
+
+<ul>
+<li>Copyright 2012, Vinnie Falco <a href="mailto:vinnie.falco@gmail.com">&lt;vinnie.falco@gmail.com&gt;</a>
+<li>Copyright 2008, Nigel Atkinson <a href="mailto:suprapilot+LuaCode@gmail.com">&lt;suprapilot+LuaCode@gmail.com&gt;</a>
+<li>Copyright 2007, Nathan Reed
+<li>Portions from The Loki Library: Copyright 2001 by Andrei Alexandrescu
+</ul>
+
+<p>
+Older versions of LuaBridge up to and including 0.2 (available separately) are
+distributed under the BSD 3-Clause License. See the corresponding license file
+in those versions (distributed separately) for more details.
+</p>
+
+</section>
+
+<!--========================================================================-->
+
+</section>
+
+<section>
+
+<h1>2 - <span id="s2">Accessing C++ from Lua</span></h1>
+
+<p>
+In order to expose C++ data and functions to Lua, each piece of exported
+information must be <em>registered</em>. There are five types of objects that
+LuaBridge can register:
+</p>
+
+<table>
+<tr>
+  <td><b>Namespaces</b>&nbsp;&nbsp;</td>
+  <td>A Lua table that contains other registrations.</td>
+</tr>
+<tr>
+  <td><b>Data</b>&nbsp;&nbsp;</td>
+  <td>Global or static variables, data members, and static data members.</td>
+</tr>
+<tr>
+  <td><b>Functions&nbsp;&nbsp;</b></td>
+  <td>Regular functions, member functions, and static member functions.</td>
+</tr>
+<tr>
+  <td><b>CFunctions&nbsp;&nbsp;</b></td>
+  <td>A regular function, member function, or static member function that
+      uses the <code>lua_CFunction</code> calling convention.</td>
+</tr>
+<tr>
+  <td><b>Properties&nbsp;&nbsp;</b></td>
+  <td>Global properties, property members, and static property members.
+      These appear like data to Lua, but are implemented in C++ using
+      functions to get and set the values.</td>
+  </tr>
+</table>
+
+<p>
+Both data and properties can be marked as <em>read-only</em> at the time of
+registration. This is different from <code>const</code>; the values of these
+objects can be modified on the C++ side, but Lua scripts cannot change them.
+Code samples that follow are in C++ or Lua, depending on context. For brevity
+of exposition code samples in C++ assume the traditional variable
+<code>lua_State* L</code> is defined, and that a <code>using namespace luabridge</code>
+using-directive is in effect.
+</p>
+
+<!--========================================================================-->
+
+<section>
+
+<h2>2.1 - <span id="s2.1">Namespaces</span></h2>
+
+<p>
+All LuaBridge registrations take place in a <em>namespace</em>. When we refer
+to a <em>namespace</em> we are always talking about a namespace in the Lua
+sense, which is implemented using tables. The namespace need not correspond
+to a C++ namespace; in fact no C++ namespaces need to exist at all unless you
+want them to. LuaBridge namespaces are visible only to Lua scripts; they are
+used as a logical grouping tool. To obtain access to the global namespace
+we write:
+</p>
+
+<pre>
+getGlobalNamespace (L);
+</pre>
+
+<p>
+This returns an object on which further registrations can be performed. The
+subsequent registrations will go into the global namespace, a practice which
+is not recommended. Instead, we can add our own namespace by writing:
+</p>
+
+<pre>
+getGlobalNamespace (L)
+  .beginNamespace ("test");
+</pre>
+
+<p>
+This creates a table in <code>_G</code> called "test". Since we have not
+performed any registrations, this table will be empty except for some
+bookkeeping key/value pairs. LuaBridge reserves all identifiers that start
+with a double underscore. So <code>__test</code> would be an invalid name
+(although LuaBridge will silently accept it). Functions like
+<code>beginNamespace</code> return the corresponding object on which we can
+make more registrations. Given:
+</p>
+
+<pre>
+getGlobalNamespace (L)
+  .beginNamespace ("test")
+    .beginNamespace ("detail")
+    .endNamespace ()
+    .beginNamespace ("utility")
+    .endNamespace ()
+  .endNamespace ();
+</pre>
+
+<p>
+The results are accessible to Lua as <code>test</code>, <code>test.detail</code>,
+and <code>test.utility</code>. Here we introduce the <code>endNamespace</code>
+function; it returns an object representing the original enclosing namespace.
+All LuaBridge functions which  create registrations return an object upon which
+subsequent registrations can be made, allowing for an unlimited number of
+registrations to be chained together using the dot operator. Adding two objects
+with the same name, in the same namespace, results in undefined behavior
+(although LuaBridge will silently accept it).
+</p>
+
+<p>
+A namespace can be re-opened later to add more functions. This lets you split
+up the registration between different source files. These are equivalent:
+</p>
+
+<pre>
+getGlobalNamespace (L)
+  .beginNamespace ("test")
+    .addFunction ("foo", foo)
+  .endNamespace ();
+
+getGlobalNamespace (L)
+  .beginNamespace ("test")
+    .addFunction ("bar", bar)
+  .endNamespace ();
+</pre>
+
+<p>
+and
+</p>
+
+<pre>
+getGlobalNamespace (L)
+  .beginNamespace ("test")
+    .addFunction ("foo", foo)
+    .addFunction ("bar", bar)
+  .endNamespace ();
+</pre>
+
+</section>
+
+<!--========================================================================-->
+
+<section>
+
+<h2>2.2 - <span id="s2.2">Data, Properties, Functions, and CFunctions</span></h2>
+
+<p>
+These are registered into a namespace using <code>addVariable</code>,
+<code>addProperty</code>, <code>addFunction</code>, and <code>addCFunction</code>.
+When registered functions are called by scripts, LuaBridge automatically takes
+care of the conversion of arguments into the appropriate data type when doing
+so is possible. This automated system works for the function's return value,
+and up to 8 parameters although more can be added by extending the templates.
+Pointers, references, and objects of class type as parameters are treated
+specially, and explained later. If we have:
+</p>
+
+<pre>
+int globalVar;
+static float staticVar;
+
+std::string stringProperty;
+std::string getString () { return stringProperty; }
+void setString (std::string s) { stringProperty = s; }
+
+int foo () { return 42; }
+void bar (char const*) { }
+int cFunc (lua_State* L) { return 0; }
+</pre>
+
+<p>
+These are registered with:
+</p>
+
+<pre>
+getGlobalNamespace (L)
+  .beginNamespace ("test")
+    .addVariable ("var1", &amp;globalVar)
+    .addVariable ("var2", &amp;staticVar, false)     // read-only
+    .addProperty ("prop1", getString, setString)
+    .addProperty ("prop2", getString)            // read only
+    .addFunction ("foo", foo)
+    .addFunction ("bar", bar)
+    .addCFunction ("cfunc", cFunc)
+  .endNamespace ();
+</pre>
+
+<p>
+Variables can be marked <em>read-only</em> by passing <code>false</code> in
+the second optional parameter. If the parameter is omitted, <em>true</em> is
+used making the variable read/write. Properties are marked read-only by
+omitting the set function. After the registrations above, the following Lua
+identifiers are valid:
+</p>
+
+<pre>
+test        -- a namespace
+test.var1   -- a lua_Number variable
+test.var2   -- a read-only lua_Number variable
+test.prop1  -- a lua_String property
+test.prop2  -- a read-only lua_String property
+test.foo    -- a function returning a lua_Number
+test.bar    -- a function taking a lua_String as a parameter
+test.cfunc  -- a function with a variable argument list and multi-return
+</pre>
+
+<p>
+Note that <code>test.prop1</code> and `test.prop2` both refer to the
+same value. However, since <code>test.prop2</code> is read-only, assignment
+attempts will generate a run-time error. These Lua statements have the stated effects:
+</p>
+
+<pre>
+test.var1 = 5         -- okay
+test.var2 = 6         -- error: var2 is not writable
+test.prop1 = "Hello"  -- okay
+test.prop1 = 68       -- okay, Lua converts the number to a string.
+test.prop2 = "bar"    -- error: prop2 is not writable
+
+test.foo ()           -- calls foo and discards the return value
+test.var1 = foo ()    -- calls foo and stores the result in var1
+test.bar ("Employee") -- calls bar with a string
+test.bar (test)       -- error: bar expects a string not a table
+</pre>
+
+<p>
+LuaBridge does not support overloaded functions nor is it likely to in the
+future. Since Lua is dynamically typed, any system that tries to resolve a set
+of parameters passed from a script will face considerable ambiguity when
+trying to choose an appropriately matching C++ function signature.
+</p>
+
+</section>
+
+<!--========================================================================-->
+
+<section>
+
+<h2>2.3 - <span id="s2.3">Class Objects</span></h2>
+
+<p>
+A class registration is opened using either <code>beginClass</code> or
+<code>deriveClass</code> and ended using <code>endClass</code>. Once
+registered, a class can later be re-opened for more registrations using
+<code>beginClass</code>. However, <code>deriveClass</code> should only be
+used once. To add more registrations to an already registered derived class,
+use <code>beginClass</code> on it. These declarations:
+</p>
+
+<pre>
+struct A {
+  static int staticData;
+  static float staticProperty;
+    
+  static float getStaticProperty () { return staticProperty; }
+  static void setStaticProperty (float f) { staticProperty = f; }
+  static void staticFunc () { }
+
+  static int staticCFunc () { return 0; }
+
+  std::string dataMember;
+
+  char dataProperty;
+  char getProperty () const { return dataProperty; }
+  void setProperty (char v) { dataProperty = v; }
+
+  void func1 () { }
+  virtual void virtualFunc () { }
+
+  int cfunc (lua_State* L) { return 0; }
+};
+
+struct B : public A {
+  double dataMember2;
+
+  void func1 () { }
+  void func2 () { }
+  void virtualFunc () { }
+};
+
+int A::staticData;
+float A::staticProperty;
+</pre>
+
+<p>
+are registered using:
+</p>
+
+<pre>
+getGlobalNamespace (L)
+  .beginNamespace ("test")
+    .beginClass &lt;A&gt; ("A")
+      .addStaticData ("staticData", &amp;A::staticData)
+      .addStaticProperty ("staticProperty", &amp;A::staticProperty)
+      .addStaticFunction ("staticFunc", &amp;A::staticFunc)
+      .addStaticCFunction ("staticCFunc", &amp;A::staticCFunc)
+      .addData ("data", &amp;A::dataMember)
+      .addProperty ("prop", &amp;A::getProperty, &amp;A::setProperty)
+      .addFunction ("func1", &amp;A::func1)
+      .addFunction ("virtualFunc", &amp;A::virtualFunc)
+      .addCFunction ("cfunc", &amp;A::cfunc)
+    .endClass ()
+    .deriveClass &lt;B, A&gt; ("B")
+      .addData ("data", &amp;B::dataMember2)
+      .addFunction ("func1", &amp;B::func1)
+      .addFunction ("func2", &amp;B::func2)
+    .endClass ()
+  .endNameSpace ();
+</pre>
+
+<p>
+Method registration works just like function registration.  Virtual methods
+work normally; no special syntax is needed. const methods are detected and
+const-correctness is enforced, so if a function returns a const object (or
+a container holding to a const object) to Lua, that reference to the object
+will be considered const and only const methods can be called on it.
+Destructors are registered automatically for each class.
+</p>
+
+<p>
+As with regular variables and properties, class data and properties can be
+marked read-only by passing false in the second parameter, or omitting the set
+set function respectively. The `deriveClass` takes two template arguments: the
+class to be registered, and its base class.  Inherited methods do not have to
+be re-declared and will function normally in Lua. If a class has a base class
+that is **not** registered with Lua, there is no need to declare it as a
+subclass.
+</p>
+
+<p>
+Remember that in Lua, the colon operator '<code>:</code>' is used for
+method call syntax:
+</p>
+
+<pre>
+local a = A ()
+
+a.func1 () -- Does nothing
+a:func1 () -- Works
+</pre>
+
+</section>
+
+<!--========================================================================-->
+
+<section>
+
+<h2>2.4 - <span id="s2.4">Property Member Proxies</span></h2>
+
+<p>
+Sometimes when registering a class which comes from a third party library, the
+data is not exposed in a way that can be expressed as a pointer to member,
+there are no get or set functions, or the get and set functons do not have the
+right function signature. Since the class declaration is closed for changes,
+LuaBridge allows for a <em>property member proxy</em>. This is a pair of get
+and set flat functions which take as their first parameter a pointer to
+the object. This is easily understood with the following example:
+</p>
+
+<pre>
+// Third party declaration, can't be changed
+struct Vec 
+{
+  float coord [3];
+};
+</pre>
+
+<p>
+Taking the address of an array element, e.g. <code>&amp;Vec::coord [0]</code>
+results in an error instead of a pointer-to-member. The class is closed for
+modifications, but we want to export Vec objects to Lua using the familiar
+object notation. To do this, first we add a "helper" class:
+</p>
+
+<pre>
+struct VecHelper
+{
+  template &lt;unsigned index&gt;
+  static float get (Vec const* vec)
+  {
+    return vec->coord [index];
+  }
+
+  template &lt;unsigned index&gt;
+  static void set (Vec* vec, float value)
+  {
+    vec->coord [index] = value;
+  }
+};
+</pre>
+
+<p>
+This helper class is only used to provide property member proxies.
+<code>Vec</code> continues to be used in the C++ code as it was before.
+Now we can register the <code>Vec</code> class with property member proxies for
+<code>x</code>, <code>y</code>, and <code>z</code>:
+</p>
+
+<pre>
+getGlobalNamespace (L)
+  .beginNamespace ("test")
+    .beginClass &lt;Vec&gt; ("Vec")
+      .addProperty ("x", &amp;VecHelper::get &lt;0&gt;, &amp;VecHelper::set &lt;0&gt;)
+      .addProperty ("y", &amp;VecHelper::get &lt;1&gt;, &amp;VecHelper::set &lt;1&gt;)
+      .addProperty ("z", &amp;VecHelper::get &lt;2&gt;, &amp;VecHelper::set &lt;2&gt;)
+    .endClass ()
+  .endNamespace ();
+</pre>
+
+</section>
+
+<!--========================================================================-->
+
+<section>
+
+<h2>2.5 - <span id="s2.5">Constructors</span></h2>
+
+<p>
+A single constructor may be added for a class using <code>addConstructor</code>.
+LuaBridge cannot automatically determine the number and types of constructor
+parameters like it can for functions and methods, so you must provide them.
+This is done by specifying the signature of the desired constructor function
+as the first template parameter to <code>addConstructor</code>. The parameter
+types will be extracted from this (the return type is ignored).  For example,
+these statements register constructors for the given classes:
+</p>
+
+<pre>
+struct A {
+  A ();
+};
+
+struct B {
+  explicit B (char const* s, int nChars);
+};
+
+getGlobalNamespace (L)
+  .beginNamespace ("test")
+    .beginClass &lt;A&gt; ("A")
+      .addConstructor &lt;void (*) (void)&gt; ()
+    .endClass ()
+    .beginClass &lt;B&gt; ("B")
+      .addConstructor &lt;void (*) (char const*, int)&gt; ()
+    .endClass ()
+  .endNamespace ();
+</pre>
+
+<p>
+Constructors added in this fashion are called from Lua using the fully
+qualified name of the class. This Lua code will create instances of
+<code>A</code> and <code>B</code>.
+</p>
+
+<pre>
+a = test.A ()           -- Create a new A.
+b = test.B ("hello", 5) -- Create a new B.
+b = test.B ()           -- Error: expected string in argument 1
+</pre>
+
+</section>
+
+<!--========================================================================-->
+
+<section>
+
+<h2>2.6 - <span id="s2.6">Lua Stack</span></h2>
+
+<p>
+In the Lua C API, all operations on the <code>lua_State</code> are performed
+through the Lua stack. In order to pass values back and forth between C++
+and Lua, LuaBridge uses specializations of this template class concept:
+</p>
+
+<pre>
+template &lt;class T&gt;
+struct Stack
+{
+  static void push (lua_State* L, T t);
+  static T get (lua_State* L, int index);
+};
+</pre>
+
+<p>
+When a specialization of <code>Stack</code> exists for a given type
+<code>T</code> we say that the <code>T</code> is <em>convertible</em>.
+Throughout this document and the LuaBridge API, these types can be used
+anywhere a convertible type is expected.
+</p>
+
+<p>
+The Stack template class specializations are used automatically for variables,
+properties, data members, property members, function arguments and return
+values. These basic types are supported:
+</p>
+
+<ul class="bullets">
+<li><code>bool</code>
+<li><code>char</code>, converted to a string of length one.
+<li><code>char const*</code> and <code>std::string</code> strings.
+<li>Integers, <code>float</code>, and <code>double</code>,
+    converted to <code>Lua_number</code>.
+</ul>
+
+<p>
+User-defined types which are convertible to one of the basic types are
+possible, simply provide a <code>Stack&lt;&gt;</code> specialization in the
+<code>luabridge</code> namespace for your user-defined type, modeled after
+the existing types. For example, here is a specialization for a
+<code>juce::String</code>:
+</p>
+
+<pre>
+template &lt;&gt;
+struct Stack &lt;juce::String&gt;
+{
+  static void push (lua_State* L, juce::String s)
+  {
+    lua_pushstring (L, s.toUTF8 ());
+  }
+
+  static juce::String get (lua_State* L, int index)
+  {
+    return juce::String (luaL_checkstring (L, index));
+  }
+};
+</pre>
+
+</section>
+
+<!--========================================================================-->
+
+<section>
+
+<h2>2.7 - <span id="s2.7">lua_State</span></h2>
+
+<p>
+Sometimes it is convenient from within a bound function or member function
+to gain access to the `lua_State*` normally available to a `lua_CFunction`.
+With LuaBridge, all you need to do is add a `lua_State*` as the last
+parameter of your bound function:
+</p>
+
+<pre>
+void useState (lua_State* L);
+
+getGlobalNamespace (L).addFunction ("useState", &amp;useState);
+</pre>
+
+<p>
+You can still include regular arguments while receiving the state:
+</p>
+
+<pre>
+void useStateAndArgs (int i, std::string s, lua_State* L);
+
+getGlobalNamespace (L).addFunction ("useStateAndArgs", &amp;useStateAndArgs);
+</pre>
+
+<p>
+When the script calls <code>useStateAndArgs</code>, it passes only the integer
+and string parameters. LuaBridge takes care of inserting the <code>lua_State*</code>
+into the argument list for the corresponding C++ function. This will work
+correctly even for the state created by coroutines. Undefined behavior results
+if the <code>lua_State*</code> is not the last parameter.
+</p>
+
+</section>
+
+<!--========================================================================-->
+
+</section>
+
+<section>
+
+<h1>3 - <span id="s3">Passing Objects</span></h1>
+
+<p>
+An object of a registered class <code>T</code> may be passed to Lua as:
+</p>
+
+<table>
+<tr>
+  <td><b><code>T</code></b></td>
+  <td>Passed by value (a copy), with <em>Lua lifetime</em>.</td>
+</tr>
+<tr>
+  <td><b><code>T const</code></b></td>
+  <td>Passed by value (a copy), with <em>Lua lifetime</em>.</td>
+</tr>
+<tr>
+  <td><b><code>T*</code></b></td>
+  <td>Passed by reference, with <em>C++ lifetime</em>.</td>
+</tr>
+<tr>
+  <td><b><code>T&amp;</code></b></td>
+  <td>Passed by reference, with <em>C++ lifetime</em>.</td>
+</tr>
+<tr>
+  <td><b><code>T const*</code></b></td>
+  <td>Passed by const reference, with <em>C++ lifetime</em>.</td>
+</tr>
+<tr>
+  <td><b><code>T const&amp;</code></b></td>
+  <td>Passed by const reference, with <em>C++ lifetime</em>.</td>
+</tr>
+</table>
+
+<!--========================================================================-->
+
+<section>
+
+<h2>3.1 - <span id="s3.1">C++ Lifetime</span></h2>
+
+<p>
+The creation and deletion of objects with <em>C++ lifetime</em> is controlled by
+the C++ code. Lua does nothing when it garbage collects a reference to such an
+object. Specifically, the object's destructor is not called (since C++ owns
+it). Care must be taken to ensure that objects with C++ lifetime are not
+deleted while still being referenced by a <code>lua_State*</code>, or else
+undefined behavior results. In the previous examples, an instance of <code>A</code>
+can be passed to Lua with C++ lifetime, like this:
+</p>
+
+<pre>
+A a;
+
+push (L, &amp;a);             // pointer to 'a', C++ lifetime
+lua_setglobal (L, "a");
+
+push (L, (A const*)&amp;a);   // pointer to 'a const', C++ lifetime
+lua_setglobal (L, "ac");
+
+push &lt;A const*> (L, &amp;a);  // equivalent to push (L, (A const*)&amp;a)
+lua_setglobal (L, "ac2");
+
+push (L, new A);          // compiles, but will leak memory
+lua_setglobal (L, "ap");
+</pre>
+
+</section>
+
+<!--========================================================================-->
+
+<section>
+
+<h2>3.2 - <span id="s3.2">Lua Lifetime</span></h2>
+
+<p>
+When an object of a registered class is passed by value to Lua, it will have
+<em>Lua lifetime</em>. A copy of the passed object is constructed inside the
+userdata. When Lua has no more references to the object, it becomes eligible
+for garbage collection. When the userdata is collected, the destructor for
+the class will be called on the object. Care must be taken to ensure that
+objects with Lua lifetime are not accessed by C++ after they are garbage
+collected, or else undefined behavior results. An instance of <code>B</code>
+can be passed to Lua with Lua lifetime this way:
+</p>
+
+<pre>
+B b;
+
+push (L, b);                    // Copy of b passed, Lua lifetime.
+lua_setglobal (L, "b");
+</pre>
+
+<p>
+Given the previous code segments, these Lua statements are applicable:
+</p>
+
+<pre>
+print (test.A.staticData)       -- Prints the static data member.
+print (test.A.staticProperty)   -- Prints the static property member.
+test.A.staticFunc ()            -- Calls the static method.
+
+print (a.data)                  -- Prints the data member.
+print (a.prop)                  -- Prints the property member.
+a:func1 ()                      -- Calls A::func1 ().
+test.A.func1 (a)                -- Equivalent to a:func1 ().
+test.A.func1 ("hello")          -- Error: "hello" is not a class A.
+a:virtualFunc ()                -- Calls A::virtualFunc ().
+
+print (b.data)                  -- Prints B::dataMember.
+print (b.prop)                  -- Prints inherited property member.
+b:func1 ()                      -- Calls B::func1 ().
+b:func2 ()                      -- Calls B::func2 ().
+test.B.func2 (a)                -- Error: a is not a class B.
+test.A.func1 (b)                -- Calls A::func1 ().
+b:virtualFunc ()                -- Calls B::virtualFunc ().
+test.B.virtualFunc (b)          -- Calls B::virtualFunc ().
+test.A.virtualFunc (b)          -- Calls B::virtualFunc ().
+test.B.virtualFunc (a)          -- Error: a is not a class B.
+
+a = nil; collectgarbage ()      -- 'a' still exists in C++.
+b = nil; collectgarbage ()      -- Lua calls ~B() on the copy of b.
+</pre>
+
+<p>
+When Lua script creates an object of class type using a registered
+constructor, the resulting value will have Lua lifetime. After Lua no longer
+references the object, it becomes eligible for garbage collection. You can
+still pass these to C++, either by reference or by value. If passed by
+reference, the usual warnings apply about accessing the reference later,
+after it has been garbage collected.
+</p>
+
+</section>
+
+<!--========================================================================-->
+
+<section>
+
+<h2>3.3 - <span id="s3.3">Pointers, References, and Pass by Value</span></h2>
+
+<p>
+When C++ objects are passed from Lua back to C++ as arguments to functions,
+or set as data members, LuaBridge does its best to automate the conversion.
+Using the previous definitions, the following functions may be registered
+to Lua:
+</p>
+
+<pre>
+void func0 (A a);
+void func1 (A* a);
+void func2 (A const* a);
+void func3 (A&amp; a);
+void func4 (A const&amp; a);
+</pre>
+
+<p>
+Executing this Lua code will have the prescribed effect:
+</p>
+
+<pre>
+func0 (a)   -- Passes a copy of a, using A's copy constructor.
+func1 (a)   -- Passes a pointer to a.
+func2 (a)   -- Passes a pointer to a const a.
+func3 (a)   -- Passes a reference to a.
+func4 (a)   -- Passes a reference to a const a.
+</pre>
+
+<p>
+In the example above, all functions can read the data members and property
+members of <code>a</code>, or call const member functions of <code>a</code>.
+Only <code>func0</code>, <code>func1</code>, and <code>func3</code> can
+modify the data members and data properties, or call non-const member
+functions of <code>a</code>.
+</p>
+
+<p>
+The usual C++ inheritance and pointer assignment rules apply. Given:
+</p>
+
+<pre>
+void func5 (B b);
+void func6 (B* b);
+</pre>
+
+<p>
+These Lua statements hold:
+</p>
+
+<pre>
+func5 (b)   - Passes a copy of b, using B's copy constructor.
+func6 (b)   - Passes a pointer to b.
+func6 (a)   - Error: Pointer to B expected.
+func1 (b)   - Okay, b is a subclass of a.
+</pre>
+
+<p>
+When a pointer or pointer to const is passed to Lua and the pointer is null
+(zero), LuaBridge will pass Lua a `nil` instead. When Lua passes a
+<code>nil</code> to C++ where a pointer is expected, a null (zero) is passed
+instead. Attempting to pass a null pointer to a C++ function expecting a
+reference results in <code>lua_error</code> being called.
+</p>
+
+</section>
+
+<!--========================================================================-->
+
+<section>
+
+<h2>3.4 - <span id="s3.4">Shared Lifetime</span></h2>
+
+<p>
+LuaBridge supports a <em>shared lifetime</em> model: dynamically allocated
+and reference counted objects whose ownership is shared by both Lua and C++.
+The object remains in existence until there are no remaining C++ or Lua
+references, and Lua performs its usual garbage collection cycle. A container
+is recognized by a specialization of the <code>ContainerTraits</code>
+template class. LuaBridge will automatically recognize when a data type is
+a container when the correspoding specialization is present. Two styles of
+containers come with LuaBridge, including the necessary specializations.
+</p>
+
+<!--========================================================================-->
+
+<section>
+
+<h3>3.4.1 - <span id="s3.4.1">Class RefCountedObjectPtr</span></h3>
+
+<p>
+This is an intrusive style container. Your existing class declaration must be
+changed to be also derived from <code>RefCountedObject</code>. Given
+<code>class T</code>, derived from <code>RefCountedObject</code>, the container
+<code>RefCountedObjectPtr &lt;T&gt;</code>` may be used. In order for
+reference counts to be maintained properly, all C++ code must store a
+container instead of the pointer. This is similar in style to
+<code>std::shared_ptr</code> although there are slight differences. For
+example:
+</p>
+
+<pre>
+// A is reference counted.
+struct A : public RefCountedObject
+{
+  void foo () { }
+};
+
+struct B
+{
+  RefCountedObjectPtr &lt;A&gt; a; // holds a reference to A
+};
+
+void bar (RefCountedObjectPtr &lt;A&gt; a)
+{
+  a->foo ();
+}
+</pre>
+
+</section>
+
+<!--========================================================================-->
+
+<section>
+
+<h3>3.4.2 - <span id="s3.4.2">Class RefCountedPtr</span></h3>
+
+<p>
+This is a non intrusive reference counted pointer. The reference counts are
+kept in a global hash table, which does incur a small performance penalty.
+However, it does not require changing any already existing class declarations.
+This is especially useful when the classes to be registered come from a third
+party library and cannot be modified. To use it, simply wrap all pointers
+to class objects with the container instead:
+</p>
+
+<pre>
+struct A
+{
+  void foo () { }
+};
+
+struct B
+{
+  RefCountedPtr &lt;A&gt; a;
+};
+
+RefCountedPtr &lt;A&gt; createA ()
+{
+  return new A;
+}
+
+void bar (RefCountedPtr &lt;A&gt; a)
+{
+  a->foo ();
+}
+
+void callFoo ()
+{
+  bar (createA ());
+
+  // The created A will be destroyed
+  // when we leave this scope
+}
+</pre>
+
+</section>
+
+<!--========================================================================-->
+
+<section>
+
+<h3>3.4.3 - <span id="s3.4.3">User-defined Containers</span></h3>
+
+<p>
+If you have your own container, you must provide a specialization of
+<code>ContainerTraits</code> in the <code>luabridge</code> namespace for your
+type before it will be recognized by LuaBridge (or else the code will not
+compile):
+</p>
+
+<pre>
+template &lt;class T&gt;
+struct ContainerTraits &lt;CustomContainer &lt;T&gt; &gt;
+{
+  typedef typename T Type;
+
+  static T* get (CustomContainer &lt;T&gt; const&amp; c)
+  {
+    return c.getPointerToObject ();
+  }
+};
+</pre>
+
+<p>
+Standard containers like <code>std::shared_ptr</code> or
+<code>boost::shared_ptr</code> <b>will not work</b>. This is because of type
+erasure; when the object goes from C++ to Lua and back to C++, there is no
+way to associate the object with the original container. The new container is
+constructed from a pointer to the object instead of an existing container.
+The result is undefined behavior since there are now two sets of reference
+counts.
+</p>
+
+</section>
+
+<!--========================================================================-->
+
+<section>
+
+<h3>3.4.4 - <span id="s3.4.4">Container Constructors</span></h3>
+
+<p>
+When a constructor is registered for a class, there is an additional
+optional second template parameter describing the type of container to use.
+If this parameter is specified, calls to the constructor will create the
+object dynamically, via operator new, and place it a container of that
+type. The container must have been previously specialized in
+<code>ContainerTraits</code>, or else a compile error will result. This code
+will register two objects, each using a constructor that creates an object
+with Lua lifetime using the specified container:
+</p>
+
+<pre>
+class C : public RefCountedObject
+{
+  C () { }
+};
+
+class D
+{
+  D () { }
+};
+
+getGlobalNamespace (L)
+  .beginNamespace ("test")
+    .beginClass &lt;C&gt; ("C")
+      .addConstructor &lt;void (*) (void), RefCountedObjectPtr &lt;C&gt; &gt; ()
+    .endClass ()
+    .beginClass &lt;D&gt; ("D")
+      .addConstructor &lt;void (*) (void), RefCountedPtr &lt;D&gt; &gt; ()
+    .endClass ();
+  .endNamespace ()
+</pre>
+
+</section>
+
+<!--========================================================================-->
+
+</section>
+
+<section>
+
+<h2>3.5 - <span id="s3.5">Mixing Lifetimes</span></h2>
+
+<p>
+Mixing object lifetime models is entirely possible, subject to the usual
+caveats of holding references to objects which could get deleted. For
+example, C++ can be called from Lua with a pointer to an object of class
+type; the function can modify the object or call non-const data members.
+These modifications are visible to Lua (since they both refer to the same
+object). An object store in a container can be passed to a function expecting
+a pointer. These conversion work seamlessly.
+<p>
+
+</section>
+
+<!--========================================================================-->
+
+<section>
+
+<h2>3.6 - <span id="s3.6">Convenience Functions</span></h2>
+
+<p>
+The <code>setGlobal</code> function can be used to assign any convertible
+value into a global variable. 
+</p>
+
+</section>
+
+<!--========================================================================-->
+
+</section>
+
+<section>
+
+<h1>4 - <span id="s4">Accessing Lua from C++</span></h1>
+
+<p>
+Because Lua is a <em>dynamically typed language</em>, special consideration
+is required to map values in Lua to C++. The following sections describe the
+classes and functions used for representing Lua types. Only the essential
+operations are explained; To gain understanding of all available functions,
+please refer to the documentation comments in the corresponding source files.
+</p>
+
+<!--========================================================================-->
+
+<section>
+
+<h2>4.1 - <span id="s4.1">Class LuaRef</span></h2>
+
+<p>
+The <code>LuaRef</code> class is a container which references any Lua type.
+It can hold anything which a Lua variable can hold: <strong>nil</strong>,
+number, boolean, string, table, function, thread, userdata, and
+lightuserdata. Because <code>LuaRef</code> uses the <code>Stack</code>
+template specializations to do its work, classes, functions, and data
+exported to Lua through namespace registrations can also be stored (these
+are instances of userdata). In general, a <code>LuaRef</code> can represent
+any <em>convertible</em> C++ type as well as all Lua types.
+</p>
+
+<p>
+A <code>LuaRef</code> variable constructed with no parameters produces a
+reference to <strong>nil</strong>:
+</p>
+
+<pre>
+LuaRef v (L); // References nil
+</pre>
+
+<p>
+To construct a <code>LuaRef</code> to a specific value, the two parameter
+constructor is used:
+</p>
+
+<pre>
+LuaRef v1 (L, 1);                   // A LUA_TNUMBER
+LuaRef v2 (L, 1.1);                 // Also a LUA_TNUMBER
+LuaRef v3 (L, true);                // A LUA_TBOOLEAN
+LuaRef v4 (L, "string");            // A LUA_TSTRING
+</pre>
+
+<p>
+The functions <code>newTable</code> and <code>getGlobal</code> create
+references to new empty table and an existing value in the global table
+respectively:
+</p>
+
+<pre>
+LuaRef v1 = newTable (L);           // Create a new table
+LuaRef v2 = getGlobal (L, "print")  // Reference to _G ["print"]
+</pre>
+
+<p>
+A <code>LuaRef</code> can hold classes <em>registered</em> using LuaBridge:
+</p>
+
+<pre>
+class A;
+//...
+LuaRef v (L, new A); // A LuaBridge userdata holding a pointer to A
+</pre>
+
+<p>
+Any convertible type may be assigned to an already-existing <code>LuaRef</code>:
+</p>
+
+<pre>
+LuaRef v (L);         // Nil
+v = newTable (L);     // An empty table
+v = "string"          // A string. The prevous value becomes
+                      // eligible for garbage collection.
+</pre>
+
+<p>
+A <code>LuaRef</code> is itself a convertible type, and the convertible
+type <code>Nil</code> can be used to represent a Lua <strong>nil</strong>.
+</p>
+
+<pre>
+LuaRef v1 (L, "x");   // assign "x"
+LuaRef v2 (L, "y");   // assign "y"
+v2 = v1;              // v2 becomes "x"
+v1 = "z";             // v1 becomes "z", v2 is unchanged
+v1 = newTable (L);    // An empty table
+v2 = v1;              // v2 references the same table as v1
+v1 = Nil ();          // v1 becomes nil, table is still
+                      // referenced by v2.
+</pre>
+
+<p>
+Values stored in a <code>LuaRef</code> object obey the same rules as
+variables in Lua: tables, functions, threads, and full userdata values are
+<em>objects</em>. The <code>LuaRef</code> does not actually <em>contain</em>
+these values, only <em>references</em> to them. Assignment, parameter
+passing, and function returns always manipulate references to such values;
+these operations do not imply any kind of copy.
+</p>
+
+<!--========================================================================-->
+
+<section>
+
+<h3>4.1.1 - <span id="s4.1.1">Type Conversions</span></h3>
+
+<p>
+A universal C++ conversion operator is provided for implicit conversions
+which allow a <code>LuaRef</code> to be used where any convertible type is
+expected. These operations will all compile:
+</p>
+
+<pre>
+void passInt (int);
+void passBool (bool);
+void passString (std::string);
+void passObject (A*);
+
+LuaRef v (L);
+//...
+passInt (v);        // implicit conversion to int
+passBool (v);       // implicit conversion to bool
+passString (v);     // implicit conversion to string
+passObject (v);     // must hold a registered LuaBridge class or a
+                    // lua_error() will be called.
+</pre>
+
+<p>
+Since Lua types are dynamic, the conversion is performed at run time using
+traditional functions like <code>lua_toboolean</code> or
+<code>lua_tostring</code>. In some cases, the type information may be
+incorrect especially when passing objects of registered class types.
+When performing these conversions, LuaBridge may raise a Lua error by
+directly or indirectly calling <code>lua_error</code> To be bullet-proof,
+such code must either be wrapped in a <code>lua_pcall</code>, or you must
+install a Lua <em>panic function</em> that throws an exception which you
+can catch.
+</p>
+
+<p>
+When an explicit conversion is required (such as when writing templates),
+use the <code>cast</code> template function or an explicit C++ style cast.
+</p>
+
+<pre>
+void passString (std::string);
+
+LuaRef v (L);
+
+// The following are all equivalent:
+
+passString (std::string (v));
+passString ((std::string)v);
+passString (static_cast &lt;std::string&gt; (v));
+passString (v.cast &lt;std::string&gt; ());
+</pre>
+
+</section>
+
+<!--========================================================================-->
+
+<section>
+
+<h3>4.1.2 - <span id="s4.1.2">Visual Studio 2010, 2012</span></h3>
+
+<p>
+There is a defect with all versions of Visual Studio up to and including
+Visual Studio 2012 which prevents the implicit conversion operator from
+being applied when it is used as an operand in a boolean operator:
+</p>
+
+<pre>
+LuaRef v1 (L);
+LuaRef v2 (L);
+
+if (v1 || v2) { } // Compile error in Visual Studio
+
+// Work-arounds:
+if (v1.cast &lt;bool&gt; () || v2.cast &lt;bool&gt; ()) { }
+if (bool (v1) || bool (v2)) { }
+</pre>
+
+</section>
+
+<!--========================================================================-->
+
+</section>
+
+<section>
+
+<h2>4.2 - <span id="s4.2">Table Proxies</span></h2>
+
+<p>
+As tables are the sole data structuring mechanism in Lua, the
+<code>LuaRef</code> class provides robust facilities for accessing and
+manipulating table elements using a simple, precise syntax. Any convertible
+type may be used as a key or value. Applying the array indexing operator
+<code>[]</code> to a <code>LuaRef</code> returns a special temporary object
+called a <em>table proxy</em> which supports all the operations which can
+be performed on a <code>LuaRef</code>. In addition, assignments made to
+table proxies change the underlying table. Because table proxies are
+compiler-created temporary objects, you don't work with them directly. A
+LuaBridge table proxy should not be confused with the Lua proxy table
+technique described in the book "Programming in Lua"; the LuaBridge table
+proxy is simply an intermediate C++ class object that works behind the
+scenes to make table manipulation syntax conform to C++ idioms. These
+operations all invoke table proxies:
+</p>
+
+<pre>
+LuaRef v (L);
+v = newTable (L);
+
+v ["name"] = "John Doe";      // string key, string value
+v [1] = 200;                  // integer key, integer value
+v [2] = newTable (L);         // integer key, LuaRef value
+v [3] = v [1];                // assign 200 to integer index 3
+v [1] = 100;                  // v[1] is 100, v[3] is still 200
+v [3] = v [2];                // v[2] and v[3] reference the same table
+v [2] = Nil ();               // Removes the value with key = 2. The table
+                              //   is still referenced by v[3].
+</pre>
+
+</section>
+
+<!--========================================================================-->
+
+<section>
+
+<h2>4.3 - <span id="s4.3">Calling Lua</span></h2>
+
+<p>
+Table proxies and <code>LuaRef</code> objects provide a convenient syntax
+for invoking <code>lua_pcall</code> on suitable referenced object. This
+includes C functions, Lua functions, or Lua objects with an appropriate
+<code>__call</code> metamethod set. The provided implementation supports
+up to eight parameters (although more can be supported by adding new
+functions). Any convertible C++ type can be passed as a parameter in its
+native format. The return value of the function call is provided as a
+<code>LuaRef</code>, which may be <strong>nil</strong>.
+</p>
+
+<pre class="split">
+LuaRef same = getGlobal (L, "same");
+
+// These all evaluate to true
+same (1,1);
+!same (1,2);
+same ("text", "text");
+!same (1, "text");
+same (1, 1, 2); // third param ignored
+</pre>
+
+<pre class="split">
+function same (arg1, arg)
+  return arg1 == arg2
+end
+</pre>
+
+<p>
+Table proxies support all of the Lua call notation that <code>LuaRef</code>
+supports, making these statements possible:
+</p>
+
+<pre class="split">
+LuaRef v = getGlobal (L, "t");
+
+t[1]();
+t[2]("a", "b");
+t[2](t[1]); // Call t[3] with the value in t[2]
+t[4]=t[3]();   // Call t[3] and store the result in t[4].
+
+t [t[5]()] = "wow"; // Store "wow" at the key returned by
+                    //   the call to t[5]
+</pre>
+
+<pre class="split">
+t = {}
+t[1] = function () print ("hello") end
+t[2] = function (u, v) print (u, v) end
+t[3] = "foo"
+</pre>
+
+<!--========================================================================-->
+
+<h3>4.3.1 - <span id="s4.3.1">Class LuaException</span></h3>
+
+<section >
+
+<p>
+When <code>LuaRef</code> is used to call into Lua using the <code>()</code>
+operator it issues a protected call using <code>lua_pcall</code>. LuaBridge
+uses the C++ exception handling mechanism, throwing a <code>LuaException</code>
+object:
+</p>
+
+<pre class="split">
+LuaRef f (L) = getGlobal (L, "fail");
+
+try {
+  f ();
+}
+catch (LuaException const&amp; e) {
+  std::cerr &amp;&amp; e.what ();
+}
+</pre>
+
+<pre class="split">
+function fail ()
+  error ("A problem occurred")
+end
+</pre>
+
+</section>
+
+<!--========================================================================-->
+
+</section>
+
+<!--========================================================================-->
+
+</section>
+
+<section>
+
+<h1>5 - <span id="s5">Security</span></h1>
+
+<p>
+The metatables and userdata that LuaBridge creates in the `lua_State*` are
+protected using a security system, to eliminate the possibility of undefined
+behavior resulting from scripted manipulation of the environment. The
+security system has these components:
+</p>
+
+<ul class="bullets">
+<li>
+Class and const class tables use the <em>table proxy</em> technique. The
+corresponding metatables have <code>__index</code> and <code>__newindex</code>
+metamethods, so these class tables are immutable from Lua.
+<li>
+Metatables have <code>__metatable</code> set to a boolean value. Scripts
+cannot obtain the metatable from a LuaBridge object.
+<li>
+Classes are mapped to metatables through the registry, which Lua scripts
+cannot access. The global environment does not expose metatables
+<li>
+Metatables created by LuaBridge are tagged with a lightuserdata key which
+is unique in the process. Other libraries cannot forge a LuaBridge
+metatable.
+</ul>
+
+<p>
+This security system can be easily bypassed if scripts are given access to
+the debug library (or functionality similar to it, i.e. a raw `getmetatable`).
+The security system can also be defeated by C code in the host, either by
+revealing the unique lightuserdata key to another module or by putting a
+LuaBridge metatable in a place that can be accessed by scripts.
+</p>
+
+<p>
+When a class member function is called, or class property member accessed,
+the `this` pointer is type-checked. This is because member functions exposed
+to Lua are just plain functions that usually get called with the Lua colon
+notation, which passes the object in question as the first parameter. Lua's
+dynamic typing makes this type-checking mandatory to prevent undefined
+behavior resulting from improper use.
+</p>
+
+<p>
+If a type check error occurs, LuaBridge uses the <code>lua_error</code>
+mechanism to trigger a failure. A host program can always recover from
+an error through the use of <code>lua_pcall</code>; proper usage of
+LuaBridge will never result in undefined behavior.
+</p>
+
+</section>
+
+<!--========================================================================-->
+
+</body>
+</html>
+
diff --git a/extern/LuaBridge/RefCountedObject.h b/extern/LuaBridge/RefCountedObject.h
new file mode 100644
index 000000000..807b4606c
--- /dev/null
+++ b/extern/LuaBridge/RefCountedObject.h
@@ -0,0 +1,363 @@
+//==============================================================================
+/*
+  https://github.com/vinniefalco/LuaBridge
+
+  Copyright 2012, Vinnie Falco <vinnie.falco@gmail.com>
+  Copyright 2004-11 by Raw Material Software Ltd.
+
+  This is a derivative work used by permission from part of
+  JUCE, available at http://www.rawaterialsoftware.com
+
+  License: The MIT License (http://www.opensource.org/licenses/mit-license.php)
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+
+  This file incorporates work covered by the following copyright and
+  permission notice:  
+
+    This file is part of the JUCE library - "Jules' Utility Class Extensions"
+    Copyright 2004-11 by Raw Material Software Ltd.
+*/
+//==============================================================================
+
+#ifndef LUABRIDGE_REFCOUNTEDOBJECT_HEADER
+#define LUABRIDGE_REFCOUNTEDOBJECT_HEADER
+
+//#define LUABRIDGE_COMPILER_SUPPORTS_MOVE_SEMANTICS 1
+
+#include <cassert>
+
+//==============================================================================
+/**
+  Adds reference-counting to an object.
+
+  To add reference-counting to a class, derive it from this class, and
+  use the RefCountedObjectPtr class to point to it.
+
+  e.g. @code
+  class MyClass : public RefCountedObjectType
+  {
+      void foo();
+
+      // This is a neat way of declaring a typedef for a pointer class,
+      // rather than typing out the full templated name each time..
+      typedef RefCountedObjectPtr<MyClass> Ptr;
+  };
+
+  MyClass::Ptr p = new MyClass();
+  MyClass::Ptr p2 = p;
+  p = 0;
+  p2->foo();
+  @endcode
+
+  Once a new RefCountedObjectType has been assigned to a pointer, be
+  careful not to delete the object manually.
+*/
+template <class CounterType>
+class RefCountedObjectType
+{
+public:
+  //==============================================================================
+  /** Increments the object's reference count.
+
+      This is done automatically by the smart pointer, but is public just
+      in case it's needed for nefarious purposes.
+  */
+  inline void incReferenceCount() const
+  {
+    ++refCount;
+  }
+
+  /** Decreases the object's reference count.
+
+      If the count gets to zero, the object will be deleted.
+  */
+  inline void decReferenceCount() const
+  {
+    assert (getReferenceCount() > 0);
+
+    if (--refCount == 0)
+      delete this;
+  }
+
+  /** Returns the object's current reference count. */
+  inline int getReferenceCount() const
+  {
+    return static_cast <int> (refCount);
+  }
+
+protected:
+  //==============================================================================
+  /** Creates the reference-counted object (with an initial ref count of zero). */
+  RefCountedObjectType() : refCount ()
+  {
+  }
+
+  /** Destructor. */
+  virtual ~RefCountedObjectType()
+  {
+    // it's dangerous to delete an object that's still referenced by something else!
+    assert (getReferenceCount() == 0);
+  }
+
+private:
+  //==============================================================================
+  CounterType mutable refCount;
+};
+
+//==============================================================================
+
+/** Non thread-safe reference counted object.
+
+    This creates a RefCountedObjectType that uses a non-atomic integer
+    as the counter.
+*/
+typedef RefCountedObjectType <int> RefCountedObject;
+
+//==============================================================================
+/**
+    A smart-pointer class which points to a reference-counted object.
+
+    The template parameter specifies the class of the object you want to point
+    to - the easiest way to make a class reference-countable is to simply make
+    it inherit from RefCountedObjectType, but if you need to, you could roll
+    your own reference-countable class by implementing a pair of methods called
+    incReferenceCount() and decReferenceCount().
+
+    When using this class, you'll probably want to create a typedef to
+    abbreviate the full templated name - e.g.
+
+    @code
+    
+    typedef RefCountedObjectPtr <MyClass> MyClassPtr;
+    
+    @endcode
+*/
+template <class ReferenceCountedObjectClass>
+class RefCountedObjectPtr
+{
+public:
+  /** The class being referenced by this pointer. */
+  typedef ReferenceCountedObjectClass ReferencedType;
+
+  //==============================================================================
+  /** Creates a pointer to a null object. */
+  inline RefCountedObjectPtr() : referencedObject (0)
+  {
+  }
+
+  /** Creates a pointer to an object.
+
+      This will increment the object's reference-count if it is non-null.
+  */
+  inline RefCountedObjectPtr (ReferenceCountedObjectClass* const refCountedObject)
+      : referencedObject (refCountedObject)
+  {
+    if (refCountedObject != 0)
+        refCountedObject->incReferenceCount();
+  }
+
+  /** Copies another pointer.
+      This will increment the object's reference-count (if it is non-null).
+  */
+  inline RefCountedObjectPtr (const RefCountedObjectPtr& other)
+      : referencedObject (other.referencedObject)
+  {
+    if (referencedObject != 0)
+        referencedObject->incReferenceCount();
+  }
+
+#if LUABRIDGE_COMPILER_SUPPORTS_MOVE_SEMANTICS
+  /** Takes-over the object from another pointer. */
+  inline RefCountedObjectPtr (RefCountedObjectPtr&& other)
+      : referencedObject (other.referencedObject)
+  {
+    other.referencedObject = 0;
+  }
+#endif
+
+  /** Copies another pointer.
+      This will increment the object's reference-count (if it is non-null).
+  */
+  template <class DerivedClass>
+  inline RefCountedObjectPtr (const RefCountedObjectPtr<DerivedClass>& other)
+      : referencedObject (static_cast <ReferenceCountedObjectClass*> (other.getObject()))
+  {
+    if (referencedObject != 0)
+      referencedObject->incReferenceCount();
+  }
+
+  /** Changes this pointer to point at a different object.
+
+      The reference count of the old object is decremented, and it might be
+      deleted if it hits zero. The new object's count is incremented.
+  */
+  RefCountedObjectPtr& operator= (const RefCountedObjectPtr& other)
+  {
+    return operator= (other.referencedObject);
+  }
+
+  /** Changes this pointer to point at a different object.
+
+      The reference count of the old object is decremented, and it might be
+      deleted if it hits zero. The new object's count is incremented.
+  */
+  template <class DerivedClass>
+  RefCountedObjectPtr& operator= (const RefCountedObjectPtr<DerivedClass>& other)
+  {
+    return operator= (static_cast <ReferenceCountedObjectClass*> (other.getObject()));
+  }
+
+#if LUABRIDGE_COMPILER_SUPPORTS_MOVE_SEMANTICS
+  /** Takes-over the object from another pointer. */
+  RefCountedObjectPtr& operator= (RefCountedObjectPtr&& other)
+  {
+    std::swap (referencedObject, other.referencedObject);
+    return *this;
+  }
+#endif
+
+  /** Changes this pointer to point at a different object.
+
+      The reference count of the old object is decremented, and it might be
+      deleted if it hits zero. The new object's count is incremented.
+  */
+  RefCountedObjectPtr& operator= (ReferenceCountedObjectClass* const newObject)
+  {
+    if (referencedObject != newObject)
+    {
+      if (newObject != 0)
+        newObject->incReferenceCount();
+
+      ReferenceCountedObjectClass* const oldObject = referencedObject;
+      referencedObject = newObject;
+
+      if (oldObject != 0)
+        oldObject->decReferenceCount();
+    }
+
+    return *this;
+  }
+
+  /** Destructor.
+
+      This will decrement the object's reference-count, and may delete it if it
+      gets to zero.
+  */
+  inline ~RefCountedObjectPtr()
+  {
+    if (referencedObject != 0)
+      referencedObject->decReferenceCount();
+  }
+
+  /** Returns the object that this pointer references.
+      The pointer returned may be zero, of course.
+  */
+  inline operator ReferenceCountedObjectClass*() const
+  {
+    return referencedObject;
+  }
+
+  // the -> operator is called on the referenced object
+  inline ReferenceCountedObjectClass* operator->() const
+  {
+    return referencedObject;
+  }
+
+  /** Returns the object that this pointer references.
+      The pointer returned may be zero, of course.
+  */
+  inline ReferenceCountedObjectClass* getObject() const
+  {
+    return referencedObject;
+  }
+
+private:
+  //==============================================================================
+  ReferenceCountedObjectClass* referencedObject;
+};
+
+/** Compares two ReferenceCountedObjectPointers. */
+template <class ReferenceCountedObjectClass>
+bool operator== (const RefCountedObjectPtr<ReferenceCountedObjectClass>& object1, ReferenceCountedObjectClass* const object2)
+{
+    return object1.getObject() == object2;
+}
+
+/** Compares two ReferenceCountedObjectPointers. */
+template <class ReferenceCountedObjectClass>
+bool operator== (const RefCountedObjectPtr<ReferenceCountedObjectClass>& object1, const RefCountedObjectPtr<ReferenceCountedObjectClass>& object2)
+{
+    return object1.getObject() == object2.getObject();
+}
+
+/** Compares two ReferenceCountedObjectPointers. */
+template <class ReferenceCountedObjectClass>
+bool operator== (ReferenceCountedObjectClass* object1, RefCountedObjectPtr<ReferenceCountedObjectClass>& object2)
+{
+    return object1 == object2.getObject();
+}
+
+/** Compares two ReferenceCountedObjectPointers. */
+template <class ReferenceCountedObjectClass>
+bool operator!= (const RefCountedObjectPtr<ReferenceCountedObjectClass>& object1, const ReferenceCountedObjectClass* object2)
+{
+    return object1.getObject() != object2;
+}
+
+/** Compares two ReferenceCountedObjectPointers. */
+template <class ReferenceCountedObjectClass>
+bool operator!= (const RefCountedObjectPtr<ReferenceCountedObjectClass>& object1, RefCountedObjectPtr<ReferenceCountedObjectClass>& object2)
+{
+    return object1.getObject() != object2.getObject();
+}
+
+/** Compares two ReferenceCountedObjectPointers. */
+template <class ReferenceCountedObjectClass>
+bool operator!= (ReferenceCountedObjectClass* object1, RefCountedObjectPtr<ReferenceCountedObjectClass>& object2)
+{
+    return object1 != object2.getObject();
+}
+
+//==============================================================================
+
+namespace luabridge
+{
+
+// forward declaration
+template <class T>
+struct ContainerTraits;
+
+template <class T>
+struct ContainerTraits <RefCountedObjectPtr <T> >
+{
+  typedef T Type;
+
+  static T* get (RefCountedObjectPtr <T> const& c)
+  {
+    return c.getObject ();
+  }
+};
+
+}
+
+//==============================================================================
+
+#endif
+
diff --git a/extern/LuaBridge/RefCountedPtr.h b/extern/LuaBridge/RefCountedPtr.h
new file mode 100644
index 000000000..7c27ca4dc
--- /dev/null
+++ b/extern/LuaBridge/RefCountedPtr.h
@@ -0,0 +1,251 @@
+//==============================================================================
+/*
+  https://github.com/vinniefalco/LuaBridge
+  
+  Copyright 2012, Vinnie Falco <vinnie.falco@gmail.com>
+  Copyright 2007, Nathan Reed
+
+  License: The MIT License (http://www.opensource.org/licenses/mit-license.php)
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+//==============================================================================
+
+#ifndef LUABRIDGE_REFCOUNTEDPTR_HEADER
+#define LUABRIDGE_REFCOUNTEDPTR_HEADER
+
+#ifdef _MSC_VER
+# include <hash_map>
+#else
+# include <stdint.h>
+# include <ext/hash_map>
+#endif
+
+//==============================================================================
+/**
+  Support for our RefCountedPtr.
+*/
+struct RefCountedPtrBase
+{
+  // Declaration of container for the refcounts
+#ifdef _MSC_VER
+  typedef stdext::hash_map <const void *, int> RefCountsType;
+#else
+  struct ptr_hash
+  {
+    size_t operator () (const void * const v) const
+    {
+      static __gnu_cxx::hash<unsigned int> H;
+      return H(uintptr_t(v));
+    }
+  };
+  typedef __gnu_cxx::hash_map<const void *, int, ptr_hash> RefCountsType;
+#endif
+
+protected:
+  inline RefCountsType& getRefCounts ()
+  {
+    static RefCountsType refcounts;
+    return refcounts ;
+  }
+};
+
+//==============================================================================
+/**
+  A reference counted smart pointer.
+
+  The api is compatible with boost::RefCountedPtr and std::RefCountedPtr, in the
+  sense that it implements a strict subset of the functionality.
+
+  This implementation uses a hash table to look up the reference count
+  associated with a particular pointer.
+
+  @tparam T The class type.
+
+  @todo Decompose RefCountedPtr using a policy. At a minimum, the underlying
+        reference count should be policy based (to support atomic operations)
+        and the delete behavior should be policy based (to support custom
+        disposal methods).
+
+  @todo Provide an intrusive version of RefCountedPtr.
+*/
+template <class T>
+class RefCountedPtr : private RefCountedPtrBase
+{
+public:
+  template <typename Other>
+  struct rebind
+  {
+    typedef RefCountedPtr <Other> other;
+  };
+
+  /** Construct as nullptr or from existing pointer to T.
+
+      @param p The optional, existing pointer to assign from.
+  */
+  RefCountedPtr (T* p = 0) : m_p (p)
+  {
+    ++getRefCounts () [m_p];
+  }
+
+  /** Construct from another RefCountedPtr.
+
+      @param rhs The RefCountedPtr to assign from.
+  */
+  RefCountedPtr (RefCountedPtr <T> const& rhs) : m_p (rhs.get())
+  {
+    ++getRefCounts () [m_p];
+  }
+
+  /** Construct from a RefCountedPtr of a different type.
+
+      @invariant A pointer to U must be convertible to a pointer to T.
+
+      @param  rhs The RefCountedPtr to assign from.
+      @tparam U   The other object type.
+  */
+  template <typename U>
+  RefCountedPtr (RefCountedPtr <U> const& rhs) : m_p (static_cast <T*> (rhs.get()))
+  {
+    ++getRefCounts () [m_p];
+  }
+
+  /** Release the object.
+
+      If there are no more references then the object is deleted.
+  */
+  ~RefCountedPtr ()
+  {
+    reset();
+  }
+
+  /** Assign from another RefCountedPtr.
+
+      @param  rhs The RefCountedPtr to assign from.
+      @return     A reference to the RefCountedPtr.
+  */
+  RefCountedPtr <T>& operator= (RefCountedPtr <T> const& rhs)
+  {
+    if (m_p != rhs.m_p)
+    {
+      reset ();
+      m_p = rhs.m_p;
+      ++getRefCounts () [m_p];
+    }
+    return *this;
+  }
+
+  /** Assign from another RefCountedPtr of a different type.
+
+      @note A pointer to U must be convertible to a pointer to T.
+
+      @tparam U   The other object type.
+      @param  rhs The other RefCountedPtr to assign from.
+      @return     A reference to the RefCountedPtr.
+  */
+  template <typename U>
+  RefCountedPtr <T>& operator= (RefCountedPtr <U> const& rhs)
+  {
+    reset ();
+    m_p = static_cast <T*> (rhs.get());
+    ++getRefCounts () [m_p];
+    return *this;
+  }
+
+  /** Retrieve the raw pointer.
+
+      @return A pointer to the object.
+  */
+  T* get () const
+  {
+    return m_p;
+  }
+
+  /** Retrieve the raw pointer.
+
+      @return A pointer to the object.
+  */
+  T* operator* () const
+  {
+    return m_p;
+  }
+
+  /** Retrieve the raw pointer.
+
+      @return A pointer to the object.
+  */
+  T* operator-> () const
+  {
+    return m_p;
+  }
+
+  /** Determine the number of references.
+
+      @note This is not thread-safe.
+
+      @return The number of active references.
+  */
+  long use_count () const
+  {
+    return getRefCounts () [m_p];
+  }
+
+  /** Release the pointer.
+
+      The reference count is decremented. If the reference count reaches
+      zero, the object is deleted.
+  */
+  void reset ()
+  {
+    if (m_p != 0)
+    {
+      if (--getRefCounts () [m_p] <= 0)
+        delete m_p;
+
+      m_p = 0;
+    }
+  }
+
+private:
+  T* m_p;
+};
+
+//==============================================================================
+
+namespace luabridge
+{
+
+// forward declaration
+template <class T>
+struct ContainerTraits;
+
+template <class T>
+struct ContainerTraits <RefCountedPtr <T> >
+{
+  typedef T Type;
+
+  static T* get (RefCountedPtr <T> const& c)
+  {
+    return c.get ();
+  }
+};
+
+}
+
+#endif
diff --git a/extern/LuaBridge/detail/CFunctions.h b/extern/LuaBridge/detail/CFunctions.h
new file mode 100644
index 000000000..0497b6bb4
--- /dev/null
+++ b/extern/LuaBridge/detail/CFunctions.h
@@ -0,0 +1,442 @@
+//------------------------------------------------------------------------------
+/*
+  https://github.com/vinniefalco/LuaBridge
+  
+  Copyright 2012, Vinnie Falco <vinnie.falco@gmail.com>
+
+  License: The MIT License (http://www.opensource.org/licenses/mit-license.php)
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+//==============================================================================
+
+// We use a structure so we can define everything in the header.
+//
+struct CFunc
+{
+  //----------------------------------------------------------------------------
+  /**
+      __index metamethod for a namespace or class static members.
+
+      This handles:
+        Retrieving functions and class static methods, stored in the metatable.
+        Reading global and class static data, stored in the __propget table.
+        Reading global and class properties, stored in the __propget table.
+  */
+  static int indexMetaMethod (lua_State* L)
+  {
+    int result = 0;
+    lua_getmetatable (L, 1);                // push metatable of arg1
+    for (;;)
+    {
+      lua_pushvalue (L, 2);                 // push key arg2
+      lua_rawget (L, -2);                   // lookup key in metatable
+      if (lua_isnil (L, -1))                // not found
+      {
+        lua_pop (L, 1);                     // discard nil
+        rawgetfield (L, -1, "__propget");   // lookup __propget in metatable
+        lua_pushvalue (L, 2);               // push key arg2
+        lua_rawget (L, -2);                 // lookup key in __propget
+        lua_remove (L, -2);                 // discard __propget
+        if (lua_iscfunction (L, -1))
+        {
+          lua_remove (L, -2);               // discard metatable
+          lua_pushvalue (L, 1);             // push arg1
+          lua_call (L, 1, 1);               // call cfunction
+          result = 1;
+          break;
+        }
+        else
+        {
+          assert (lua_isnil (L, -1));
+          lua_pop (L, 1);                   // discard nil and fall through
+        }
+      }
+      else
+      {
+        assert (lua_istable (L, -1) || lua_iscfunction (L, -1));
+        lua_remove (L, -2);
+        result = 1;
+        break;
+      }
+
+      rawgetfield (L, -1, "__parent");
+      if (lua_istable (L, -1))
+      {
+        // Remove metatable and repeat the search in __parent.
+        lua_remove (L, -2);
+      }
+      else
+      {
+        // Discard metatable and return nil.
+        assert (lua_isnil (L, -1));
+        lua_remove (L, -2);
+        result = 1;
+        break;
+      }
+    }
+
+    return result;
+  }
+
+  //----------------------------------------------------------------------------
+  /**
+      __newindex metamethod for a namespace or class static members.
+
+      The __propset table stores proxy functions for assignment to:
+        Global and class static data.
+        Global and class properties.
+  */
+  static int newindexMetaMethod (lua_State* L)
+  {
+    int result = 0;
+    lua_getmetatable (L, 1);                // push metatable of arg1
+    for (;;)
+    {
+      rawgetfield (L, -1, "__propset");     // lookup __propset in metatable
+      assert (lua_istable (L, -1));
+      lua_pushvalue (L, 2);                 // push key arg2
+      lua_rawget (L, -2);                   // lookup key in __propset
+      lua_remove (L, -2);                   // discard __propset
+      if (lua_iscfunction (L, -1))          // ensure value is a cfunction
+      {
+        lua_remove (L, -2);                 // discard metatable
+        lua_pushvalue (L, 3);               // push new value arg3
+        lua_call (L, 1, 0);                 // call cfunction
+        result = 0;
+        break;
+      }
+      else
+      {
+        assert (lua_isnil (L, -1));
+        lua_pop (L, 1);
+      }
+
+      rawgetfield (L, -1, "__parent");
+      if (lua_istable (L, -1))
+      {
+        // Remove metatable and repeat the search in __parent.
+        lua_remove (L, -2);
+      }
+      else
+      {
+        assert (lua_isnil (L, -1));
+        lua_pop (L, 2);
+        result = luaL_error (L,"no writable variable '%s'", lua_tostring (L, 2));
+      }
+    }
+
+    return result;
+  }
+
+  //----------------------------------------------------------------------------
+  /**
+      lua_CFunction to report an error writing to a read-only value.
+
+      The name of the variable is in the first upvalue.
+  */
+  static int readOnlyError (lua_State* L)
+  {
+    std::string s;
+    
+    s = s + "'" + lua_tostring (L, lua_upvalueindex (1)) + "' is read-only";
+
+    return luaL_error (L, s.c_str ());
+  }
+  
+  //----------------------------------------------------------------------------
+  /**
+      lua_CFunction to get a variable.
+
+      This is used for global variables or class static data members.
+
+      The pointer to the data is in the first upvalue.
+  */
+  template <class T>
+  static int getVariable (lua_State* L)
+  {
+    assert (lua_islightuserdata (L, lua_upvalueindex (1)));
+    T const* ptr = static_cast <T const*> (lua_touserdata (L, lua_upvalueindex (1)));
+    assert (ptr != 0);
+    Stack <T>::push (L, *ptr);
+    return 1;
+  }
+
+  //----------------------------------------------------------------------------
+  /**
+      lua_CFunction to set a variable.
+
+      This is used for global variables or class static data members.
+
+      The pointer to the data is in the first upvalue.
+  */
+  template <class T>
+  static int setVariable (lua_State* L)
+  {
+    assert (lua_islightuserdata (L, lua_upvalueindex (1)));
+    T* ptr = static_cast <T*> (lua_touserdata (L, lua_upvalueindex (1)));
+    assert (ptr != 0);
+    *ptr = Stack <T>::get (L, 1);
+    return 0;
+  }
+
+  //----------------------------------------------------------------------------
+  /**
+      lua_CFunction to call a function with a return value.
+
+      This is used for global functions, global properties, class static methods,
+      and class static properties.
+
+      The function pointer is in the first upvalue.
+  */
+  template <class FnPtr,
+            class ReturnType = typename FuncTraits <FnPtr>::ReturnType>
+  struct Call
+  {
+    typedef typename FuncTraits <FnPtr>::Params Params;
+    static int f (lua_State* L)
+    {
+      assert (isfulluserdata (L, lua_upvalueindex (1)));
+      FnPtr const& fnptr = *static_cast <FnPtr const*> (lua_touserdata (L, lua_upvalueindex (1)));
+      assert (fnptr != 0);
+      ArgList <Params> args (L);
+      Stack <typename FuncTraits <FnPtr>::ReturnType>::push (L, FuncTraits <FnPtr>::call (fnptr, args));
+      return 1;
+    }
+  };
+
+  //----------------------------------------------------------------------------
+  /**
+      lua_CFunction to call a function with no return value.
+
+      This is used for global functions, global properties, class static methods,
+      and class static properties.
+
+      The function pointer is in the first upvalue.
+  */
+  template <class FnPtr>
+  struct Call <FnPtr, void>
+  {
+    typedef typename FuncTraits <FnPtr>::Params Params;
+    static int f (lua_State* L)
+    {
+      assert (isfulluserdata (L, lua_upvalueindex (1)));
+      FnPtr const& fnptr = *static_cast <FnPtr const*> (lua_touserdata (L, lua_upvalueindex (1)));
+      assert (fnptr != 0);
+      ArgList <Params> args (L);
+      FuncTraits <FnPtr>::call (fnptr, args);
+      return 0;
+    }
+  };
+
+  //----------------------------------------------------------------------------
+  /**
+      lua_CFunction to call a class member function with a return value.
+
+      The member function pointer is in the first upvalue.
+      The class userdata object is at the top of the Lua stack.
+  */
+  template <class MemFnPtr,
+            class ReturnType = typename FuncTraits <MemFnPtr>::ReturnType>
+  struct CallMember
+  {
+    typedef typename FuncTraits <MemFnPtr>::ClassType T;
+    typedef typename FuncTraits <MemFnPtr>::Params Params;
+
+    static int f (lua_State* L)
+    {
+      assert (isfulluserdata (L, lua_upvalueindex (1)));
+      T* const t = Userdata::get <T> (L, 1, false);
+      MemFnPtr const& fnptr = *static_cast <MemFnPtr const*> (lua_touserdata (L, lua_upvalueindex (1)));
+      assert (fnptr != 0);
+      ArgList <Params, 2> args (L);
+      Stack <ReturnType>::push (L, FuncTraits <MemFnPtr>::call (t, fnptr, args));
+      return 1;
+    }
+  };
+
+  template <class MemFnPtr,
+            class ReturnType = typename FuncTraits <MemFnPtr>::ReturnType>
+  struct CallConstMember
+  {
+    typedef typename FuncTraits <MemFnPtr>::ClassType T;
+    typedef typename FuncTraits <MemFnPtr>::Params Params;
+
+    static int f (lua_State* L)
+    {
+      assert (isfulluserdata (L, lua_upvalueindex (1)));
+      T const* const t = Userdata::get <T> (L, 1, true);
+      MemFnPtr const& fnptr = *static_cast <MemFnPtr const*> (lua_touserdata (L, lua_upvalueindex (1)));
+      assert (fnptr != 0);
+      ArgList <Params, 2> args(L);
+      Stack <ReturnType>::push (L, FuncTraits <MemFnPtr>::call (t, fnptr, args));
+      return 1;
+    }
+  };
+
+  //----------------------------------------------------------------------------
+  /**
+      lua_CFunction to call a class member function with no return value.
+
+      The member function pointer is in the first upvalue.
+      The class userdata object is at the top of the Lua stack.
+  */
+  template <class MemFnPtr>
+  struct CallMember <MemFnPtr, void>
+  {
+    typedef typename FuncTraits <MemFnPtr>::ClassType T;
+    typedef typename FuncTraits <MemFnPtr>::Params Params;
+
+    static int f (lua_State* L)
+    {
+      assert (isfulluserdata (L, lua_upvalueindex (1)));
+      T* const t = Userdata::get <T> (L, 1, false);
+      MemFnPtr const& fnptr = *static_cast <MemFnPtr const*> (lua_touserdata (L, lua_upvalueindex (1)));
+      assert (fnptr != 0);
+      ArgList <Params, 2> args (L);
+      FuncTraits <MemFnPtr>::call (t, fnptr, args);
+      return 0;
+    }
+  };
+
+  template <class MemFnPtr>
+  struct CallConstMember <MemFnPtr, void>
+  {
+    typedef typename FuncTraits <MemFnPtr>::ClassType T;
+    typedef typename FuncTraits <MemFnPtr>::Params Params;
+
+    static int f (lua_State* L)
+    {
+      assert (isfulluserdata (L, lua_upvalueindex (1)));
+      T const* const t = Userdata::get <T> (L, 1, true);
+      MemFnPtr const& fnptr = *static_cast <MemFnPtr const*> (lua_touserdata (L, lua_upvalueindex (1)));
+      assert (fnptr != 0);
+      ArgList <Params, 2> args (L);
+      FuncTraits <MemFnPtr>::call (t, fnptr, args);
+      return 0;
+    }
+  };
+
+  //--------------------------------------------------------------------------
+  /**
+      lua_CFunction to call a class member lua_CFunction.
+
+      The member function pointer is in the first upvalue.
+      The class userdata object is at the top of the Lua stack.
+  */
+  template <class T>
+  struct CallMemberCFunction
+  {
+    static int f (lua_State* L)
+    {
+      assert (isfulluserdata (L, lua_upvalueindex (1)));
+      typedef int (T::*MFP)(lua_State* L);
+      T* const t = Userdata::get <T> (L, 1, false);
+      MFP const& fnptr = *static_cast <MFP const*> (lua_touserdata (L, lua_upvalueindex (1)));
+      assert (fnptr != 0);
+      return (t->*fnptr) (L);
+    }
+  };
+
+  template <class T>
+  struct CallConstMemberCFunction
+  {
+    static int f (lua_State* L)
+    {
+      assert (isfulluserdata (L, lua_upvalueindex (1)));
+      typedef int (T::*MFP)(lua_State* L);
+      T const* const t = Userdata::get <T> (L, 1, true);
+      MFP const& fnptr = *static_cast <MFP const*> (lua_touserdata (L, lua_upvalueindex (1)));
+      assert (fnptr != 0);
+      return (t->*fnptr) (L);
+    }
+  };
+
+  //--------------------------------------------------------------------------
+
+  // SFINAE Helpers
+
+  template <class MemFnPtr, bool isConst>
+  struct CallMemberFunctionHelper
+  {
+    static void add (lua_State* L, char const* name, MemFnPtr mf)
+    {
+      new (lua_newuserdata (L, sizeof (MemFnPtr))) MemFnPtr (mf);
+      lua_pushcclosure (L, &CallConstMember <MemFnPtr>::f, 1);
+      lua_pushvalue (L, -1);
+      rawsetfield (L, -5, name); // const table
+      rawsetfield (L, -3, name); // class table
+    }
+  };
+
+  template <class MemFnPtr>
+  struct CallMemberFunctionHelper <MemFnPtr, false>
+  {
+    static void add (lua_State* L, char const* name, MemFnPtr mf)
+    {
+      new (lua_newuserdata (L, sizeof (MemFnPtr))) MemFnPtr (mf);
+      lua_pushcclosure (L, &CallMember <MemFnPtr>::f, 1);
+      rawsetfield (L, -3, name); // class table
+    }
+  };
+
+  //--------------------------------------------------------------------------
+  /**
+      __gc metamethod for a class.
+  */
+  template <class C>
+  static int gcMetaMethod (lua_State* L)
+  {
+    Userdata* const ud = Userdata::getExact <C> (L, 1);
+    ud->~Userdata ();
+    return 0;
+  }
+
+  //--------------------------------------------------------------------------
+  /**
+      lua_CFunction to get a class data member.
+
+      The pointer-to-member is in the first upvalue.
+      The class userdata object is at the top of the Lua stack.
+  */
+  template <class C, typename T>
+  static int getProperty (lua_State* L)
+  {
+    C const* const c = Userdata::get <C> (L, 1, true);
+    T C::** mp = static_cast <T C::**> (lua_touserdata (L, lua_upvalueindex (1)));
+    Stack <T>::push (L, c->**mp);
+    return 1;
+  }
+
+  //--------------------------------------------------------------------------
+  /**
+      lua_CFunction to set a class data member.
+
+      The pointer-to-member is in the first upvalue.
+      The class userdata object is at the top of the Lua stack.
+  */
+  template <class C, typename T>
+  static int setProperty (lua_State* L)
+  {
+    C* const c = Userdata::get <C> (L, 1, false);
+    T C::** mp = static_cast <T C::**> (lua_touserdata (L, lua_upvalueindex (1)));
+    c->**mp = Stack <T>::get (L, 2);
+    return 0;
+  }
+};
diff --git a/extern/LuaBridge/detail/ClassInfo.h b/extern/LuaBridge/detail/ClassInfo.h
new file mode 100644
index 000000000..8d5806947
--- /dev/null
+++ b/extern/LuaBridge/detail/ClassInfo.h
@@ -0,0 +1,73 @@
+//------------------------------------------------------------------------------
+/*
+  https://github.com/vinniefalco/LuaBridge
+  
+  Copyright 2012, Vinnie Falco <vinnie.falco@gmail.com>
+
+  License: The MIT License (http://www.opensource.org/licenses/mit-license.php)
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+//==============================================================================
+
+/** Unique Lua registry keys for a class.
+
+    Each registered class inserts three keys into the registry, whose
+    values are the corresponding static, class, and const metatables. This
+    allows a quick and reliable lookup for a metatable from a template type.
+*/
+template <class T>
+class ClassInfo
+{
+public:
+  /** Get the key for the static table.
+
+      The static table holds the static data members, static properties, and
+      static member functions for a class.
+  */
+  static void const* getStaticKey ()
+  {
+    static char value;
+    return &value;
+  }
+
+  /** Get the key for the class table.
+
+      The class table holds the data members, properties, and member functions
+      of a class. Read-only data and properties, and const member functions are
+      also placed here (to save a lookup in the const table).
+  */
+  static void const* getClassKey ()
+  {
+    static char value;
+    return &value;
+  }
+
+  /** Get the key for the const table.
+
+      The const table holds read-only data members and properties, and const
+      member functions of a class.
+  */
+  static void const* getConstKey ()
+  {
+    static char value;
+    return &value;
+  }
+};
+
diff --git a/extern/LuaBridge/detail/Constructor.h b/extern/LuaBridge/detail/Constructor.h
new file mode 100644
index 000000000..7b2dad059
--- /dev/null
+++ b/extern/LuaBridge/detail/Constructor.h
@@ -0,0 +1,204 @@
+//------------------------------------------------------------------------------
+/*
+  https://github.com/vinniefalco/LuaBridge
+  
+  Copyright 2012, Vinnie Falco <vinnie.falco@gmail.com>
+  Copyright 2007, Nathan Reed
+
+  License: The MIT License (http://www.opensource.org/licenses/mit-license.php)
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+//==============================================================================
+
+#ifndef LUABRIDGE_CONSTRUCTOR_HEADER
+#define LUABRIDGE_CONSTRUCTOR_HEADER
+
+/*
+* Constructor generators.  These templates allow you to call operator new and
+* pass the contents of a type/value list to the Constructor.  Like the
+* function pointer containers, these are only defined up to 8 parameters.
+*/
+
+/** Constructor generators.
+
+    These templates call operator new with the contents of a type/value
+    list passed to the Constructor with up to 8 parameters. Two versions
+    of call() are provided. One performs a regular new, the other performs
+    a placement new.
+*/
+template <class T, typename List>
+struct Constructor {};
+
+template <class T>
+struct Constructor <T, None>
+{
+  static T* call (TypeListValues <None> const&)
+  {
+    return new T;
+  }
+  static T* call (void* mem, TypeListValues <None> const&)
+  {
+    return new (mem) T;
+  }
+};
+
+template <class T, class P1>
+struct Constructor <T, TypeList <P1> >
+{
+  static T* call (const TypeListValues<TypeList <P1> > &tvl)
+  {
+    return new T(tvl.hd);
+  }
+  static T* call (void* mem, const TypeListValues<TypeList <P1> > &tvl)
+  {
+    return new (mem) T(tvl.hd);
+  }
+};
+
+template <class T, class P1, class P2>
+struct Constructor <T, TypeList <P1, TypeList <P2> > >
+{
+  static T* call (const TypeListValues<TypeList <P1, TypeList <P2> > > &tvl)
+  {
+    return new T(tvl.hd, tvl.tl.hd);
+  }
+  static T* call (void* mem, const TypeListValues<TypeList <P1, TypeList <P2> > > &tvl)
+  {
+    return new (mem) T(tvl.hd, tvl.tl.hd);
+  }
+};
+
+template <class T, class P1, class P2, class P3>
+struct Constructor <T, TypeList <P1, TypeList <P2, TypeList <P3> > > >
+{
+  static T* call (const TypeListValues<TypeList <P1, TypeList <P2,
+    TypeList <P3> > > > &tvl)
+  {
+    return new T(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd);
+  }
+  static T* call (void* mem, const TypeListValues<TypeList <P1, TypeList <P2,
+    TypeList <P3> > > > &tvl)
+  {
+    return new (mem) T(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd);
+  }
+};
+
+template <class T, class P1, class P2, class P3, class P4>
+struct Constructor <T, TypeList <P1, TypeList <P2, TypeList <P3,
+  TypeList <P4> > > > >
+{
+  static T* call (const TypeListValues<TypeList <P1, TypeList <P2,
+    TypeList <P3, TypeList <P4> > > > > &tvl)
+  {
+    return new T(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd);
+  }
+  static T* call (void* mem, const TypeListValues<TypeList <P1, TypeList <P2,
+    TypeList <P3, TypeList <P4> > > > > &tvl)
+  {
+    return new (mem) T(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd);
+  }
+};
+
+template <class T, class P1, class P2, class P3, class P4,
+  class P5>
+struct Constructor <T, TypeList <P1, TypeList <P2, TypeList <P3,
+  TypeList <P4, TypeList <P5> > > > > >
+{
+  static T* call (const TypeListValues<TypeList <P1, TypeList <P2,
+    TypeList <P3, TypeList <P4, TypeList <P5> > > > > > &tvl)
+  {
+    return new T(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd,
+      tvl.tl.tl.tl.tl.hd);
+  }
+  static T* call (void* mem, const TypeListValues<TypeList <P1, TypeList <P2,
+    TypeList <P3, TypeList <P4, TypeList <P5> > > > > > &tvl)
+  {
+    return new (mem) T(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd,
+      tvl.tl.tl.tl.tl.hd);
+  }
+};
+
+template <class T, class P1, class P2, class P3, class P4,
+  class P5, class P6>
+struct Constructor <T, TypeList <P1, TypeList <P2, TypeList <P3,
+  TypeList <P4, TypeList <P5, TypeList <P6> > > > > > >
+{
+  static T* call (const TypeListValues<TypeList <P1, TypeList <P2,
+    TypeList <P3, TypeList <P4, TypeList <P5, TypeList <P6> > > > > > > &tvl)
+  {
+    return new T(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd,
+      tvl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.hd);
+  }
+  static T* call (void* mem, const TypeListValues<TypeList <P1, TypeList <P2,
+    TypeList <P3, TypeList <P4, TypeList <P5, TypeList <P6> > > > > > > &tvl)
+  {
+    return new (mem) T(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd,
+      tvl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.hd);
+  }
+};
+
+template <class T, class P1, class P2, class P3, class P4,
+  class P5, class P6, class P7>
+struct Constructor <T, TypeList <P1, TypeList <P2, TypeList <P3,
+  TypeList <P4, TypeList <P5, TypeList <P6, TypeList <P7> > > > > > > >
+{
+  static T* call (const TypeListValues<TypeList <P1, TypeList <P2,
+    TypeList <P3, TypeList <P4, TypeList <P5, TypeList <P6,
+    TypeList <P7> > > > > > > > &tvl)
+  {
+    return new T(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd,
+      tvl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.hd,
+      tvl.tl.tl.tl.tl.tl.tl.hd);
+  }
+  static T* call (void* mem, const TypeListValues<TypeList <P1, TypeList <P2,
+    TypeList <P3, TypeList <P4, TypeList <P5, TypeList <P6,
+    TypeList <P7> > > > > > > > &tvl)
+  {
+    return new (mem) T(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd,
+      tvl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.hd,
+      tvl.tl.tl.tl.tl.tl.tl.hd);
+  }
+};
+
+template <class T, class P1, class P2, class P3, class P4,
+  class P5, class P6, class P7, class P8>
+struct Constructor <T, TypeList <P1, TypeList <P2, TypeList <P3,
+  TypeList <P4, TypeList <P5, TypeList <P6, TypeList <P7, 
+  TypeList <P8> > > > > > > > >
+{
+  static T* call (const TypeListValues<TypeList <P1, TypeList <P2,
+    TypeList <P3, TypeList <P4, TypeList <P5, TypeList <P6,
+    TypeList <P7, TypeList <P8> > > > > > > > > &tvl)
+  {
+    return new T(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd,
+      tvl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.hd,
+      tvl.tl.tl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.tl.tl.hd);
+  }
+  static T* call (void* mem, const TypeListValues<TypeList <P1, TypeList <P2,
+    TypeList <P3, TypeList <P4, TypeList <P5, TypeList <P6,
+    TypeList <P7, TypeList <P8> > > > > > > > > &tvl)
+  {
+    return new (mem) T(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd,
+      tvl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.hd,
+      tvl.tl.tl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.tl.tl.hd);
+  }
+};
+
+#endif
diff --git a/extern/LuaBridge/detail/FuncTraits.h b/extern/LuaBridge/detail/FuncTraits.h
new file mode 100644
index 000000000..7eccb6183
--- /dev/null
+++ b/extern/LuaBridge/detail/FuncTraits.h
@@ -0,0 +1,852 @@
+//------------------------------------------------------------------------------
+/*
+  https://github.com/vinniefalco/LuaBridge
+  
+  Copyright 2012, Vinnie Falco <vinnie.falco@gmail.com>
+
+  License: The MIT License (http://www.opensource.org/licenses/mit-license.php)
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+//==============================================================================
+
+/**
+  Since the throw specification is part of a function signature, the FuncTraits
+  family of templates needs to be specialized for both types. The
+  LUABRIDGE_THROWSPEC macro controls whether we use the 'throw ()' form, or
+  'noexcept' (if C++11 is available) to distinguish the functions.
+*/
+#if defined (__APPLE_CPP__) || defined(__APPLE_CC__) || defined(__clang__) || defined(__GNUC__) || \
+    (defined (_MSC_VER) && (_MSC_VER >= 1700))
+// Do not define LUABRIDGE_THROWSPEC since the Xcode and gcc  compilers do not
+// distinguish the throw specification in the function signature.
+#else
+// Visual Studio 10 and earlier pay too much mind to useless throw() spec.
+//
+# define LUABRIDGE_THROWSPEC throw()
+#endif
+
+//==============================================================================
+/**
+    Traits for function pointers.
+
+    There are three types of functions: global, non-const member, and const
+    member. These templates determine the type of function, which class type it
+    belongs to if it is a class member, the const-ness if it is a member
+    function, and the type information for the return value and argument list.
+
+    Expansions are provided for functions with up to 8 parameters. This can be
+    manually extended, or expanded to an arbitrary amount using C++11 features.
+*/
+template <class MemFn, class D = MemFn>
+struct FuncTraits
+{
+};
+
+/* Ordinary function pointers. */
+
+template <class R, class D>
+struct FuncTraits <R (*) (), D>
+{
+  static bool const isMemberFunction = false;
+  typedef D DeclType;
+  typedef R ReturnType;
+  typedef None Params;
+  static R call (D fp, TypeListValues <Params>)
+  {
+    return fp ();
+  }
+};
+
+template <class R, class P1, class D>
+struct FuncTraits <R (*) (P1), D>
+{
+  static bool const isMemberFunction = false;
+  typedef D DeclType;
+  typedef R ReturnType;
+  typedef TypeList <P1> Params;
+  static R call (D fp, TypeListValues <Params> tvl)
+  {
+    return fp (tvl.hd);
+  }
+};
+
+template <class R, class P1, class P2, class D>
+struct FuncTraits <R (*) (P1, P2), D>
+{
+  static bool const isMemberFunction = false;
+  typedef D DeclType;
+  typedef R ReturnType;
+  typedef TypeList <P1, TypeList <P2> > Params;
+  static R call (D fp, TypeListValues <Params> tvl)
+  {
+    return fp (tvl.hd, tvl.tl.hd);
+  }
+};
+
+template <class R, class P1, class P2, class P3, class D>
+struct FuncTraits <R (*) (P1, P2, P3), D>
+{
+  static bool const isMemberFunction = false;
+  typedef D DeclType;
+  typedef R ReturnType;
+  typedef TypeList <P1, TypeList <P2, TypeList <P3> > > Params;
+  static R call (D fp, TypeListValues <Params> tvl)
+  {
+    return fp (tvl.hd, tvl.tl.hd, tvl.tl.tl.hd);
+  }
+};
+
+template <class R, class P1, class P2, class P3, class P4, class D>
+struct FuncTraits <R (*) (P1, P2, P3, P4), D>
+{
+  static bool const isMemberFunction = false;
+  typedef D DeclType;
+  typedef R ReturnType;
+  typedef TypeList <P1, TypeList <P2, TypeList <P3, TypeList <P4> > > > Params;
+  static R call (D fp, TypeListValues <Params> tvl)
+  {
+    return fp (tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd);
+  }
+};
+
+template <class R, class P1, class P2, class P3, class P4, class P5, class D>
+struct FuncTraits <R (*) (P1, P2, P3, P4, P5), D>
+{
+  static bool const isMemberFunction = false;
+  typedef D DeclType;
+  typedef R ReturnType;
+  typedef TypeList <P1, TypeList <P2, TypeList <P3, TypeList <P4, TypeList <P5> > > > > Params;
+  static R call (D fp, TypeListValues <Params> tvl)
+  {
+    return fp (tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.hd);
+  }
+};
+
+template <class R, class P1, class P2, class P3, class P4, class P5, class P6, class D>
+struct FuncTraits <R (*) (P1, P2, P3, P4, P5, P6), D>
+{
+  static bool const isMemberFunction = false;
+  typedef D DeclType;
+  typedef R ReturnType;
+  typedef TypeList <P1, TypeList <P2, TypeList <P3, TypeList <P4, TypeList <P5,  TypeList <P6> > > > > > Params;
+  static R call (D fp, TypeListValues <Params> tvl)
+  {
+    return fp (tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.hd);
+  }
+};
+
+template <class R, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class D>
+struct FuncTraits <R (*) (P1, P2, P3, P4, P5, P6, P7), D>
+{
+  static bool const isMemberFunction = false;
+  typedef D DeclType;
+  typedef R ReturnType;
+  typedef TypeList <P1, TypeList <P2, TypeList <P3, TypeList <P4, TypeList <P5, TypeList <P6, TypeList <P7> > > > > > > Params;
+  static R call (D fp, TypeListValues <Params> tvl)
+  {
+    return fp (tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.tl.hd);
+  }
+};
+
+template <class R, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class D>
+struct FuncTraits <R (*) (P1, P2, P3, P4, P5, P6, P7, P8), D>
+{
+  static bool const isMemberFunction = false;
+  typedef D DeclType;
+  typedef R ReturnType;
+  typedef TypeList <P1, TypeList <P2, TypeList <P3, TypeList <P4, TypeList <P5, TypeList <P6, TypeList <P7, TypeList <P8> > > > > > > > Params;
+  static R call (D fp, TypeListValues <Params> tvl)
+  {
+    return fp (tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.tl.tl.hd);
+  }
+};
+
+/* Non-const member function pointers. */
+
+template <class T, class R, class D>
+struct FuncTraits <R (T::*) (), D>
+{
+  static bool const isMemberFunction = true;
+  static bool const isConstMemberFunction = false;
+  typedef D DeclType;
+  typedef T ClassType;
+  typedef R ReturnType;
+  typedef None Params;
+  static R call (T* obj, D fp, TypeListValues <Params>)
+  {
+    return (obj->*fp)();
+  }
+};
+
+template <class T, class R, class P1, class D>
+struct FuncTraits <R (T::*) (P1), D>
+{
+  static bool const isMemberFunction = true;
+  static bool const isConstMemberFunction = false;
+  typedef D DeclType;
+  typedef T ClassType;
+  typedef R ReturnType;
+  typedef TypeList <P1> Params;
+  static R call (T* obj, D fp, TypeListValues <Params> tvl)
+  {
+    return (obj->*fp)(tvl.hd);
+  }
+};
+
+template <class T, class R, class P1, class P2, class D>
+struct FuncTraits <R (T::*) (P1, P2), D>
+{
+  static bool const isMemberFunction = true;
+  static bool const isConstMemberFunction = false;
+  typedef D DeclType;
+  typedef T ClassType;
+  typedef R ReturnType;
+  typedef TypeList <P1, TypeList <P2> > Params;
+  static R call (T* obj, D fp, TypeListValues <Params> tvl)
+  {
+    return (obj->*fp)(tvl.hd, tvl.tl.hd);
+  }
+};
+
+template <class T, class R, class P1, class P2, class P3, class D>
+struct FuncTraits <R (T::*) (P1, P2, P3), D>
+{
+  static bool const isMemberFunction = true;
+  static bool const isConstMemberFunction = false;
+  typedef D DeclType;
+  typedef T ClassType;
+  typedef R ReturnType;
+  typedef TypeList <P1, TypeList <P2, TypeList <P3> > > Params;
+  static R call (T* obj, D fp, TypeListValues <Params> tvl)
+  {
+    return (obj->*fp)(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd);
+  }
+};
+
+template <class T, class R, class P1, class P2, class P3, class P4, class D>
+struct FuncTraits <R (T::*) (P1, P2, P3, P4), D>
+{
+  static bool const isMemberFunction = true;
+  static bool const isConstMemberFunction = false;
+  typedef D DeclType;
+  typedef T ClassType;
+  typedef R ReturnType;
+  typedef TypeList <P1, TypeList <P2, TypeList <P3, TypeList <P4> > > > Params;
+  static R call (T* obj, D fp, TypeListValues <Params> tvl)
+  {
+    return (obj->*fp)(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd);
+  }
+};
+
+template <class T, class R, class P1, class P2, class P3, class P4, class P5, class D>
+struct FuncTraits <R (T::*) (P1, P2, P3, P4, P5), D>
+{
+  static bool const isMemberFunction = true;
+  static bool const isConstMemberFunction = false;
+  typedef D DeclType;
+  typedef T ClassType;
+  typedef R ReturnType;
+  typedef TypeList <P1, TypeList <P2, TypeList <P3, TypeList <P4, TypeList <P5> > > > > Params;
+  static R call (T* obj, D fp, TypeListValues <Params> tvl)
+  {
+    return (obj->*fp)(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.hd);
+  }
+};
+
+template <class T, class R, class P1, class P2, class P3, class P4, class P5, class P6, class D>
+struct FuncTraits <R (T::*) (P1, P2, P3, P4, P5, P6), D>
+{
+  static bool const isMemberFunction = true;
+  static bool const isConstMemberFunction = false;
+  typedef D DeclType;
+  typedef T ClassType;
+  typedef R ReturnType;
+  typedef TypeList <P1, TypeList <P2, TypeList <P3, TypeList <P4, TypeList <P5, TypeList <P6> > > > > > Params;
+  static R call (T* obj, D fp, TypeListValues <Params> tvl)
+  {
+    return (obj->*fp)(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.hd);
+  }
+};
+
+template <class T, class R, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class D>
+struct FuncTraits <R (T::*) (P1, P2, P3, P4, P5, P6, P7), D>
+{
+  static bool const isMemberFunction = true;
+  static bool const isConstMemberFunction = false;
+  typedef D DeclType;
+  typedef T ClassType;
+  typedef R ReturnType;
+  typedef TypeList <P1, TypeList <P2, TypeList <P3, TypeList <P4, TypeList <P5, TypeList <P6, TypeList <P7> > > > > > > Params;
+  static R call (T* obj, D fp, TypeListValues <Params> tvl)
+  {
+    return (obj->*fp)(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.tl.hd);
+  }
+};
+
+template <class T, class R, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class D>
+struct FuncTraits <R (T::*) (P1, P2, P3, P4, P5, P6, P7, P8), D>
+{
+  static bool const isMemberFunction = true;
+  static bool const isConstMemberFunction = false;
+  typedef D DeclType;
+  typedef T ClassType;
+  typedef R ReturnType;
+  typedef TypeList <P1, TypeList <P2, TypeList <P3, TypeList <P4, TypeList <P5, TypeList <P6, TypeList <P7, TypeList <P8> > > > > > > > Params;
+  static R call (T* obj, D fp, TypeListValues <Params> tvl)
+  {
+    return (obj->*fp)(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.tl.tl.hd);
+  }
+};
+
+/* Const member function pointers. */
+
+template <class T, class R, class D>
+struct FuncTraits <R (T::*) () const, D>
+{
+  static bool const isMemberFunction = true;
+  static bool const isConstMemberFunction = true;
+  typedef D DeclType;
+  typedef T ClassType;
+  typedef R ReturnType;
+  typedef None Params;
+  static R call (T const* obj, D fp, TypeListValues <Params>)
+  {
+    return (obj->*fp)();
+  }
+};
+
+template <class T, class R, class P1, class D>
+struct FuncTraits <R (T::*) (P1) const, D>
+{
+  static bool const isMemberFunction = true;
+  static bool const isConstMemberFunction = true;
+  typedef D DeclType;
+  typedef T ClassType;
+  typedef R ReturnType;
+  typedef TypeList <P1> Params;
+  static R call (T const* obj, D fp, TypeListValues <Params> tvl)
+  {
+    return (obj->*fp)(tvl.hd);
+  }
+};
+
+template <class T, class R, class P1, class P2, class D>
+struct FuncTraits <R (T::*) (P1, P2) const, D>
+{
+  static bool const isMemberFunction = true;
+  static bool const isConstMemberFunction = true;
+  typedef D DeclType;
+  typedef T ClassType;
+  typedef R ReturnType;
+  typedef TypeList <P1, TypeList <P2> > Params;
+  static R call (T const* obj, R (T::*fp) (P1, P2) const,
+    TypeListValues <Params> tvl)
+  {
+    return (obj->*fp)(tvl.hd, tvl.tl.hd);
+  }
+};
+
+template <class T, class R, class P1, class P2, class P3, class D>
+struct FuncTraits <R (T::*) (P1, P2, P3) const, D>
+{
+  static bool const isMemberFunction = true;
+  static bool const isConstMemberFunction = true;
+  typedef D DeclType;
+  typedef T ClassType;
+  typedef R ReturnType;
+  typedef TypeList <P1, TypeList <P2, TypeList <P3> > > Params;
+  static R call (T const* obj, D fp, TypeListValues <Params> tvl)
+  {
+    return (obj->*fp)(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd);
+  }
+};
+
+template <class T, class R, class P1, class P2, class P3, class P4, class D>
+struct FuncTraits <R (T::*) (P1, P2, P3, P4) const, D>
+{
+  static bool const isMemberFunction = true;
+  static bool const isConstMemberFunction = true;
+  typedef D DeclType;
+  typedef T ClassType;
+  typedef R ReturnType;
+  typedef TypeList <P1, TypeList <P2, TypeList <P3, TypeList <P4> > > > Params;
+  static R call (T const* obj, D fp, TypeListValues <Params> tvl)
+  {
+    return (obj->*fp)(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd);
+  }
+};
+
+template <class T, class R, class P1, class P2, class P3, class P4, class P5, class D>
+struct FuncTraits <R (T::*) (P1, P2, P3, P4, P5) const, D>
+{
+  static bool const isMemberFunction = true;
+  static bool const isConstMemberFunction = true;
+  typedef D DeclType;
+  typedef T ClassType;
+  typedef R ReturnType;
+  typedef TypeList <P1, TypeList <P2, TypeList <P3, TypeList <P4, TypeList <P5> > > > > Params;
+  static R call (T const* obj, D fp, TypeListValues <Params> tvl)
+  {
+    return (obj->*fp)(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.hd);
+  }
+};
+
+template <class T, class R, class P1, class P2, class P3, class P4, class P5, class P6, class D>
+struct FuncTraits <R (T::*) (P1, P2, P3, P4, P5, P6) const, D>
+{
+  static bool const isMemberFunction = true;
+  static bool const isConstMemberFunction = true;
+  typedef D DeclType;
+  typedef T ClassType;
+  typedef R ReturnType;
+  typedef TypeList <P1, TypeList <P2, TypeList <P3, TypeList <P4, TypeList <P5, TypeList <P6> > > > > > Params;
+  static R call (T const* obj, D fp, TypeListValues <Params> tvl)
+  {
+    return (obj->*fp)(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.hd);
+  }
+};
+
+template <class T, class R, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class D>
+struct FuncTraits <R (T::*) (P1, P2, P3, P4, P5, P6, P7) const, D>
+{
+  static bool const isMemberFunction = true;
+  static bool const isConstMemberFunction = true;
+  typedef D DeclType;
+  typedef T ClassType;
+  typedef R ReturnType;
+  typedef TypeList <P1, TypeList <P2, TypeList <P3, TypeList <P4, TypeList <P5, TypeList <P6, TypeList <P7> > > > > > > Params;
+  static R call (T const* obj, D fp, TypeListValues <Params> tvl)
+  {
+    return (obj->*fp)(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.tl.hd);
+  }
+};
+
+template <class T, class R, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class D>
+struct FuncTraits <R (T::*) (P1, P2, P3, P4, P5, P6, P7, P8) const, D>
+{
+  static bool const isMemberFunction = true;
+  static bool const isConstMemberFunction = true;
+  typedef D DeclType;
+  typedef T ClassType;
+  typedef R ReturnType;
+  typedef TypeList <P1, TypeList <P2, TypeList <P3, TypeList <P4, TypeList <P5, TypeList <P6, TypeList <P7, TypeList <P8> > > > > > > > Params;
+  static R call (T const* obj, D fp, TypeListValues <Params> tvl)
+  {
+    return (obj->*fp)(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.tl.tl.hd);
+  }
+};
+
+#if defined (LUABRIDGE_THROWSPEC)
+
+/* Ordinary function pointers. */
+
+template <class R, class D>
+struct FuncTraits <R (*) () LUABRIDGE_THROWSPEC, D>
+{
+  static bool const isMemberFunction = false;
+  typedef D DeclType;
+  typedef R ReturnType;
+  typedef None Params;
+  static R call (D fp, TypeListValues <Params> const&)
+  {
+    return fp ();
+  }
+};
+
+template <class R, class P1, class D>
+struct FuncTraits <R (*) (P1) LUABRIDGE_THROWSPEC, D>
+{
+  static bool const isMemberFunction = false;
+  typedef D DeclType;
+  typedef R ReturnType;
+  typedef TypeList <P1> Params;
+  static R call (D fp, TypeListValues <Params> tvl)
+  {
+    return fp (tvl.hd);
+  }
+};
+
+template <class R, class P1, class P2, class D>
+struct FuncTraits <R (*) (P1, P2) LUABRIDGE_THROWSPEC, D>
+{
+  static bool const isMemberFunction = false;
+  typedef D DeclType;
+  typedef R ReturnType;
+  typedef TypeList <P1, TypeList <P2> > Params;
+  static R call (D fp, TypeListValues <Params> tvl)
+  {
+    return fp (tvl.hd, tvl.tl.hd);
+  }
+};
+
+template <class R, class P1, class P2, class P3, class D>
+struct FuncTraits <R (*) (P1, P2, P3) LUABRIDGE_THROWSPEC, D>
+{
+  static bool const isMemberFunction = false;
+  typedef D DeclType;
+  typedef R ReturnType;
+  typedef TypeList <P1, TypeList <P2, TypeList <P3> > > Params;
+  static R call (D fp, TypeListValues <Params> tvl)
+  {
+    return fp (tvl.hd, tvl.tl.hd, tvl.tl.tl.hd);
+  }
+};
+
+template <class R, class P1, class P2, class P3, class P4, class D>
+struct FuncTraits <R (*) (P1, P2, P3, P4) LUABRIDGE_THROWSPEC, D>
+{
+  static bool const isMemberFunction = false;
+  typedef D DeclType;
+  typedef R ReturnType;
+  typedef TypeList <P1, TypeList <P2, TypeList <P3, TypeList <P4> > > > Params;
+  static R call (D fp, TypeListValues <Params> tvl)
+  {
+    return fp (tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd);
+  }
+};
+
+template <class R, class P1, class P2, class P3, class P4, class P5, class D>
+struct FuncTraits <R (*) (P1, P2, P3, P4, P5) LUABRIDGE_THROWSPEC, D>
+{
+  static bool const isMemberFunction = false;
+  typedef D DeclType;
+  typedef R ReturnType;
+  typedef TypeList <P1, TypeList <P2, TypeList <P3, TypeList <P4, TypeList <P5> > > > > Params;
+  static R call (D fp, TypeListValues <Params> tvl)
+  {
+    return fp (tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.hd);
+  }
+};
+
+template <class R, class P1, class P2, class P3, class P4, class P5, class P6, class D>
+struct FuncTraits <R (*) (P1, P2, P3, P4, P5, P6) LUABRIDGE_THROWSPEC, D>
+{
+  static bool const isMemberFunction = false;
+  typedef D DeclType;
+  typedef R ReturnType;
+  typedef TypeList <P1, TypeList <P2, TypeList <P3, TypeList <P4, TypeList <P5,  TypeList <P6> > > > > > Params;
+  static R call (D fp, TypeListValues <Params> tvl)
+  {
+    return fp (tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.hd);
+  }
+};
+
+template <class R, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class D>
+struct FuncTraits <R (*) (P1, P2, P3, P4, P5, P6, P7) LUABRIDGE_THROWSPEC, D>
+{
+  static bool const isMemberFunction = false;
+  typedef D DeclType;
+  typedef R ReturnType;
+  typedef TypeList <P1, TypeList <P2, TypeList <P3, TypeList <P4, TypeList <P5, TypeList <P6, TypeList <P7> > > > > > > Params;
+  static R call (D fp, TypeListValues <Params> tvl)
+  {
+    return fp (tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.tl.hd);
+  }
+};
+
+template <class R, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class D>
+struct FuncTraits <R (*) (P1, P2, P3, P4, P5, P6, P7, P8) LUABRIDGE_THROWSPEC, D>
+{
+  static bool const isMemberFunction = false;
+  typedef D DeclType;
+  typedef R ReturnType;
+  typedef TypeList <P1, TypeList <P2, TypeList <P3, TypeList <P4, TypeList <P5, TypeList <P6, TypeList <P7, TypeList <P8> > > > > > > > Params;
+  static R call (D fp, TypeListValues <Params> tvl)
+  {
+    return fp (tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.tl.tl.hd);
+  }
+};
+
+/* Non-const member function pointers with THROWSPEC. */
+
+template <class T, class R, class D>
+struct FuncTraits <R (T::*) () LUABRIDGE_THROWSPEC, D>
+{
+  static bool const isMemberFunction = true;
+  static bool const isConstMemberFunction = false;
+  typedef D DeclType;
+  typedef T ClassType;
+  typedef R ReturnType;
+  typedef None Params;
+  static R call (T* obj, D fp, TypeListValues <Params> const&)
+  {
+    return (obj->*fp)();
+  }
+};
+
+template <class T, class R, class P1, class D>
+struct FuncTraits <R (T::*) (P1) LUABRIDGE_THROWSPEC, D>
+{
+  static bool const isMemberFunction = true;
+  static bool const isConstMemberFunction = false;
+  typedef D DeclType;
+  typedef T ClassType;
+  typedef R ReturnType;
+  typedef TypeList <P1> Params;
+  static R call (T* obj, D fp, TypeListValues <Params> tvl)
+  {
+    return (obj->*fp)(tvl.hd);
+  }
+};
+
+template <class T, class R, class P1, class P2, class D>
+struct FuncTraits <R (T::*) (P1, P2) LUABRIDGE_THROWSPEC, D>
+{
+  static bool const isMemberFunction = true;
+  static bool const isConstMemberFunction = false;
+  typedef D DeclType;
+  typedef T ClassType;
+  typedef R ReturnType;
+  typedef TypeList <P1, TypeList <P2> > Params;
+  static R call (T* obj, D fp, TypeListValues <Params> tvl)
+  {
+    return (obj->*fp)(tvl.hd, tvl.tl.hd);
+  }
+};
+
+template <class T, class R, class P1, class P2, class P3, class D>
+struct FuncTraits <R (T::*) (P1, P2, P3) LUABRIDGE_THROWSPEC, D>
+{
+  static bool const isMemberFunction = true;
+  static bool const isConstMemberFunction = false;
+  typedef D DeclType;
+  typedef T ClassType;
+  typedef R ReturnType;
+  typedef TypeList <P1, TypeList <P2, TypeList <P3> > > Params;
+  static R call (T* obj, D fp, TypeListValues <Params> tvl)
+  {
+    return (obj->*fp)(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd);
+  }
+};
+
+template <class T, class R, class P1, class P2, class P3, class P4, class D>
+struct FuncTraits <R (T::*) (P1, P2, P3, P4) LUABRIDGE_THROWSPEC, D>
+{
+  static bool const isMemberFunction = true;
+  static bool const isConstMemberFunction = false;
+  typedef D DeclType;
+  typedef T ClassType;
+  typedef R ReturnType;
+  typedef TypeList <P1, TypeList <P2, TypeList <P3, TypeList <P4> > > > Params;
+  static R call (T* obj, D fp, TypeListValues <Params> tvl)
+  {
+    return (obj->*fp)(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd);
+  }
+};
+
+template <class T, class R, class P1, class P2, class P3, class P4, class P5, class D>
+struct FuncTraits <R (T::*) (P1, P2, P3, P4, P5) LUABRIDGE_THROWSPEC, D>
+{
+  static bool const isMemberFunction = true;
+  static bool const isConstMemberFunction = false;
+  typedef D DeclType;
+  typedef T ClassType;
+  typedef R ReturnType;
+  typedef TypeList <P1, TypeList <P2, TypeList <P3, TypeList <P4, TypeList <P5> > > > > Params;
+  static R call (T* obj, D fp, TypeListValues <Params> tvl)
+  {
+    return (obj->*fp)(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.hd);
+  }
+};
+
+template <class T, class R, class P1, class P2, class P3, class P4, class P5, class P6, class D>
+struct FuncTraits <R (T::*) (P1, P2, P3, P4, P5, P6) LUABRIDGE_THROWSPEC, D>
+{
+  static bool const isMemberFunction = true;
+  static bool const isConstMemberFunction = false;
+  typedef D DeclType;
+  typedef T ClassType;
+  typedef R ReturnType;
+  typedef TypeList <P1, TypeList <P2, TypeList <P3, TypeList <P4, TypeList <P5, TypeList <P6> > > > > > Params;
+  static R call (T* obj, D fp, TypeListValues <Params> tvl)
+  {
+    return (obj->*fp)(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.hd);
+  }
+};
+
+template <class T, class R, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class D>
+struct FuncTraits <R (T::*) (P1, P2, P3, P4, P5, P6, P7) LUABRIDGE_THROWSPEC, D>
+{
+  static bool const isMemberFunction = true;
+  static bool const isConstMemberFunction = false;
+  typedef D DeclType;
+  typedef T ClassType;
+  typedef R ReturnType;
+  typedef TypeList <P1, TypeList <P2, TypeList <P3, TypeList <P4, TypeList <P5, TypeList <P6, TypeList <P7> > > > > > > Params;
+  static R call (T* obj, D fp, TypeListValues <Params> tvl)
+  {
+    return (obj->*fp)(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.tl.hd);
+  }
+};
+
+template <class T, class R, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class D>
+struct FuncTraits <R (T::*) (P1, P2, P3, P4, P5, P6, P7, P8) LUABRIDGE_THROWSPEC, D>
+{
+  static bool const isMemberFunction = true;
+  static bool const isConstMemberFunction = false;
+  typedef D DeclType;
+  typedef T ClassType;
+  typedef R ReturnType;
+  typedef TypeList <P1, TypeList <P2, TypeList <P3, TypeList <P4, TypeList <P5, TypeList <P6, TypeList <P7, TypeList <P8> > > > > > > > Params;
+  static R call (T* obj, D fp, TypeListValues <Params> tvl)
+  {
+    return (obj->*fp)(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.tl.tl.hd);
+  }
+};
+
+/* Const member function pointers with THROWSPEC. */
+
+template <class T, class R, class D>
+struct FuncTraits <R (T::*) () const LUABRIDGE_THROWSPEC, D>
+{
+  static bool const isMemberFunction = true;
+  static bool const isConstMemberFunction = true;
+  typedef D DeclType;
+  typedef T ClassType;
+  typedef R ReturnType;
+  typedef None Params;
+  static R call (T const* obj, D fp, TypeListValues <Params>)
+  {
+    return (obj->*fp)();
+  }
+};
+
+template <class T, class R, class P1, class D>
+struct FuncTraits <R (T::*) (P1) const LUABRIDGE_THROWSPEC, D>
+{
+  static bool const isMemberFunction = true;
+  static bool const isConstMemberFunction = true;
+  typedef D DeclType;
+  typedef T ClassType;
+  typedef R ReturnType;
+  typedef TypeList <P1> Params;
+  static R call (T const* obj, D fp, TypeListValues <Params> tvl)
+  {
+    return (obj->*fp)(tvl.hd);
+  }
+};
+
+template <class T, class R, class P1, class P2, class D>
+struct FuncTraits <R (T::*) (P1, P2) const LUABRIDGE_THROWSPEC, D>
+{
+  static bool const isMemberFunction = true;
+  static bool const isConstMemberFunction = true;
+  typedef D DeclType;
+  typedef T ClassType;
+  typedef R ReturnType;
+  typedef TypeList <P1, TypeList <P2> > Params;
+  static R call (T const* obj, D fp, TypeListValues <Params> tvl)
+  {
+    return (obj->*fp)(tvl.hd, tvl.tl.hd);
+  }
+};
+
+template <class T, class R, class P1, class P2, class P3, class D>
+struct FuncTraits <R (T::*) (P1, P2, P3) const LUABRIDGE_THROWSPEC, D>
+{
+  static bool const isMemberFunction = true;
+  static bool const isConstMemberFunction = true;
+  typedef D DeclType;
+  typedef T ClassType;
+  typedef R ReturnType;
+  typedef TypeList <P1, TypeList <P2, TypeList <P3> > > Params;
+  static R call (T const* obj, D fp, TypeListValues <Params> tvl)
+  {
+    return (obj->*fp)(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd);
+  }
+};
+
+template <class T, class R, class P1, class P2, class P3, class P4, class D>
+struct FuncTraits <R (T::*) (P1, P2, P3, P4) const LUABRIDGE_THROWSPEC, D>
+{
+  static bool const isMemberFunction = true;
+  static bool const isConstMemberFunction = true;
+  typedef D DeclType;
+  typedef T ClassType;
+  typedef R ReturnType;
+  typedef TypeList <P1, TypeList <P2, TypeList <P3, TypeList <P4> > > > Params;
+  static R call (T const* obj, D fp, TypeListValues <Params> tvl)
+  {
+    return (obj->*fp)(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd);
+  }
+};
+
+template <class T, class R, class P1, class P2, class P3, class P4, class P5, class D>
+struct FuncTraits <R (T::*) (P1, P2, P3, P4, P5) const LUABRIDGE_THROWSPEC, D>
+{
+  static bool const isMemberFunction = true;
+  static bool const isConstMemberFunction = true;
+  typedef D DeclType;
+  typedef T ClassType;
+  typedef R ReturnType;
+  typedef TypeList <P1, TypeList <P2, TypeList <P3, TypeList <P4, TypeList <P5> > > > > Params;
+  static R call (T const* obj, D fp, TypeListValues <Params> tvl)
+  {
+    return (obj->*fp)(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd,
+      tvl.tl.tl.tl.tl.hd);
+  }
+};
+
+template <class T, class R, class P1, class P2, class P3, class P4, class P5, class P6, class D>
+struct FuncTraits <R (T::*) (P1, P2, P3, P4, P5, P6) const LUABRIDGE_THROWSPEC, D>
+{
+  static bool const isMemberFunction = true;
+  static bool const isConstMemberFunction = true;
+  typedef D DeclType;
+  typedef T ClassType;
+  typedef R ReturnType;
+  typedef TypeList <P1, TypeList <P2, TypeList <P3, TypeList <P4, TypeList <P5, TypeList <P6> > > > > > Params;
+  static R call (T const* obj, D fp, TypeListValues <Params> tvl)
+  {
+    return (obj->*fp)(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.hd);
+  }
+};
+
+template <class T, class R, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class D>
+struct FuncTraits <R (T::*) (P1, P2, P3, P4, P5, P6, P7) const LUABRIDGE_THROWSPEC, D>
+{
+  static bool const isMemberFunction = true;
+  static bool const isConstMemberFunction = true;
+  typedef D DeclType;
+  typedef T ClassType;
+  typedef R ReturnType;
+  typedef TypeList <P1, TypeList <P2, TypeList <P3, TypeList <P4, TypeList <P5, TypeList <P6, TypeList <P7> > > > > > > Params;
+  static R call (T const* obj, D fp, TypeListValues <Params> tvl)
+  {
+    return (obj->*fp)(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.tl.hd);
+  }
+};
+
+template <class T, class R, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class D>
+struct FuncTraits <R (T::*) (P1, P2, P3, P4, P5, P6, P7, P8) const LUABRIDGE_THROWSPEC, D>
+{
+  static bool const isMemberFunction = true;
+  static bool const isConstMemberFunction = true;
+  typedef D DeclType;
+  typedef T ClassType;
+  typedef R ReturnType;
+  typedef TypeList <P1, TypeList <P2, TypeList <P3, TypeList <P4, TypeList <P5, TypeList <P6, TypeList <P7, TypeList <P8> > > > > > > > Params;
+  static R call (T const* obj, D fp, TypeListValues <Params> tvl)
+  {
+    return (obj->*fp)(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.tl.tl.hd);
+  }
+};
+
+#endif
diff --git a/extern/LuaBridge/detail/Iterator.h b/extern/LuaBridge/detail/Iterator.h
new file mode 100644
index 000000000..d883fb398
--- /dev/null
+++ b/extern/LuaBridge/detail/Iterator.h
@@ -0,0 +1,114 @@
+//------------------------------------------------------------------------------
+/*
+  https://github.com/vinniefalco/LuaBridge
+  
+  Copyright 2012, Vinnie Falco <vinnie.falco@gmail.com>
+
+  License: The MIT License (http://www.opensource.org/licenses/mit-license.php)
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+//==============================================================================
+
+/** Allows table iteration.
+*/
+class Iterator
+{
+private:
+  lua_State* m_L;
+  LuaRef m_table;
+  LuaRef m_key;
+  LuaRef m_value;
+
+  void next ()
+  {
+    m_table.push(m_L);
+    m_key.push (m_L);
+    if (lua_next (m_L, -2))
+    {
+      m_value.pop (m_L);
+      m_key.pop (m_L);
+    }
+    else
+    {
+      m_key = Nil();
+      m_value = Nil();
+    }
+    lua_pop(m_L, 1);
+  }
+
+public:
+  explicit Iterator (LuaRef table)
+    : m_L (table.state ())
+    , m_table (table)
+    , m_key (table.state ()) // m_key is nil
+    , m_value (table.state ()) // m_value is nil
+  {
+    next (); // get the first (key, value) pair from table
+  }
+
+  lua_State* state () const
+  {
+    return m_L;
+  }
+
+  LuaRef operator* () const
+  {
+    return m_value;
+  }
+
+  LuaRef operator-> () const
+  {
+    return m_value;
+  }
+
+  Iterator& operator++ ()
+  {
+    if (isNil())
+    {
+      // if the iterator reaches the end, do nothing
+      return *this;
+    }
+    else
+    {
+      next();
+      return *this;
+    }
+  }
+
+  inline bool isNil () const
+  {
+    return m_key.isNil ();
+  }
+
+  inline LuaRef key () const
+  {
+    return m_key;
+  }
+
+  inline LuaRef value () const
+  {
+    return m_value;
+  }
+
+private:
+  // Don't use postfix increment, it is less efficient
+  Iterator operator++ (int);
+};
+
diff --git a/extern/LuaBridge/detail/LuaException.h b/extern/LuaBridge/detail/LuaException.h
new file mode 100644
index 000000000..a0944961c
--- /dev/null
+++ b/extern/LuaBridge/detail/LuaException.h
@@ -0,0 +1,113 @@
+//------------------------------------------------------------------------------
+/*
+  https://github.com/vinniefalco/LuaBridge
+  
+  Copyright 2012, Vinnie Falco <vinnie.falco@gmail.com>
+  Copyright 2008, Nigel Atkinson <suprapilot+LuaCode@gmail.com>
+
+  License: The MIT License (http://www.opensource.org/licenses/mit-license.php)
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+//==============================================================================
+
+class LuaException : public std::exception 
+{
+private:
+  lua_State* m_L;
+  std::string m_what;
+
+public:
+  //----------------------------------------------------------------------------
+  /**
+      Construct a LuaException after a lua_pcall().
+  */
+  LuaException (lua_State* L, int /*code*/)
+    : m_L (L)
+  {
+    whatFromStack ();
+  }
+
+  //----------------------------------------------------------------------------
+
+  LuaException (lua_State *L,
+                char const*,
+                char const*,
+                long)
+    : m_L (L)
+  {
+    whatFromStack ();
+  }
+
+  //----------------------------------------------------------------------------
+
+  ~LuaException() throw ()
+  {
+  }
+
+  //----------------------------------------------------------------------------
+
+  char const* what() const throw ()
+  {
+    return m_what.c_str();
+  }
+
+  //============================================================================
+  /**
+      Throw an exception.
+
+      This centralizes all the exceptions thrown, so that we can set
+      breakpoints before the stack is unwound, or otherwise customize the
+      behavior.
+  */
+  template <class Exception>
+  static void Throw (Exception e)
+  {
+    throw e;
+  }
+
+  //----------------------------------------------------------------------------
+  /**
+      Wrapper for lua_pcall that throws.
+  */
+  static void pcall (lua_State* L, int nargs = 0, int nresults = 0, int msgh = 0)
+  {
+    int code = lua_pcall (L, nargs, nresults, msgh);
+
+    if (code != LUABRIDGE_LUA_OK)
+      Throw (LuaException (L, code));
+  }
+
+  //----------------------------------------------------------------------------
+
+protected:
+  void whatFromStack ()
+  {
+    if (lua_gettop (m_L) > 0)
+    {
+      char const* s = lua_tostring (m_L, -1);
+      m_what = s ? s : "";
+    }
+    else
+    {
+      // stack is empty
+      m_what = "missing error";
+    }
+  }
+};
diff --git a/extern/LuaBridge/detail/LuaHelpers.h b/extern/LuaBridge/detail/LuaHelpers.h
new file mode 100644
index 000000000..7bc84eb16
--- /dev/null
+++ b/extern/LuaBridge/detail/LuaHelpers.h
@@ -0,0 +1,143 @@
+//------------------------------------------------------------------------------
+/*
+  https://github.com/vinniefalco/LuaBridge
+  
+  Copyright 2012, Vinnie Falco <vinnie.falco@gmail.com>
+  Copyright 2007, Nathan Reed
+
+  License: The MIT License (http://www.opensource.org/licenses/mit-license.php)
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+//==============================================================================
+
+// These are for Lua versions prior to 5.2.0.
+//
+#if LUA_VERSION_NUM < 502
+inline int lua_absindex (lua_State* L, int idx)
+{
+  if (idx > LUA_REGISTRYINDEX && idx < 0)
+    return lua_gettop (L) + idx + 1;
+  else
+    return idx;
+}
+
+inline void lua_rawgetp (lua_State* L, int idx, void const* p)
+{
+  idx = lua_absindex (L, idx);
+  lua_pushlightuserdata (L, const_cast <void*> (p));
+  lua_rawget (L,idx);
+}
+
+inline void lua_rawsetp (lua_State* L, int idx, void const* p)
+{
+  idx = lua_absindex (L, idx);
+  lua_pushlightuserdata (L, const_cast <void*> (p));
+  // put key behind value
+  lua_insert (L, -2);
+  lua_rawset (L, idx);
+}
+
+#define LUA_OPEQ 1
+#define LUA_OPLT 2
+#define LUA_OPLE 3
+
+inline int lua_compare (lua_State* L, int idx1, int idx2, int op)
+{
+  switch (op)
+  {
+  case LUA_OPEQ:
+    return lua_equal (L, idx1, idx2);
+    break;
+
+  case LUA_OPLT:
+    return lua_lessthan (L, idx1, idx2);
+    break;
+
+  case LUA_OPLE:
+    return lua_equal (L, idx1, idx2) || lua_lessthan (L, idx1, idx2);
+    break;
+
+  default:
+    return 0;
+  };
+}
+
+inline int get_length (lua_State* L, int idx)
+{
+  return int (lua_objlen (L, idx));
+}
+
+#else
+inline int get_length (lua_State* L, int idx)
+{
+  lua_len (L, idx);
+  int len = int (luaL_checknumber (L, -1));
+  lua_pop (L, 1);
+  return len;
+}
+
+#endif
+
+#ifndef LUA_OK
+# define LUABRIDGE_LUA_OK 0
+#else
+# define LUABRIDGE_LUA_OK LUA_OK
+#endif
+
+/** Get a table value, bypassing metamethods.
+*/  
+inline void rawgetfield (lua_State* L, int index, char const* key)
+{
+  assert (lua_istable (L, index));
+  index = lua_absindex (L, index);
+  lua_pushstring (L, key);
+  lua_rawget (L, index);
+}
+
+/** Set a table value, bypassing metamethods.
+*/  
+inline void rawsetfield (lua_State* L, int index, char const* key)
+{
+  assert (lua_istable (L, index));
+  index = lua_absindex (L, index);
+  lua_pushstring (L, key);
+  lua_insert (L, -2);
+  lua_rawset (L, index);
+}
+
+/** Returns true if the value is a full userdata (not light).
+*/
+inline bool isfulluserdata (lua_State* L, int index)
+{
+  return lua_isuserdata (L, index) && !lua_islightuserdata (L, index);
+}
+
+/** Test lua_State objects for global equality.
+
+    This can determine if two different lua_State objects really point
+    to the same global state, such as when using coroutines.
+
+    @note This is used for assertions.
+*/
+inline bool equalstates (lua_State* L1, lua_State* L2)
+{
+  return lua_topointer (L1, LUA_REGISTRYINDEX) ==
+         lua_topointer (L2, LUA_REGISTRYINDEX);
+}
diff --git a/extern/LuaBridge/detail/LuaRef.h b/extern/LuaBridge/detail/LuaRef.h
new file mode 100644
index 000000000..e726bcafe
--- /dev/null
+++ b/extern/LuaBridge/detail/LuaRef.h
@@ -0,0 +1,1215 @@
+//------------------------------------------------------------------------------
+/*
+  https://github.com/vinniefalco/LuaBridge
+  
+  Copyright 2012, Vinnie Falco <vinnie.falco@gmail.com>
+  Copyright 2008, Nigel Atkinson <suprapilot+LuaCode@gmail.com>
+
+  License: The MIT License (http://www.opensource.org/licenses/mit-license.php)
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+//==============================================================================
+
+//------------------------------------------------------------------------------
+/**
+    Type tag for representing LUA_TNIL.
+
+    Construct one of these using `Nil()` to represent a Lua nil. This is faster
+    than creating a reference in the registry to nil. Example:
+
+        LuaRef t (LuaRef::createTable (L));
+        ...
+        t ["k"] = Nil(); // assign nil
+*/
+struct Nil
+{
+};
+
+//------------------------------------------------------------------------------
+/**
+    Lightweight reference to a Lua object.
+
+    The reference is maintained for the lifetime of the C++ object.
+*/
+class LuaRef
+{
+private:
+  class Proxy;
+  friend struct Stack <Proxy>;
+
+  //----------------------------------------------------------------------------
+  /**
+      Pop the Lua stack.
+
+      Pops the specified number of stack items on destruction. We use this
+      when returning objects, to avoid an explicit temporary variable, since
+      the destructor executes after the return statement. For example:
+
+          template <class U>
+          U cast (lua_State* L)
+          {
+            StackPop p (L, 1);
+            ...
+            return U (); // dtor called after this line
+          }
+
+      @note The `StackPop` object must always be a named local variable.
+  */
+  class StackPop
+  {
+  public:
+    /** Create a StackPop object.
+
+        @param count The number of stack entries to pop on destruction.
+    */
+    StackPop (lua_State* L, int count)
+      : m_L (L)
+      , m_count (count)
+    {
+    }
+
+    ~StackPop ()
+    {
+      lua_pop (m_L, m_count);
+    }
+
+  private:
+    lua_State* m_L;
+    int m_count;
+  };
+
+  //----------------------------------------------------------------------------
+  /**
+      A proxy for representing table values.
+  */
+  class Proxy
+  {
+  private:
+    lua_State* m_L;
+    int m_tableRef;
+    int m_keyRef;
+
+  public:
+    //--------------------------------------------------------------------------
+    /**
+        Construct a Proxy from a table value.
+
+        The table is in the registry, and the key is at the top of the stack.
+        The key is popped off the stack.
+    */
+    Proxy (lua_State* L, int tableRef)
+      : m_L (L)
+      , m_tableRef (tableRef)
+      , m_keyRef (luaL_ref (L, LUA_REGISTRYINDEX))
+    {
+    }
+
+    //--------------------------------------------------------------------------
+    /**
+        Create a Proxy via copy constructor.
+
+        It is best to avoid code paths that invoke this, because it creates
+        an extra temporary Lua reference. Typically this is done by passing
+        the Proxy parameter as a `const` reference.
+    */
+    Proxy (Proxy const& other)
+      : m_L (other.m_L)
+      , m_tableRef (other.m_tableRef)
+    {
+      // If this assert goes off it means code is taking this path,
+      // which is better avoided.
+      //
+      assert (0);
+
+      lua_rawgeti (m_L, LUA_REGISTRYINDEX, other.m_keyRef);
+      m_keyRef = luaL_ref (m_L, LUA_REGISTRYINDEX);
+    }
+
+    //--------------------------------------------------------------------------
+    /**
+        Destroy the proxy.
+
+        This does not destroy the table value.
+    */
+    ~Proxy ()
+    {
+      luaL_unref (m_L, LUA_REGISTRYINDEX, m_keyRef);
+    }
+
+    //--------------------------------------------------------------------------
+    /**
+        Return a reference to the table value.
+    */
+    int createRef () const
+    {
+      push (m_L);
+      return luaL_ref (m_L, LUA_REGISTRYINDEX);
+    }
+
+    //--------------------------------------------------------------------------
+    /**
+        Assign a new value to this table key.
+
+        This may invoke metamethods.
+    */
+    template <class T>
+    Proxy& operator= (T v)
+    {
+      StackPop p (m_L, 1);
+      lua_rawgeti (m_L, LUA_REGISTRYINDEX, m_tableRef);
+      lua_rawgeti (m_L, LUA_REGISTRYINDEX, m_keyRef);
+      Stack <T>::push (m_L, v);
+      lua_rawset (m_L, -3);
+      return *this;
+    }
+
+    //--------------------------------------------------------------------------
+    /**
+        Assign a new value to this table key.
+
+        The assignment is raw, no metamethods are invoked.
+    */
+    template <class T>
+    Proxy& rawset (T v)
+    {
+      StackPop p (m_L, 1);
+      lua_rawgeti (m_L, LUA_REGISTRYINDEX, m_tableRef);
+      lua_rawgeti (m_L, LUA_REGISTRYINDEX, m_keyRef);
+      Stack <T>::push (m_L, v);
+      lua_settable (m_L, -3);
+      return *this;
+    }
+
+    //==========================================================================
+    //
+    // This group of member functions mirrors the member functions in LuaRef.
+
+    /** Retrieve the lua_State associated with the table value.
+    */
+    lua_State* state () const
+    {
+      return m_L;
+    }
+
+    //--------------------------------------------------------------------------
+    /**
+        Push the value onto the Lua stack.
+    */
+    void push (lua_State* L) const
+    {
+      assert (equalstates (L, m_L));
+      lua_rawgeti (L, LUA_REGISTRYINDEX, m_tableRef);
+      lua_rawgeti (L, LUA_REGISTRYINDEX, m_keyRef);
+      lua_gettable (L, -2);
+      lua_remove (L, -2); // remove the table
+    }
+
+    //--------------------------------------------------------------------------
+    /**
+        Determine the object type.
+
+        The return values are the same as for `lua_type`.
+    */
+    int type () const
+    {
+      int result;
+      push (m_L);
+      result = lua_type (m_L, -1);
+      lua_pop (m_L, 1);
+      return result;
+    }
+
+    inline bool isNil () const { return type () == LUA_TNIL; }
+    inline bool isNumber () const { return type () == LUA_TNUMBER; }
+    inline bool isString () const { return type () == LUA_TSTRING; }
+    inline bool isTable () const { return type () == LUA_TTABLE; }
+    inline bool isFunction () const { return type () == LUA_TFUNCTION; }
+    inline bool isUserdata () const { return type () == LUA_TUSERDATA; }
+    inline bool isThread () const { return type () == LUA_TTHREAD; }
+    inline bool isLightUserdata () const { return type () == LUA_TLIGHTUSERDATA; }
+
+    //--------------------------------------------------------------------------
+    /**
+        Perform an explicit conversion.
+    */
+    template <class T>
+    T cast () const
+    {
+      StackPop p (m_L, 1);
+      push (m_L);
+
+      // lua_gettop is used because Userdata::getClass() doesn't handle
+      // negative stack indexes.
+      //
+      return Stack <T>::get (m_L, lua_gettop (m_L));
+    }
+
+    //--------------------------------------------------------------------------
+    /**
+        Universal implicit conversion operator.
+
+        NOTE: Visual Studio 2010 and 2012 have a bug where this function
+              is not used. See:
+
+        http://social.msdn.microsoft.com/Forums/en-US/vcgeneral/thread/e30b2664-a92d-445c-9db2-e8e0fbde2014
+        https://connect.microsoft.com/VisualStudio/feedback/details/771509/correct-code-doesnt-compile
+
+            // This code snippet fails to compile in vs2010,vs2012
+            struct S {
+              template <class T> inline operator T () const { return T (); }
+            };
+            int main () {
+              S () || false;
+              return 0;
+            }
+    */
+    template <class T>
+    inline operator T () const
+    {
+      return cast <T> ();
+    }
+
+    //--------------------------------------------------------------------------
+    /**
+        Universal comparison operators.
+    */
+    /** @{ */
+    template <class T>
+    bool operator== (T rhs) const
+    {
+      StackPop p (m_L, 2);
+      push (m_L);
+      Stack <T>::push (m_L, rhs);
+      return lua_compare (m_L, -2, -1, LUA_OPEQ) == 1;
+    }
+
+    template <class T>
+    bool operator< (T rhs) const
+    {
+      StackPop p (m_L, 2);
+      push (m_L);
+      Stack <T>::push (m_L, rhs);
+      return lua_compare (m_L, -2, -1, LUA_OPLT) == 1;
+    }
+
+    template <class T>
+    bool operator<= (T rhs) const
+    {
+      StackPop p (m_L, 2);
+      push (m_L);
+      Stack <T>::push (m_L, rhs);
+      return lua_compare (m_L, -2, -1, LUA_OPLE) == 1;
+    }
+
+    template <class T>
+    bool operator> (T rhs) const
+    {
+      StackPop p (m_L, 2);
+      push (m_L);
+      Stack <T>::push (m_L, rhs);
+      return lua_compare (m_L, -1, -2, LUA_OPLT) == 1;
+    }
+
+    template <class T>
+    bool operator>= (T rhs) const
+    {
+      StackPop p (m_L, 2);
+      push (m_L);
+      Stack <T>::push (m_L, rhs);
+      return lua_compare (m_L, -1, -2, LUA_OPLE) == 1;
+    }
+
+    template <class T>
+    bool rawequal (T rhs) const
+    {
+      StackPop p (m_L, 2);
+      push (m_L);
+      Stack <T>::push (m_L, rhs);
+      return lua_rawequal (m_L, -1, -2) == 1;
+    }
+    /** @} */
+
+    //--------------------------------------------------------------------------
+    /**
+        Access a table value using a key.
+
+        This invokes metamethods.
+    */
+    template <class T>
+    Proxy operator[] (T key) const
+    {
+      return LuaRef (*this) [key];
+    }
+
+    //--------------------------------------------------------------------------
+    /**
+        Access a table value using a key.
+
+        The operation is raw, metamethods are not invoked. The result is
+        passed by value and may not be modified.
+    */
+    template <class T>
+    LuaRef rawget (T key) const
+    {
+      StackPop (m_L, 1);
+      push (m_L);
+      Stack <T>::push (m_L, key);
+      lua_rawget (m_L, -2);
+      return LuaRef (m_L, FromStack ());
+    }
+
+    //--------------------------------------------------------------------------
+    /**
+        Append a value to the table.
+
+        If the table is a sequence this will add another element to it.
+    */
+    template <class T>
+    void append (T v) const
+    {
+      push (m_L);
+      Stack <T>::push (m_L, v);
+      luaL_ref (m_L, -2);
+      lua_pop (m_L, 1);
+    }
+
+    //--------------------------------------------------------------------------
+    /**
+        Call the length operator.
+
+        This is identical to applying the Lua # operator.
+    */
+    int length () const
+    {
+      StackPop p (m_L, 1);
+      push (m_L);
+      return get_length (m_L, -1);
+    }
+
+    //--------------------------------------------------------------------------
+    /**
+        Call Lua code.
+
+        These overloads allow Lua code to be called with up to 8 parameters.
+        The return value is provided as a LuaRef (which may be LUA_REFNIL).
+        If an error occurs, a LuaException is thrown.
+    */
+    /** @{ */
+    LuaRef const operator() () const
+    {
+      push (m_L);
+      LuaException::pcall (m_L, 0, 1);
+      return LuaRef (m_L, FromStack ());
+    }
+
+    template <class P1>
+    LuaRef const operator() (P1 p1) const
+    {
+      push (m_L);
+      Stack <P1>::push (m_L, p1);
+      LuaException::pcall (m_L, 1, 1);
+      return LuaRef (m_L, FromStack ());
+    }
+
+    template <class P1, class P2>
+    LuaRef const operator() (P1 p1, P2 p2) const
+    {
+      push (m_L);
+      Stack <P1>::push (m_L, p1);
+      Stack <P2>::push (m_L, p2);
+      LuaException::pcall (m_L, 2, 1);
+      return LuaRef (m_L, FromStack ());
+    }
+
+    template <class P1, class P2, class P3>
+    LuaRef const operator() (P1 p1, P2 p2, P3 p3) const
+    {
+      push (m_L);
+      Stack <P1>::push (m_L, p1);
+      Stack <P2>::push (m_L, p2);
+      Stack <P3>::push (m_L, p3);
+      LuaException::pcall (m_L, 3, 1);
+      return LuaRef (m_L, FromStack ());
+    }
+
+    template <class P1, class P2, class P3, class P4>
+    LuaRef const operator() (P1 p1, P2 p2, P3 p3, P4 p4) const
+    {
+      push (m_L);
+      Stack <P1>::push (m_L, p1);
+      Stack <P2>::push (m_L, p2);
+      Stack <P3>::push (m_L, p3);
+      Stack <P4>::push (m_L, p4);
+      LuaException::pcall (m_L, 4, 1);
+      return LuaRef (m_L, FromStack ());
+    }
+
+    template <class P1, class P2, class P3, class P4, class P5>
+    LuaRef const operator() (P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) const
+    {
+      push (m_L);
+      Stack <P1>::push (m_L, p1);
+      Stack <P2>::push (m_L, p2);
+      Stack <P3>::push (m_L, p3);
+      Stack <P4>::push (m_L, p4);
+      Stack <P5>::push (m_L, p5);
+      LuaException::pcall (m_L, 5, 1);
+      return LuaRef (m_L, FromStack ());
+    }
+
+    template <class P1, class P2, class P3, class P4, class P5, class P6>
+    LuaRef const operator() (P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) const
+    {
+      push (m_L);
+      Stack <P1>::push (m_L, p1);
+      Stack <P2>::push (m_L, p2);
+      Stack <P3>::push (m_L, p3);
+      Stack <P4>::push (m_L, p4);
+      Stack <P5>::push (m_L, p5);
+      Stack <P6>::push (m_L, p6);
+      LuaException::pcall (m_L, 6, 1);
+      return LuaRef (m_L, FromStack ());
+    }
+
+    template <class P1, class P2, class P3, class P4, class P5, class P6, class P7>
+    LuaRef const operator() (P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7) const
+    {
+      push (m_L);
+      Stack <P1>::push (m_L, p1);
+      Stack <P2>::push (m_L, p2);
+      Stack <P3>::push (m_L, p3);
+      Stack <P4>::push (m_L, p4);
+      Stack <P5>::push (m_L, p5);
+      Stack <P6>::push (m_L, p6);
+      Stack <P7>::push (m_L, p7);
+      LuaException::pcall (m_L, 7, 1);
+      return LuaRef (m_L, FromStack ());
+    }
+
+    template <class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8>
+    LuaRef const operator() (P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8) const
+    {
+      push (m_L);
+      Stack <P1>::push (m_L, p1);
+      Stack <P2>::push (m_L, p2);
+      Stack <P3>::push (m_L, p3);
+      Stack <P4>::push (m_L, p4);
+      Stack <P5>::push (m_L, p5);
+      Stack <P6>::push (m_L, p6);
+      Stack <P7>::push (m_L, p7);
+      Stack <P8>::push (m_L, p8);
+      LuaException::pcall (m_L, 8, 1);
+      return LuaRef (m_L, FromStack ());
+    }
+    /** @} */
+
+    //==========================================================================
+  };
+
+private:
+  friend struct Stack <LuaRef>;
+
+  //----------------------------------------------------------------------------
+  /**
+      Type tag for stack construction.
+  */
+  struct FromStack { };
+
+  //----------------------------------------------------------------------------
+  /**
+      Create a reference to an object at the top of the Lua stack and pop it.
+
+      This constructor is private and not invoked directly.
+      Instead, use the `fromStack` function.
+
+      @note The object is popped.
+  */
+  LuaRef (lua_State* L, FromStack)
+    : m_L (L)
+  {
+    m_ref = luaL_ref (m_L, LUA_REGISTRYINDEX);
+  }
+
+  //----------------------------------------------------------------------------
+  /**
+      Create a reference to an object on the Lua stack.
+
+      This constructor is private and not invoked directly.
+      Instead, use the `fromStack` function.
+
+      @note The object is not popped.
+  */
+  LuaRef (lua_State* L, int index, FromStack)
+    : m_L (L)
+  {
+    lua_pushvalue (m_L, index);
+    m_ref = luaL_ref (m_L, LUA_REGISTRYINDEX);
+  }
+
+  //----------------------------------------------------------------------------
+
+  // This type of construction is disallowed, since we don't have a `lua_State`.
+  //
+  template <class T>
+  LuaRef (T)
+  {
+  }
+
+  //----------------------------------------------------------------------------
+  /**
+      Create a reference to this ref.
+
+      This is used internally.
+  */
+  int createRef () const
+  {
+    if (m_ref != LUA_REFNIL)
+    {
+      push (m_L);
+      return luaL_ref (m_L, LUA_REGISTRYINDEX);
+    }
+    else
+    {
+      return LUA_REFNIL;
+    }
+  }
+
+public:
+  //----------------------------------------------------------------------------
+  /**
+      Create a nil reference.
+
+      The LuaRef may be assigned later.
+  */
+  LuaRef (lua_State* L)
+    : m_L (L)
+    , m_ref (LUA_REFNIL)
+  {
+  }
+
+  //----------------------------------------------------------------------------
+  /**
+      Create a reference to a value.
+  */
+  template <class T>
+  LuaRef (lua_State* L, T v)
+    : m_L (L)
+  {
+    Stack <T>::push (m_L, v);
+    m_ref = luaL_ref (m_L, LUA_REGISTRYINDEX);
+  }
+
+  //----------------------------------------------------------------------------
+  /**
+      Create a reference to a table value.
+  */
+  LuaRef (Proxy const& v)
+    : m_L (v.state ())
+    , m_ref (v.createRef ())
+  {
+  }
+
+  //----------------------------------------------------------------------------
+  /**
+      Create a new reference to an existing reference.
+  */
+  LuaRef (LuaRef const& other)
+    : m_L (other.m_L)
+    , m_ref (other.createRef ())
+  {
+  }
+
+  //----------------------------------------------------------------------------
+  /**
+      Destroy a reference.
+
+      The corresponding Lua registry reference will be released.
+
+      @note If the state refers to a thread, it is the responsibility of the
+            caller to ensure that the thread still exists when the LuaRef
+            is destroyed.
+  */
+  ~LuaRef ()
+  {
+    luaL_unref (m_L, LUA_REGISTRYINDEX, m_ref);
+  }
+
+  //----------------------------------------------------------------------------
+  /**
+      Return a LuaRef from a stack item.
+
+      The stack item is not popped.
+  */
+  static LuaRef fromStack (lua_State* L, int index)
+  {
+    lua_pushvalue (L, index);
+    return LuaRef (L, FromStack ());
+  }
+
+  //----------------------------------------------------------------------------
+  /**
+      Create a new empty table and return a reference to it.
+
+      It is also possible to use the free function `newTable`.
+
+      @see ::getGlobal
+  */
+  static LuaRef newTable (lua_State* L)
+  {
+    lua_newtable (L);
+    return LuaRef (L, FromStack ());
+  }
+
+  //----------------------------------------------------------------------------
+  /**
+      Return a reference to a named global.
+
+      It is also possible to use the free function `getGlobal`.
+
+      @see ::getGlobal
+  */
+  static LuaRef getGlobal (lua_State *L, char const* name)
+  {
+    lua_getglobal (L, name);
+    return LuaRef (L, FromStack ());
+  }
+
+  //----------------------------------------------------------------------------
+  /**
+      Assign a different value to this LuaRef.
+  */
+  template <class T>
+  LuaRef& operator= (T rhs)
+  {
+    luaL_unref (m_L, LUA_REGISTRYINDEX, m_ref);
+    Stack <T>::push (m_L, rhs);
+    m_ref = luaL_ref (m_L, LUA_REGISTRYINDEX);
+    return *this;
+  }
+
+  //----------------------------------------------------------------------------
+  /**
+      Assign another LuaRef to this LuaRef.
+  */
+  LuaRef& operator= (LuaRef const& rhs)
+  {
+    luaL_unref (m_L, LUA_REGISTRYINDEX, m_ref);
+    rhs.push (m_L);
+    m_L = rhs.state ();
+    m_ref = luaL_ref (m_L, LUA_REGISTRYINDEX);
+    return *this;
+  }
+
+  //----------------------------------------------------------------------------
+  /**
+      converts to a string using luas tostring function
+  */
+  std::string tostring() const
+  {
+    lua_getglobal (m_L, "tostring");
+    push (m_L);
+    lua_call (m_L, 1, 1);
+    const char* str = lua_tostring(m_L, 1);
+    lua_pop(m_L, 1);
+    return std::string(str);
+  }
+
+  //----------------------------------------------------------------------------
+  /**
+      Print a text description of the value to a stream.
+
+      This is used for diagnostics.
+  */
+  void print (std::ostream& os) const
+  {
+    switch (type ())
+    {
+    case LUA_TNIL:
+      os << "nil";
+      break;
+
+    case LUA_TNUMBER:
+      os << cast <lua_Number> ();
+      break;
+
+    case LUA_TBOOLEAN:
+      os << (cast <bool> () ? "true" : "false");
+      break;
+
+    case LUA_TSTRING:
+      os << '"' << cast <std::string> () << '"';
+      break;
+
+    case LUA_TTABLE:
+      os << "table: " << tostring();
+      break;
+
+    case LUA_TFUNCTION:
+      os << "function: " << tostring();
+      break;
+
+    case LUA_TUSERDATA:
+      os << "userdata: " << tostring();
+      break;
+
+    case LUA_TTHREAD:
+      os << "thread: " << tostring();
+      break;
+
+    case LUA_TLIGHTUSERDATA:
+      os << "lightuserdata: " << tostring();
+      break;
+
+    default:
+      os << "unknown";
+      break;
+    }
+  }
+
+  //============================================================================
+  //
+  // This group of member functions is mirrored in Proxy
+  //
+
+  /** Retrieve the lua_State associated with the reference.
+  */
+  lua_State* state () const
+  {
+    return m_L;
+  }
+
+  //----------------------------------------------------------------------------
+  /**
+      Place the object onto the Lua stack.
+  */
+  void push (lua_State* L) const
+  {
+    assert (equalstates (L, m_L));
+    lua_rawgeti (L, LUA_REGISTRYINDEX, m_ref);
+  }
+
+  //----------------------------------------------------------------------------
+  /**
+      Pop the top of Lua stack and assign the ref to m_ref
+  */
+  void pop (lua_State* L)
+  {
+    assert (equalstates (L, m_L));
+    luaL_unref (m_L, LUA_REGISTRYINDEX, m_ref);
+    m_ref = luaL_ref (m_L, LUA_REGISTRYINDEX);
+  }
+
+  //----------------------------------------------------------------------------
+  /**
+      Determine the object type.
+
+      The return values are the same as for `lua_type`.
+  */
+  /** @{ */
+  int type () const
+  {
+    int result;
+    if (m_ref != LUA_REFNIL)
+    {
+      push (m_L);
+      result = lua_type (m_L, -1);
+      lua_pop (m_L, 1);
+    }
+    else
+    {
+      result = LUA_TNIL;
+    }
+
+    return result;
+  }
+
+  // should never happen
+  //inline bool isNone () const { return m_ref == LUA_NOREF; }
+
+  inline bool isNil () const { return type () == LUA_TNIL; }
+  inline bool isNumber () const { return type () == LUA_TNUMBER; }
+  inline bool isString () const { return type () == LUA_TSTRING; }
+  inline bool isTable () const { return type () == LUA_TTABLE; }
+  inline bool isFunction () const { return type () == LUA_TFUNCTION; }
+  inline bool isUserdata () const { return type () == LUA_TUSERDATA; }
+  inline bool isThread () const { return type () == LUA_TTHREAD; }
+  inline bool isLightUserdata () const { return type () == LUA_TLIGHTUSERDATA; }
+  /** @} */
+
+  //----------------------------------------------------------------------------
+  /**
+      Perform an explicit conversion.
+  */
+  template <class T>
+  T cast () const
+  {
+    StackPop p (m_L, 1);
+    push (m_L);
+
+    // lua_gettop is used because Userdata::getClass() doesn't handle
+    // negative stack indexes.
+    //
+    return Stack <T>::get (m_L, lua_gettop (m_L));
+  }
+
+  //----------------------------------------------------------------------------
+  /**
+      Universal implicit conversion operator.
+
+      NOTE: Visual Studio 2010 and 2012 have a bug where this function
+            is not used. See:
+
+      http://social.msdn.microsoft.com/Forums/en-US/vcgeneral/thread/e30b2664-a92d-445c-9db2-e8e0fbde2014
+      https://connect.microsoft.com/VisualStudio/feedback/details/771509/correct-code-doesnt-compile
+
+          // This code snippet fails to compile in vs2010,vs2012
+          struct S {
+            template <class T> inline operator T () const { return T (); }
+          };
+          int main () {
+            S () || false;
+            return 0;
+          }
+  */
+  template <class T>
+  inline operator T () const
+  {
+    return cast <T> ();
+  }
+
+  //----------------------------------------------------------------------------
+  /**
+      Universal comparison operators.
+  */
+  /** @{ */
+  template <class T>
+  bool operator== (T rhs) const
+  {
+    StackPop p (m_L, 2);
+    push (m_L);
+    Stack <T>::push (m_L, rhs);
+    return lua_compare (m_L, -2, -1, LUA_OPEQ) == 1;
+  }
+
+  template <class T>
+  bool operator< (T rhs) const
+  {
+    StackPop p (m_L, 2);
+    push (m_L);
+    Stack <T>::push (m_L, rhs);
+    return lua_compare (m_L, -2, -1, LUA_OPLT) == 1;
+  }
+
+  template <class T>
+  bool operator<= (T rhs) const
+  {
+    StackPop p (m_L, 2);
+    push (m_L);
+    Stack <T>::push (m_L, rhs);
+    return lua_compare (m_L, -2, -1, LUA_OPLE) == 1;
+  }
+
+  template <class T>
+  bool operator> (T rhs) const
+  {
+    StackPop p (m_L, 2);
+    push (m_L);
+    Stack <T>::push (m_L, rhs);
+    return lua_compare (m_L, -1, -2, LUA_OPLT) == 1;
+  }
+
+  template <class T>
+  bool operator>= (T rhs) const
+  {
+    StackPop p (m_L, 2);
+    push (m_L);
+    Stack <T>::push (m_L, rhs);
+    return lua_compare (m_L, -1, -2, LUA_OPLE) == 1;
+  }
+
+  template <class T>
+  bool rawequal (T rhs) const
+  {
+    StackPop p (m_L, 2);
+    push (m_L);
+    Stack <T>::push (m_L, rhs);
+    return lua_rawequal (m_L, -1, -2) == 1;
+  }
+  /** @} */
+
+  //----------------------------------------------------------------------------
+  /**
+      Append a value to the table.
+
+      If the table is a sequence this will add another element to it.
+  */
+  template <class T>
+  void append (T v) const
+  {
+    push (m_L);
+    Stack <T>::push (m_L, v);
+    luaL_ref (m_L, -2);
+    lua_pop (m_L, 1);
+  }
+
+  //----------------------------------------------------------------------------
+  /**
+      Call the length operator.
+
+      This is identical to applying the Lua # operator.
+  */
+  int length () const
+  {
+    StackPop p (m_L, 1);
+    push (m_L);
+    return get_length (m_L, -1);
+  }
+
+  //----------------------------------------------------------------------------
+  /**
+      Access a table value using a key.
+
+      This invokes metamethods.
+  */
+  template <class T>
+  Proxy operator[] (T key) const
+  {
+    Stack <T>::push (m_L, key);
+    return Proxy (m_L, m_ref);
+  }
+
+  //----------------------------------------------------------------------------
+  /**
+      Call Lua code.
+
+      These overloads allow Lua code to be called with up to 8 parameters.
+      The return value is provided as a LuaRef (which may be LUA_REFNIL).
+      If an error occurs, a LuaException is thrown.
+  */
+  /** @{ */
+  LuaRef const operator() () const
+  {
+    push (m_L);
+    LuaException::pcall (m_L, 0, 1);
+    return LuaRef (m_L, FromStack ());
+  }
+
+  template <class P1>
+  LuaRef const operator() (P1 p1) const
+  {
+    push (m_L);
+    Stack <P1>::push (m_L, p1);
+    LuaException::pcall (m_L, 1, 1);
+    return LuaRef (m_L, FromStack ());
+  }
+
+  template <class P1, class P2>
+  LuaRef const operator() (P1 p1, P2 p2) const
+  {
+    push (m_L);
+    Stack <P1>::push (m_L, p1);
+    Stack <P2>::push (m_L, p2);
+    LuaException::pcall (m_L, 2, 1);
+    return LuaRef (m_L, FromStack ());
+  }
+
+  template <class P1, class P2, class P3>
+  LuaRef const operator() (P1 p1, P2 p2, P3 p3) const
+  {
+    push (m_L);
+    Stack <P1>::push (m_L, p1);
+    Stack <P2>::push (m_L, p2);
+    Stack <P3>::push (m_L, p3);
+    LuaException::pcall (m_L, 3, 1);
+    return LuaRef (m_L, FromStack ());
+  }
+
+  template <class P1, class P2, class P3, class P4>
+  LuaRef const operator() (P1 p1, P2 p2, P3 p3, P4 p4) const
+  {
+    push (m_L);
+    Stack <P1>::push (m_L, p1);
+    Stack <P2>::push (m_L, p2);
+    Stack <P3>::push (m_L, p3);
+    Stack <P4>::push (m_L, p4);
+    LuaException::pcall (m_L, 4, 1);
+    return LuaRef (m_L, FromStack ());
+  }
+
+  template <class P1, class P2, class P3, class P4, class P5>
+  LuaRef const operator() (P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) const
+  {
+    push (m_L);
+    Stack <P1>::push (m_L, p1);
+    Stack <P2>::push (m_L, p2);
+    Stack <P3>::push (m_L, p3);
+    Stack <P4>::push (m_L, p4);
+    Stack <P5>::push (m_L, p5);
+    LuaException::pcall (m_L, 5, 1);
+    return LuaRef (m_L, FromStack ());
+  }
+
+  template <class P1, class P2, class P3, class P4, class P5, class P6>
+  LuaRef const operator() (P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) const
+  {
+    push (m_L);
+    Stack <P1>::push (m_L, p1);
+    Stack <P2>::push (m_L, p2);
+    Stack <P3>::push (m_L, p3);
+    Stack <P4>::push (m_L, p4);
+    Stack <P5>::push (m_L, p5);
+    Stack <P6>::push (m_L, p6);
+    LuaException::pcall (m_L, 6, 1);
+    return LuaRef (m_L, FromStack ());
+  }
+
+  template <class P1, class P2, class P3, class P4, class P5, class P6, class P7>
+  LuaRef const operator() (P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7) const
+  {
+    push (m_L);
+    Stack <P1>::push (m_L, p1);
+    Stack <P2>::push (m_L, p2);
+    Stack <P3>::push (m_L, p3);
+    Stack <P4>::push (m_L, p4);
+    Stack <P5>::push (m_L, p5);
+    Stack <P6>::push (m_L, p6);
+    Stack <P7>::push (m_L, p7);
+    LuaException::pcall (m_L, 7, 1);
+    return LuaRef (m_L, FromStack ());
+  }
+
+  template <class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8>
+  LuaRef const operator() (P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8) const
+  {
+    push (m_L);
+    Stack <P1>::push (m_L, p1);
+    Stack <P2>::push (m_L, p2);
+    Stack <P3>::push (m_L, p3);
+    Stack <P4>::push (m_L, p4);
+    Stack <P5>::push (m_L, p5);
+    Stack <P6>::push (m_L, p6);
+    Stack <P7>::push (m_L, p7);
+    Stack <P8>::push (m_L, p8);
+    LuaException::pcall (m_L, 8, 1);
+    return LuaRef (m_L, FromStack ());
+  }
+  /** @} */
+
+  //============================================================================
+
+private:
+  lua_State* m_L;
+  int m_ref;
+};
+
+//------------------------------------------------------------------------------
+/**
+    Stack specialization for Nil
+*/
+template <>
+struct Stack <Nil>
+{
+public:
+  static inline void push (lua_State* L, Nil)
+  {
+    lua_pushnil (L);
+  }
+};
+
+//------------------------------------------------------------------------------
+/**
+    Stack specialization for LuaRef.
+*/
+template <>
+struct Stack <LuaRef>
+{
+public:
+  // The value is const& to prevent a copy construction.
+  //
+  static inline void push (lua_State* L, LuaRef const& v)
+  {
+    v.push (L);
+  }
+
+  static inline LuaRef get (lua_State* L, int index)
+  {
+    return LuaRef (L, index, LuaRef::FromStack ());
+  }
+};
+
+//------------------------------------------------------------------------------
+/**
+    Stack specialization for Proxy.
+*/
+template <>
+struct Stack <LuaRef::Proxy>
+{
+public:
+  // The value is const& to prevent a copy construction.
+  //
+  static inline void push (lua_State* L, LuaRef::Proxy const& v)
+  {
+    v.push (L);
+  }
+};
+
+//------------------------------------------------------------------------------
+/**
+    Create a reference to a new, empty table.
+
+    This is a syntactic abbreviation for LuaRef::newTable().
+*/
+inline LuaRef newTable (lua_State* L)
+{
+  return LuaRef::newTable (L);
+}
+
+//------------------------------------------------------------------------------
+/**
+    Create a reference to a value in the global table.
+
+    This is a syntactic abbreviation for LuaRef::getGlobal().
+*/
+inline LuaRef getGlobal (lua_State *L, char const* name)
+{
+  return LuaRef::getGlobal (L, name);
+}
+
+//------------------------------------------------------------------------------
+/**
+    Write a LuaRef to a stream.
+
+    This allows LuaRef and table proxies to work with streams.
+*/
+inline std::ostream& operator<< (std::ostream& os, LuaRef const& ref)
+{
+  ref.print (os);
+  return os;
+}
+
+//------------------------------------------------------------------------------
+
+// more C++-like cast syntax
+//
+template<class T>
+inline T LuaRef_cast(LuaRef const& lr)
+{
+  return lr.cast<T>();
+}
diff --git a/extern/LuaBridge/detail/Namespace.h b/extern/LuaBridge/detail/Namespace.h
new file mode 100644
index 000000000..ff22e6b09
--- /dev/null
+++ b/extern/LuaBridge/detail/Namespace.h
@@ -0,0 +1,1136 @@
+//------------------------------------------------------------------------------
+/*
+  https://github.com/vinniefalco/LuaBridge
+  
+  Copyright 2012, Vinnie Falco <vinnie.falco@gmail.com>
+  Copyright 2007, Nathan Reed
+
+  License: The MIT License (http://www.opensource.org/licenses/mit-license.php)
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+//==============================================================================
+
+/** Provides C++ to Lua registration capabilities.
+
+    This class is not instantiated directly, call `getGlobalNamespace` to start
+    the registration process.
+*/
+class Namespace
+{
+private:
+  Namespace& operator= (Namespace const& other);
+
+  lua_State* const L;
+  int mutable m_stackSize;
+
+private:
+  //============================================================================
+  /**
+    Error reporting.
+
+    VF: This function looks handy, why aren't we using it?
+  */
+#if 0
+  static int luaError (lua_State* L, std::string message)
+  {
+    assert (lua_isstring (L, lua_upvalueindex (1)));
+    std::string s;
+
+    // Get information on the caller's caller to format the message,
+    // so the error appears to originate from the Lua source.
+    lua_Debug ar;
+    int result = lua_getstack (L, 2, &ar);
+    if (result != 0)
+    {
+      lua_getinfo (L, "Sl", &ar);
+      s = ar.short_src;
+      if (ar.currentline != -1)
+      {
+        // poor mans int to string to avoid <strstrream>.
+        lua_pushnumber (L, ar.currentline);
+        s = s + ":" + lua_tostring (L, -1) + ": ";
+        lua_pop (L, 1);
+      }
+    }
+
+    s = s + message;
+
+    return luaL_error (L, s.c_str ());
+  }
+#endif
+
+  //----------------------------------------------------------------------------
+  /**
+    Pop the Lua stack.
+  */
+  void pop (int n) const
+  {
+    if (m_stackSize >= n && lua_gettop (L) >= n)
+    {
+      lua_pop (L, n);
+      m_stackSize -= n;
+    }
+    else
+    {
+      throw std::logic_error ("invalid stack");
+    }
+  }
+
+private:
+  /**
+    Factored base to reduce template instantiations.
+  */
+  class ClassBase
+  {
+  private:
+    ClassBase& operator= (ClassBase const& other);
+
+  protected:
+    friend class Namespace;
+
+    lua_State* const L;
+    int mutable m_stackSize;
+
+  protected:
+    //--------------------------------------------------------------------------
+    /**
+      __index metamethod for a class.
+
+      This implements member functions, data members, and property members.
+      Functions are stored in the metatable and const metatable. Data members
+      and property members are in the __propget table.
+
+      If the key is not found, the search proceeds up the hierarchy of base
+      classes.
+    */
+    static int indexMetaMethod (lua_State* L)
+    {
+      int result = 0;
+
+      assert (lua_isuserdata (L, 1));               // warn on security bypass
+      lua_getmetatable (L, 1);                      // get metatable for object
+      for (;;)
+      {
+        lua_pushvalue (L, 2);                       // push key arg2
+        lua_rawget (L, -2);                         // lookup key in metatable
+        if (lua_iscfunction (L, -1))                // ensure its a cfunction
+        {
+          lua_remove (L, -2);                       // remove metatable
+          result = 1;
+          break;
+        }
+        else if (lua_isnil (L, -1))
+        {
+          lua_pop (L, 1);
+        }
+        else
+        {
+          lua_pop (L, 2);
+          throw std::logic_error ("not a cfunction");
+        }
+
+        rawgetfield (L, -1, "__propget");           // get __propget table
+        if (lua_istable (L, -1))                    // ensure it is a table
+        {
+          lua_pushvalue (L, 2);                     // push key arg2
+          lua_rawget (L, -2);                       // lookup key in __propget
+          lua_remove (L, -2);                       // remove __propget
+          if (lua_iscfunction (L, -1))              // ensure its a cfunction
+          {
+            lua_remove (L, -2);                     // remove metatable
+            lua_pushvalue (L, 1);                   // push class arg1
+            lua_call (L, 1, 1);
+            result = 1;
+            break;
+          }
+          else if (lua_isnil (L, -1))
+          {
+            lua_pop (L, 1);
+          }
+          else
+          {
+            lua_pop (L, 2);
+
+            // We only put cfunctions into __propget.
+            throw std::logic_error ("not a cfunction");
+          }
+        }
+        else
+        {
+          lua_pop (L, 2);
+
+          // __propget is missing, or not a table.
+          throw std::logic_error ("missing __propget table");
+        }
+
+        // Repeat the lookup in the __parent metafield,
+        // or return nil if the field doesn't exist.
+        rawgetfield (L, -1, "__parent");
+        if (lua_istable (L, -1))
+        {
+          // Remove metatable and repeat the search in __parent.
+          lua_remove (L, -2);
+        }
+        else if (lua_isnil (L, -1))
+        {
+          result = 1;
+          break;
+        }
+        else
+        {
+          lua_pop (L, 2);
+
+          throw std::logic_error ("__parent is not a table");
+        }
+      }
+
+      return result;
+    }
+
+    //--------------------------------------------------------------------------
+    /**
+      __newindex metamethod for classes.
+
+      This supports writable variables and properties on class objects. The
+      corresponding object is passed in the first parameter to the set function.
+    */
+    static int newindexMetaMethod (lua_State* L)
+    {
+      int result = 0;
+
+      lua_getmetatable (L, 1);
+
+      for (;;)
+      {
+        // Check __propset
+        rawgetfield (L, -1, "__propset");
+        if (!lua_isnil (L, -1))
+        {
+          lua_pushvalue (L, 2);
+          lua_rawget (L, -2);
+          if (!lua_isnil (L, -1))
+          {
+            // found it, call the setFunction.
+            assert (lua_isfunction (L, -1));
+            lua_pushvalue (L, 1);
+            lua_pushvalue (L, 3);
+            lua_call (L, 2, 0);
+            result = 0;
+            break;
+          }
+          lua_pop (L, 1);
+        }
+        lua_pop (L, 1);
+
+        // Repeat the lookup in the __parent metafield.
+        rawgetfield (L, -1, "__parent");
+        if (lua_isnil (L, -1))
+        {
+          // Either the property or __parent must exist.
+          result = luaL_error (L,
+            "no member named '%s'", lua_tostring (L, 2));
+        }
+        lua_remove (L, -2);
+      }
+
+      return result;
+    }
+
+    //--------------------------------------------------------------------------
+    /**
+      Create the const table.
+    */
+    void createConstTable (char const* name)
+    {
+      lua_newtable (L);
+      lua_pushvalue (L, -1);
+      lua_setmetatable (L, -2);
+      lua_pushboolean (L, 1);
+      lua_rawsetp (L, -2, getIdentityKey ());
+      lua_pushstring (L, (std::string ("const ") + name).c_str ());
+      rawsetfield (L, -2, "__type");
+      lua_pushcfunction (L, &indexMetaMethod);
+      rawsetfield (L, -2, "__index");
+      lua_pushcfunction (L, &newindexMetaMethod);
+      rawsetfield (L, -2, "__newindex");
+      lua_newtable (L);
+      rawsetfield (L, -2, "__propget");
+      
+      if (Security::hideMetatables ())
+      {
+        lua_pushnil (L);
+        rawsetfield (L, -2, "__metatable");
+      }
+    }
+
+    //--------------------------------------------------------------------------
+    /**
+      Create the class table.
+
+      The Lua stack should have the const table on top.
+    */
+    void createClassTable (char const* name)
+    {
+      lua_newtable (L);
+      lua_pushvalue (L, -1);
+      lua_setmetatable (L, -2);
+      lua_pushboolean (L, 1);
+      lua_rawsetp (L, -2, getIdentityKey ());
+      lua_pushstring (L, name);
+      rawsetfield (L, -2, "__type");
+      lua_pushcfunction (L, &indexMetaMethod);
+      rawsetfield (L, -2, "__index");
+      lua_pushcfunction (L, &newindexMetaMethod);
+      rawsetfield (L, -2, "__newindex");
+      lua_newtable (L);
+      rawsetfield (L, -2, "__propget");
+      lua_newtable (L);
+      rawsetfield (L, -2, "__propset");
+
+      lua_pushvalue (L, -2);
+      rawsetfield (L, -2, "__const"); // point to const table
+
+      lua_pushvalue (L, -1);
+      rawsetfield (L, -3, "__class"); // point const table to class table
+
+      if (Security::hideMetatables ())
+      {
+        lua_pushnil (L);
+        rawsetfield (L, -2, "__metatable");
+      }
+    }
+
+    //--------------------------------------------------------------------------
+    /**
+      Create the static table.
+
+      The Lua stack should have:
+        -1 class table
+        -2 const table
+        -3 enclosing namespace
+    */
+    void createStaticTable (char const* name)
+    {
+      lua_newtable (L);
+      lua_newtable (L);
+      lua_pushvalue (L, -1);
+      lua_setmetatable (L, -3);
+      lua_insert (L, -2);
+      rawsetfield (L, -5, name);
+
+#if 0
+      lua_pushlightuserdata (L, this);
+      lua_pushcclosure (L, &tostringMetaMethod, 1);
+      rawsetfield (L, -2, "__tostring");
+#endif
+      lua_pushcfunction (L, &CFunc::indexMetaMethod);
+      rawsetfield (L, -2, "__index");
+      lua_pushcfunction (L, &CFunc::newindexMetaMethod);
+      rawsetfield (L, -2, "__newindex");
+      lua_newtable (L);
+      rawsetfield (L, -2, "__propget");
+      lua_newtable (L);
+      rawsetfield (L, -2, "__propset");
+
+      lua_pushvalue (L, -2);
+      rawsetfield (L, -2, "__class"); // point to class table
+
+      if (Security::hideMetatables ())
+      {
+        lua_pushnil (L);
+        rawsetfield (L, -2, "__metatable");
+      }
+    }
+
+    //==========================================================================
+    /**
+      lua_CFunction to construct a class object wrapped in a container.
+    */
+    template <class Params, class C>
+    static int ctorContainerProxy (lua_State* L)
+    {
+      typedef typename ContainerTraits <C>::Type T;
+      ArgList <Params, 2> args (L);
+      T* const p = Constructor <T, Params>::call (args);
+      UserdataSharedHelper <C, false>::push (L, p);
+      return 1;
+    }
+
+    //--------------------------------------------------------------------------
+    /**
+      lua_CFunction to construct a class object in-place in the userdata.
+    */
+    template <class Params, class T>
+    static int ctorPlacementProxy (lua_State* L)
+    {
+      ArgList <Params, 2> args (L);
+      Constructor <T, Params>::call (UserdataValue <T>::place (L), args);
+      return 1;
+    }
+
+    //--------------------------------------------------------------------------
+    /**
+      Pop the Lua stack.
+    */
+    void pop (int n) const
+    {
+      if (m_stackSize >= n && lua_gettop (L) >= n)
+      {
+        lua_pop (L, n);
+        m_stackSize -= n;
+      }
+      else
+      {
+        throw std::logic_error ("invalid stack");
+      }
+    }
+
+  public:
+    //--------------------------------------------------------------------------
+    explicit ClassBase (lua_State* L_)
+      : L (L_)
+      , m_stackSize (0)
+    {
+    }
+
+    //--------------------------------------------------------------------------
+    /**
+      Copy Constructor.
+    */
+    ClassBase (ClassBase const& other)
+      : L (other.L)
+      , m_stackSize (0)
+    {
+      m_stackSize = other.m_stackSize;
+      other.m_stackSize = 0;
+    }
+
+    ~ClassBase ()
+    {
+      pop (m_stackSize);
+    }
+  };
+
+  //============================================================================
+  //
+  // Class
+  //
+  //============================================================================
+  /**
+    Provides a class registration in a lua_State.
+
+    After contstruction the Lua stack holds these objects:
+      -1 static table
+      -2 class table
+      -3 const table
+      -4 (enclosing namespace)
+  */
+  template <class T>
+  class Class : public ClassBase
+  {
+  public:
+    //==========================================================================
+    /**
+      Register a new class or add to an existing class registration.
+    */
+    Class (char const* name, Namespace const* parent) : ClassBase (parent->L)
+    {
+      m_stackSize = parent->m_stackSize + 3;
+      parent->m_stackSize = 0;
+
+      assert (lua_istable (L, -1));
+      rawgetfield (L, -1, name);
+      
+      if (lua_isnil (L, -1))
+      {
+        lua_pop (L, 1);
+
+        createConstTable (name);
+        lua_pushcfunction (L, &CFunc::gcMetaMethod <T>);
+        rawsetfield (L, -2, "__gc");
+
+        createClassTable (name);
+        lua_pushcfunction (L, &CFunc::gcMetaMethod <T>);
+        rawsetfield (L, -2, "__gc");
+
+        createStaticTable (name);
+
+        // Map T back to its tables.
+        lua_pushvalue (L, -1);
+        lua_rawsetp (L, LUA_REGISTRYINDEX, ClassInfo <T>::getStaticKey ());
+        lua_pushvalue (L, -2);
+        lua_rawsetp (L, LUA_REGISTRYINDEX, ClassInfo <T>::getClassKey ());
+        lua_pushvalue (L, -3);
+        lua_rawsetp (L, LUA_REGISTRYINDEX, ClassInfo <T>::getConstKey ());
+      }
+      else
+      {
+        rawgetfield (L, -1, "__class");
+        rawgetfield (L, -1, "__const");
+
+        // Reverse the top 3 stack elements
+        lua_insert (L, -3);
+        lua_insert (L, -2);
+      }
+    }
+
+    //==========================================================================
+    /**
+      Derive a new class.
+    */
+    Class (char const* name, Namespace const* parent, void const* const staticKey)
+      : ClassBase (parent->L)
+    {
+      m_stackSize = parent->m_stackSize + 3;
+      parent->m_stackSize = 0;
+
+      assert (lua_istable (L, -1));
+
+      createConstTable (name);
+      lua_pushcfunction (L, &CFunc::gcMetaMethod <T>);
+      rawsetfield (L, -2, "__gc");
+
+      createClassTable (name);
+      lua_pushcfunction (L, &CFunc::gcMetaMethod <T>);
+      rawsetfield (L, -2, "__gc");
+
+      createStaticTable (name);
+
+      lua_rawgetp (L, LUA_REGISTRYINDEX, staticKey);
+      assert (lua_istable (L, -1));
+      rawgetfield (L, -1, "__class");
+      assert (lua_istable (L, -1));
+      rawgetfield (L, -1, "__const");
+      assert (lua_istable (L, -1));
+
+      rawsetfield (L, -6, "__parent");
+      rawsetfield (L, -4, "__parent");
+      rawsetfield (L, -2, "__parent");
+
+      lua_pushvalue (L, -1);
+      lua_rawsetp (L, LUA_REGISTRYINDEX, ClassInfo <T>::getStaticKey ());
+      lua_pushvalue (L, -2);
+      lua_rawsetp (L, LUA_REGISTRYINDEX, ClassInfo <T>::getClassKey ());
+      lua_pushvalue (L, -3);
+      lua_rawsetp (L, LUA_REGISTRYINDEX, ClassInfo <T>::getConstKey ());
+    }
+
+    //--------------------------------------------------------------------------
+    /**
+      Continue registration in the enclosing namespace.
+    */
+    Namespace endClass ()
+    {
+      return Namespace (this);
+    }
+
+    //--------------------------------------------------------------------------
+    /**
+      Add or replace a static data member.
+    */
+    template <class U>
+    Class <T>& addStaticData (char const* name, U* pu, bool isWritable = true)
+    {
+      assert (lua_istable (L, -1));
+
+      rawgetfield (L, -1, "__propget");
+      assert (lua_istable (L, -1));
+      lua_pushlightuserdata (L, pu);
+      lua_pushcclosure (L, &CFunc::getVariable <U>, 1);
+      rawsetfield (L, -2, name);
+      lua_pop (L, 1);
+
+      rawgetfield (L, -1, "__propset");
+      assert (lua_istable (L, -1));
+      if (isWritable)
+      {
+        lua_pushlightuserdata (L, pu);
+        lua_pushcclosure (L, &CFunc::setVariable <U>, 1);
+      }
+      else
+      {
+        lua_pushstring (L, name);
+        lua_pushcclosure (L, &CFunc::readOnlyError, 1);
+      }
+      rawsetfield (L, -2, name);
+      lua_pop (L, 1);
+
+      return *this;
+    }
+
+    //--------------------------------------------------------------------------
+    /**
+      Add or replace a static property member.
+
+      If the set function is null, the property is read-only.
+    */
+    template <class U>
+    Class <T>& addStaticProperty (char const* name, U (*get)(), void (*set)(U) = 0)
+    {
+      typedef U (*get_t)();
+      typedef void (*set_t)(U);
+      
+      assert (lua_istable (L, -1));
+
+      rawgetfield (L, -1, "__propget");
+      assert (lua_istable (L, -1));
+      new (lua_newuserdata (L, sizeof (get))) get_t (get);
+      lua_pushcclosure (L, &CFunc::Call <U (*) (void)>::f, 1);
+      rawsetfield (L, -2, name);
+      lua_pop (L, 1);
+
+      rawgetfield (L, -1, "__propset");
+      assert (lua_istable (L, -1));
+      if (set != 0)
+      {
+        new (lua_newuserdata (L, sizeof (set))) set_t (set);
+        lua_pushcclosure (L, &CFunc::Call <void (*) (U)>::f, 1);
+      }
+      else
+      {
+        lua_pushstring (L, name);
+        lua_pushcclosure (L, &CFunc::readOnlyError, 1);
+      }
+      rawsetfield (L, -2, name);
+      lua_pop (L, 1);
+
+      return *this;
+    }
+
+    //--------------------------------------------------------------------------
+    /**
+      Add or replace a static member function.
+    */
+    template <class FP>
+    Class <T>& addStaticFunction (char const* name, FP const fp)
+    {
+      new (lua_newuserdata (L, sizeof (fp))) FP (fp);
+      lua_pushcclosure (L, &CFunc::Call <FP>::f, 1);
+      rawsetfield (L, -2, name);
+
+      return *this;
+    }
+
+    //--------------------------------------------------------------------------
+    /**
+      Add or replace a lua_CFunction.
+    */
+    Class <T>& addStaticCFunction (char const* name, int (*const fp)(lua_State*))
+    {
+      lua_pushcfunction (L, fp);
+      rawsetfield (L, -2, name);
+      return *this;
+    }
+
+    //--------------------------------------------------------------------------
+    /**
+      Add or replace a data member.
+    */
+    template <class U>
+    Class <T>& addData (char const* name, const U T::* mp, bool isWritable = true)
+    {
+      typedef const U T::*mp_t;
+
+      // Add to __propget in class and const tables.
+      {
+        rawgetfield (L, -2, "__propget");
+        rawgetfield (L, -4, "__propget");
+        new (lua_newuserdata (L, sizeof (mp_t))) mp_t (mp);
+        lua_pushcclosure (L, &CFunc::getProperty <T,U>, 1);
+        lua_pushvalue (L, -1);
+        rawsetfield (L, -4, name);
+        rawsetfield (L, -2, name);
+        lua_pop (L, 2);
+      }
+
+      if (isWritable)
+      {
+        // Add to __propset in class table.
+        rawgetfield (L, -2, "__propset");
+        assert (lua_istable (L, -1));
+        new (lua_newuserdata (L, sizeof (mp_t))) mp_t (mp);
+        lua_pushcclosure (L, &CFunc::setProperty <T,U>, 1);
+        rawsetfield (L, -2, name);
+        lua_pop (L, 1);
+      }
+
+      return *this;
+    }
+
+    //--------------------------------------------------------------------------
+    /**
+      Add or replace a property member.
+    */
+    template <class TG, class TS>
+    Class <T>& addProperty (char const* name, TG (T::* get) () const, void (T::* set) (TS))
+    {
+      // Add to __propget in class and const tables.
+      {
+        rawgetfield (L, -2, "__propget");
+        rawgetfield (L, -4, "__propget");
+        typedef TG (T::*get_t) () const;
+        new (lua_newuserdata (L, sizeof (get_t))) get_t (get);
+        lua_pushcclosure (L, &CFunc::CallConstMember <get_t>::f, 1);
+        lua_pushvalue (L, -1);
+        rawsetfield (L, -4, name);
+        rawsetfield (L, -2, name);
+        lua_pop (L, 2);
+      }
+
+      {
+        // Add to __propset in class table.
+        rawgetfield (L, -2, "__propset");
+        assert (lua_istable (L, -1));
+        typedef void (T::* set_t) (TS);
+        new (lua_newuserdata (L, sizeof (set_t))) set_t (set);
+        lua_pushcclosure (L, &CFunc::CallMember <set_t>::f, 1);
+        rawsetfield (L, -2, name);
+        lua_pop (L, 1);
+      }
+
+      return *this;
+    }
+
+    // read-only
+    template <class TG>
+    Class <T>& addProperty (char const* name, TG (T::* get) () const)
+    {
+      // Add to __propget in class and const tables.
+      rawgetfield (L, -2, "__propget");
+      rawgetfield (L, -4, "__propget");
+      typedef TG (T::*get_t) () const;
+      new (lua_newuserdata (L, sizeof (get_t))) get_t (get);
+      lua_pushcclosure (L, &CFunc::CallConstMember <get_t>::f, 1);
+      lua_pushvalue (L, -1);
+      rawsetfield (L, -4, name);
+      rawsetfield (L, -2, name);
+      lua_pop (L, 2);
+
+      return *this;
+    }
+
+    //--------------------------------------------------------------------------
+    /**
+      Add or replace a property member, by proxy.
+
+      When a class is closed for modification and does not provide (or cannot
+      provide) the function signatures necessary to implement get or set for
+      a property, this will allow non-member functions act as proxies.
+
+      Both the get and the set functions require a T const* and T* in the first
+      argument respectively.
+    */
+    template <class TG, class TS>
+    Class <T>& addProperty (char const* name, TG (*get) (T const*), void (*set) (T*, TS))
+    {
+      // Add to __propget in class and const tables.
+      {
+        rawgetfield (L, -2, "__propget");
+        rawgetfield (L, -4, "__propget");
+        typedef TG (*get_t) (T const*);
+        new (lua_newuserdata (L, sizeof (get_t))) get_t (get);
+        lua_pushcclosure (L, &CFunc::Call <get_t>::f, 1);
+        lua_pushvalue (L, -1);
+        rawsetfield (L, -4, name);
+        rawsetfield (L, -2, name);
+        lua_pop (L, 2);
+      }
+
+      if (set != 0)
+      {
+        // Add to __propset in class table.
+        rawgetfield (L, -2, "__propset");
+        assert (lua_istable (L, -1));
+        typedef void (*set_t) (T*, TS);
+        new (lua_newuserdata (L, sizeof (set_t))) set_t (set);
+        lua_pushcclosure (L, &CFunc::Call <set_t>::f, 1);
+        rawsetfield (L, -2, name);
+        lua_pop (L, 1);
+      }
+
+      return *this;
+    }
+
+    // read-only
+    template <class TG, class TS>
+    Class <T>& addProperty (char const* name, TG (*get) (T const*))
+    {
+      // Add to __propget in class and const tables.
+      rawgetfield (L, -2, "__propget");
+      rawgetfield (L, -4, "__propget");
+      typedef TG (*get_t) (T const*);
+      new (lua_newuserdata (L, sizeof (get_t))) get_t (get);
+      lua_pushcclosure (L, &CFunc::Call <get_t>::f, 1);
+      lua_pushvalue (L, -1);
+      rawsetfield (L, -4, name);
+      rawsetfield (L, -2, name);
+      lua_pop (L, 2);
+
+      return *this;
+    }
+
+    //--------------------------------------------------------------------------
+    /**
+        Add or replace a member function.
+    */
+    template <class MemFn>
+    Class <T>& addFunction (char const* name, MemFn mf)
+    {
+      CFunc::CallMemberFunctionHelper <MemFn, FuncTraits <MemFn>::isConstMemberFunction>::add (L, name, mf);
+      return *this;
+    }
+
+    //--------------------------------------------------------------------------
+    /**
+        Add or replace a member lua_CFunction.
+    */
+    Class <T>& addCFunction (char const* name, int (T::*mfp)(lua_State*))
+    {
+      typedef int (T::*MFP)(lua_State*);
+      assert (lua_istable (L, -1));
+      new (lua_newuserdata (L, sizeof (mfp))) MFP (mfp);
+      lua_pushcclosure (L, &CFunc::CallMemberCFunction <T>::f, 1);
+      rawsetfield (L, -3, name); // class table
+
+      return *this;
+    }
+
+    //--------------------------------------------------------------------------
+    /**
+        Add or replace a const member lua_CFunction.
+    */
+    Class <T>& addCFunction (char const* name, int (T::*mfp)(lua_State*) const)
+    {
+      typedef int (T::*MFP)(lua_State*) const;
+      assert (lua_istable (L, -1));
+      new (lua_newuserdata (L, sizeof (mfp))) MFP (mfp);
+      lua_pushcclosure (L, &CFunc::CallConstMemberCFunction <T>::f, 1);
+      lua_pushvalue (L, -1);
+      rawsetfield (L, -5, name); // const table
+      rawsetfield (L, -3, name); // class table
+
+      return *this;
+    }
+
+    //--------------------------------------------------------------------------
+    /**
+      Add or replace a primary Constructor.
+
+      The primary Constructor is invoked when calling the class type table
+      like a function.
+
+      The template parameter should be a function pointer type that matches
+      the desired Constructor (since you can't take the address of a Constructor
+      and pass it as an argument).
+    */
+    template <class MemFn, class C>
+    Class <T>& addConstructor ()
+    {
+      lua_pushcclosure (L,
+        &ctorContainerProxy <typename FuncTraits <MemFn>::Params, C>, 0);
+      rawsetfield(L, -2, "__call");
+
+      return *this;
+    }
+
+    template <class MemFn>
+    Class <T>& addConstructor ()
+    {
+      lua_pushcclosure (L,
+        &ctorPlacementProxy <typename FuncTraits <MemFn>::Params, T>, 0);
+      rawsetfield(L, -2, "__call");
+
+      return *this;
+    }
+  };
+
+private:
+  //----------------------------------------------------------------------------
+  /**
+      Open the global namespace for registrations.
+  */
+  explicit Namespace (lua_State* L_)
+    : L (L_)
+    , m_stackSize (0)
+  {
+    lua_getglobal (L, "_G");
+    ++m_stackSize;
+  }
+
+  //----------------------------------------------------------------------------
+  /**
+      Open a namespace for registrations.
+
+      The namespace is created if it doesn't already exist.
+      The parent namespace is at the top of the Lua stack.
+  */
+  Namespace (char const* name, Namespace const* parent)
+    : L (parent->L)
+    , m_stackSize (0)
+  {
+    m_stackSize = parent->m_stackSize + 1;
+    parent->m_stackSize = 0;
+
+    assert (lua_istable (L, -1));
+    rawgetfield (L, -1, name);
+    if (lua_isnil (L, -1))
+    {
+      lua_pop (L, 1);
+
+      lua_newtable (L);
+      lua_pushvalue (L, -1);
+      lua_setmetatable (L, -2);
+      lua_pushcfunction (L, &CFunc::indexMetaMethod);
+      rawsetfield (L, -2, "__index");
+      lua_pushcfunction (L, &CFunc::newindexMetaMethod);
+      rawsetfield (L, -2, "__newindex");
+      lua_newtable (L);
+      rawsetfield (L, -2, "__propget");
+      lua_newtable (L);
+      rawsetfield (L, -2, "__propset");
+      lua_pushvalue (L, -1);
+      rawsetfield (L, -3, name);
+#if 0
+      lua_pushcfunction (L, &tostringMetaMethod);
+      rawsetfield (L, -2, "__tostring");
+#endif
+    }
+  }
+
+  //----------------------------------------------------------------------------
+  /**
+      Creates a continued registration from a child namespace.
+  */
+  explicit Namespace (Namespace const* child)
+    : L (child->L)
+    , m_stackSize (0)
+  {
+    m_stackSize = child->m_stackSize - 1;
+    child->m_stackSize = 1;
+    child->pop (1);
+
+    // It is not necessary or valid to call
+    // endNamespace() for the global namespace!
+    //
+    assert (m_stackSize != 0);
+  }
+
+  //----------------------------------------------------------------------------
+  /**
+      Creates a continued registration from a child class.
+  */
+  explicit Namespace (ClassBase const* child)
+    : L (child->L)
+    , m_stackSize (0)
+  {
+    m_stackSize = child->m_stackSize - 3;
+    child->m_stackSize = 3;
+    child->pop (3);
+  }
+
+public:
+  //----------------------------------------------------------------------------
+  /**
+      Copy Constructor.
+
+      Ownership of the stack is transferred to the new object. This happens
+      when the compiler emits temporaries to hold these objects while chaining
+      registrations across namespaces.
+  */
+  Namespace (Namespace const& other) : L (other.L)
+  {
+    m_stackSize = other.m_stackSize;
+    other.m_stackSize = 0;
+  }
+
+  //----------------------------------------------------------------------------
+  /**
+      Closes this namespace registration.
+  */
+  ~Namespace ()
+  {
+    pop (m_stackSize);
+  }
+
+  //----------------------------------------------------------------------------
+  /**
+      Open the global namespace.
+  */
+  static Namespace getGlobalNamespace (lua_State* L)
+  {
+    return Namespace (L);
+  }
+
+  //----------------------------------------------------------------------------
+  /**
+      Open a new or existing namespace for registrations.
+  */
+  Namespace beginNamespace (char const* name)
+  {
+    return Namespace (name, this);
+  }
+
+  //----------------------------------------------------------------------------
+  /**
+      Continue namespace registration in the parent.
+
+      Do not use this on the global namespace.
+  */
+  Namespace endNamespace ()
+  {
+    return Namespace (this);
+  }
+
+  //----------------------------------------------------------------------------
+  /**
+      Add or replace a variable.
+  */
+  template <class T>
+  Namespace& addVariable (char const* name, T* pt, bool isWritable = true)
+  {
+    assert (lua_istable (L, -1));
+
+    rawgetfield (L, -1, "__propget");
+    assert (lua_istable (L, -1));
+    lua_pushlightuserdata (L, pt);
+    lua_pushcclosure (L, &CFunc::getVariable <T>, 1);
+    rawsetfield (L, -2, name);
+    lua_pop (L, 1);
+
+    rawgetfield (L, -1, "__propset");
+    assert (lua_istable (L, -1));
+    if (isWritable)
+    {
+      lua_pushlightuserdata (L, pt);
+      lua_pushcclosure (L, &CFunc::setVariable <T>, 1);
+    }
+    else
+    {
+      lua_pushstring (L, name);
+      lua_pushcclosure (L, &CFunc::readOnlyError, 1);
+    }
+    rawsetfield (L, -2, name);
+    lua_pop (L, 1);
+
+    return *this;
+  }
+  
+  //----------------------------------------------------------------------------
+  /**
+      Add or replace a property.
+
+      If the set function is omitted or null, the property is read-only.
+  */
+  template <class TG, class TS>
+  Namespace& addProperty (char const* name, TG (*get) (), void (*set)(TS) = 0)
+  {
+    assert (lua_istable (L, -1));
+
+    rawgetfield (L, -1, "__propget");
+    assert (lua_istable (L, -1));
+    typedef TG (*get_t) ();
+    new (lua_newuserdata (L, sizeof (get_t))) get_t (get);
+    lua_pushcclosure (L, &CFunc::Call <TG (*) (void)>::f, 1);
+    rawsetfield (L, -2, name);
+    lua_pop (L, 1);
+
+    rawgetfield (L, -1, "__propset");
+    assert (lua_istable (L, -1));
+    if (set != 0)
+    {
+      typedef void (*set_t) (TS);
+      new (lua_newuserdata (L, sizeof (set_t))) set_t (set);
+      lua_pushcclosure (L, &CFunc::Call <void (*) (TS)>::f, 1);
+    }
+    else
+    {
+      lua_pushstring (L, name);
+      lua_pushcclosure (L, &CFunc::readOnlyError, 1);
+    }
+    rawsetfield (L, -2, name);
+    lua_pop (L, 1);
+
+    return *this;
+  }
+
+  //----------------------------------------------------------------------------
+  /**
+      Add or replace a free function.
+  */
+  template <class FP>
+  Namespace& addFunction (char const* name, FP const fp)
+  {
+    assert (lua_istable (L, -1));
+
+    new (lua_newuserdata (L, sizeof (fp))) FP (fp);
+    lua_pushcclosure (L, &CFunc::Call <FP>::f, 1);
+    rawsetfield (L, -2, name);
+
+    return *this;
+  }
+
+  //----------------------------------------------------------------------------
+  /**
+      Add or replace a lua_CFunction.
+  */
+  Namespace& addCFunction (char const* name, int (*const fp)(lua_State*))
+  {
+    lua_pushcfunction (L, fp);
+    rawsetfield (L, -2, name);
+
+    return *this;
+  }
+
+  //----------------------------------------------------------------------------
+  /**
+      Open a new or existing class for registrations.
+  */
+  template <class T>
+  Class <T> beginClass (char const* name)
+  {
+    return Class <T> (name, this);
+  }
+
+  //----------------------------------------------------------------------------
+  /**
+      Derive a new class for registrations.
+
+      To continue registrations for the class later, use beginClass().
+      Do not call deriveClass() again.
+  */
+  template <class T, class U>
+  Class <T> deriveClass (char const* name)
+  {
+    return Class <T> (name, this, ClassInfo <U>::getStaticKey ());
+  }
+};
+
+//------------------------------------------------------------------------------
+/**
+    Retrieve the global namespace.
+
+    It is recommended to put your namespace inside the global namespace, and
+    then add your classes and functions to it, rather than adding many classes
+    and functions directly to the global namespace.
+*/
+inline Namespace getGlobalNamespace (lua_State* L)
+{
+  return Namespace::getGlobalNamespace (L);
+}
diff --git a/extern/LuaBridge/detail/Stack.h b/extern/LuaBridge/detail/Stack.h
new file mode 100644
index 000000000..d10fa8a2c
--- /dev/null
+++ b/extern/LuaBridge/detail/Stack.h
@@ -0,0 +1,469 @@
+//------------------------------------------------------------------------------
+/*
+  https://github.com/vinniefalco/LuaBridge
+
+  Copyright 2012, Vinnie Falco <vinnie.falco@gmail.com>
+  Copyright 2007, Nathan Reed
+
+  License: The MIT License (http://www.opensource.org/licenses/mit-license.php)
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+//==============================================================================
+
+//------------------------------------------------------------------------------
+/**
+    Receive the lua_State* as an argument.
+*/
+template <>
+struct Stack <lua_State*>
+{
+  static lua_State* get (lua_State* L, int)
+  {
+    return L;
+  }
+};
+
+//------------------------------------------------------------------------------
+/**
+    Push a lua_CFunction.
+*/
+template <>
+struct Stack <lua_CFunction>
+{
+  static void push (lua_State* L, lua_CFunction f)
+  {
+    lua_pushcfunction (L, f);
+  }
+
+  static lua_CFunction get (lua_State* L, int index)
+  {
+    return lua_tocfunction (L, index);
+  }
+};
+
+//------------------------------------------------------------------------------
+/**
+    Stack specialization for `int`.
+*/
+template <>
+struct Stack <int>
+{
+  static inline void push (lua_State* L, int value)
+  {
+    lua_pushinteger (L, static_cast <lua_Integer> (value));
+  }
+  
+  static inline int get (lua_State* L, int index)
+  {
+    return static_cast <int> (luaL_checkinteger (L, index));
+  }
+};
+
+template <>
+struct Stack <int const&>
+{
+  static inline void push (lua_State* L, int value)
+  {
+    lua_pushnumber (L, static_cast <lua_Number> (value));
+  }
+  
+  static inline int get (lua_State* L, int index)
+  {
+    return static_cast <int > (luaL_checknumber (L, index));
+  }
+};
+//------------------------------------------------------------------------------
+/**
+    Stack specialization for `unsigned int`.
+*/
+template <>
+struct Stack <unsigned int>
+{
+  static inline void push (lua_State* L, unsigned int value)
+  {
+    lua_pushinteger (L, static_cast <lua_Integer> (value));
+  }
+  
+  static inline unsigned int get (lua_State* L, int index)
+  {
+    return static_cast <unsigned int> (luaL_checkinteger (L, index));
+  }
+};
+
+template <>
+struct Stack <unsigned int const&>
+{
+  static inline void push (lua_State* L, unsigned int value)
+  {
+    lua_pushnumber (L, static_cast <lua_Number> (value));
+  }
+  
+  static inline unsigned int get (lua_State* L, int index)
+  {
+    return static_cast <unsigned int > (luaL_checknumber (L, index));
+  }
+};
+
+//------------------------------------------------------------------------------
+/**
+    Stack specialization for `unsigned char`.
+*/
+template <>
+struct Stack <unsigned char>
+{
+  static inline void push (lua_State* L, unsigned char value)
+  {
+    lua_pushinteger (L, static_cast <lua_Integer> (value));
+  }
+  
+  static inline unsigned char get (lua_State* L, int index)
+  {
+    return static_cast <unsigned char> (luaL_checkinteger (L, index));
+  }
+};
+
+template <>
+struct Stack <unsigned char const&>
+{
+  static inline void push (lua_State* L, unsigned char value)
+  {
+    lua_pushnumber (L, static_cast <lua_Number> (value));
+  }
+  
+  static inline unsigned char get (lua_State* L, int index)
+  {
+    return static_cast <unsigned char> (luaL_checknumber (L, index));
+  }
+};
+
+//------------------------------------------------------------------------------
+/**
+    Stack specialization for `short`.
+*/
+template <>
+struct Stack <short>
+{
+  static inline void push (lua_State* L, short value)
+  {
+    lua_pushinteger (L, static_cast <lua_Integer> (value));
+  }
+  
+  static inline short get (lua_State* L, int index)
+  {
+    return static_cast <short> (luaL_checkinteger (L, index));
+  }
+};
+
+template <>
+struct Stack <short const&>
+{
+  static inline void push (lua_State* L, short value)
+  {
+    lua_pushnumber (L, static_cast <lua_Number> (value));
+  }
+  
+  static inline short get (lua_State* L, int index)
+  {
+    return static_cast <short> (luaL_checknumber (L, index));
+  }
+};
+
+//------------------------------------------------------------------------------
+/**
+    Stack specialization for `unsigned short`.
+*/
+template <>
+struct Stack <unsigned short>
+{
+  static inline void push (lua_State* L, unsigned short value)
+  {
+    lua_pushinteger (L, static_cast <lua_Integer> (value));
+  }
+  
+  static inline unsigned short get (lua_State* L, int index)
+  {
+    return static_cast <unsigned short> (luaL_checkinteger (L, index));
+  }
+};
+
+template <>
+struct Stack <unsigned short const&>
+{
+  static inline void push (lua_State* L, unsigned short value)
+  {
+    lua_pushnumber (L, static_cast <lua_Number> (value));
+  }
+  
+  static inline unsigned short get (lua_State* L, int index)
+  {
+    return static_cast <unsigned short> (luaL_checknumber (L, index));
+  }
+};
+
+//------------------------------------------------------------------------------
+/**
+    Stack specialization for `long`.
+*/
+template <>
+struct Stack <long>
+{
+  static inline void push (lua_State* L, long value)
+  {
+    lua_pushinteger (L, static_cast <lua_Integer> (value));
+  }
+  
+  static inline long get (lua_State* L, int index)
+  {
+    return static_cast <long> (luaL_checkinteger (L, index));
+  }
+};
+
+template <>
+struct Stack <long const&>
+{
+  static inline void push (lua_State* L, long value)
+  {
+    lua_pushnumber (L, static_cast <lua_Number> (value));
+  }
+  
+  static inline long get (lua_State* L, int index)
+  {
+    return static_cast <long> (luaL_checknumber (L, index));
+  }
+};
+
+//------------------------------------------------------------------------------
+/**
+    Stack specialization for `unsigned long`.
+*/
+template <>
+struct Stack <unsigned long>
+{
+  static inline void push (lua_State* L, unsigned long value)
+  {
+    lua_pushinteger (L, static_cast <lua_Integer> (value));
+  }
+  
+  static inline unsigned long get (lua_State* L, int index)
+  {
+    return static_cast <unsigned long> (luaL_checkinteger (L, index));
+  }
+};
+
+template <>
+struct Stack <unsigned long const&>
+{
+  static inline void push (lua_State* L, unsigned long value)
+  {
+    lua_pushnumber (L, static_cast <lua_Number> (value));
+  }
+  
+  static inline unsigned long get (lua_State* L, int index)
+  {
+    return static_cast <unsigned long> (luaL_checknumber (L, index));
+  }
+};
+
+//------------------------------------------------------------------------------
+/**
+    Stack specialization for `float`.
+*/
+template <>
+struct Stack <float>
+{
+  static inline void push (lua_State* L, float value)
+  {
+    lua_pushnumber (L, static_cast <lua_Number> (value));
+  }
+  
+  static inline float get (lua_State* L, int index)
+  {
+    return static_cast <float> (luaL_checknumber (L, index));
+  }
+};
+
+template <>
+struct Stack <float const&>
+{
+  static inline void push (lua_State* L, float value)
+  {
+    lua_pushnumber (L, static_cast <lua_Number> (value));
+  }
+  
+  static inline float get (lua_State* L, int index)
+  {
+    return static_cast <float> (luaL_checknumber (L, index));
+  }
+};
+
+//------------------------------------------------------------------------------
+/**
+    Stack specialization for `double`.
+*/
+template <> struct Stack <double>
+{
+  static inline void push (lua_State* L, double value)
+  {
+    lua_pushnumber (L, static_cast <lua_Number> (value));
+  }
+  
+  static inline double get (lua_State* L, int index)
+  {
+    return static_cast <double> (luaL_checknumber (L, index));
+  }
+};
+
+template <> struct Stack <double const&>
+{
+  static inline void push (lua_State* L, double value)
+  {
+    lua_pushnumber (L, static_cast <lua_Number> (value));
+  }
+  
+  static inline double get (lua_State* L, int index)
+  {
+    return static_cast <double> (luaL_checknumber (L, index));
+  }
+};
+
+//------------------------------------------------------------------------------
+/**
+    Stack specialization for `bool`.
+*/
+template <>
+struct Stack <bool> {
+  static inline void push (lua_State* L, bool value)
+  {
+    lua_pushboolean (L, value ? 1 : 0);
+  }
+  
+  static inline bool get (lua_State* L, int index)
+  {
+    return lua_toboolean (L, index) ? true : false;
+  }
+};
+
+template <>
+struct Stack <bool const&> {
+  static inline void push (lua_State* L, bool value)
+  {
+    lua_pushboolean (L, value ? 1 : 0);
+  }
+  
+  static inline bool get (lua_State* L, int index)
+  {
+    return lua_toboolean (L, index) ? true : false;
+  }
+};
+
+//------------------------------------------------------------------------------
+/**
+    Stack specialization for `char`.
+*/
+template <>
+struct Stack <char>
+{
+  static inline void push (lua_State* L, char value)
+  {
+    char str [2] = { value, 0 };
+    lua_pushstring (L, str);
+  }
+  
+  static inline char get (lua_State* L, int index)
+  {
+    return luaL_checkstring (L, index) [0];
+  }
+};
+
+template <>
+struct Stack <char const&>
+{
+  static inline void push (lua_State* L, char value)
+  {
+    char str [2] = { value, 0 };
+    lua_pushstring (L, str);
+  }
+  
+  static inline char get (lua_State* L, int index)
+  {
+    return luaL_checkstring (L, index) [0];
+  }
+};
+
+//------------------------------------------------------------------------------
+/**
+    Stack specialization for `float`.
+*/
+template <>
+struct Stack <char const*>
+{
+  static inline void push (lua_State* L, char const* str)
+  {
+    if (str != 0)
+      lua_pushstring (L, str);
+    else
+      lua_pushnil (L);
+  }
+
+  static inline char const* get (lua_State* L, int index)
+  {
+    return lua_isnil (L, index) ? 0 : luaL_checkstring (L, index);
+  }
+};
+
+//------------------------------------------------------------------------------
+/**
+    Stack specialization for `std::string`.
+*/
+template <>
+struct Stack <std::string>
+{
+  static inline void push (lua_State* L, std::string const& str)
+  {
+    lua_pushlstring (L, str.c_str (), str.size());
+  }
+
+  static inline std::string get (lua_State* L, int index)
+  {
+    size_t len;
+    const char *str = luaL_checklstring(L, index, &len);
+    return std::string (str, len);
+  }
+};
+
+//------------------------------------------------------------------------------
+/**
+    Stack specialization for `std::string const&`.
+*/
+template <>
+struct Stack <std::string const&>
+{
+  static inline void push (lua_State* L, std::string const& str)
+  {
+    lua_pushlstring (L, str.c_str(), str.size());
+  }
+
+  static inline std::string get (lua_State* L, int index)
+  {
+    size_t len;
+    const char *str = luaL_checklstring(L, index, &len);
+    return std::string (str, len);
+  }
+};
diff --git a/extern/LuaBridge/detail/TypeList.h b/extern/LuaBridge/detail/TypeList.h
new file mode 100644
index 000000000..21f850e89
--- /dev/null
+++ b/extern/LuaBridge/detail/TypeList.h
@@ -0,0 +1,174 @@
+//------------------------------------------------------------------------------
+/*
+  https://github.com/vinniefalco/LuaBridge
+  
+  Copyright 2012, Vinnie Falco <vinnie.falco@gmail.com>
+  Copyright 2007, Nathan Reed
+
+  License: The MIT License (http://www.opensource.org/licenses/mit-license.php)
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+
+  This file incorporates work covered by the following copyright and
+  permission notice:  
+
+    The Loki Library
+    Copyright (c) 2001 by Andrei Alexandrescu
+    This code accompanies the book:
+    Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design 
+        Patterns Applied". Copyright (c) 2001. Addison-Wesley.
+    Permission to use, copy, modify, distribute and sell this software for any 
+        purpose is hereby granted without fee, provided that the above copyright 
+        notice appear in all copies and that both that copyright notice and this 
+        permission notice appear in supporting documentation.
+    The author or Addison-Welsey Longman make no representations about the 
+        suitability of this software for any purpose. It is provided "as is" 
+        without express or implied warranty.
+*/
+//==============================================================================
+
+/**
+  None type means void parameters or return value.
+*/
+typedef void None;
+
+template <typename Head, typename Tail = None>
+struct TypeList
+{
+};
+
+/**
+  A TypeList with actual values.
+*/
+template <typename List>
+struct TypeListValues
+{
+  static std::string const tostring (bool)
+  {
+    return "";
+  }
+};
+
+/**
+  TypeListValues recursive template definition.
+*/
+template <typename Head, typename Tail>
+struct TypeListValues <TypeList <Head, Tail> >
+{
+  Head hd;
+  TypeListValues <Tail> tl;
+
+  TypeListValues (Head hd_, TypeListValues <Tail> const& tl_)
+    : hd (hd_), tl (tl_)
+  {
+  }
+
+  static std::string const tostring (bool comma = false)
+  {
+    std::string s;
+
+    if (comma)
+      s = ", ";
+
+    s = s + typeid (Head).name ();
+
+    return s + TypeListValues <Tail>::tostring (true);
+  }
+};
+
+// Specializations of type/value list for head types that are references and
+// const-references.  We need to handle these specially since we can't count
+// on the referenced object hanging around for the lifetime of the list.
+
+template <typename Head, typename Tail>
+struct TypeListValues <TypeList <Head&, Tail> >
+{
+  Head hd;
+  TypeListValues <Tail> tl;
+
+  TypeListValues (Head& hd_, TypeListValues <Tail> const& tl_)
+    : hd (hd_), tl (tl_)
+  {
+  }
+
+  static std::string const tostring (bool comma = false)
+  {
+    std::string s;
+
+    if (comma)
+      s = ", ";
+
+    s = s + typeid (Head).name () + "&";
+
+    return s + TypeListValues <Tail>::tostring (true);
+  }
+};
+
+template <typename Head, typename Tail>
+struct TypeListValues <TypeList <Head const&, Tail> >
+{
+  Head hd;
+  TypeListValues <Tail> tl;
+
+  TypeListValues (Head const& hd_, const TypeListValues <Tail>& tl_)
+    : hd (hd_), tl (tl_)
+  {
+  }
+
+  static std::string const tostring (bool comma = false)
+  {
+    std::string s;
+
+    if (comma)
+      s = ", ";
+
+    s = s + typeid (Head).name () + " const&";
+
+    return s + TypeListValues <Tail>::tostring (true);
+  }
+};
+
+//==============================================================================
+/**
+  Subclass of a TypeListValues constructable from the Lua stack.
+*/
+
+template <typename List, int Start = 1>
+struct ArgList
+{
+};
+
+template <int Start>
+struct ArgList <None, Start> : public TypeListValues <None>
+{
+  ArgList (lua_State*)
+  {
+  }
+};
+
+template <typename Head, typename Tail, int Start>
+struct ArgList <TypeList <Head, Tail>, Start>
+  : public TypeListValues <TypeList <Head, Tail> >
+{
+  ArgList (lua_State* L)
+    : TypeListValues <TypeList <Head, Tail> > (Stack <Head>::get (L, Start),
+                                            ArgList <Tail, Start + 1> (L))
+  {
+  }
+};
diff --git a/extern/LuaBridge/detail/TypeTraits.h b/extern/LuaBridge/detail/TypeTraits.h
new file mode 100644
index 000000000..5dd077194
--- /dev/null
+++ b/extern/LuaBridge/detail/TypeTraits.h
@@ -0,0 +1,125 @@
+//------------------------------------------------------------------------------
+/*
+  https://github.com/vinniefalco/LuaBridge
+  
+  Copyright 2012, Vinnie Falco <vinnie.falco@gmail.com>
+
+  License: The MIT License (http://www.opensource.org/licenses/mit-license.php)
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+//==============================================================================
+
+#ifndef LUABRIDGE_TYPEINFO_HEADER
+#define LUABRIDGE_TYPEINFO_HEADER
+
+//------------------------------------------------------------------------------
+/**
+    Container traits.
+
+    Unspecialized ContainerTraits has the isNotContainer typedef for SFINAE.
+    All user defined containers must supply an appropriate specialization for
+    ContinerTraits (without the typedef isNotContainer). The containers that
+    come with LuaBridge also come with the appropriate ContainerTraits
+    specialization. See the corresponding declaration for details.
+
+    A specialization of ContainerTraits for some generic type ContainerType
+    looks like this:
+
+        template <class T>
+        struct ContainerTraits <ContainerType <T> >
+        {
+          typedef typename T Type;
+
+          static T* get (ContainerType <T> const& c)
+          {
+            return c.get (); // Implementation-dependent on ContainerType
+          }
+        };
+*/
+template <class T>
+struct ContainerTraits
+{
+  typedef bool isNotContainer;
+};
+
+//------------------------------------------------------------------------------
+/**
+    Type traits.
+
+    Specializations return information about a type.
+*/
+struct TypeTraits
+{
+  /** Determine if type T is a container.
+
+      To be considered a container, there must be a specialization of
+      ContainerTraits with the required fields.
+  */
+  template <typename T>
+  class isContainer
+  {
+  private:
+    typedef char yes[1]; // sizeof (yes) == 1
+    typedef char no [2]; // sizeof (no)  == 2
+
+    template <typename C>
+    static no& test (typename C::isNotContainer*);
+ 
+    template <typename>
+    static yes& test (...);
+ 
+  public:
+    static const bool value = sizeof (test <ContainerTraits <T> >(0)) == sizeof (yes);
+  };
+
+  /** Determine if T is const qualified.
+  */
+  /** @{ */
+  template <class T>
+  struct isConst
+  {
+    static bool const value = false;
+  };
+
+  template <class T>
+  struct isConst <T const>
+  {
+    static bool const value = true;
+  };
+  /** @} */
+
+  /** Remove the const qualifier from T.
+  */
+  /** @{ */
+  template <class T>
+  struct removeConst
+  {
+    typedef T Type;
+  };
+
+  template <class T>
+  struct removeConst <T const>
+  {
+    typedef T Type;
+  };
+  /**@}*/
+};
+
+#endif
diff --git a/extern/LuaBridge/detail/Userdata.h b/extern/LuaBridge/detail/Userdata.h
new file mode 100644
index 000000000..19451bd7d
--- /dev/null
+++ b/extern/LuaBridge/detail/Userdata.h
@@ -0,0 +1,817 @@
+//------------------------------------------------------------------------------
+/*
+  https://github.com/vinniefalco/LuaBridge
+  
+  Copyright 2012, Vinnie Falco <vinnie.falco@gmail.com>
+
+  License: The MIT License (http://www.opensource.org/licenses/mit-license.php)
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+//==============================================================================
+
+//==============================================================================
+/**
+  Return the identity pointer for our lightuserdata tokens.
+
+  LuaBridge metatables are tagged with a security "token." The token is a
+  lightuserdata created from the identity pointer, used as a key in the
+  metatable. The value is a boolean = true, although any value could have been
+  used.
+
+  Because of Lua's dynamic typing and our improvised system of imposing C++
+  class structure, there is the possibility that executing scripts may
+  knowingly or unknowingly cause invalid data to get passed to the C functions
+  created by LuaBridge. In particular, our security model addresses the
+  following:
+
+  Notes:
+    1. Scripts cannot create a userdata (ignoring the debug lib).
+    2. Scripts cannot create a lightuserdata (ignoring the debug lib).
+    3. Scripts cannot set the metatable on a userdata.
+    4. Our identity key is a unique pointer in the process.
+    5. Our metatables have a lightuserdata identity key / value pair.
+    6. Our metatables have "__metatable" set to a boolean = false.
+    7. Our lightuserdata is unique.
+*/
+inline void* getIdentityKey ()
+{
+  static char value;
+  return &value;
+}
+
+/**
+  Interface to a class pointer retrievable from a userdata.
+*/
+class Userdata
+{
+protected:
+  void* m_p; // subclasses must set this
+
+  //--------------------------------------------------------------------------
+  /**
+    Get an untyped pointer to the contained class.
+  */
+  inline void* const getPointer ()
+  {
+    return m_p;
+  }
+
+private:
+  //--------------------------------------------------------------------------
+  /**
+    Validate and retrieve a Userdata on the stack.
+
+    The Userdata must exactly match the corresponding class table or
+    const table, or else a Lua error is raised. This is used for the
+    __gc metamethod.
+  */
+  static Userdata* getExactClass (lua_State* L,
+                                  int narg,
+                                  void const* classKey)
+  {
+    Userdata* ud = 0;
+    int const index = lua_absindex (L, narg);
+
+    bool mismatch = false;
+    char const* got = 0;
+
+    lua_rawgetp (L, LUA_REGISTRYINDEX, classKey);
+    assert (lua_istable (L, -1));
+
+    // Make sure we have a userdata.
+    if (!lua_isuserdata (L, index))
+      mismatch = true;
+
+    // Make sure it's metatable is ours.
+    if (!mismatch)
+    {
+      lua_getmetatable (L, index);
+      lua_rawgetp (L, -1, getIdentityKey ());
+      if (lua_isboolean (L, -1))
+      {
+        lua_pop (L, 1);
+      }
+      else
+      {
+        lua_pop (L, 2);
+        mismatch = true;
+      }      
+    }
+
+    if (!mismatch)
+    {
+      if (lua_rawequal (L, -1, -2))
+      {
+        // Matches class table.
+        lua_pop (L, 2);
+        ud = static_cast <Userdata*> (lua_touserdata (L, index));
+      }
+      else
+      {
+        rawgetfield (L, -2, "__const");
+        if (lua_rawequal (L, -1, -2))
+        {
+          // Matches const table
+          lua_pop (L, 3);
+          ud = static_cast <Userdata*> (lua_touserdata (L, index));
+        }
+        else
+        {
+          // Mismatch, but its one of ours so get a type name.
+          rawgetfield (L, -2, "__type");
+          lua_insert (L, -4);
+          lua_pop (L, 2);
+          got = lua_tostring (L, -2);
+          mismatch = true;
+        }
+      }
+    }
+
+    if (mismatch)
+    {
+      rawgetfield (L, -1, "__type");
+      assert (lua_type (L, -1) == LUA_TSTRING);
+      char const* const expected = lua_tostring (L, -1);
+
+      if (got == 0)
+        got = lua_typename (L, lua_type (L, index));
+
+      char const* const msg = lua_pushfstring (
+        L, "%s expected, got %s", expected, got);
+
+      if (narg > 0)
+        luaL_argerror (L, narg, msg);
+      else
+        lua_error (L);
+    }
+
+    return ud;
+  }
+
+  //--------------------------------------------------------------------------
+  /**
+    Validate and retrieve a Userdata on the stack.
+
+    The Userdata must be derived from or the same as the given base class,
+    identified by the key. If canBeConst is false, generates an error if
+    the resulting Userdata represents to a const object. We do the type check
+    first so that the error message is informative.
+  */
+  static Userdata* getClass (lua_State* L,
+                             int index,
+                             void const* baseClassKey,
+                             bool canBeConst)
+  {
+    assert (index > 0);
+    Userdata* ud = 0;
+
+    bool mismatch = false;
+    char const* got = 0;
+
+    lua_rawgetp (L, LUA_REGISTRYINDEX, baseClassKey);
+    assert (lua_istable (L, -1));
+
+    // Make sure we have a userdata.
+    if (lua_isuserdata (L, index))
+    {
+      // Make sure it's metatable is ours.
+      lua_getmetatable (L, index);
+      lua_rawgetp (L, -1, getIdentityKey ());
+      if (lua_isboolean (L, -1))
+      {
+        lua_pop (L, 1);
+
+        // If __const is present, object is NOT const.
+        rawgetfield (L, -1, "__const");
+        assert (lua_istable (L, -1) || lua_isnil (L, -1));
+        bool const isConst = lua_isnil (L, -1);
+        lua_pop (L, 1);
+
+        // Replace the class table with the const table if needed.
+        if (isConst)
+        {
+          rawgetfield (L, -2, "__const");
+          assert (lua_istable (L, -1));
+          lua_replace (L, -3);
+        }
+
+        for (;;)
+        {
+          if (lua_rawequal (L, -1, -2))
+          {
+            lua_pop (L, 2);
+
+            // Match, now check const-ness.
+            if (isConst && !canBeConst)
+            {
+              luaL_argerror (L, index, "cannot be const");
+            }
+            else
+            {
+              ud = static_cast <Userdata*> (lua_touserdata (L, index));
+              break;
+            }
+          }
+          else
+          {
+            // Replace current metatable with it's base class.
+            rawgetfield (L, -1, "__parent");
+/*
+ud
+class metatable
+ud metatable
+ud __parent (nil)
+*/
+
+            if (lua_isnil (L, -1))
+            {
+              lua_remove (L, -1);
+              // Mismatch, but its one of ours so get a type name.
+              rawgetfield (L, -1, "__type");
+              lua_insert (L, -3);
+              lua_pop (L, 1);
+              got = lua_tostring (L, -2);
+              mismatch = true;
+              break;
+            }
+            else
+            {
+              lua_remove (L, -2);
+            }
+          }
+        }
+      }
+      else
+      {
+        lua_pop (L, 2);
+        mismatch = true;
+      }      
+    }
+    else
+    {
+      mismatch = true;
+    }
+
+    if (mismatch)
+    {
+      assert (lua_type (L, -1) == LUA_TTABLE);
+      rawgetfield (L, -1, "__type");
+      assert (lua_type (L, -1) == LUA_TSTRING);
+      char const* const expected = lua_tostring (L, -1);
+
+      if (got == 0)
+        got = lua_typename (L, lua_type (L, index));
+
+      char const* const msg = lua_pushfstring (
+        L, "%s expected, got %s", expected, got);
+
+      luaL_argerror (L, index, msg);
+    }
+
+    return ud;
+  }
+
+public:
+  virtual ~Userdata () { }
+
+  //--------------------------------------------------------------------------
+  /**
+    Returns the Userdata* if the class on the Lua stack matches.
+
+    If the class does not match, a Lua error is raised.
+  */
+  template <class T>
+  static inline Userdata* getExact (lua_State* L, int index)
+  {
+    return getExactClass (L, index, ClassInfo <T>::getClassKey ());
+  }
+
+  //--------------------------------------------------------------------------
+  /**
+    Get a pointer to the class from the Lua stack.
+
+    If the object is not the class or a subclass, or it violates the
+    const-ness, a Lua error is raised.
+  */
+  template <class T>
+  static inline T* get (lua_State* L, int index, bool canBeConst)
+  {
+    if (lua_isnil (L, index))
+      return 0;
+    else
+      return static_cast <T*> (getClass (L, index,
+        ClassInfo <T>::getClassKey (), canBeConst)->getPointer ());
+  }
+};
+
+//----------------------------------------------------------------------------
+/**
+  Wraps a class object stored in a Lua userdata.
+
+  The lifetime of the object is managed by Lua. The object is constructed
+  inside the userdata using placement new.
+*/
+template <class T>
+class UserdataValue : public Userdata
+{
+private:
+  UserdataValue <T> (UserdataValue <T> const&);
+  UserdataValue <T> operator= (UserdataValue <T> const&);
+
+  char m_storage [sizeof (T)];
+
+  inline T* getObject ()
+  {
+    // If this fails to compile it means you forgot to provide
+    // a Container specialization for your container!
+    //
+    return reinterpret_cast <T*> (&m_storage [0]);
+  }
+
+private:
+  /**
+    Used for placement construction.
+  */
+  UserdataValue ()
+  {
+    m_p = getObject ();
+  }
+
+  ~UserdataValue ()
+  {
+    getObject ()->~T ();
+  }
+
+public:
+  /**
+    Push a T via placement new.
+
+    The caller is responsible for calling placement new using the
+    returned uninitialized storage.
+  */
+  static void* place (lua_State* const L)
+  {
+    UserdataValue <T>* const ud = new (
+      lua_newuserdata (L, sizeof (UserdataValue <T>))) UserdataValue <T> ();
+    lua_rawgetp (L, LUA_REGISTRYINDEX, ClassInfo <T>::getClassKey ());
+    // If this goes off it means you forgot to register the class!
+    assert (lua_istable (L, -1));
+    lua_setmetatable (L, -2);
+    return ud->getPointer ();
+  }
+
+  /**
+    Push T via copy construction from U.
+  */
+  template <class U>
+  static inline void push (lua_State* const L, U const& u)
+  {
+    new (place (L)) U (u);
+  }
+};
+
+//----------------------------------------------------------------------------
+/**
+  Wraps a pointer to a class object inside a Lua userdata.
+
+  The lifetime of the object is managed by C++.
+*/
+class UserdataPtr : public Userdata
+{
+private:
+  UserdataPtr (UserdataPtr const&);
+  UserdataPtr operator= (UserdataPtr const&);
+
+private:
+  /** Push non-const pointer to object using metatable key.
+  */
+  static void push (lua_State* L, void* const p, void const* const key)
+  {
+    if (p)
+    {
+      new (lua_newuserdata (L, sizeof (UserdataPtr))) UserdataPtr (p);
+      lua_rawgetp (L, LUA_REGISTRYINDEX, key);
+      // If this goes off it means you forgot to register the class!
+      assert (lua_istable (L, -1));
+      lua_setmetatable (L, -2);
+    }
+    else
+    {
+      lua_pushnil (L);
+    }
+  }
+
+  /** Push const pointer to object using metatable key.
+  */
+  static void push (lua_State* L, void const* const p, void const* const key)
+  {
+    if (p)
+    {
+      new (lua_newuserdata (L, sizeof (UserdataPtr)))
+        UserdataPtr (const_cast <void*> (p));
+      lua_rawgetp (L, LUA_REGISTRYINDEX, key);
+      // If this goes off it means you forgot to register the class!
+      assert (lua_istable (L, -1));
+      lua_setmetatable (L, -2);
+    }
+    else
+    {
+      lua_pushnil (L);
+    }
+  }
+
+  explicit UserdataPtr (void* const p)
+  {
+    m_p = p;
+
+    // Can't construct with a null pointer!
+    //
+    assert (m_p != 0);
+  }
+
+public:
+  /** Push non-const pointer to object.
+  */
+  template <class T>
+  static inline void push (lua_State* const L, T* const p)
+  {
+    if (p)
+      push (L, p, ClassInfo <T>::getClassKey ());
+    else
+      lua_pushnil (L);
+  }
+
+  /** Push const pointer to object.
+  */
+  template <class T>
+  static inline void push (lua_State* const L, T const* const p)
+  {
+    if (p)
+      push (L, p, ClassInfo <T>::getConstKey ());
+    else
+      lua_pushnil (L);
+  }
+};
+
+//============================================================================
+/**
+  Wraps a container thet references a class object.
+
+  The template argument C is the container type, ContainerTraits must be
+  specialized on C or else a compile error will result.
+*/
+template <class C>
+class UserdataShared : public Userdata
+{
+private:
+  UserdataShared (UserdataShared <C> const&);
+  UserdataShared <C>& operator= (UserdataShared <C> const&);
+
+  typedef typename TypeTraits::removeConst <
+    typename ContainerTraits <C>::Type>::Type T;
+
+  C m_c;
+
+private:
+  ~UserdataShared ()
+  {
+  }
+
+public:
+  /**
+    Construct from a container to the class or a derived class.
+  */
+  template <class U>
+  explicit UserdataShared (U const& u) : m_c (u)
+  {
+    m_p = const_cast <void*> (reinterpret_cast <void const*> (
+        (ContainerTraits <C>::get (m_c))));
+  }
+
+  /**
+    Construct from a pointer to the class or a derived class.
+  */
+  template <class U>
+  explicit UserdataShared (U* u) : m_c (u)
+  {
+    m_p = const_cast <void*> (reinterpret_cast <void const*> (
+        (ContainerTraits <C>::get (m_c))));
+  }
+};
+
+//----------------------------------------------------------------------------
+//
+// SFINAE helpers.
+//
+
+// non-const objects
+template <class C, bool makeObjectConst>
+struct UserdataSharedHelper
+{
+  typedef typename TypeTraits::removeConst <
+    typename ContainerTraits <C>::Type>::Type T;
+
+  static void push (lua_State* L, C const& c)
+  {
+    if (ContainerTraits <C>::get (c) != 0)
+    {
+      new (lua_newuserdata (L, sizeof (UserdataShared <C>))) UserdataShared <C> (c);
+      lua_rawgetp (L, LUA_REGISTRYINDEX, ClassInfo <T>::getClassKey ());
+      // If this goes off it means the class T is unregistered!
+      assert (lua_istable (L, -1));
+      lua_setmetatable (L, -2);
+    }
+    else
+    {
+      lua_pushnil (L);
+    }
+  }
+
+  static void push (lua_State* L, T* const t)
+  {
+    if (t)
+    {
+      new (lua_newuserdata (L, sizeof (UserdataShared <C>))) UserdataShared <C> (t);
+      lua_rawgetp (L, LUA_REGISTRYINDEX, ClassInfo <T>::getClassKey ());
+      // If this goes off it means the class T is unregistered!
+      assert (lua_istable (L, -1));
+      lua_setmetatable (L, -2);
+    }
+    else
+    {
+      lua_pushnil (L);
+    }
+  }
+};
+
+// const objects
+template <class C>
+struct UserdataSharedHelper <C, true>
+{
+  typedef typename TypeTraits::removeConst <
+    typename ContainerTraits <C>::Type>::Type T;
+
+  static void push (lua_State* L, C const& c)
+  {
+    if (ContainerTraits <C>::get (c) != 0)
+    {
+      new (lua_newuserdata (L, sizeof (UserdataShared <C>))) UserdataShared <C> (c);
+      lua_rawgetp (L, LUA_REGISTRYINDEX, ClassInfo <T>::getConstKey ());
+      // If this goes off it means the class T is unregistered!
+      assert (lua_istable (L, -1));
+      lua_setmetatable (L, -2);
+    }
+    else
+    {
+      lua_pushnil (L);
+    }
+  }
+
+  static void push (lua_State* L, T* const t)
+  {
+    if (t)
+    {
+      new (lua_newuserdata (L, sizeof (UserdataShared <C>))) UserdataShared <C> (t);
+      lua_rawgetp (L, LUA_REGISTRYINDEX, ClassInfo <T>::getConstKey ());
+      // If this goes off it means the class T is unregistered!
+      assert (lua_istable (L, -1));
+      lua_setmetatable (L, -2);
+    }
+    else
+    {
+      lua_pushnil (L);
+    }
+  }
+};
+
+/**
+  Pass by container.
+
+  The container controls the object lifetime. Typically this will be a
+  lifetime shared by C++ and Lua using a reference count. Because of type
+  erasure, containers like std::shared_ptr will not work. Containers must
+  either be of the intrusive variety, or in the style of the RefCountedPtr
+  type provided by LuaBridge (that uses a global hash table).
+*/
+template <class C, bool byContainer>
+struct StackHelper
+{
+  static inline void push (lua_State* L, C const& c)
+  {
+    UserdataSharedHelper <C,
+      TypeTraits::isConst <typename ContainerTraits <C>::Type>::value>::push (L, c);
+  }
+
+  typedef typename TypeTraits::removeConst <
+    typename ContainerTraits <C>::Type>::Type T;
+
+  static inline C get (lua_State* L, int index)
+  {
+    return Userdata::get <T> (L, index, true);
+  }
+};
+
+/**
+  Pass by value.
+
+  Lifetime is managed by Lua. A C++ function which accesses a pointer or
+  reference to an object outside the activation record in which it was
+  retrieved may result in undefined behavior if Lua garbage collected it.
+*/
+template <class T>
+struct StackHelper <T, false>
+{
+  static inline void push (lua_State* L, T const& t)
+  {
+    UserdataValue <T>::push (L, t);
+  }
+
+  static inline T const& get (lua_State* L, int index)
+  {
+    return *Userdata::get <T> (L, index, true);
+  }
+};
+
+//==============================================================================
+
+/**
+  Lua stack conversions for class objects passed by value.
+*/
+template <class T>
+struct Stack
+{
+public:
+  static inline void push (lua_State* L, T const& t)
+  {
+    StackHelper <T,
+      TypeTraits::isContainer <T>::value>::push (L, t);
+  }
+
+  static inline T get (lua_State* L, int index)
+  {
+    return StackHelper <T,
+      TypeTraits::isContainer <T>::value>::get (L, index);
+  }
+};
+
+//------------------------------------------------------------------------------
+/**
+  Lua stack conversions for pointers and references to class objects.
+
+  Lifetime is managed by C++. Lua code which remembers a reference to the
+  value may result in undefined behavior if C++ destroys the object. The
+  handling of the const and volatile qualifiers happens in UserdataPtr.
+*/
+
+// pointer
+template <class T>
+struct Stack <T*>
+{
+  static inline void push (lua_State* L, T* const p)
+  {
+    UserdataPtr::push (L, p);
+  }
+
+  static inline T* const get (lua_State* L, int index)
+  {
+    return Userdata::get <T> (L, index, false);
+  }
+};
+
+// Strips the const off the right side of *
+template <class T>
+struct Stack <T* const>
+{
+  static inline void push (lua_State* L, T* const p)
+  {
+    UserdataPtr::push (L, p);
+  }
+
+  static inline T* const get (lua_State* L, int index)
+  {
+    return Userdata::get <T> (L, index, false);
+  }
+};
+
+// pointer to const
+template <class T>
+struct Stack <T const*>
+{
+  static inline void push (lua_State* L, T const* const p)
+  {
+    UserdataPtr::push (L, p);
+  }
+
+  static inline T const* const get (lua_State* L, int index)
+  {
+    return Userdata::get <T> (L, index, true);
+  }
+};
+
+// Strips the const off the right side of *
+template <class T>
+struct Stack <T const* const>
+{
+  static inline void push (lua_State* L, T const* const p)
+  {
+    UserdataPtr::push (L, p);
+  }
+
+  static inline T const* const get (lua_State* L, int index)
+  {
+    return Userdata::get <T> (L, index, true);
+  }
+};
+
+// reference
+template <class T>
+struct Stack <T&>
+{
+  static inline void push (lua_State* L, T& t)
+  {
+    UserdataPtr::push (L, &t);
+  }
+
+  static T& get (lua_State* L, int index)
+  {
+    T* const t = Userdata::get <T> (L, index, false);
+    if (!t)
+      luaL_error (L, "nil passed to reference");
+    return *t;
+  }
+};
+
+template <class C, bool byContainer>
+struct RefStackHelper
+{
+  typedef C return_type;  
+	
+  static inline void push (lua_State* L, C const& t)
+  {
+    UserdataSharedHelper <C,
+      TypeTraits::isConst <typename ContainerTraits <C>::Type>::value>::push (L, t);
+  }
+
+  typedef typename TypeTraits::removeConst <
+    typename ContainerTraits <C>::Type>::Type T;
+
+  static return_type get (lua_State* L, int index)
+  {
+    return Userdata::get <T> (L, index, true);
+  }
+};
+
+template <class T>
+struct RefStackHelper <T, false>
+{
+  typedef T const& return_type;  
+	
+	static inline void push (lua_State* L, T const& t)
+	{
+	  UserdataPtr::push (L, &t);
+	}
+
+  static return_type get (lua_State* L, int index)
+  {
+    T const* const t = Userdata::get <T> (L, index, true);
+
+    if (!t)
+      luaL_error (L, "nil passed to reference");
+    return *t;
+  }
+    
+};
+
+// reference to const
+template <class T>
+struct Stack <T const&>
+{
+  typedef RefStackHelper <T, TypeTraits::isContainer <T>::value> helper_t;
+  
+  static inline void push (lua_State* L, T const& t)
+  {
+    helper_t::push (L, t);
+  }
+
+  static typename helper_t::return_type get (lua_State* L, int index)
+  {
+    return helper_t::get (L, index);
+  }
+};
diff --git a/extern/LuaBridge/detail/dump.h b/extern/LuaBridge/detail/dump.h
new file mode 100644
index 000000000..c06680357
--- /dev/null
+++ b/extern/LuaBridge/detail/dump.h
@@ -0,0 +1,28 @@
+#include <sstream>
+#include <string>
+
+std::string dumpLuaState(lua_State *L) {
+	std::stringstream ostr;
+	int i;
+	int top = lua_gettop(L);
+	ostr << "top=" << top << ":\n";
+	for (i = 1; i <= top; ++i) {
+		int t = lua_type(L, i);
+		switch(t) {
+		case LUA_TSTRING:
+			ostr << "  " << i << ": '" << lua_tostring(L, i) << "'\n";
+			break;
+		case LUA_TBOOLEAN:
+			ostr << "  " << i << ": " << 
+					(lua_toboolean(L, i) ? "true" : "false") << "\n";
+			break;
+		case LUA_TNUMBER:
+			ostr << "  " << i << ": " << lua_tonumber(L, i) << "\n";
+			break;
+		default:
+			ostr << "  " << i << ": TYPE=" << lua_typename(L, t) << "\n";
+			break;
+		}
+	}
+	return ostr.str();
+}
diff --git a/files/mygui/CMakeLists.txt b/files/mygui/CMakeLists.txt
index 7494d3ba2..8515ef063 100644
--- a/files/mygui/CMakeLists.txt
+++ b/files/mygui/CMakeLists.txt
@@ -89,6 +89,9 @@ set(MYGUI_FILES
     ../launcher/images/openmw.png
     OpenMWResourcePlugin.xml
     skins.xml
+
+    tes3mp_login.layout
+    tes3mp_login.skin.xml
 )
 
 
diff --git a/files/mygui/tes3mp_login.layout b/files/mygui/tes3mp_login.layout
new file mode 100644
index 000000000..7c9c37d7f
--- /dev/null
+++ b/files/mygui/tes3mp_login.layout
@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<MyGUI type="Layout" version="3.2.0">
+    <Widget type="Window" skin="MW_Dialog" position="0 0 600 600" layer="Windows" name="_Main">
+        <Widget type="TextBox" skin="ProgressText" position="6 6 300 18" align="Left Top" name="LabelName">
+            <Property key="TextAlign" value="Left Top"/>
+            <Property key="Caption" value="Login"/>
+        </Widget>
+        <Widget type="EditBox" skin="MW_TextEdit" position="6 28 300 30" align="Left Top" name="EditLogin"/>
+        <Widget type="TextBox" skin="ProgressText" position="6 58 300 18" align="Left Top" name="LabelServer">
+            <Property key="TextAlign" value="Left Top"/>
+            <Property key="Caption" value="Server address and port"/>
+        </Widget>
+        <Widget type="EditBox" skin="MW_TextEdit" position="6 80 300 30" align="Left Top" name="EditServer"/>
+        <Widget type="EditBox" skin="MW_TextEdit" position="306 80 80 30" align="Left Top" name="EditPort"/>
+
+        <Widget type="AutoSizedButton" skin="MW_Button" position="540 560 42 23" name="ButtonConnect">
+            <Property key="ExpandDirection" value="Left"/>
+            <Property key="Caption" value="Connect"/>
+        </Widget>
+
+    </Widget>
+    <CodeGeneratorSettings/>
+</MyGUI>
diff --git a/files/mygui/tes3mp_login.skin.xml b/files/mygui/tes3mp_login.skin.xml
new file mode 100644
index 000000000..70c2a5c81
--- /dev/null
+++ b/files/mygui/tes3mp_login.skin.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<MyGUI>
+
+</MyGUI>
\ No newline at end of file
diff --git a/files/tes3mp/files/scripts/include/tes3mp.callbacks.inc b/files/tes3mp/files/scripts/include/tes3mp.callbacks.inc
new file mode 100644
index 000000000..e66d97ee2
--- /dev/null
+++ b/files/tes3mp/files/scripts/include/tes3mp.callbacks.inc
@@ -0,0 +1,23 @@
+forward OnCreate(ID);
+forward OnDestroy(ID);
+forward OnSpawn(ID);
+forward OnActivate(ID, actor);
+forward OnCellChange(ID, cell);
+forward OnItemCountChange(ID, count);
+forward OnItemConditionChange(ID, Float:condition);
+forward OnItemEquippedChange(ID, Bool:equipped);
+forward OnActorValueChange(ID, ActorValue:index, Float:value);
+forward OnActorBaseValueChange(ID, ActorValue:index, Float:value);
+forward OnActorSneak(ID, Bool:sneaking);
+forward OnActorDeath(ID, killer, cause);
+forward OnActorAttack(victim, attacker, weapon, damage);
+forward OnPlayerDisconnect(ID, reason);
+forward OnPlayerRequestGame(ID);
+forward OnPlayerChat(ID, message{});
+
+forward OnClientAuthenticate(const name{}, const pwd{});
+forward OnGameTimeChange(year, month, day, hour);
+forward OnServerInit();
+forward OnServerExit(Bool:error);
+
+forward OnCharGen(ID);
diff --git a/files/tes3mp/files/scripts/include/tes3mp.functions.inc b/files/tes3mp/files/scripts/include/tes3mp.functions.inc
new file mode 100644
index 000000000..c31993a67
--- /dev/null
+++ b/files/tes3mp/files/scripts/include/tes3mp.functions.inc
@@ -0,0 +1,30 @@
+const Sex: {
+	Male = 0,
+	Female = 1,
+}
+
+const Race: {
+	Argoninan = "Argonian",
+	Breton = "Breton",
+	DarkElf = "Dark Elf",
+	HighElf = "High Elf",
+	Imperial = "Imperial",
+	Khajiit = "Khajiit",
+	Nord = "Nord",
+	Orc = "Orc",
+	Redguard = "Redguard",
+	WoodElf = "Wood Elf"
+}
+
+native Bool:Kick(ID);
+native SetRespawnTime(interval);
+native GetRespawnTime();
+native SetSpawnCell(cell);
+native GetSpawnCell();
+
+native Bool:IsPlayer(ID);
+
+native GetBaseName(ID, message);
+native SetBaseName(ID);
+
+native CharGen(ID);
diff --git a/files/tes3mp/files/scripts/include/tes3mp.inc b/files/tes3mp/files/scripts/include/tes3mp.inc
new file mode 100644
index 000000000..e69de29bb
diff --git a/files/tes3mp/files/scripts/include/tes3mp.transloc.inc b/files/tes3mp/files/scripts/include/tes3mp.transloc.inc
new file mode 100644
index 000000000..a879b3f91
--- /dev/null
+++ b/files/tes3mp/files/scripts/include/tes3mp.transloc.inc
@@ -0,0 +1,10 @@
+native Bool:IsCell(cell);
+native Bool:IsInterior(cell);
+
+native GetPosition(ID, Float:x, Float:y, Float:z);
+native SetPosition(ID, Float:x, Float:y, Float:z);
+native GetRotation(ID, Float:x, Float:y, Float:z);
+native SetRotation(ID, Float:x, Float:y, Float:z);
+native SetCell(ID, cell);
+native GetCell(ID);
+
diff --git a/files/tes3mp/files/scripts/include/tes3mp.world.inc b/files/tes3mp/files/scripts/include/tes3mp.world.inc
new file mode 100644
index 000000000..aa1c62542
--- /dev/null
+++ b/files/tes3mp/files/scripts/include/tes3mp.world.inc
@@ -0,0 +1,15 @@
+native SetGameWeather(weather);
+native SetGameTime(time);
+native SetGameYear(year);
+native SetGameMonth(month);
+native SetGameDay(day);
+native SetGameHour(hour);
+native SetTimeScale(Float:scale);
+
+native GetGameWeather();
+native GetGameTime();
+native GetGameYear();
+native GetGameMonth();
+native GetGameDay();
+native GetGameHour();
+native Float:GetTimeScale();
diff --git a/files/tes3mp/tes3mp-client-default.cfg b/files/tes3mp/tes3mp-client-default.cfg
new file mode 100644
index 000000000..24f461e02
--- /dev/null
+++ b/files/tes3mp/tes3mp-client-default.cfg
@@ -0,0 +1,16 @@
+[General]
+#master = master.tes3mp.com:8088
+server = mp.tes3mp.com
+port = 25565
+#name = Player
+
+[Chat]
+#use https://wiki.libsdl.org/SDL_Keycode for rebind keys
+keySay = Y #key for switch chat mode enabled/hidden/disabled
+keyChatMode = F2
+x = 0
+y = 0
+w = 390
+h = 250
+delay = 5.0 #how long the message will be displayed in hidden mode
+
diff --git a/files/tes3mp/tes3mp-server-default.cfg b/files/tes3mp/tes3mp-server-default.cfg
new file mode 100644
index 000000000..a6054fdfd
--- /dev/null
+++ b/files/tes3mp/tes3mp-server-default.cfg
@@ -0,0 +1,12 @@
+[General]
+;master = master.tes3mp.com:8088
+port = 25565
+;query = false #enable query server
+;query-port = 25566
+players = 4
+
+[Plugins]
+;home = ~/local/openmw/tes3mp
+home = ~/ClionProjects/PS-dev
+plugins = tes3mp.lua,chat_parser.lua
+