mmaps_commandscript Class Reference

Inheritance diagram for mmaps_commandscript:

Public Member Functions
	mmaps_commandscript ()
ChatCommandTable	GetCommands () const override
Public Member Functions inherited from ScriptObject
virtual bool	IsDatabaseBound () const
virtual bool	isAfterLoadScript () const
virtual void	checkValidity ()
const std::string &	GetName () const
uint16	GetTotalAvailableHooks ()

Static Public Member Functions
static bool	HandleMmapPathCommand (ChatHandler *handler, Optional< std::string > param)
static bool	HandleMmapLocCommand (ChatHandler *handler)
static bool	HandleMmapLoadedTilesCommand (ChatHandler *handler)
static bool	HandleMmapStatsCommand (ChatHandler *handler)
static bool	HandleMmapTestArea (ChatHandler *handler)

Additional Inherited Members
Protected Member Functions inherited from CommandScript
	CommandScript (const char *name)
Protected Member Functions inherited from ScriptObject
	ScriptObject (const char *name, uint16 totalAvailableHooks=0)
virtual	~ScriptObject ()=default

Detailed Description

Constructor & Destructor Documentation

mmaps_commandscript()

mmaps_commandscript::mmaps_commandscript ( )

inline

: CommandScript("mmaps_commandscript") { }

Member Function Documentation

GetCommands()

ChatCommandTable mmaps_commandscript::GetCommands ( ) const

inlineoverridevirtual

Implements CommandScript.

    {
        static ChatCommandTable mmapCommandTable =
        {
            { "loadedtiles", HandleMmapLoadedTilesCommand, rbac::RBAC_PERM_COMMAND_MMAP_LOADEDTILES, Console::No },
            { "loc",         HandleMmapLocCommand,         rbac::RBAC_PERM_COMMAND_MMAP_LOC,         Console::No },
            { "path",        HandleMmapPathCommand,        rbac::RBAC_PERM_COMMAND_MMAP_PATH,        Console::No },
            { "stats",       HandleMmapStatsCommand,       rbac::RBAC_PERM_COMMAND_MMAP_STATS,       Console::No },
            { "testarea",    HandleMmapTestArea,           rbac::RBAC_PERM_COMMAND_MMAP_TESTAREA,    Console::No }
        };
 
        static ChatCommandTable commandTable =
        {
            { "mmap", mmapCommandTable }
        };
        return commandTable;
    }

References HandleMmapLoadedTilesCommand(), HandleMmapLocCommand(), HandleMmapPathCommand(), HandleMmapStatsCommand(), HandleMmapTestArea(), rbac::RBAC_PERM_COMMAND_MMAP_LOADEDTILES, rbac::RBAC_PERM_COMMAND_MMAP_LOC, rbac::RBAC_PERM_COMMAND_MMAP_PATH, rbac::RBAC_PERM_COMMAND_MMAP_STATS, and rbac::RBAC_PERM_COMMAND_MMAP_TESTAREA.

HandleMmapLoadedTilesCommand()

static bool mmaps_commandscript::HandleMmapLoadedTilesCommand ( ChatHandler *  handler )

inlinestatic

    {
        Map* map = handler->GetSession()->GetPlayer()->GetMap();
        dtNavMesh const* navmesh = map->GetMapCollisionData().GetMMapData().GetNavMesh();
        dtNavMeshQuery const* navmeshquery = map->GetMapCollisionData().GetMMapData().GetNavMeshQuery();
        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("[{}, {}]", tile->header->x, tile->header->y);
        }
 
        return true;
    }

References WorldObject::GetMap(), Map::GetMapCollisionData(), MapCollisionData::GetMMapData(), MMapData::GetNavMesh(), MMapData::GetNavMeshQuery(), WorldSession::GetPlayer(), ChatHandler::GetSession(), and ChatHandler::PSendSysMessage().

Referenced by GetCommands().

HandleMmapLocCommand()

static bool mmaps_commandscript::HandleMmapLocCommand ( ChatHandler *  handler )

