#include "Config.h"

Classes
struct	GlobalConfig

struct	MapOverride

struct	TileOverride

Public Member Functions
	~Config ()=default

ResolvedMeshConfig	GetConfigForTile (uint32 mapID, uint32 tileX, uint32 tileY) const

bool	ShouldSkipLiquid () const

bool	ShouldSkipContinents () const

bool	ShouldSkipJunkMaps () const

bool	ShouldSkipBattlegrounds () const

bool	IsDebugOutputEnabled () const

std::string	VMapsPath () const

std::string	MapsPath () const

std::string	MMapsPath () const

std::string	DataDirPath () const

std::vector< std::string > const &	OffMeshConnections () const

Static Public Member Functions
static std::optional< Config >	FromFile (std::string_view configFile)

Private Member Functions
	Config ()

bool	LoadConfig (std::string_view configFile)

Private Attributes
GlobalConfig	_global

std::unordered_map< uint32, MapOverride >	_maps

bool	_skipLiquid

bool	_skipContinents

bool	_skipJunkMaps

bool	_skipBattlegrounds

bool	_debugOutput

std::filesystem::path	_dataDir

std::vector< std::string >	_offmeshConnections

Detailed Description

Constructor & Destructor Documentation

◆ ~Config()

MMAP::Config::~Config ( )

default

◆ Config()

MMAP::Config::Config ( )

explicitprivate

72 {

73 }

Member Function Documentation

◆ DataDirPath()

std::string MMAP::Config::DataDirPath ( ) const

inline

77{ return _dataDir.string(); }

MMAP::Config::_dataDir

std::filesystem::path _dataDir

Definition Config.h:157

References _dataDir.

Referenced by MMAP::TileBuilder::buildMoveMapTile(), MMAP::MapBuilder::buildNavMesh(), MMAP::MapBuilder::MapBuilder(), MMAP::TileBuilder::shouldSkipTile(), and MMAP::TileBuilder::TileBuilder().

◆ FromFile()

std::optional< Config > MMAP::Config::FromFile ( std::string_view configFile )

static

                                                                  {
        Config config;
        if (!config.LoadConfig(configFile))
            return std::nullopt;
 
        return config;
    }

References LoadConfig().

Referenced by main().

◆ GetConfigForTile()

ResolvedMeshConfig MMAP::Config::GetConfigForTile	(	uint32	mapID,
		uint32	tileX,
		uint32	tileY
	)		const

    {
        MapOverride const* mapOverride = nullptr;
        TileOverride const* tileOverride = nullptr;
 
        // Lookup map and tile overrides
        if (auto mapIt = _maps.find(mapID); mapIt != _maps.end())
        {
            mapOverride = &mapIt->second;
 
            auto tileIt = mapOverride->tileOverrides.find(MakeTileKey(tileY, tileX));
            if (tileIt != mapOverride->tileOverrides.end())
                tileOverride = &tileIt->second;
        }
 
        // Helper lambdas to resolve values in order: tile -> map -> global
        auto resolveFloat = [&](auto TileField, auto MapField, float GlobalValue) -> float {
            if (tileOverride && TileField(tileOverride)) return *TileField(tileOverride);
            if (mapOverride && MapField(mapOverride)) return *MapField(mapOverride);
            return GlobalValue;
        };
 
        auto resolveInt = [&](auto TileField, auto MapField, int GlobalValue) -> int {
            if (tileOverride && TileField(tileOverride)) return *TileField(tileOverride);
            if (mapOverride && MapField(mapOverride)) return *MapField(mapOverride);
            return GlobalValue;
        };
 
        // Resolve vertex settings
        int vertexPerMap = resolveInt(
            [](TileOverride const*) { return std::optional<int>{}; },
            [](MapOverride const* m) { return m->vertexPerMapEdge; },
            _global.vertexPerMapEdge
        );
 
        int vertexPerTile = resolveInt(
            [](TileOverride const*) { return std::optional<int>{}; },
            [](MapOverride const* m) { return m->vertexPerTileEdge; },
            _global.vertexPerTileEdge
        );
 
        ResolvedMeshConfig config;
        config.walkableSlopeAngle = resolveFloat(
            [](TileOverride const* t) { return t->walkableSlopeAngle; },
            [](MapOverride const* m) { return m->walkableSlopeAngle; },
            _global.walkableSlopeAngle
        );
 
        config.walkableRadius = resolveInt(
            [](TileOverride const* t) { return t->walkableRadius; },
            [](MapOverride const* m) { return m->walkableRadius; },
            _global.walkableRadius
        );
 
        config.walkableHeight = resolveInt(
            [](TileOverride const* t) { return t->walkableHeight; },
            [](MapOverride const* m) { return m->walkableHeight; },
            _global.walkableHeight
        );
 
        config.walkableClimb = resolveInt(
            [](TileOverride const* t) { return t->walkableClimb; },
            [](MapOverride const* m) { return m->walkableClimb; },
            _global.walkableClimb
        );
 
        config.vertexPerMapEdge = vertexPerMap;
        config.vertexPerTileEdge = vertexPerTile;
        config.baseUnitDim = ComputeBaseUnitDim(vertexPerMap);
        config.tilesPerMapEdge = vertexPerMap / vertexPerTile;
        config.maxSimplificationError = _global.maxSimplificationError;
        config.cellSizeHorizontal = config.baseUnitDim;
        config.cellSizeVertical = config.baseUnitDim;
 
        if (mapOverride && mapOverride->cellSizeHorizontal.has_value())
            config.cellSizeHorizontal = *mapOverride->cellSizeHorizontal;
 
        if (mapOverride && mapOverride->cellSizeVertical.has_value())
            config.cellSizeVertical = *mapOverride->cellSizeVertical;
 
        return config;
    }

