OrekiWoofsBeehives/OrekiWoofsBeehives/ModConfigSetup.cs

using ConfigLib;
using System;
using Vintagestory.API.Client;
using Vintagestory.API.Common;
using Vintagestory.API.Server;

namespace OrekiWoofsBeehives;

public partial class OrekiWoofsBeehivesModSystem : ModSystem
{
    private ConfigLibModSystem? configLibSystem;
    public const string CONFIG_CHANNEL_NAME = "orekiwoofsbeehives-config";
    private const string config_filename = "OrekiWoofsBeehives.json";

    private void SubscribeToConfigChange(ICoreAPI api)
    {
        configLibSystem = api.ModLoader.GetModSystem<ConfigLibModSystem>();
        if (configLibSystem == null)
            return;

        configLibSystem.SettingChanged += OnSettingChanged;
        configLibSystem.ConfigsLoaded += OnConfigsLoaded;
    }

    private void UnsubscribeFromConfigChange()
    {
        if (configLibSystem is null)
            return;
        configLibSystem.SettingChanged -= OnSettingChanged;
        configLibSystem.ConfigsLoaded -= OnConfigsLoaded;
    }

    private void OnConfigsLoaded()
    {
        configLibSystem?.GetConfig("orekiwoofsbeehives")?.AssignSettingsValues(Config.Instance);
    }

    private void OnSettingChanged(string domain, IConfig config, ISetting setting)
    {
        if (domain != "orekiwoofsbeehives")
            return;

        try
        {
            if (api != null)
                Config.Instance = api.LoadModConfig<Config>(config_filename) ?? Config.Instance;
            setting.AssignSettingValue(Config.Instance);
            serverApi?.Network.GetChannel(CONFIG_CHANNEL_NAME).BroadcastPacket(Config.Instance);
            if (api?.Side == EnumAppSide.Server)
                api.StoreModConfig(Config.Instance, config_filename);
        }
        catch (Exception ex)
        {
            Mod.Logger.Error(ex);
        }
    }

    private void InitializeServerConfig(ICoreServerAPI api)
    {
        try
        {
            var oldCropBonus = GetBackCompatibilityCropBonus(api);
            Config.Instance = api.LoadModConfig<Config>(config_filename);
            Config.Instance ??= new Config();

            ConvertOldCropBonus(oldCropBonus, Config.Instance);
            var temperatureMigrated = ConvertBackCompatibilityTemperature(api, Config.Instance);

            api.StoreModConfig(Config.Instance, config_filename);

            if ((oldCropBonus is not null || temperatureMigrated) && api.ModLoader.IsModEnabled("configlib"))
                ReloadConfigForConfigLib(api);

            api.Event.PlayerJoin += OnPlayerJoin;
        }
        catch (Exception e)
        {
            Mod.Logger.Error("Could not load config! Loading default settings instead.");
            Mod.Logger.Error(e);
            Config.Instance = new Config();
        }
    }

    private void InitializeClientConfig(ICoreClientAPI api)
    {
        Config? clientSideConfig;
        try
        {
            clientSideConfig = (Config?)api.LoadModConfig<Config>(config_filename);
        }
        catch (Exception e)
        {
            Mod.Logger.Error("Could not load client-side config! Loading default client-side settings instead.");
            Mod.Logger.Error(e);
            clientSideConfig = new Config();
        }

        if (clientSideConfig is null)
            return;

        Config.Instance.BeehiveAmbientVolume = clientSideConfig.BeehiveAmbientVolume;
        Config.Instance.InformationVerbosity = clientSideConfig.InformationVerbosity;
        Config.Instance.DisableServerRecommended = clientSideConfig.DisableServerRecommended;
    }

    private static void ReloadConfigForConfigLib(ICoreAPI api)
    {
        var configLibModSystem = api.ModLoader.GetModSystem<ConfigLibModSystem>();
        var configLibConfig = configLibModSystem.GetConfig("orekiwoofsbeehives");
        configLibConfig?.ReadFromFile();
    }

    private void OnPlayerJoin(IServerPlayer byPlayer)
    {
        serverApi!.Network.GetChannel(CONFIG_CHANNEL_NAME).SendPacket(Config.Instance, byPlayer);
    }

    private void OnConfigReceivedFromServer(Config packet)
    {
        var currentConfig = Config.Instance;
        Config.Instance = packet;
        Config.Instance.InformationVerbosity = currentConfig.InformationVerbosity;
        Config.Instance.DisableServerRecommended = currentConfig.DisableServerRecommended;
        Config.Instance.BeehiveAmbientVolume = currentConfig.BeehiveAmbientVolume;
    }

    private static CropBonusType? GetBackCompatibilityCropBonus(ICoreAPI api)
    {
        var cfgJson = api.LoadModConfig(config_filename);
        if (cfgJson is null || !cfgJson.KeyExists("CropBonus"))
            return null;

        var cropBonusObj = cfgJson["CropBonus"];
        if (cropBonusObj is null)
            return null;

        var cropBonusInt = cropBonusObj.AsInt(-1);
        if (cropBonusInt >= 0)
        {
            var cropBonus = (CropBonusType)cropBonusInt;
            return cropBonus;
        }

        var cropBonusStr = cropBonusObj.AsString(null);
        return cropBonusStr switch
        {
            "Yield" => CropBonusType.Yield,
            "Speed" => CropBonusType.Speed,
            "YieldAndSpeed" => CropBonusType.YieldAndSpeed,
            "None" => CropBonusType.None,
            _ => null,
        };
    }

    private void ConvertOldCropBonus(CropBonusType? cropBonus, Config config)
    {
        if (cropBonus == null)
            return;

        config.SpeedBoost = false;
        config.YieldBoost = false;
        switch (cropBonus.Value)
        {
            case CropBonusType.Yield:
                config.YieldBoost = true;
                break;
            case CropBonusType.Speed:
                config.SpeedBoost = true;
                break;
            case CropBonusType.YieldAndSpeed:
                config.YieldBoost = true;
                config.SpeedBoost = true;
                break;
            default:
                break;
        }

        Mod.Logger.Event($"Converted CropBonus:{cropBonus} to YieldBoost:{config.YieldBoost}, SpeedBoost:{config.SpeedBoost}");
    }

    private bool ConvertBackCompatibilityTemperature(ICoreAPI api, Config config)
    {
        const string old_min_temperature_growth_key = "MinTemperatureGrowth";
        const string old_max_temperature_growth_key = "MaxTemperatureGrowth";

        var cfgJson = api.LoadModConfig(config_filename);
        if (cfgJson is null)
            return false;

        var migrated = false;

        if (!cfgJson.KeyExists(nameof(Config.TemperatureMinimum)) && cfgJson.KeyExists(old_min_temperature_growth_key))
        {
            config.TemperatureMinimum = cfgJson[old_min_temperature_growth_key].AsFloat(config.TemperatureMinimum);
            migrated = true;
        }

        if (!cfgJson.KeyExists(nameof(Config.TemperatureOptimal)) && cfgJson.KeyExists(old_max_temperature_growth_key))
        {
            config.TemperatureOptimal = cfgJson[old_max_temperature_growth_key].AsFloat(config.TemperatureOptimal);
            migrated = true;
        }

        if (migrated)
            Mod.Logger.Event($"Converted legacy temperature config values to TemperatureMinimum:{config.TemperatureMinimum}, TemperatureOptimal:{config.TemperatureOptimal}");

        return migrated;
    }
}