#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

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

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:155

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

    {
        const MapOverride* mapOverride = nullptr;
        const TileOverride* 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(
            [](const TileOverride*) { return std::optional<int>{}; },
            [](const MapOverride* m) { return m->vertexPerMapEdge; },
            _global.vertexPerMapEdge
        );
 
        int vertexPerTile = resolveInt(
            [](const TileOverride*) { return std::optional<int>{}; },
            [](const MapOverride* m) { return m->vertexPerTileEdge; },
            _global.vertexPerTileEdge
        );
 
        ResolvedMeshConfig config;
        config.walkableSlopeAngle = resolveFloat(
            [](const TileOverride* t) { return t->walkableSlopeAngle; },
            [](const MapOverride* m) { return m->walkableSlopeAngle; },
            _global.walkableSlopeAngle
        );
 
        config.walkableRadius = resolveInt(
            [](const TileOverride* t) { return t->walkableRadius; },
            [](const MapOverride* m) { return m->walkableRadius; },
            _global.walkableRadius
        );
 
        config.walkableHeight = resolveInt(
            [](const TileOverride* t) { return t->walkableHeight; },
            [](const MapOverride* m) { return m->walkableHeight; },
            _global.walkableHeight
        );
 
        config.walkableClimb = resolveInt(
            [](const TileOverride* t) { return t->walkableClimb; },
            [](const MapOverride* 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:153

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 = [](const fkyaml::node& n, const char* key, float& out)
        {
            if (n.contains(key)) out = n[key].get_value<float>();
        };
        auto tryInt = [](const fkyaml::node& n, const char* key, int& out)
        {
            if (n.contains(key)) out = n[key].get_value<int>();
        };
        auto tryBoolean = [](const fkyaml::node& n, const char* key, bool& out)
        {
            if (n.contains(key)) out = n[key].get_value<bool>();
        };
        auto tryString = [](const fkyaml::node& n, const char* 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);
 
        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, "vertexPerMapEdge", _global.vertexPerMapEdge);
        tryInt(mmapsNode, "vertexPerTileEdge", _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("vertexPerMapEdge"))
                    override.vertexPerMapEdge = mapNode["vertexPerMapEdge"].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;
    }