Merge remote-tracking branch 'origin/master' into 4.3.4

Conflicts:
	dep/PackageList.txt
	src/server/game/Battlegrounds/Battleground.cpp
	src/server/game/Combat/ThreatManager.cpp
	src/server/game/Entities/Object/Object.cpp
	src/server/game/Entities/Player/Player.cpp
	src/server/game/Entities/Unit/Unit.cpp
	src/server/game/Handlers/BattleGroundHandler.cpp
	src/server/game/Movement/MovementGenerators/RandomMovementGenerator.cpp
	src/server/game/Movement/MovementGenerators/TargetedMovementGenerator.cpp
	src/server/game/Movement/Spline/MoveSplineInit.cpp
	src/server/game/Spells/Auras/SpellAuraEffects.cpp
	src/server/game/Spells/SpellEffects.cpp
	src/server/game/World/World.cpp
	src/server/game/World/World.h
	src/server/scripts/EasternKingdoms/ZulGurub/boss_arlokk.cpp
	src/server/scripts/EasternKingdoms/ZulGurub/instance_zulgurub.cpp
	src/server/scripts/EasternKingdoms/ZulGurub/zulgurub.h
	src/server/scripts/Spells/spell_druid.cpp
	src/server/scripts/Spells/spell_mage.cpp
	src/server/scripts/Spells/spell_paladin.cpp
	src/server/scripts/Spells/spell_priest.cpp
	src/server/scripts/Spells/spell_rogue.cpp
	src/server/scripts/Spells/spell_shaman.cpp
	src/server/scripts/Spells/spell_warlock.cpp
	src/server/scripts/Spells/spell_warrior.cpp
	src/tools/map_extractor/CMakeLists.txt
	src/tools/map_extractor/System.cpp
	src/tools/map_extractor/loadlib.cpp
	src/tools/map_extractor/mpq_libmpq.cpp
	src/tools/map_extractor/mpq_libmpq04.h
	src/tools/vmap4_assembler/CMakeLists.txt
	src/tools/vmap4_extractor/CMakeLists.txt
	src/tools/vmap4_extractor/mpq_libmpq.cpp
	src/tools/vmap4_extractor/mpq_libmpq04.h

5 files changed, 520 insertions, 5 deletions

diff --git a/src/server/scripts/Commands/CMakeLists.txt b/src/server/scripts/Commands/CMakeLists.txt
index 97e9b35e6cd..7b9e2444952 100644
--- a/src/server/scripts/Commands/CMakeLists.txt
+++ b/src/server/scripts/Commands/CMakeLists.txt
@@ -42,6 +42,7 @@ set(scripts_STAT_SRCS
   Commands/cs_server.cpp
   Commands/cs_titles.cpp
   Commands/cs_wp.cpp
+  Commands/cs_mmaps.cpp
 #  Commands/cs_pdump.cpp
 #  Commands/cs_channel.cpp
 #  Commands/cs_pet.cpp
diff --git a/src/server/scripts/Commands/cs_disable.cpp b/src/server/scripts/Commands/cs_disable.cpp
index 37e282cac8e..34738777c85 100644
--- a/src/server/scripts/Commands/cs_disable.cpp
+++ b/src/server/scripts/Commands/cs_disable.cpp
@@ -48,6 +48,7 @@ public:
             { "achievement_criteria",   SEC_ADMINISTRATOR,      true,   &HandleRemoveDisableAchievementCriteriaCommand, "", NULL },
             { "outdoorpvp",             SEC_ADMINISTRATOR,      true,   &HandleRemoveDisableOutdoorPvPCommand,          "", NULL },
             { "vmap",                   SEC_ADMINISTRATOR,      true,   &HandleRemoveDisableVmapCommand,                "", NULL },
+            { "mmap",                   SEC_ADMINISTRATOR,      true,   &HandleRemoveDisableMMapCommand,                "", NULL },
             { NULL,                     0,                      false,  NULL,                                           "", NULL }
         };
         static ChatCommand addDisableCommandTable[] =