References _global, _maps, MMAP::Config::MapOverride::cellSizeHorizontal, MMAP::Config::MapOverride::cellSizeVertical, MMAP::ComputeBaseUnitDim(), MMAP::MakeTileKey(), MMAP::Config::GlobalConfig::maxSimplificationError, MMAP::Config::MapOverride::tileOverrides, MMAP::Config::GlobalConfig::vertexPerMapEdge, MMAP::Config::GlobalConfig::vertexPerTileEdge, MMAP::Config::TileOverride::walkableClimb, MMAP::Config::GlobalConfig::walkableClimb, MMAP::Config::TileOverride::walkableHeight, MMAP::Config::GlobalConfig::walkableHeight, MMAP::Config::TileOverride::walkableRadius, MMAP::Config::GlobalConfig::walkableRadius, MMAP::ResolvedMeshConfig::walkableSlopeAngle, MMAP::Config::TileOverride::walkableSlopeAngle, and MMAP::Config::GlobalConfig::walkableSlopeAngle.

Referenced by MMAP::TileBuilder::buildMoveMapTile(), and MMAP::TileBuilder::shouldSkipTile().

◆ IsDebugOutputEnabled()

bool MMAP::Config::IsDebugOutputEnabled ( ) const

inline

72{ return _debugOutput; }

MMAP::Config::_debugOutput

bool _debugOutput

Definition Config.h:155

References _debugOutput.

◆ LoadConfig()

bool MMAP::Config::LoadConfig ( std::string_view configFile )

