internal ConfigObjectNode(dynamic n, KeyType key, ConfigNode parent)
            : base(key, parent)
        {
            _children = new Dictionary<string, ConfigNode>();

            var expando = n as IDictionary<string, object>;
            foreach (var kvp in expando)
            {
                ConfigNode valueNode;
                var newKey = new StringKey(kvp.Key);

                if (kvp.Value is ExpandoObject)
                {
                    valueNode = ConfigNodeFactory.CreateConfigObjectNode(kvp.Value, newKey, this);
                }
                else if (kvp.Value is IList<object>)
                {
                    valueNode = ConfigNodeFactory.CreateConfigListNode(kvp.Value, newKey, this);
                }
                else
                {
                    valueNode = ConfigNodeFactory.CreateConfigLeafNode(kvp.Value, newKey, this);
                }

                _children.Add(kvp.Key, valueNode);
            }
        }

        public override void OnSave(ConfigNode node)
        {
            PluginConfiguration config = PluginConfiguration.CreateForType<AntennaPrototype>();

            config.SetValue("Window Position", windowPosition);
            config.save();
        }

 public void saveText(ConfigNode node)
 {
     saveMonoOverlay(node);
     node.AddValue("text", _text);
     node.AddValue("fontName", _fontName);
     node.AddValue("fontSize", _fontSize);
 }

        public static Layout Load(string name, ConfigNode node)
        {
            try
            {
                var layout = new Layout(name);

                foreach (var child in node.GetNodes())
                {
                    IElement element = Element.Create(child.name);

                    if (element != null)
                    {
                        element.Load(child);
                        layout.AddElement(element);
                    }
                    else
                    {
                        Historian.Print("Failed to load layout element of type '{0}'.", child.name);
                    }
                }

                return layout;
            }
            catch
            {
                Historian.Print("Failed to load layout '{0}'.", name);
            }

            return Empty;
        }

 public ResourceInfo(ConfigNode node)
 {
     node.TryGetValue("name", ref this.name);
     resource = PartResourceLibrary.Instance.GetDefinition(this.Name);
     node.TryGetValue("realName", ref this.realName);
     node.TryGetValue("colour", ref this.colour);
 }

    public void HandleSettings()
    {
        if (!File.Exists<KineTechAnimationModuleLoader>(SETTINGS_FILE_NAME))
        {
            ConfigNode node = new ConfigNode();
            node.AddValue("DumpDocumentationOnStartup", false);
            node.Save(IOUtils.GetFilePathFor(typeof(KineTechAnimationModuleLoader), SETTINGS_FILE_NAME));
        }

        if (File.Exists<KineTechAnimationModuleLoader>(SETTINGS_FILE_NAME))
        {
            ConfigNode node = ConfigNode.Load(
                IOUtils.GetFilePathFor(typeof(KineTechAnimationModuleLoader), SETTINGS_FILE_NAME));

            if(node == null)
                return;

            //Dump Documentation
            if(node.HasValue("DumpDocumentationOnStartup"))
            {
                bool working = false;
                if(bool.TryParse(node.GetValue("DumpDocumentationOnStartup"), out working))
                {
                    GameObject dumperObject = new GameObject("Kine-Tech Animation - ConfigDocumentationGenerator");
                    dumperObject.AddComponent<KConfigDocumentationGenerator>();
                    GameObject.DontDestroyOnLoad(dumperObject);
                }
            }

        }
    }

        public void Configure(ConfigNode node)
        {
            ConfigNode[] pages = node.GetNodes("PAGE_DEFINITION");

            if (pages != null && pages.Length > 0)
            {
                definitions = new PageDefinition[pages.Length];

                for (int i = 0; i < pages.Length; ++i)
                {
                    string variableName = pages[i].GetValue("variableName");
                    string range = pages[i].GetValue("range");
                    string page = pages[i].GetValue("page");
                    if (string.IsNullOrEmpty(variableName) || string.IsNullOrEmpty(range) || string.IsNullOrEmpty(page))
                    {
                        JUtil.LogErrorMessage(this, "Incorrect page definition for page {0}", i);
                        definitions = null;
                        if (string.IsNullOrEmpty(definitionIn))
                        {
                            // Make sure we aren't crashing later.
                            definitionIn = definitionOut;
                        }
                        return;
                    }
                    definitions[i] = new PageDefinition(variableName, range, page);
                }
            }
        }

 internal IEnumerator<YieldInstruction> LoadItems(ConfigNode settings, System.Random random)
 {
     foreach (string type in KRESUtils.types.Values)
     {
         if (KRESUtils.GetRelevantBodies(type).Any(b => b.bodyName == this.Name))
         {
             foreach (ConfigNode data in settings.GetNode(type).GetNode(this.Name).GetNodes("KRES_DATA"))
             {
                 string resourceName = string.Empty;
                 data.TryGetValue("name", ref resourceName);
                 if (!PartResourceLibrary.Instance.resourceDefinitions.Contains(resourceName)) { continue; }
                 if (type == "ore")
                 {
                     string path = Path.Combine(KRESUtils.GetSavePath(), "KRESTextures/" + name + "/" + resourceName + ".png");
                     if (File.Exists(path))
                     {
                         ResourceItem item = new ResourceItem(data, resourceName, this.Name, random);
                         resourceItems.Add(item);
                     }
                 }
                 else if (type == "gas" || type == "liquid")
                 {
                     ResourceItem item = new ResourceItem(data, resourceName, this.Name, type, random);
                     resourceItems.Add(item);
                 }
                 yield return null;
             }
         }
     }
 }

 protected override void OnLoad(ConfigNode node)
 {
     if (node.HasValue("FIELD"))
     {
         matchFields.AddRange(node.GetValues("FIELD"));
     }
 }

        public override void OnSave(ConfigNode node)
        {
            PluginConfiguration config = PluginConfiguration.CreateForType<PluginTutorial>();

            config.SetValue("Window Position", _windowPosition);
            config.save();
        }

 protected void saveMonoOverlay(ConfigNode node)
 {
     saveOverlay(node);
     node.AddValue("red", _red);
     node.AddValue("green", _green);
     node.AddValue("blue", _blue);
 }

        private GUIStyle _windowStyle, _labelStyle; // Setup Gui Style

        #endregion Fields

        #region Methods

        public override void OnLoad(ConfigNode node)
        {
            PluginConfiguration config = PluginConfiguration.CreateForType<PluginTutorial>();

            config.load();
            _windowPosition = config.GetValue<Rect>("Window Position");
        }

 /// <summary>
 /// Creates a material definition from a config node
 /// </summary>
 /// <param name="node">Node to initiate the material from</param>
 public MaterialDefinition(ConfigNode node)
 {
     node.TryGetValue("name", ref _name);
     node.TryGetValue("description", ref _description);
     node.TryGetValue("areaDensity", ref _areaDensity);
     node.TryGetValue("dragCoefficient", ref _dragCoefficient);
 }

 public override void OnLoad(ConfigNode node)
 {
     base.OnLoad(node);
     //deprecated config conversion//
     ModuleConfig = node.HasValue("base_mass")? node : null;
     //****************************//
 }

 public void Save(ConfigNode node)
 {
     ConfigNode newNode = new ConfigNode("Resource");
     newNode.AddValue("name", resource.name);
     newNode.AddValue("ratio", ratio);
     node.AddNode(newNode);
 }

 protected override void OnSave(ConfigNode node)
 {
     foreach (string field in matchFields)
     {
         node.AddValue("FIELD", field);
     }
 }

        public void Save(ConfigNode node)
        {
            if (node.HasNode("KOLONIZATION"))
            {
                SettingsNode = node.GetNode("KOLONIZATION");
            }
            else
            {
                SettingsNode = node.AddNode("KOLONIZATION");
            }

            foreach (KolonizationEntry r in _LogInfo)
            {
                var rNode = new ConfigNode("KOLONY_ENTRY");
                rNode.AddValue("BodyIndex", r.BodyIndex);
                rNode.AddValue("VesselId", r.VesselId);
                rNode.AddValue("LastUpdate", r.LastUpdate);
                rNode.AddValue("KolonyDate", r.KolonyDate);
                rNode.AddValue("GeologyResearch", r.GeologyResearch);
                rNode.AddValue("BotanyResearch", r.BotanyResearch);
                rNode.AddValue("KolonizationResearch", r.KolonizationResearch);
                rNode.AddValue("Science", r.Science);
                rNode.AddValue("Rep", r.Rep);
                rNode.AddValue("Funds", r.Funds);
                SettingsNode.AddNode(rNode);
            }

            //Reset cache
            KolonizationManager.Instance.ResetCache();
        }

        /// <summary>
        /// Initiates all the texture and model nodes in this model config
        /// </summary>
        public TextureConfig(ConfigNode node)
        {
            node.TryGetValue("name", ref _name);
            foreach(ConfigNode cfg in node.nodes)
            {
                if (cfg.name == "CASE_TEXTURE")
                {
                    CaseConfig parachuteCase = new CaseConfig(cfg);
                    _cases.Add(parachuteCase);
                    continue;
                }

                if (cfg.name == "CANOPY_TEXTURE")
                {
                    CanopyConfig canopy = new CanopyConfig(cfg);
                    _canopies.Add(canopy);
                    continue;
                }

                if (cfg.name == "CANOPY_MODEL")
                {
                    ModelConfig model = new ModelConfig(cfg);
                    _models.Add(model);
                    continue;
                }
            }
            if (_cases.Count > 0) { _caseNames = _cases.Select(c => c.name).ToArray(); }
            if (_canopies.Count > 0) { _canopyNames = _canopies.Select(c => c.name).ToArray(); }
            if (_models.Count > 0) { _modelNames = _models.Select(m => m.name).ToArray(); }
        }

 public Grid2DControler(int width, int height, int numberOfClasses, ConfigNode node)
     : base(width * height, numberOfClasses, node)
 {
     _width = width;
     _height = height;
     this.StructureBuilder = new DefaultGrid2DStructureBuilder(width, height, NumberOfClasses);
 }

 /// <summary>
 /// Initiates all the texture and model nodes in this model config
 /// </summary>
 public TextureConfig(ConfigNode node)
 {
     node.TryGetValue("name", ref _name);
     _cases = node.GetNodes("CASE_TEXTURE").Select(n => new CaseConfig(n)).ToDictionary(c => c, c => c.name);
     _canopies = node.GetNodes("CANOPY_TEXTURE").Select(n => new CanopyConfig(n)).ToDictionary(c => c, c => c.name);
     _models = node.GetNodes("CANOPY_MODEL").Select(n => new ModelConfig(n)).ToDictionary(m => m, m => m.name);
 }