@@ -59,6 +60,7 @@ public:
             { "achievement_criteria",   SEC_ADMINISTRATOR,      true,   &HandleAddDisableAchievementCriteriaCommand,    "", NULL },
             { "outdoorpvp",             SEC_ADMINISTRATOR,      true,   &HandleAddDisableOutdoorPvPCommand,             "", NULL },
             { "vmap",                   SEC_ADMINISTRATOR,      true,   &HandleAddDisableVmapCommand,                   "", NULL },
+            { "mmap",                   SEC_ADMINISTRATOR,      true,   &HandleAddDisableMMapCommand,                   "", NULL },
             { NULL,                     0,                      false,  NULL,                                           "", NULL }
         };
         static ChatCommand disableCommandTable[] =
@@ -172,6 +174,17 @@ public:
                 disableTypeStr = "vmap";
                 break;
             }
+            case DISABLE_TYPE_MMAP:
+            {
+                if (!sMapStore.LookupEntry(entry))
+                {
+                    handler->PSendSysMessage(LANG_COMMAND_NOMAPFOUND);
+                    handler->SetSentErrorMessage(true);
+                    return false;
+                }
+                disableTypeStr = "mmap";
+                break;
+            }
             default:
                 break;
         }
@@ -256,6 +269,14 @@ public:
         return HandleAddDisables(handler, args, DISABLE_TYPE_VMAP);
     }
 
+    static bool HandleAddDisableMMapCommand(ChatHandler* handler, char const* args)
+    {
+        if (!*args)
+            return false;
+
+        return HandleAddDisables(handler, args, DISABLE_TYPE_MMAP);
+    }
+
     static bool HandleRemoveDisables(ChatHandler* handler, char const* args, uint8 disableType)
     {
         char* entryStr = strtok((char*)args, " ");
@@ -289,6 +310,9 @@ public:
             case DISABLE_TYPE_VMAP:
                 disableTypeStr = "vmap";
                 break;
+            case DISABLE_TYPE_MMAP:
+                disableTypeStr = "mmap";
+                break;
         }
 
         PreparedStatement* stmt = NULL;
@@ -367,6 +391,14 @@ public:
 
         return HandleRemoveDisables(handler, args, DISABLE_TYPE_VMAP);
     }
+
+    static bool HandleRemoveDisableMMapCommand(ChatHandler* handler, char const* args)
+    {
+        if (!*args)
+            return false;
+
+        return HandleRemoveDisables(handler, args, DISABLE_TYPE_MMAP);
+    }
 };
 
 void AddSC_disable_commandscript()
diff --git a/src/server/scripts/Commands/cs_misc.cpp b/src/server/scripts/Commands/cs_misc.cpp
index a1098cff5d3..18dbeba8f89 100644
--- a/src/server/scripts/Commands/cs_misc.cpp
+++ b/src/server/scripts/Commands/cs_misc.cpp
@@ -33,6 +33,8 @@
 #include "ace/INET_Addr.h"
 #include "Player.h"
 #include "Pet.h"
+#include "LFG.h"
+#include "GroupMgr.h"
 
 class misc_commandscript : public CommandScript
 {
@@ -46,6 +48,8 @@ public:
             { "leader",         SEC_ADMINISTRATOR,          false,  &HandleGroupLeaderCommand,          "", NULL },
             { "disband",        SEC_ADMINISTRATOR,          false,  &HandleGroupDisbandCommand,         "", NULL },
             { "remove",         SEC_ADMINISTRATOR,          false,  &HandleGroupRemoveCommand,          "", NULL },
+            { "join",           SEC_ADMINISTRATOR,          false,  &HandleGroupJoinCommand,            "", NULL },
+            { "list",           SEC_ADMINISTRATOR,          false,  &HandleGroupListCommand,            "", NULL },
             { NULL,             0,                          false,  NULL,                               "", NULL }
         };
         static ChatCommand petCommandTable[] =
@@ -1734,6 +1738,29 @@ public:
         else
            handler->PSendSysMessage(LANG_PINFO_MAP_OFFLINE, map->name, areaName.c_str());
 