inlinestatic

    {
        handler->PSendSysMessage("mmap tileloc:");
 
        // grid tile location
        Player* player = handler->GetSession()->GetPlayer();
 
        GridCoord const gridCoord = Acore::ComputeGridCoord(player->GetPositionX(), player->GetPositionY());
 
        handler->PSendSysMessage("{}{}{}.mmtile", player->GetMapId(), gridCoord.x_coord, gridCoord.y_coord);
 
        std::string fileName = Acore::StringFormat(MMAP::TILE_FILE_NAME_FORMAT, sConfigMgr->GetOption<std::string>("DataDir", "."), player->GetMapId(), gridCoord.x_coord, gridCoord.y_coord);
        FILE* file = fopen(fileName.c_str(), "rb");
        if (!file)
        {
            LOG_DEBUG("maps", "MMAP:loadMap: Could not open mmtile file '{}'", fileName);
            return false;
        }
 
        // read header
        MmapTileHeader fileHeader;
        if (fread(&fileHeader, sizeof(MmapTileHeader), 1, file) != 1 || fileHeader.mmapMagic != MMAP_MAGIC)
        {
            LOG_ERROR("maps", "MMAP:loadMap: Bad header in mmap {:03}{:02}{:02}.mmtile", player->GetMapId(), gridCoord.x_coord, gridCoord.y_coord);
            fclose(file);
            return false;
        }
        fclose(file);
        handler->PSendSysMessage("Recast config used:");
        handler->PSendSysMessage("- walkableSlopeAngle: {}", fileHeader.recastConfig.walkableSlopeAngle);
 
        const float cellHeight = fileHeader.recastConfig.cellSizeVertical;
        handler->PSendSysMessage("- walkableHeight: {} ({} units)", fileHeader.recastConfig.walkableHeight * cellHeight, fileHeader.recastConfig.walkableHeight);
        handler->PSendSysMessage("- walkableClimb: {} ({} units)", fileHeader.recastConfig.walkableClimb * cellHeight, fileHeader.recastConfig.walkableClimb);
        handler->PSendSysMessage("- walkableRadius: {} ({} units)", fileHeader.recastConfig.walkableRadius * cellHeight, fileHeader.recastConfig.walkableRadius);
 
        handler->PSendSysMessage("- maxSimplificationError: {}", fileHeader.recastConfig.maxSimplificationError);
        handler->PSendSysMessage("- vertexPerMapEdge: {}", fileHeader.recastConfig.vertexPerMapEdge);
        handler->PSendSysMessage("- vertexPerTileEdge: {}", fileHeader.recastConfig.vertexPerTileEdge);
        handler->PSendSysMessage("- tilesPerMapEdge: {}", fileHeader.recastConfig.tilesPerMapEdge);
        handler->PSendSysMessage("- baseUnitDim: {}", fileHeader.recastConfig.baseUnitDim);
        handler->PSendSysMessage("- cellSizeHorizontal: {}", fileHeader.recastConfig.cellSizeHorizontal);
        handler->PSendSysMessage("- cellSizeVertical: {}", fileHeader.recastConfig.cellSizeVertical);
 
        handler->PSendSysMessage("gridloc [{}, {}]", gridCoord.x_coord, gridCoord.y_coord);
 
        Map* map = handler->GetSession()->GetPlayer()->GetMap();
 
        // calculate navmesh tile location
        dtNavMesh const* navmesh = map->GetMapCollisionData().GetMMapData().GetNavMesh();
        dtNavMeshQuery const* navmeshquery = map->GetMapCollisionData().GetMMapData().GetNavMeshQuery();
        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   [{}, {}]", tilex, tiley);
 
        // navmesh poly -> navmesh tile location
        dtQueryFilterExt filter = dtQueryFilterExt();
        dtPolyRef polyRef = INVALID_POLYREF;
        if (dtStatusFailed(navmeshquery->findNearestPoly(location, extents, &filter, &polyRef, nullptr)))
        {
            handler->PSendSysMessage("Dt     [??,??] (invalid poly, probably no tile loaded)");
            return true;
        }
 
        if (polyRef == INVALID_POLYREF)
            handler->PSendSysMessage("Dt     [??, ??] (invalid poly, probably no tile loaded)");
        else
        {
            dtMeshTile const* tile;
            dtPoly const* poly;
            if (dtStatusSucceed(navmesh->getTileAndPolyByRef(polyRef, &tile, &poly)))
            {
                if (tile)
                {
                    handler->PSendSysMessage("Dt     [{},{}]", tile->header->x, tile->header->y);
                    return false;
                }
            }
 
            handler->PSendSysMessage("Dt     [??,??] (no tile loaded)");
        }
 
        return true;
    }

