* Move VMap3 code to a separate static 'collision' library.

--HG--
branch : trunk

5 files changed, 735 insertions, 0 deletions

diff --git a/src/server/collision/Management/IVMapManager.h b/src/server/collision/Management/IVMapManager.h
new file mode 100644
index 00000000000..00629eb122c
--- /dev/null
+++ b/src/server/collision/Management/IVMapManager.h
@@ -0,0 +1,106 @@
+/*
+ * Copyright (C) 2005-2010 MaNGOS <http://getmangos.com/>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef _IVMAPMANAGER_H
+#define _IVMAPMANAGER_H
+
+#include<string>
+#include <Platform/Define.h>
+
+//===========================================================
+
+/**
+This is the minimum interface to the VMapMamager.
+*/
+
+namespace VMAP
+{
+
+    enum VMAP_LOAD_RESULT
+    {
+        VMAP_LOAD_RESULT_ERROR,
+        VMAP_LOAD_RESULT_OK,
+        VMAP_LOAD_RESULT_IGNORED,
+    };
+
+    #define VMAP_INVALID_HEIGHT       -100000.0f            // for check
+    #define VMAP_INVALID_HEIGHT_VALUE -200000.0f            // real assigned value in unknown height case
+
+    //===========================================================
+    class IVMapManager
+    {
+        private:
+            bool iEnableLineOfSightCalc;
+            bool iEnableHeightCalc;
+
+        public:
+            IVMapManager() : iEnableLineOfSightCalc(true), iEnableHeightCalc(true) {}
+
+            virtual ~IVMapManager(void) {}
+
+            virtual int loadMap(const char* pBasePath, unsigned int pMapId, int x, int y) = 0;
+
+            virtual bool existsMap(const char* pBasePath, unsigned int pMapId, int x, int y) = 0;
+
+            virtual void unloadMap(unsigned int pMapId, int x, int y) = 0;
+            virtual void unloadMap(unsigned int pMapId) = 0;
+
+            virtual bool isInLineOfSight(unsigned int pMapId, float x1, float y1, float z1, float x2, float y2, float z2) = 0;
+            virtual float getHeight(unsigned int pMapId, float x, float y, float z) = 0;
+            /**
+            test if we hit an object. return true if we hit one. rx,ry,rz will hold the hit position or the dest position, if no intersection was found
+            return a position, that is pReduceDist closer to the origin
+            */
+            virtual bool getObjectHitPos(unsigned int pMapId, float x1, float y1, float z1, float x2, float y2, float z2, float& rx, float &ry, float& rz, float pModifyDist) = 0;
+            /**
+            send debug commands
+            */
+            virtual bool processCommand(char *pCommand)= 0;
+
+            /**
+            Enable/disable LOS calculation
+            It is enabled by default. If it is enabled in mid game the maps have to loaded manualy
+            */
+            void setEnableLineOfSightCalc(bool pVal) { iEnableLineOfSightCalc = pVal; }
+            /**
+            Enable/disable model height calculation
+            It is enabled by default. If it is enabled in mid game the maps have to loaded manualy
+            */
+            void setEnableHeightCalc(bool pVal) { iEnableHeightCalc = pVal; }
+
+            bool isLineOfSightCalcEnabled() const { return(iEnableLineOfSightCalc); }
+            bool isHeightCalcEnabled() const { return(iEnableHeightCalc); }
+            bool isMapLoadingEnabled() const { return(iEnableLineOfSightCalc || iEnableHeightCalc  ); }
+
+            virtual std::string getDirFileName(unsigned int pMapId, int x, int y) const =0;
+            /**
+            Block maps from being used.
+            parameter: String of map ids. Delimiter = ","
+            e.g.: "0,1,530"
+            */
+            virtual void preventMapsFromBeingUsed(const char* pMapIdString) =0;
+            /**
+            Query world model area info.
+            \param z gets adjusted to the ground height for which this are info is valid
+            */
+            virtual bool getAreaInfo(unsigned int pMapId, float x, float y, float &z, uint32 &flags, int32 &adtId, int32 &rootId, int32 &groupId) const=0;
+            virtual bool GetLiquidLevel(uint32 pMapId, float x, float y, float z, uint8 ReqLiquidType, float &level, float &floor, uint32 &type) const=0;
+    };
+
+}
+#endif
diff --git a/src/server/collision/Management/VMapFactory.cpp b/src/server/collision/Management/VMapFactory.cpp
new file mode 100644
index 00000000000..331acbace47
--- /dev/null
+++ b/src/server/collision/Management/VMapFactory.cpp
@@ -0,0 +1,136 @@
+/*
+ * Copyright (C) 2005-2010 MaNGOS <http://getmangos.com/>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include <sys/types.h>
+#include "VMapFactory.h"
+#include "VMapManager2.h"
+
+using namespace G3D;
+
+namespace VMAP
+{
+    void chompAndTrim(std::string& str)
+    {
+        while(str.length() >0)
+        {
+            char lc = str[str.length()-1];
+            if(lc == '\r' || lc == '\n' || lc == ' ' || lc == '"' || lc == '\'')
+            {
+                str = str.substr(0,str.length()-1);
+            }
+            else
+            {
+                break;
+            }
+        }
+        while(str.length() >0)
+        {
+            char lc = str[0];
+            if(lc == ' ' || lc == '"' || lc == '\'')
+            {
+                str = str.substr(1,str.length()-1);
+            }
+            else
+            {
+                break;
+            }
+        }
+    }
+
+    IVMapManager *gVMapManager = 0;
+    Table<unsigned int , bool>* iIgnoreSpellIds=0;
+
+    //===============================================
+    // result false, if no more id are found
+
+    bool getNextId(const std::string& pString, unsigned int& pStartPos, unsigned int& pId)
+    {
+        bool result = false;
+        unsigned int i;
+        for(i=pStartPos;i<pString.size(); ++i)
+        {
+            if(pString[i] == ',')
+            {
+                break;
+            }
+        }
+        if(i>pStartPos)
+        {
+            std::string idString = pString.substr(pStartPos, i-pStartPos);
+            pStartPos = i+1;
+            chompAndTrim(idString);
+            pId = atoi(idString.c_str());
+            result = true;
+        }
+        return(result);
+    }
+
+    //===============================================
+    /**
+    parameter: String of map ids. Delimiter = ","
+    */
+
+    void VMapFactory::preventSpellsFromBeingTestedForLoS(const char* pSpellIdString)
+    {
+        if(!iIgnoreSpellIds)
+            iIgnoreSpellIds = new Table<unsigned int , bool>();
+        if(pSpellIdString != NULL)
+        {
+            unsigned int pos =0;
+            unsigned int id;
+            std::string confString(pSpellIdString);
+            chompAndTrim(confString);
+            while(getNextId(confString, pos, id))
+            {
+                iIgnoreSpellIds->set(id, true);
+            }
+        }
+    }
+
+    //===============================================
+
+    bool VMapFactory::checkSpellForLoS(unsigned int pSpellId)
+    {
+        return(!iIgnoreSpellIds->containsKey(pSpellId));
+    }
+
+    //===============================================
+    // just return the instance
+    IVMapManager* VMapFactory::createOrGetVMapManager()
+    {
+        if(gVMapManager == 0)
+            gVMapManager= new VMapManager2();                // should be taken from config ... Please change if you like :-)
+        return gVMapManager;
+    }
+
+    //===============================================
+    // delete all internal data structures
+    void VMapFactory::clear()
+    {
+        if(iIgnoreSpellIds)
+        {
+            delete iIgnoreSpellIds;
+            iIgnoreSpellIds = NULL;
+        }
+        if(gVMapManager)
+        {
+            delete gVMapManager;
+            gVMapManager = NULL;
+        }
+    }
+}
diff --git a/src/server/collision/Management/VMapFactory.h b/src/server/collision/Management/VMapFactory.h
new file mode 100644
index 00000000000..8dc2c01938a
--- /dev/null
+++ b/src/server/collision/Management/VMapFactory.h
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2005-2010 MaNGOS <http://getmangos.com/>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef _VMAPFACTORY_H
+#define _VMAPFACTORY_H
+
+#include "IVMapManager.h"
+
+/**
+This is the access point to the VMapManager.
+*/
+
+namespace VMAP
+{
+    //===========================================================
+
+    class VMapFactory
+    {
+        public:
+            static IVMapManager* createOrGetVMapManager();
+            static void clear();
+
+            static void preventSpellsFromBeingTestedForLoS(const char* pSpellIdString);
+            static bool checkSpellForLoS(unsigned int pSpellId);
+    };
+
+}
+#endif
diff --git a/src/server/collision/Management/VMapManager2.cpp b/src/server/collision/Management/VMapManager2.cpp
new file mode 100644
index 00000000000..1e8a84aee52
--- /dev/null
+++ b/src/server/collision/Management/VMapManager2.cpp
@@ -0,0 +1,336 @@
+/*
+ * Copyright (C) 2005-2010 MaNGOS <http://getmangos.com/>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include <iostream>
+#include <iomanip>
+#include <string>
+#include <sstream>
+#include "VMapManager2.h"
+#include "MapTree.h"
+#include "ModelInstance.h"
+#include "WorldModel.h"
+#include "VMapDefinitions.h"
+
+using G3D::Vector3;
+
+namespace VMAP
+{
+
+    //=========================================================
+
+    VMapManager2::VMapManager2()
+    {
+    }
+
+    //=========================================================
+
+    VMapManager2::~VMapManager2(void)
+    {
+        for (InstanceTreeMap::iterator i = iInstanceMapTrees.begin(); i != iInstanceMapTrees.end(); ++i)
+        {
+            delete i->second;
+        }
+        for (ModelFileMap::iterator i = iLoadedModelFiles.begin(); i != iLoadedModelFiles.end(); ++i)
+        {
+            delete i->second.getModel();
+        }
+    }
+
+    //=========================================================
+
+    Vector3 VMapManager2::convertPositionToInternalRep(float x, float y, float z) const
+    {
+        Vector3 pos;
+        const float mid = 0.5 * 64.0 * 533.33333333f;
+        pos.x = mid - x;
+        pos.y = mid - y;
+        pos.z = z;
+
+        return pos;
+    }
+
+    //=========================================================
+
+    Vector3 VMapManager2::convertPositionToMangosRep(float x, float y, float z) const
+    {
+        Vector3 pos;
+        const float mid = 0.5 * 64.0 * 533.33333333f;
+        pos.x = mid - x;
+        pos.y = mid - y;
+        pos.z = z;
+
+        return pos;
+    }
+    //=========================================================
+
+    // move to MapTree too?
+    std::string VMapManager2::getMapFileName(unsigned int pMapId)
+    {
+        std::stringstream fname;
+        fname.width(3);
+        fname << std::setfill('0') << pMapId << std::string(MAP_FILENAME_EXTENSION2);
+        return fname.str();
+    }
+
+    //=========================================================
+    /**
+    Block maps from being used.
+    parameter: String of map ids. Delimiter = ","
+    e.g.: "0,1,590"
+    */
+
+    void VMapManager2::preventMapsFromBeingUsed(const char* pMapIdString)
+    {
+        iIgnoreMapIds.clear();
+        if (pMapIdString != NULL)
+        {
+            std::string map_str;
+            std::stringstream map_ss;
+            map_ss.str(std::string(pMapIdString));
+            while (std::getline(map_ss, map_str, ','))
+            {
+                std::stringstream ss2(map_str);
+                int map_num = -1;
+                ss2 >> map_num;
+                if (map_num >= 0)
+                {
+                    std::cout << "ingoring Map " << map_num << " for VMaps\n";
+                    iIgnoreMapIds[map_num] = true;
+                    // unload map in case it is loaded
+                    unloadMap(map_num);
+                }
+            }
+        }
+    }
+
+    //=========================================================
+
+    int VMapManager2::loadMap(const char* pBasePath, unsigned int pMapId, int x, int y)
+    {
+        int result = VMAP_LOAD_RESULT_IGNORED;
+        if (isMapLoadingEnabled() && !iIgnoreMapIds.count(pMapId))
+        {
+            if (_loadMap(pMapId, pBasePath, x, y))
+                result = VMAP_LOAD_RESULT_OK;
+            else
+                result = VMAP_LOAD_RESULT_ERROR;
+        }
+        return result;
+    }
+
+    //=========================================================
+    // load one tile (internal use only)
+
+    bool VMapManager2::_loadMap(unsigned int pMapId, const std::string &basePath, uint32 tileX, uint32 tileY)
+    {
+        InstanceTreeMap::iterator instanceTree = iInstanceMapTrees.find(pMapId);
+        if (instanceTree == iInstanceMapTrees.end())
+        {
+            std::string mapFileName = getMapFileName(pMapId);
+            StaticMapTree *newTree = new StaticMapTree(pMapId, basePath);
+            if (!newTree->InitMap(mapFileName, this))
+                return false;
+            instanceTree = iInstanceMapTrees.insert(InstanceTreeMap::value_type(pMapId, newTree)).first;
+        }
+        return instanceTree->second->LoadMapTile(tileX, tileY, this);
+    }
+
+    //=========================================================
+
+    void VMapManager2::unloadMap(unsigned int pMapId)
+    {
+        InstanceTreeMap::iterator instanceTree = iInstanceMapTrees.find(pMapId);
+        if (instanceTree != iInstanceMapTrees.end())
+        {
+            instanceTree->second->UnloadMap(this);
+            if (instanceTree->second->numLoadedTiles() == 0)
+            {
+                delete instanceTree->second;
+                iInstanceMapTrees.erase(pMapId);
+            }
+        }
+    }
+
+    //=========================================================
+
+    void VMapManager2::unloadMap(unsigned int  pMapId, int x, int y)
+    {
+        InstanceTreeMap::iterator instanceTree = iInstanceMapTrees.find(pMapId);
+        if (instanceTree != iInstanceMapTrees.end())
+        {
+            instanceTree->second->UnloadMapTile(x, y, this);
+            if (instanceTree->second->numLoadedTiles() == 0)
+            {
+                delete instanceTree->second;
+                iInstanceMapTrees.erase(pMapId);
+            }
+        }
+    }
+
+    //==========================================================
+
+    bool VMapManager2::isInLineOfSight(unsigned int pMapId, float x1, float y1, float z1, float x2, float y2, float z2)
+    {
+        if (!isLineOfSightCalcEnabled()) return true;
+        bool result = true;
+        InstanceTreeMap::iterator instanceTree = iInstanceMapTrees.find(pMapId);
+        if (instanceTree != iInstanceMapTrees.end())
+        {
+            Vector3 pos1 = convertPositionToInternalRep(x1,y1,z1);
+            Vector3 pos2 = convertPositionToInternalRep(x2,y2,z2);
+            if (pos1 != pos2)
+            {
+                result = instanceTree->second->isInLineOfSight(pos1, pos2);
+            }
+        }
+        return result;
+    }
+    //=========================================================
+    /**
+    get the hit position and return true if we hit something
+    otherwise the result pos will be the dest pos
+    */
+    bool VMapManager2::getObjectHitPos(unsigned int pMapId, float x1, float y1, float z1, float x2, float y2, float z2, float& rx, float &ry, float& rz, float pModifyDist)
+    {
+        bool result = false;
+        rx=x2;
+        ry=y2;
+        rz=z2;
+        if (isLineOfSightCalcEnabled())
+        {
+            InstanceTreeMap::iterator instanceTree = iInstanceMapTrees.find(pMapId);
+            if (instanceTree != iInstanceMapTrees.end())
+            {
+                Vector3 pos1 = convertPositionToInternalRep(x1,y1,z1);
+                Vector3 pos2 = convertPositionToInternalRep(x2,y2,z2);
+                Vector3 resultPos;
+                result = instanceTree->second->getObjectHitPos(pos1, pos2, resultPos, pModifyDist);
+                resultPos = convertPositionToMangosRep(resultPos.x,resultPos.y,resultPos.z);
+                rx = resultPos.x;
+                ry = resultPos.y;
+                rz = resultPos.z;
+            }
+        }
+        return result;
+    }
+
+    //=========================================================
+    /**
+    get height or INVALID_HEIGHT if no height available
+    */
+
+    float VMapManager2::getHeight(unsigned int pMapId, float x, float y, float z)
+    {
+        float height = VMAP_INVALID_HEIGHT_VALUE;           //no height
+        if (isHeightCalcEnabled())
+        {
+            InstanceTreeMap::iterator instanceTree = iInstanceMapTrees.find(pMapId);
+            if (instanceTree != iInstanceMapTrees.end())
+            {
+                Vector3 pos = convertPositionToInternalRep(x,y,z);
+                height = instanceTree->second->getHeight(pos);
+                if (!(height < G3D::inf()))
+                {
+                    height = VMAP_INVALID_HEIGHT_VALUE;         //no height
+                }
+            }
+        }
+        return height;
+    }
+
+    //=========================================================
+
+    bool VMapManager2::getAreaInfo(unsigned int pMapId, float x, float y, float &z, uint32 &flags, int32 &adtId, int32 &rootId, int32 &groupId) const
+    {
+        bool result=false;
+        InstanceTreeMap::const_iterator instanceTree = iInstanceMapTrees.find(pMapId);
+        if (instanceTree != iInstanceMapTrees.end())
+        {
+            Vector3 pos = convertPositionToInternalRep(x, y, z);
+            result = instanceTree->second->getAreaInfo(pos, flags, adtId, rootId, groupId);
+            // z is not touched by convertPositionToMangosRep(), so just copy
+            z = pos.z;
+        }
+        return(result);
+    }
+
+    bool VMapManager2::GetLiquidLevel(uint32 pMapId, float x, float y, float z, uint8 ReqLiquidType, float &level, float &floor, uint32 &type) const
+    {
+        InstanceTreeMap::const_iterator instanceTree = iInstanceMapTrees.find(pMapId);
+        if (instanceTree != iInstanceMapTrees.end())
+        {
+            LocationInfo info;
+            Vector3 pos = convertPositionToInternalRep(x, y, z);
+            if (instanceTree->second->GetLocationInfo(pos, info))
+            {
+                floor = info.ground_Z;
+                type = info.hitModel->GetLiquidType();
+                if (ReqLiquidType && !(type & ReqLiquidType))
+                    return false;
+                if (info.hitInstance->GetLiquidLevel(pos, info, level))
+                    return true;
+            }
+        }
+        return false;
+    }
+
+    //=========================================================
+
+    WorldModel* VMapManager2::acquireModelInstance(const std::string &basepath, const std::string &filename)
+    {
+        ModelFileMap::iterator model = iLoadedModelFiles.find(filename);
+        if (model == iLoadedModelFiles.end())
+        {
+            WorldModel *worldmodel = new WorldModel();
+            if (!worldmodel->readFile(basepath + filename + ".vmo"))
+            {
+                std::cout << "VMapManager2: could not load '" << basepath << filename << ".vmo'!\n";
+                delete worldmodel;
+                return NULL;
+            }
+            std::cout << "VMapManager2: loading file '" << basepath << filename << "'.\n";
+            model = iLoadedModelFiles.insert(std::pair<std::string, ManagedModel>(filename, ManagedModel())).first;
+            model->second.setModel(worldmodel);
+        }
+        model->second.incRefCount();
+        return model->second.getModel();
+    }
+
+    void VMapManager2::releaseModelInstance(const std::string &filename)
+    {
+        ModelFileMap::iterator model = iLoadedModelFiles.find(filename);
+        if (model == iLoadedModelFiles.end())
+        {
+            std::cout << "VMapManager2: trying to unload non-loaded file '" << filename << "'!\n";
+            return;
+        }
+        if( model->second.decRefCount() == 0)
+        {
+            std::cout << "VMapManager2: unloading file '" << filename << "'.\n";
+            delete model->second.getModel();
+            iLoadedModelFiles.erase(model);
+        }
+    }
+    //=========================================================
+
+    bool VMapManager2::existsMap(const char* pBasePath, unsigned int pMapId, int x, int y)
+    {
+        return StaticMapTree::CanLoadMap(std::string(pBasePath), pMapId, x, y);
+    }
+
+} // namespace VMAP
diff --git a/src/server/collision/Management/VMapManager2.h b/src/server/collision/Management/VMapManager2.h
new file mode 100644
index 00000000000..5f03b87b07f
--- /dev/null
+++ b/src/server/collision/Management/VMapManager2.h
@@ -0,0 +1,114 @@
+/*
+ * Copyright (C) 2005-2010 MaNGOS <http://getmangos.com/>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef _VMAPMANAGER2_H
+#define _VMAPMANAGER2_H
+
+#include "IVMapManager.h"
+#include "Utilities/UnorderedMap.h"
+#include "Platform/Define.h"
+#include <G3D/Vector3.h>
+
+//===========================================================
+
+#define MAP_FILENAME_EXTENSION2 ".vmtree"
+
+#define FILENAMEBUFFER_SIZE 500
+
+/**
+This is the main Class to manage loading and unloading of maps, line of sight, height calculation and so on.
+For each map or map tile to load it reads a directory file that contains the ModelContainer files used by this map or map tile.
+Each global map or instance has its own dynamic BSP-Tree.
+The loaded ModelContainers are included in one of these BSP-Trees.
+Additionally a table to match map ids and map names is used.
+*/
+
+//===========================================================
+
+namespace VMAP
+{
+    class StaticMapTree;
+    class WorldModel;
+
+    class ManagedModel
+    {
+        public:
+            ManagedModel(): iModel(0), iRefCount(0) {}
+            void setModel(WorldModel *model) { iModel = model; }
+            WorldModel *getModel() { return iModel; }
+            void incRefCount() { ++iRefCount; }
+            int decRefCount() { return --iRefCount; }
+        protected:
+            WorldModel *iModel;
+            int iRefCount;
+    };
+
+    typedef UNORDERED_MAP<uint32 , StaticMapTree *> InstanceTreeMap;
+    typedef UNORDERED_MAP<std::string, ManagedModel> ModelFileMap;
+
+    class VMapManager2 : public IVMapManager
+    {
+        protected:
+            // Tree to check collision
+            ModelFileMap iLoadedModelFiles;
+            InstanceTreeMap iInstanceMapTrees;
+            // UNORDERED_MAP<unsigned int , bool> iMapsSplitIntoTiles;
+            UNORDERED_MAP<unsigned int , bool> iIgnoreMapIds;
+
+            bool _loadMap(uint32 pMapId, const std::string &basePath, uint32 tileX, uint32 tileY);
+            /* void _unloadMap(uint32 pMapId, uint32 x, uint32 y); */
+
+        public:
+            // public for debug
+            G3D::Vector3 convertPositionToInternalRep(float x, float y, float z) const;
+            G3D::Vector3 convertPositionToMangosRep(float x, float y, float z) const;
+            static std::string getMapFileName(unsigned int pMapId);
+
+            VMapManager2();
+            ~VMapManager2(void);
+
+            int loadMap(const char* pBasePath, unsigned int pMapId, int x, int y);
+
+            void unloadMap(unsigned int pMapId, int x, int y);
+            void unloadMap(unsigned int pMapId);
+
+            bool isInLineOfSight(unsigned int pMapId, float x1, float y1, float z1, float x2, float y2, float z2) ;
+            /**
+            fill the hit pos and return true, if an object was hit
+            */
+            bool getObjectHitPos(unsigned int pMapId, float x1, float y1, float z1, float x2, float y2, float z2, float& rx, float &ry, float& rz, float pModifyDist);
+            float getHeight(unsigned int pMapId, float x, float y, float z);
+
+            bool processCommand(char *pCommand) { return false; }      // for debug and extensions
+
+            void preventMapsFromBeingUsed(const char* pMapIdString);
+            bool getAreaInfo(unsigned int pMapId, float x, float y, float &z, uint32 &flags, int32 &adtId, int32 &rootId, int32 &groupId) const;
+            bool GetLiquidLevel(uint32 pMapId, float x, float y, float z, uint8 ReqLiquidType, float &level, float &floor, uint32 &type) const;
+
+            WorldModel* acquireModelInstance(const std::string &basepath, const std::string &filename);
+            void releaseModelInstance(const std::string &filename);
+
+            // what's the use of this? o.O
+            virtual std::string getDirFileName(unsigned int pMapId, int x, int y) const
+            {
+                return getMapFileName(pMapId);
+            }
+            virtual bool existsMap(const char* pBasePath, unsigned int pMapId, int x, int y);
+    };
+}
+#endif