ClientConfig.cs

using UnityEngine;
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using System.Linq;
using Lidgren.Network;

[Serializable]
public class ClientConfig
{
    public ClientVideoConfig Video = new ClientVideoConfig();
    public ClientAudioConfig Audio = new ClientAudioConfig();
    public ClientControlsConfig Controls = new ClientControlsConfig();
    public ClientNetworkConfig Network = new ClientNetworkConfig();
    public ClientUIConfig UI = new ClientUIConfig();
    public ClientStudyConfig Study = new ClientStudyConfig();
    public ClientDevicesConfig Devices = new ClientDevicesConfig();

    public void Load ()
    {
        try { Video.Load(); }
        catch { Video.Save(); }
        try { Controls.Load(); }
        catch { Controls.Save(); }
        try { Network.Load(); }
        catch { Network.Save(); }
        try { UI.Load(); }
        catch { UI.Save(); }
        try { Devices.Load(); }
        catch { Devices.Save(); }
        try { Study.Load(); }
        catch { Study.Save(); }
    }

    public void Save ()
    {
        Video.Save();
        Audio.Save();
        Controls.Save();
        UI.Save();
        Devices.Save();
        Study.Save();
    }

    public ClientConfig Clone ()
    {
        using (var ms = new MemoryStream())
        {
            var formatter = new BinaryFormatter();
            formatter.Serialize(ms, this);
            ms.Position = 0;

            return (ClientConfig)formatter.Deserialize(ms);
        }
    }
}

[Serializable]
public class ClientVideoConfig
{
    public int Width = 1280;
    public int Height = 720;
    public bool FullScreen = false;

    public void Load ()
    {
        UJeli configJeli = UJeli.Load(GameClient.Instance.ConfigBase + "Video.ini");

        if (configJeli == null)
        {
            Save();
            return;
        }

        Width = configJeli["Width"].IntValue;
        Height = configJeli["Height"].IntValue;
        FullScreen = configJeli["FullScreen"].BoolValue;
    }

    public void Save ()
    {
        UJeli configJeli = new UJeli();

        configJeli.AddChild("Width", Width);
        configJeli.AddChild("Height", Height);
        configJeli.AddChild("FullScreen", FullScreen);

        configJeli.Save(GameClient.Instance.ConfigBase + "Video.ini");
    }
}

[Serializable]
public class ClientAudioConfig
{
    public float MasterVolume = 1f;

    public void Load ()
    {
        UJeli configJeli = UJeli.Load(GameClient.Instance.ConfigBase + "Audio.ini");

        if (configJeli == null)
        {
            Save();
            return;
        }

        MasterVolume = configJeli["MasterVolume"].FloatValue;
    }

    public void Save ()
    {
        UJeli configJeli = new UJeli();

        configJeli.AddChild("MasterVolume", MasterVolume);

        configJeli.Save(GameClient.Instance.ConfigBase + "Audio.ini");
    }
}

[Serializable]
public class ClientControlsConfig
{
    public KeyCode ToggleFullScreen = KeyCode.F11;
    public KeyCode TakeScreenshot = KeyCode.F12;

    public void Load ()
    {
        UJeli configJeli = UJeli.Load(GameClient.Instance.ConfigBase + "Controls.ini");

        if (configJeli == null)
        {
            Save();
            return;
        }

        ToggleFullScreen = configJeli["ToggleFullScreen"].GetEnumValue<KeyCode>();
        TakeScreenshot = configJeli["TakeScreenshot"].GetEnumValue<KeyCode>();
    }

    public void Save ()
    {
        UJeli configJeli = new UJeli();

        configJeli.AddChild("ToggleFullScreen", ToggleFullScreen);
        configJeli.AddChild("TakeScreenshot", TakeScreenshot);

        configJeli.Save(GameClient.Instance.ConfigBase + "Controls.ini");
    }
}

[Serializable]
public class ClientNetworkConfig
{
    public string PlayerID = "guest";
    public string WorldID = "localhost";