private

                                                     {
        FILE* f = std::fopen(configFile.data(), "r");
        if (!f)
            return false;
 
        fkyaml::node root = fkyaml::node::deserialize(f);
        std::fclose(f);
 
        if (!root.contains("mmapsConfig"))
            return false;
 
        fkyaml::node mmapsNode = root["mmapsConfig"];
 
        auto tryFloat = [](fkyaml::node const& n, char const* key, float& out)
        {
            if (n.contains(key)) out = n[key].get_value<float>();
        };
        auto tryInt = [](fkyaml::node const& n, char const* key, int& out)
        {
            if (n.contains(key)) out = n[key].get_value<int>();
        };
        auto tryBoolean = [](fkyaml::node const& n, char const* key, bool& out)
        {
            if (n.contains(key)) out = n[key].get_value<bool>();
        };
        auto tryString = [](fkyaml::node const& n, char const* key, std::string& out)
        {
            if (n.contains(key)) out = n[key].get_value<std::string>();
        };
 
        tryBoolean(mmapsNode, "skipLiquid", _skipLiquid);
        tryBoolean(mmapsNode, "skipContinents", _skipContinents);
        tryBoolean(mmapsNode, "skipJunkMaps", _skipJunkMaps);
        tryBoolean(mmapsNode, "skipBattlegrounds", _skipBattlegrounds);
        tryBoolean(mmapsNode, "debugOutput", _debugOutput);
 
        if (mmapsNode.contains("offmeshConnections") && mmapsNode["offmeshConnections"].is_sequence())
        {
            _offmeshConnections = mmapsNode["offmeshConnections"].get_value<std::vector<std::string>>();
        }
        else
        {
            _offmeshConnections.clear();
        }
 
        std::string dataDirPath;
        tryString(mmapsNode, "dataDir", dataDirPath);
        _dataDir = dataDirPath;
 
        mmapsNode = mmapsNode["meshSettings"];
 
        // Global config
        tryFloat(mmapsNode, "walkableSlopeAngle", _global.walkableSlopeAngle);
        tryInt(mmapsNode, "walkableHeight", _global.walkableHeight);
        tryInt(mmapsNode, "walkableClimb", _global.walkableClimb);
        tryInt(mmapsNode, "walkableRadius", _global.walkableRadius);
        tryInt(mmapsNode, "verticesPerMapEdge", _global.vertexPerMapEdge);
        tryInt(mmapsNode, "verticesPerTileEdge", _global.vertexPerTileEdge);
        tryFloat(mmapsNode, "maxSimplificationError", _global.maxSimplificationError);
 
        // Map overrides
        if (mmapsNode.contains("mapsOverrides"))
        {
            fkyaml::node maps = mmapsNode["mapsOverrides"];
            for (auto const& mapEntry : maps.as_map())
            {
                uint32 mapId = std::stoi(mapEntry.first.as_str());
 
                MapOverride override;
                fkyaml::node mapNode = mapEntry.second;
 
                if (mapNode.contains("walkableSlopeAngle"))
                    override.walkableSlopeAngle = mapNode["walkableSlopeAngle"].get_value<float>();
                if (mapNode.contains("walkableRadius"))
                    override.walkableRadius = mapNode["walkableRadius"].get_value<int>();
                if (mapNode.contains("walkableHeight"))
                    override.walkableHeight = mapNode["walkableHeight"].get_value<int>();
                if (mapNode.contains("walkableClimb"))
                    override.walkableClimb = mapNode["walkableClimb"].get_value<int>();
                if (mapNode.contains("verticesPerMapEdge"))
                    override.vertexPerMapEdge = mapNode["verticesPerMapEdge"].get_value<int>();
                if (mapNode.contains("verticesPerTileEdge"))
                    override.vertexPerTileEdge = mapNode["verticesPerTileEdge"].get_value<int>();
                if (mapNode.contains("cellSizeHorizontal"))
                    override.cellSizeHorizontal = mapNode["cellSizeHorizontal"].get_value<float>();
                if (mapNode.contains("cellSizeVertical"))
                    override.cellSizeVertical = mapNode["cellSizeVertical"].get_value<float>();
 
                // Tile overrides
                if (mapNode.contains("tilesOverrides"))
                {
                    fkyaml::node tiles = mapNode["tilesOverrides"];
                    for (auto const& tileEntry : tiles.as_map())
                    {
                        std::string key = tileEntry.first.as_str();
                        fkyaml::node tileNode = tileEntry.second;
 
                        size_t comma = key.find(',');
                        if (comma == std::string::npos)
                            continue;
 
                        uint32 tileX = static_cast<uint32>(std::stoi(key.substr(0, comma)));
                        uint32 tileY = static_cast<uint32>(std::stoi(key.substr(comma + 1)));
 
                        TileOverride tileOverride;
                        if (tileNode.contains("walkableSlopeAngle"))
                            tileOverride.walkableSlopeAngle = tileNode["walkableSlopeAngle"].get_value<float>();
                        if (tileNode.contains("walkableRadius"))
                            tileOverride.walkableRadius = tileNode["walkableRadius"].get_value<int>();
                        if (tileNode.contains("walkableHeight"))
                            tileOverride.walkableHeight = tileNode["walkableHeight"].get_value<int>();
                        if (tileNode.contains("walkableClimb"))
                            tileOverride.walkableClimb = tileNode["walkableClimb"].get_value<int>();
 
                        override.tileOverrides[{tileX, tileY}] = std::move(tileOverride);
                    }
                }
 
                _maps[mapId] = std::move(override);
            }
        }
 
        // Resolve data dir path. Maybe we need to use an executable path instead of the current dir.
        if (isCurrentDirectory(_dataDir.string()) && !std::filesystem::exists(MapsPath()))
            if (auto execPath = std::filesystem::path(executableDirectoryPath()); std::filesystem::exists(execPath/ "maps"))
                _dataDir = execPath;
 
        return true;
    }