References MmapTileRecastConfig::baseUnitDim, MmapTileRecastConfig::cellSizeHorizontal, MmapTileRecastConfig::cellSizeVertical, Acore::ComputeGridCoord(), WorldObject::GetMap(), Map::GetMapCollisionData(), WorldLocation::GetMapId(), MapCollisionData::GetMMapData(), MMapData::GetNavMesh(), MMapData::GetNavMeshQuery(), WorldSession::GetPlayer(), Position::GetPosition(), Position::GetPositionX(), Position::GetPositionY(), ChatHandler::GetSession(), INVALID_POLYREF, LOG_DEBUG, LOG_ERROR, MmapTileRecastConfig::maxSimplificationError, MMAP_MAGIC, MmapTileHeader::mmapMagic, ChatHandler::PSendSysMessage(), MmapTileHeader::recastConfig, sConfigMgr, SIZE_OF_GRIDS, Acore::StringFormat(), MMAP::TILE_FILE_NAME_FORMAT, MmapTileRecastConfig::tilesPerMapEdge, VERTEX_SIZE, MmapTileRecastConfig::vertexPerMapEdge, MmapTileRecastConfig::vertexPerTileEdge, MmapTileRecastConfig::walkableClimb, MmapTileRecastConfig::walkableHeight, MmapTileRecastConfig::walkableRadius, MmapTileRecastConfig::walkableSlopeAngle, CoordPair< LIMIT >::x_coord, and CoordPair< LIMIT >::y_coord.

Referenced by GetCommands().

HandleMmapPathCommand()

static bool mmaps_commandscript::HandleMmapPathCommand ( ChatHandler *  handler, Optional< std::string >  param  )

inlinestatic

    {
        Map* map = handler->GetSession()->GetPlayer()->GetMap();
        if (!map->GetMapCollisionData().GetMMapData().GetNavMesh())
        {
            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;
        }
 
        bool useStraightPath = false;
        bool useRaycast = false;
        if (param)
        {
            auto paramValue = param.value();
            if (paramValue.starts_with("true"))
            {
                useStraightPath = true;
            }
 
            if (paramValue.starts_with("line") || paramValue.starts_with("ray") || paramValue.starts_with("raycast"))
            {
                useRaycast = true;
            }
        }
 
        // unit locations
        float x, y, z;
        player->GetPosition(x, y, z);
 
        // path
        PathGenerator path(target);
        path.SetUseStraightPath(useStraightPath);
        path.SetUseRaycast(useRaycast);
        bool result = path.CalculatePath(x, y, z, false);
 
        Movement::PointsArray const& pointPath = path.GetPath();
        handler->PSendSysMessage("{}'s path to {}:", target->GetName(), player->GetName());
        handler->PSendSysMessage("Building: {}", useStraightPath ? "StraightPath" : useRaycast ? "Raycast" : "SmoothPath");
        handler->PSendSysMessage("Result: {} - Length: {} - Type: {}", (result ? "true" : "false"), pointPath.size(), path.GetPathType());
 
        G3D::Vector3 const& start = path.GetStartPosition();
        G3D::Vector3 const& end = path.GetEndPosition();
        G3D::Vector3 const& actualEnd = path.GetActualEndPosition();
 
        handler->PSendSysMessage("StartPosition     ({}, {}, {})", start.x, start.y, start.z);
        handler->PSendSysMessage("EndPosition       ({}, {}, {})", end.x, end.y, end.z);
        handler->PSendSysMessage("ActualEndPosition ({}, {}, {})", actualEnd.x, actualEnd.y, actualEnd.z);
 
        if (!player->IsGameMaster())
            handler->PSendSysMessage("Enable GM mode to see the path points.");
 
        for (auto i : pointPath)
            player->SummonCreature(VISUAL_WAYPOINT, i.x, i.y, i.z, 0, TEMPSUMMON_TIMED_DESPAWN, 9000);
 
        return true;
    }