    public void Load ()
    {
        UJeli configJeli = UJeli.Load(GameClient.Instance.ConfigBase + "Network.ini");

        if (configJeli == null)
        {
            Save();
            return;
        }

        PlayerID = configJeli["PlayerID"].Value;
        WorldID = configJeli["WorldID"].Value;
    }

    public void Save ()
    {
        UJeli configJeli = new UJeli();

        configJeli.AddChild("PlayerID", PlayerID);
        configJeli.AddChild("WorldID", WorldID);

        configJeli.Save(GameClient.Instance.ConfigBase + "Network.ini");
    }
}

[Serializable]
public class ClientUIConfig
{
    public SystemLanguage Language = SystemLanguage.English;

    public void Load ()
    {
        UJeli configJeli = UJeli.Load(GameClient.Instance.ConfigBase + "UI.ini");

        if (configJeli == null)
        {
            Save();
            return;
        }

        Language = configJeli["Language"].GetEnumValue<SystemLanguage>();
    }

    public void Save ()
    {
        UJeli configJeli = new UJeli();

        configJeli.AddChild("Language", Language);

        configJeli.Save(GameClient.Instance.ConfigBase + "UI.ini");
    }
}

[Serializable]
public class ClientStudyConfig
{
    public bool LoggingEnabled = true;
    public string[] LogPaths = new string[]
    {
        "Study Logs/<p>_<d>_<t>.dat"
    };

    public BalanceCondition BalanceAlgorithm = BalanceCondition.GenericBalance;

    public void Load ()
    {
        UJeli configJeli = UJeli.Load(GameClient.Instance.ConfigBase + "Study.ini");

        if (configJeli == null)
        {
            Save();
            return;
        }

        LoggingEnabled = configJeli["LoggingEnabled"].BoolValue;
        LogPaths = configJeli["LogPaths"].ChildValues;
        BalanceAlgorithm = configJeli["BalanceAlgorithm"].GetEnumValue<BalanceCondition>();
    }

    public void Save ()
    {
        UJeli configJeli = new UJeli();

        configJeli.AddChild("LoggingEnabled", LoggingEnabled);

        UJeli logPathsJeli = configJeli.AddChild("LogPaths");

        foreach (string path in LogPaths)
        {
            logPathsJeli.AddChild("LogPath", path);
        }

        configJeli.AddChild("BalanceAlgorithm", BalanceAlgorithm);
        
        configJeli.Save(GameClient.Instance.ConfigBase + "Study.ini");
    }
}

[Serializable]
public class ClientDevicesConfig
{
    public Dictionary<string, bool> States = new Dictionary<string, bool>();
    public Dictionary<string, UJeli> Options = new Dictionary<string, UJeli>();

    public void Load ()
    {   
        foreach (var deviceId in DeviceManager.Instance.DeviceIDs)
        {
            States[deviceId] = DeviceManager.Instance.IsDeviceEnabled(deviceId);
        }

        UJeli configJeli = UJeli.Load(GameClient.Instance.ConfigBase + "Devices.ini");

        if (configJeli == null)
        {
            Save();
            return;
        }

        try
        {
            States = configJeli.GetChildDictionary<string, bool>(s => s, s => bool.Parse(s));
            
            foreach (var state in States)
            {
                configJeli[state.Key].HasChild("options");
            
                if (configJeli[state.Key].HasChild("options"))
                    Options.Add(state.Key, configJeli[state.Key]["options"]);
            }
        }
        catch { Save(); }
    }

    public void Save ()
    {
        UJeli configJeli = new UJeli();

        foreach (var deviceState in States)
        {
            configJeli.AddChild(deviceState.Key, deviceState.Value);
            
            UJeli optionsJeli = DeviceManager.Instance.GetDeviceSaveOptions(deviceState.Key);
            
            if (optionsJeli != null)
            {
                optionsJeli.Name = "options";
                configJeli[deviceState.Key].AddChild(optionsJeli);  
            }
        }

        configJeli.Save(GameClient.Instance.ConfigBase + "Devices.ini");
    }
}