Ascent-of-Man/terrainyieldmanager.cpp

#include "terrainyieldmanager.h"
#include "terrainmovementmanager.h"
#include "yamlparser.h"
#include "pathfinder.h"
#include <QDebug>
#include <cmath>

TerrainYieldManager& TerrainYieldManager::instance()
{
    static TerrainYieldManager s_instance;
    return s_instance;
}

TerrainYieldManager::TerrainYieldManager()
    : m_loaded(false)
{
}

bool TerrainYieldManager::loadConfigs(const QString &baseDir)
{
    // 0. Load terrain_movement.yaml
    TerrainMovementManager::instance().loadConfig(baseDir + "/config/terrain_movement.yaml");

    // 1. Load city.yaml
    QString cityFile = baseDir + "/config/city.yaml";
    YamlNode cityRoot = YamlParser::parseFile(cityFile);
    if (!cityRoot.children.isEmpty()) {
        m_cityConfig.initialInhabitants = cityRoot["initial_inhabitants"].asInt(1000);
        m_cityConfig.inhabitantsPerPop = cityRoot["inhabitants_per_pop"].asInt(100000);
        m_cityConfig.initialBorderRadius = cityRoot["initial_border_radius"].asInt(1);
        m_cityConfig.maxWorkableRadius = cityRoot["max_workable_radius"].asInt(3);
        m_cityConfig.defaultTileSlots = cityRoot["default_tile_slots"].asInt(1);
        m_cityConfig.cityViewZoom = cityRoot["city_view_zoom"].asFloat(4.8f);

        m_cityConfig.baseResourceYieldPerTick = cityRoot["base_resource_yield_per_tick"].asInt(500);
        m_cityConfig.tileCultureCost = cityRoot["tile_culture_cost"].asInt(10000);
        m_cityConfig.foodToInhabitantsRatio = cityRoot["food_to_inhabitants_ratio"].asFloat(1.0f);
        m_cityConfig.maxProductionQueueSize = cityRoot["max_production_queue_size"].asInt(6);

        if (cityRoot.hasChild("base_yields")) {
            const YamlNode &bNode = cityRoot["base_yields"];
            for (auto it = bNode.children.begin(); it != bNode.children.end(); ++it) {
                m_cityConfig.baseYields[it.key()] = it.value().asInt(m_cityConfig.baseResourceYieldPerTick);
            }
        }

        if (cityRoot.hasChild("initial_national_resources")) {
            const YamlNode &rNode = cityRoot["initial_national_resources"];
            for (auto it = rNode.children.begin(); it != rNode.children.end(); ++it) {
                m_cityConfig.initialNationalResources[it.key()] = it.value().asInt(0);
            }
        }

        m_cityConfig.slotLongPressDurationMs = cityRoot["slot_long_press_duration_ms"].asInt(400);

        if (cityRoot.hasChild("resource_priority") && !cityRoot["resource_priority"].listValues.isEmpty()) {
            m_cityConfig.resourcePriority = cityRoot["resource_priority"].listValues;
        }
    }

    // 2. Load terrain_yields.yaml
    QString yieldsFile = baseDir + "/config/terrain_yields.yaml";
    YamlNode yieldsRoot = YamlParser::parseFile(yieldsFile);

    for (auto it = yieldsRoot.children.begin(); it != yieldsRoot.children.end(); ++it) {
        QString typeKey = it.key();
        const YamlNode &node = it.value();

        TerrainYieldConfig cfg;
        cfg.id = typeKey;
        cfg.name = node["name"].asString(typeKey);
        cfg.workable = node["workable"].asBool(true);
        cfg.defaultSlots = node["default_slots"].asInt(cfg.workable ? 1 : 0);
        cfg.primaryResource = node["primary_resource"].asString("voedsel");

        if (node.hasChild("yields")) {
            const YamlNode &yNode = node["yields"];
            for (auto yIt = yNode.children.begin(); yIt != yNode.children.end(); ++yIt) {
                cfg.yields[yIt.key()] = yIt.value().asInt(0);
            }
        }

        m_yieldConfigs[typeKey] = cfg;
    }

    // 3. Load improvements.yaml
    QString impFile = baseDir + "/config/improvements.yaml";
    YamlNode impRoot = YamlParser::parseFile(impFile);
    for (auto it = impRoot.children.begin(); it != impRoot.children.end(); ++it) {
        QString impKey = it.key();
        const YamlNode &node = it.value();

        ImprovementConfig cfg;
        cfg.id = node.hasChild("id") ? node["id"].asString() : impKey;
        cfg.name = node.hasChild("name") ? node["name"].asString() : cfg.id;
        cfg.action = node.hasChild("action") ? node["action"].asString() : "boerderij_bouwen";
        cfg.texturePath = node.hasChild("texture") ? node["texture"].asString() : "images/farm.jpeg";
        cfg.textureScale = node.hasChild("texture_scale") ? node["texture_scale"].asFloat(0.6f) : 0.6f;
        cfg.textureMapping = node.hasChild("texture_mapping") ? node["texture_mapping"].asString("world") : "world";

        if (node.hasChild("valid_terrains")) {
            cfg.validTerrains = node["valid_terrains"].listValues;
        } else {
            cfg.validTerrains = QStringList{"grasland", "tundra"};
        }

        if (node.hasChild("yield_bonus")) {
            const YamlNode &ybNode = node["yield_bonus"];
            for (auto ybIt = ybNode.children.begin(); ybIt != ybNode.children.end(); ++ybIt) {
                cfg.yieldBonus[ybIt.key()] = ybIt.value().asInt(0);
            }
        }

        m_improvementConfigs[impKey] = cfg;
    }

    m_loaded = true;
    qDebug() << "TerrainYieldManager loaded" << m_yieldConfigs.size() << "terrain types,"
             << m_improvementConfigs.size() << "improvements, and city config.";
    return true;
}

QString TerrainYieldManager::getTerrainType(int tx, int ty, Matrix2D<TerrainPoint> *mapPoints, int numPoints05) const
{
    return TerrainMovementManager::instance().getTerrainType(tx, ty, mapPoints, numPoints05);
}

const TerrainYieldConfig* TerrainYieldManager::getYieldConfig(const QString &terrainType) const
{
    auto it = m_yieldConfigs.find(terrainType);
    if (it != m_yieldConfigs.end()) {
        return &it.value();
    }
    return nullptr;
}

const ImprovementConfig* TerrainYieldManager::getImprovementConfig(const QString &id) const
{
    auto it = m_improvementConfigs.find(id);
    if (it != m_improvementConfigs.end()) {
        return &it.value();
    }
    return nullptr;
}