References PathGenerator::CalculatePath(), PathGenerator::GetActualEndPosition(), PathGenerator::GetEndPosition(), WorldObject::GetMap(), Map::GetMapCollisionData(), MapCollisionData::GetMMapData(), WorldObject::GetName(), MMapData::GetNavMesh(), PathGenerator::GetPath(), PathGenerator::GetPathType(), WorldSession::GetPlayer(), Position::GetPosition(), ChatHandler::getSelectedUnit(), ChatHandler::GetSession(), PathGenerator::GetStartPosition(), Player::IsGameMaster(), ChatHandler::PSendSysMessage(), PathGenerator::SetUseRaycast(), PathGenerator::SetUseStraightPath(), WorldObject::SummonCreature(), TEMPSUMMON_TIMED_DESPAWN, and VISUAL_WAYPOINT.

Referenced by GetCommands().

HandleMmapStatsCommand()

static bool mmaps_commandscript::HandleMmapStatsCommand ( ChatHandler *  handler )

inlinestatic

    {
        Map* map = handler->GetSession()->GetPlayer()->GetMap();
 
        //handler->PSendSysMessage("mmap stats:");
        //handler->PSendSysMessage("  global mmap pathfinding is {}abled", sDisableMgr->IsPathfindingEnabled(mapId) ? "en" : "dis");
        //MMAP::MMapMgr* manager = MMAP::MMapFactory::createOrGetMMapMgr();
        //handler->PSendSysMessage(" {} maps loaded with {} tiles overall", manager->getLoadedMapsCount(), manager->getLoadedTilesCount());
 
        dtNavMesh const* navmesh = map->GetMapCollisionData().GetMMapData().GetNavMesh();
        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(" {} tiles loaded", tileCount);
        handler->PSendSysMessage(" {} BVTree nodes", nodeCount);
        handler->PSendSysMessage(" {} polygons ({} vertices)", polyCount, vertCount);
        handler->PSendSysMessage(" {} triangles ({} vertices)", triCount, triVertCount);
        handler->PSendSysMessage(" {} MB of data (not including pointers)", ((float)dataSize / sizeof(unsigned char)) / 1048576);
 
        return true;
    }

References WorldObject::GetMap(), Map::GetMapCollisionData(), MapCollisionData::GetMMapData(), MMapData::GetNavMesh(), WorldSession::GetPlayer(), ChatHandler::GetSession(), and ChatHandler::PSendSysMessage().

Referenced by GetCommands().

HandleMmapTestArea()

static bool mmaps_commandscript::HandleMmapTestArea ( ChatHandler *  handler )

inlinestatic

    {
        float radius = 40.0f;
        WorldObject* object = handler->GetSession()->GetPlayer();
 
        // Get Creatures
        std::list<Creature*> creatureList;
        Acore::AnyUnitInObjectRangeCheck go_check(object, radius);
        Acore::CreatureListSearcher<Acore::AnyUnitInObjectRangeCheck> go_search(object, creatureList, go_check);
        Cell::VisitObjects(object, go_search, radius);
 
        if (!creatureList.empty())
        {
            handler->PSendSysMessage("Found {} 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 {} paths in {} ms", paths, uPathLoadTime);
        }
        else
            handler->PSendSysMessage("No creatures in {} yard range.", radius);
 
        return true;
    }

References PathGenerator::CalculatePath(), getMSTime(), getMSTimeDiff(), WorldSession::GetPlayer(), ChatHandler::GetSession(), ChatHandler::PSendSysMessage(), and Cell::VisitObjects().

Referenced by GetCommands().

---

The documentation for this class was generated from the following file:

• azerothcore-wotlk/src/server/scripts/Commands/cs_mmaps.cpp