+        stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_GUILD_MEMBER_EXTENDED);
+        stmt->setUInt32(0, GUID_LOPART(targetGuid));
+
+        result = CharacterDatabase.Query(stmt);
+        if (result)
+        {
+            uint32 guildId           = 0;
+            std::string guildName   = "";
+            std::string guildRank   = "";
+            std::string note        = "";
+            std::string officeNote  = "";
+
+            Field* fields      = result->Fetch();
+            guildId            = fields[0].GetUInt32();
+            guildName          = fields[1].GetString();
+            //rankId           = fields[2].GetUInt8();
+            guildRank          = fields[3].GetString();
+            note               = fields[4].GetString();
+            officeNote         = fields[5].GetString();
+
+            handler->PSendSysMessage(LANG_PINFO_GUILD_INFO, guildName.c_str(), guildId, guildRank.c_str(), note.c_str(), officeNote.c_str());
+        }
+
         return true;
     }
 
@@ -2723,6 +2750,133 @@ public:
         return true;
     }
 
+    static bool HandleGroupJoinCommand(ChatHandler* handler, char const* args)
+    {
+        if (!*args)
+            return false;
+
+        Player* playerSource = NULL;
+        Player* playerTarget = NULL;
+        Group* groupSource = NULL;
+        Group* groupTarget = NULL;
+        uint64 guidSource = 0;
+        uint64 guidTarget = 0;
+        char* nameplgrStr = strtok((char*)args, " ");
+        char* nameplStr = strtok(NULL, " ");
+
+        if (handler->GetPlayerGroupAndGUIDByName(nameplgrStr, playerSource, groupSource, guidSource, true))
+        {
+            if (groupSource)
+            {
+                if (handler->GetPlayerGroupAndGUIDByName(nameplStr, playerTarget, groupTarget, guidTarget, true))
+                {
+                    if (!groupTarget && playerTarget->GetGroup() != groupSource)
+                    {
+                        if (!groupSource->IsFull())
+                        {
+                            groupSource->AddMember(playerTarget);
+                            groupSource->BroadcastGroupUpdate();
+                            handler->PSendSysMessage(LANG_GROUP_PLAYER_JOINED, playerTarget->GetName().c_str(), playerSource->GetName().c_str());
+                            return true;
+                        }
+                        else
+                        {
+                            // group is full
+                            handler->PSendSysMessage(LANG_GROUP_FULL);
+                            return true;
+                        }
+                    }
+                    else
+                    {
+                        // group is full or target player already in a group
+                        handler->PSendSysMessage(LANG_GROUP_ALREADY_IN_GROUP, playerTarget->GetName().c_str());
+                        return true;
+                    }
+                }
+            }
+            else
+            {
+                // specified source player is not in a group
+                handler->PSendSysMessage(LANG_GROUP_NOT_IN_GROUP, playerSource->GetName().c_str());
+                return true;
+            }
+        }
+
+        return true;
+    }
+
+    static bool HandleGroupListCommand(ChatHandler* handler, char const* args)
+    {
+        Player* playerTarget;
+        uint64 guidTarget;
+        std::string nameTarget;
+
+        uint32 parseGUID = MAKE_NEW_GUID(atol((char*)args), 0, HIGHGUID_PLAYER);
+
+        if (sObjectMgr->GetPlayerNameByGUID(parseGUID, nameTarget))
+        {
+            playerTarget = sObjectMgr->GetPlayerByLowGUID(parseGUID);
+            guidTarget = parseGUID;
+        }
+        else if (!handler->extractPlayerTarget((char*)args, &playerTarget, &guidTarget, &nameTarget))
+            return false;
+
+        Group* groupTarget = NULL;
+        if (playerTarget)
+            groupTarget = playerTarget->GetGroup();
+
+        if (!groupTarget)
+        {
+            PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_GROUP_MEMBER);
+            stmt->setUInt32(0, guidTarget);
+            PreparedQueryResult resultGroup = CharacterDatabase.Query(stmt);
+            if (resultGroup)
+                groupTarget = sGroupMgr->GetGroupByDbStoreId((*resultGroup)[0].GetUInt32());
+        }
+
+        if (groupTarget)
+        {
+            handler->PSendSysMessage(LANG_GROUP_TYPE, (groupTarget->isRaidGroup() ? "raid" : "party"));
+            Group::MemberSlotList const& members = groupTarget->GetMemberSlots();
+            Group::MemberSlotList::const_iterator itr;
+            for (itr = members.begin(); itr != members.end(); ++itr)
+            {
+                std::ostringstream flags, roles;
+                if ((*itr).flags & MEMBER_FLAG_ASSISTANT)
+                    flags << "Assistant ";
+                if ((*itr).flags & MEMBER_FLAG_MAINTANK)
+                    flags << "MainTank ";
+                if ((*itr).flags & MEMBER_FLAG_MAINASSIST)
+                    flags << "MainAssist ";
+
+                if ((*itr).roles & PLAYER_ROLE_LEADER)
+                    roles << "Leader ";
+                if ((*itr).roles & PLAYER_ROLE_TANK)
+                    roles << "Tank ";
+                if ((*itr).roles & PLAYER_ROLE_HEALER)
+                    roles << "Healer ";
+                if ((*itr).roles & PLAYER_ROLE_DAMAGE)
+                    roles << "Damage ";
+
+                Player* p = ObjectAccessor::FindPlayer((*itr).guid);
+                const char* onlineState = (p && p->IsInWorld()) ? "online" : "offline";
+
+                std::string flagsStr = (flags.str().empty()) ? "None" : flags.str();
+                std::string rolesStr = (roles.str().empty()) ? "None" : roles.str();
+
+                handler->PSendSysMessage(LANG_GROUP_PLAYER_NAME_GUID, (*itr).name.c_str(), onlineState, GUID_LOPART((*itr).guid), flagsStr.c_str(), rolesStr.c_str());
+            }
+            return true;
+        }
+        else
+        {
+            handler->PSendSysMessage(LANG_GROUP_NOT_IN_GROUP, nameTarget.c_str());
+            return true;
+        }
+
+        return true;
+    }
+
     static bool HandlePlayAllCommand(ChatHandler* handler, char const* args)
     {
         if (!*args)
diff --git a/src/server/scripts/Commands/cs_mmaps.cpp b/src/server/scripts/Commands/cs_mmaps.cpp
new file mode 100644
index 00000000000..97861133983
--- /dev/null
+++ b/src/server/scripts/Commands/cs_mmaps.cpp
@@ -0,0 +1,294 @@
+/*
+ * Copyright (C) 2008-2013 TrinityCore <http://www.trinitycore.org/>
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+* @file cs_mmaps.cpp
+* @brief .mmap related commands
+*
+* This file contains the CommandScripts for all
+* mmap sub-commands
+*/
+
+#include "ScriptMgr.h"
+#include "Chat.h"
+#include "ObjectMgr.h"
+#include "Player.h"
+#include "PointMovementGenerator.h"
+#include "PathGenerator.h"
+#include "MMapFactory.h"
+#include "Map.h"
+#include "TargetedMovementGenerator.h"
+#include "GridNotifiers.h"
+#include "GridNotifiersImpl.h"
+#include "CellImpl.h"
+
+class mmaps_commandscript : public CommandScript
+{
+public:
+    mmaps_commandscript() : CommandScript("mmaps_commandscript") { }
+
+    ChatCommand* GetCommands() const
+    {
+        static ChatCommand mmapCommandTable[] =
+        {
+            { "path",           SEC_ADMINISTRATOR,     false, &HandleMmapPathCommand,            "", NULL },
+            { "loc",            SEC_ADMINISTRATOR,     false, &HandleMmapLocCommand,             "", NULL },
+            { "loadedtiles",    SEC_ADMINISTRATOR,     false, &HandleMmapLoadedTilesCommand,     "", NULL },
+            { "stats",          SEC_ADMINISTRATOR,     false, &HandleMmapStatsCommand,           "", NULL },
+            { "testarea",       SEC_ADMINISTRATOR,     false, &HandleMmapTestArea,               "", NULL },
+            { NULL,             0,                     false, NULL,                              "", NULL }
+        };
+
+        static ChatCommand commandTable[] =
+        {
+            { "mmap",           SEC_ADMINISTRATOR,     true,  NULL,                 "", mmapCommandTable  },
+            { NULL,             0,                     false, NULL,                              "", NULL }
+        };
+        return commandTable;
+    }
+
+    static bool HandleMmapPathCommand(ChatHandler* handler, char const* args)
+    {
+        if (!MMAP::MMapFactory::createOrGetMMapManager()->GetNavMesh(handler->GetSession()->GetPlayer()->GetMapId()))
+        {
+            handler->PSendSysMessage("NavMesh not loaded for current map.");
+            return true;
+        }
+
+        handler->PSendSysMessage("mmap path:");
+
+        // units
+        Player* player = handler->GetSession()->GetPlayer();
+        Unit* target = handler->getSelectedUnit();
+        if (!player || !target)
+        {
+            handler->PSendSysMessage("Invalid target/source selection.");
+            return true;
+        }
+
+        char* para = strtok((char*)args, " ");
+
+        bool useStraightPath = false;
+        if (para && strcmp(para, "true") == 0)
+            useStraightPath = true;
+
+        // unit locations
+        float x, y, z;
+        player->GetPosition(x, y, z);
+
+        // path
+        PathGenerator path(target);
+        path.SetUseStraightPath(useStraightPath);
+        bool result = path.CalculatePath(x, y, z);
+
+        PointsArray pointPath = path.GetPath();
+        handler->PSendSysMessage("%s's path to %s:", target->GetName().c_str(), player->GetName().c_str());
+        handler->PSendSysMessage("Building: %s", useStraightPath ? "StraightPath" : "SmoothPath");
+        handler->PSendSysMessage("Result: %s - Length: "SIZEFMTD" - Type: %u", (result ? "true" : "false"), pointPath.size(), path.GetPathType());
+
+        Vector3 start = path.GetStartPosition();
+        Vector3 end = path.GetEndPosition();
+        Vector3 actualEnd = path.GetActualEndPosition();
+
+        handler->PSendSysMessage("StartPosition     (%.3f, %.3f, %.3f)", start.x, start.y, start.z);
+        handler->PSendSysMessage("EndPosition       (%.3f, %.3f, %.3f)", end.x, end.y, end.z);
+        handler->PSendSysMessage("ActualEndPosition (%.3f, %.3f, %.3f)", actualEnd.x, actualEnd.y, actualEnd.z);
+
+        if (!player->isGameMaster())
+            handler->PSendSysMessage("Enable GM mode to see the path points.");
+
+        for (uint32 i = 0; i < pointPath.size(); ++i)
+            player->SummonCreature(VISUAL_WAYPOINT, pointPath[i].x, pointPath[i].y, pointPath[i].z, 0, TEMPSUMMON_TIMED_DESPAWN, 9000);
+
+        return true;
+    }
+
+    static bool HandleMmapLocCommand(ChatHandler* handler, char const* /*args*/)
+    {
+        handler->PSendSysMessage("mmap tileloc:");
+
+        // grid tile location
+        Player* player = handler->GetSession()->GetPlayer();
+
+        int32 gx = 32 - player->GetPositionX() / SIZE_OF_GRIDS;
+        int32 gy = 32 - player->GetPositionY() / SIZE_OF_GRIDS;
+
+        handler->PSendSysMessage("%03u%02i%02i.mmtile", player->GetMapId(), gy, gx);
+        handler->PSendSysMessage("gridloc [%i,%i]", gx, gy);
+
+        // calculate navmesh tile location
+        dtNavMesh const* navmesh = MMAP::MMapFactory::createOrGetMMapManager()->GetNavMesh(handler->GetSession()->GetPlayer()->GetMapId());
+        dtNavMeshQuery const* navmeshquery = MMAP::MMapFactory::createOrGetMMapManager()->GetNavMeshQuery(handler->GetSession()->GetPlayer()->GetMapId(), player->GetInstanceId());
+        if (!navmesh || !navmeshquery)
+        {
+            handler->PSendSysMessage("NavMesh not loaded for current map.");
+            return true;
+        }
+
+        float const* min = navmesh->getParams()->orig;
+        float x, y, z;
+        player->GetPosition(x, y, z);
+        float location[VERTEX_SIZE] = {y, z, x};
+        float extents[VERTEX_SIZE] = {3.0f, 5.0f, 3.0f};
+
+        int32 tilex = int32((y - min[0]) / SIZE_OF_GRIDS);
+        int32 tiley = int32((x - min[2]) / SIZE_OF_GRIDS);
+
+        handler->PSendSysMessage("Calc   [%02i,%02i]", tilex, tiley);
+
+        // navmesh poly -> navmesh tile location
+        dtQueryFilter filter = dtQueryFilter();
+        dtPolyRef polyRef = INVALID_POLYREF;
+        navmeshquery->findNearestPoly(location, extents, &filter, &polyRef, NULL);
+
+        if (polyRef == INVALID_POLYREF)
+            handler->PSendSysMessage("Dt     [??,??] (invalid poly, probably no tile loaded)");
+        else
+        {
+            dtMeshTile const* tile;
+            dtPoly const* poly;
+            navmesh->getTileAndPolyByRef(polyRef, &tile, &poly);
+            if (tile)
+                handler->PSendSysMessage("Dt     [%02i,%02i]", tile->header->x, tile->header->y);
+            else
+                handler->PSendSysMessage("Dt     [??,??] (no tile loaded)");
+        }
+
+        return true;
+    }
+
+    static bool HandleMmapLoadedTilesCommand(ChatHandler* handler, char const* /*args*/)
+    {
+        uint32 mapid = handler->GetSession()->GetPlayer()->GetMapId();
+        dtNavMesh const* navmesh = MMAP::MMapFactory::createOrGetMMapManager()->GetNavMesh(mapid);
+        dtNavMeshQuery const* navmeshquery = MMAP::MMapFactory::createOrGetMMapManager()->GetNavMeshQuery(mapid, handler->GetSession()->GetPlayer()->GetInstanceId());
+        if (!navmesh || !navmeshquery)
+        {
+            handler->PSendSysMessage("NavMesh not loaded for current map.");
+            return true;
+        }
+
+        handler->PSendSysMessage("mmap loadedtiles:");
+
+        for (int32 i = 0; i < navmesh->getMaxTiles(); ++i)
+        {
+            dtMeshTile const* tile = navmesh->getTile(i);
+            if (!tile || !tile->header)
+                continue;
+
+            handler->PSendSysMessage("[%02i,%02i]", tile->header->x, tile->header->y);
+        }
+
+        return true;
+    }
+
+    static bool HandleMmapStatsCommand(ChatHandler* handler, char const* /*args*/)
+    {
+        uint32 mapId = handler->GetSession()->GetPlayer()->GetMapId();
+        handler->PSendSysMessage("mmap stats:");
+        handler->PSendSysMessage("  global mmap pathfinding is %sabled", MMAP::MMapFactory::IsPathfindingEnabled(mapId) ? "en" : "dis");
+
+        MMAP::MMapManager* manager = MMAP::MMapFactory::createOrGetMMapManager();
+        handler->PSendSysMessage(" %u maps loaded with %u tiles overall", manager->getLoadedMapsCount(), manager->getLoadedTilesCount());
+
+        dtNavMesh const* navmesh = manager->GetNavMesh(handler->GetSession()->GetPlayer()->GetMapId());
+        if (!navmesh)
+        {
+            handler->PSendSysMessage("NavMesh not loaded for current map.");
+            return true;
+        }
+
+        uint32 tileCount = 0;
+        uint32 nodeCount = 0;
+        uint32 polyCount = 0;
+        uint32 vertCount = 0;
+        uint32 triCount = 0;
+        uint32 triVertCount = 0;
+        uint32 dataSize = 0;
+        for (int32 i = 0; i < navmesh->getMaxTiles(); ++i)
+        {
+            dtMeshTile const* tile = navmesh->getTile(i);
+            if (!tile || !tile->header)
+                continue;
+
+            tileCount++;
+            nodeCount += tile->header->bvNodeCount;
+            polyCount += tile->header->polyCount;
+            vertCount += tile->header->vertCount;
+            triCount += tile->header->detailTriCount;
+            triVertCount += tile->header->detailVertCount;
+            dataSize += tile->dataSize;
+        }
+
+        handler->PSendSysMessage("Navmesh stats:");
+        handler->PSendSysMessage(" %u tiles loaded", tileCount);
+        handler->PSendSysMessage(" %u BVTree nodes", nodeCount);
+        handler->PSendSysMessage(" %u polygons (%u vertices)", polyCount, vertCount);
+        handler->PSendSysMessage(" %u triangles (%u vertices)", triCount, triVertCount);
+        handler->PSendSysMessage(" %.2f MB of data (not including pointers)", ((float)dataSize / sizeof(unsigned char)) / 1048576);
+
+        return true;
+    }
+
+    static bool HandleMmapTestArea(ChatHandler* handler, char const* /*args*/)
+    {
+        float radius = 40.0f;
+        WorldObject* object = handler->GetSession()->GetPlayer();
+
+        CellCoord pair(Trinity::ComputeCellCoord(object->GetPositionX(), object->GetPositionY()));
+        Cell cell(pair);
+        cell.SetNoCreate();
+
+        std::list<Creature*> creatureList;
+
+        Trinity::AnyUnitInObjectRangeCheck go_check(object, radius);
+        Trinity::CreatureListSearcher<Trinity::AnyUnitInObjectRangeCheck> go_search(object, creatureList, go_check);
+        TypeContainerVisitor<Trinity::CreatureListSearcher<Trinity::AnyUnitInObjectRangeCheck>, GridTypeMapContainer> go_visit(go_search);
+
+        // Get Creatures
+        cell.Visit(pair, go_visit, *(object->GetMap()), *object, radius);
+
+        if (!creatureList.empty())
+        {
+            handler->PSendSysMessage("Found "SIZEFMTD" Creatures.", creatureList.size());
+
+            uint32 paths = 0;
+            uint32 uStartTime = getMSTime();
+
+            float gx, gy, gz;
+            object->GetPosition(gx, gy, gz);
+            for (std::list<Creature*>::iterator itr = creatureList.begin(); itr != creatureList.end(); ++itr)
+            {
+                PathGenerator path(*itr);
+                path.CalculatePath(gx, gy, gz);
+                ++paths;
+            }
+
+            uint32 uPathLoadTime = getMSTimeDiff(uStartTime, getMSTime());
+            handler->PSendSysMessage("Generated %i paths in %i ms", paths, uPathLoadTime);
+        }
+        else
+            handler->PSendSysMessage("No creatures in %f yard range.", radius);
+
+        return true;
+    }
+};
+
+void AddSC_mmaps_commandscript()
+{
+    new mmaps_commandscript();
+}
diff --git a/src/server/scripts/Commands/cs_npc.cpp b/src/server/scripts/Commands/cs_npc.cpp
index 0217aea1149..6653439b703 100644
--- a/src/server/scripts/Commands/cs_npc.cpp
+++ b/src/server/scripts/Commands/cs_npc.cpp
@@ -33,6 +33,42 @@ EndScriptData */
 #include "Player.h"
 #include "Pet.h"
 
+struct NpcFlagText
+{
+    uint32 flag;
+    int32 text;
+};
+
+#define NPCFLAG_COUNT   24
+
+const NpcFlagText npcFlagTexts[NPCFLAG_COUNT] =
+{
+    { UNIT_NPC_FLAG_AUCTIONEER,         LANG_NPCINFO_AUCTIONEER         },
+    { UNIT_NPC_FLAG_BANKER,             LANG_NPCINFO_BANKER             },
+    { UNIT_NPC_FLAG_BATTLEMASTER,       LANG_NPCINFO_BATTLEMASTER       },
+    { UNIT_NPC_FLAG_FLIGHTMASTER,       LANG_NPCINFO_FLIGHTMASTER       },
+    { UNIT_NPC_FLAG_GOSSIP,             LANG_NPCINFO_GOSSIP             },
+    { UNIT_NPC_FLAG_GUILD_BANKER,       LANG_NPCINFO_GUILD_BANKER       },
+    { UNIT_NPC_FLAG_INNKEEPER,          LANG_NPCINFO_INNKEEPER          },
+    { UNIT_NPC_FLAG_PETITIONER,         LANG_NPCINFO_PETITIONER         },
+    { UNIT_NPC_FLAG_PLAYER_VEHICLE,     LANG_NPCINFO_PLAYER_VEHICLE     },
+    { UNIT_NPC_FLAG_QUESTGIVER,         LANG_NPCINFO_QUESTGIVER         },
+    { UNIT_NPC_FLAG_REPAIR,             LANG_NPCINFO_REPAIR             },
+    { UNIT_NPC_FLAG_SPELLCLICK,         LANG_NPCINFO_SPELLCLICK         },
+    { UNIT_NPC_FLAG_SPIRITGUIDE,        LANG_NPCINFO_SPIRITGUIDE        },
+    { UNIT_NPC_FLAG_SPIRITHEALER,       LANG_NPCINFO_SPIRITHEALER       },
+    { UNIT_NPC_FLAG_STABLEMASTER,       LANG_NPCINFO_STABLEMASTER       },
+    { UNIT_NPC_FLAG_TABARDDESIGNER,     LANG_NPCINFO_TABARDDESIGNER     },
+    { UNIT_NPC_FLAG_TRAINER,            LANG_NPCINFO_TRAINER            },
+    { UNIT_NPC_FLAG_TRAINER_CLASS,      LANG_NPCINFO_TRAINER_CLASS      },
+    { UNIT_NPC_FLAG_TRAINER_PROFESSION, LANG_NPCINFO_TRAINER_PROFESSION },
+    { UNIT_NPC_FLAG_VENDOR,             LANG_NPCINFO_VENDOR             },
+    { UNIT_NPC_FLAG_VENDOR_AMMO,        LANG_NPCINFO_VENDOR_AMMO        },
+    { UNIT_NPC_FLAG_VENDOR_FOOD,        LANG_NPCINFO_VENDOR_FOOD        },
+    { UNIT_NPC_FLAG_VENDOR_POISON,      LANG_NPCINFO_VENDOR_POISON      },
+    { UNIT_NPC_FLAG_VENDOR_REAGENT,     LANG_NPCINFO_VENDOR_REAGENT     }
+};
+
 class npc_commandscript : public CommandScript
 {
 public:
@@ -623,11 +659,9 @@ public:
         handler->PSendSysMessage(LANG_NPCINFO_POSITION, float(target->GetPositionX()), float(target->GetPositionY()), float(target->GetPositionZ()));
         handler->PSendSysMessage(LANG_NPCINFO_AIINFO, target->GetAIName().c_str(), target->GetScriptName().c_str());
 
-        if (npcflags & UNIT_NPC_FLAG_VENDOR)
-            handler->SendSysMessage(LANG_NPCINFO_VENDOR);
-
-        if (npcflags & UNIT_NPC_FLAG_TRAINER)
-            handler->SendSysMessage(LANG_NPCINFO_TRAINER);
+        for (uint8 i = 0; i < NPCFLAG_COUNT; i++)
+            if (npcflags & npcFlagTexts[i].flag)
+                handler->PSendSysMessage(npcFlagTexts[i].text, npcFlagTexts[i].flag);
 
         return true;
     }