C# ConfigNode.CopyTo方法代码示例

        public override void OnLoad(ConfigNode config)
        {
            if (this.config == null)
            {
                this.config = new ConfigNode();
                config.CopyTo(this.config);
            }

            resources = this.config.GetNodes("Resource").Select(n => new Resource(n)).ToList();
        }

        public static Part CreatePart(ConfigNode partConfig, Vector3 position, Quaternion rotation, Part fromPart, Part coupleToPart = null, string srcAttachNodeID = null, AttachNode tgtAttachNode = null, OnPartCoupled onPartCoupled = null)
        {
            ConfigNode node_copy = new ConfigNode();
            partConfig.CopyTo(node_copy);
            ProtoPartSnapshot snapshot = new ProtoPartSnapshot(node_copy, null, HighLogic.CurrentGame);

            if (HighLogic.CurrentGame.flightState.ContainsFlightID(snapshot.flightID) || snapshot.flightID == 0)
            {
                snapshot.flightID = ShipConstruction.GetUniqueFlightID(HighLogic.CurrentGame.flightState);
            }
            snapshot.parentIdx = 0;
            snapshot.position = position;
            snapshot.rotation = rotation;
            snapshot.stageIndex = 0;
            snapshot.defaultInverseStage = 0;
            snapshot.seqOverride = -1;
            snapshot.inStageIndex = -1;
            snapshot.attachMode = (int)AttachModes.SRF_ATTACH;
            snapshot.attached = true;
            snapshot.connected = true;
            snapshot.flagURL = fromPart.flagURL;

            Part newPart = snapshot.Load(fromPart.vessel, false);

            newPart.transform.position = position;
            newPart.transform.rotation = rotation;
            newPart.missionID = fromPart.missionID;

            fromPart.vessel.Parts.Add(newPart);

            newPart.physicalSignificance = Part.PhysicalSignificance.NONE;
            newPart.PromoteToPhysicalPart();
            newPart.Unpack();
            newPart.InitializeModules();

            if (coupleToPart)
            {
                newPart.rigidbody.velocity = coupleToPart.rigidbody.velocity;
                newPart.rigidbody.angularVelocity = coupleToPart.rigidbody.angularVelocity;
            }
            else
            {
                if (fromPart.rigidbody)
                {
                    newPart.rigidbody.velocity = fromPart.rigidbody.velocity;
                    newPart.rigidbody.angularVelocity = fromPart.rigidbody.angularVelocity;
                }
                else
                {
                    // If fromPart is a carried container
                    newPart.rigidbody.velocity = fromPart.vessel.rootPart.rigidbody.velocity;
                    newPart.rigidbody.angularVelocity = fromPart.vessel.rootPart.rigidbody.angularVelocity;
                }
            }

            newPart.decouple();

            if (coupleToPart)
            {
                newPart.StartCoroutine(WaitAndCouple(newPart, coupleToPart, srcAttachNodeID, tgtAttachNode, onPartCoupled));
            }
            else
            {
                newPart.vessel.vesselType = VesselType.Unknown;
                //name container
                ModuleKISInventory inv = newPart.GetComponent<ModuleKISInventory>();
                if (inv)
                {
                    if (inv.invName != "")
                    {
                        newPart.vessel.vesselName = inv.part.partInfo.title + " | " + inv.invName;
                    }
                    else
                    {
                        newPart.vessel.vesselName = inv.part.partInfo.title;
                    }
                }
            }
            return newPart;
        }

        public static Part LoadPartSnapshot(Vessel vessel, ConfigNode node, Vector3 position, Quaternion rotation)
        {
            ConfigNode node_copy = new ConfigNode();
            node.CopyTo(node_copy);

            node_copy.RemoveValues("kas_total_mass");

            ProtoPartSnapshot snapshot = new ProtoPartSnapshot(node_copy, null, HighLogic.CurrentGame);

            if (HighLogic.CurrentGame.flightState.ContainsFlightID(snapshot.flightID))
                snapshot.flightID = ShipConstruction.GetUniqueFlightID(HighLogic.CurrentGame.flightState);

            snapshot.parentIdx = 0;
            snapshot.position = position;
            snapshot.rotation = rotation;
            snapshot.stageIndex = 0;
            snapshot.defaultInverseStage = 0;
            snapshot.seqOverride = -1;
            snapshot.inStageIndex = -1;
            snapshot.attachMode = (int)AttachModes.SRF_ATTACH;
            snapshot.attached = true;
            snapshot.connected = true;
            snapshot.flagURL = vessel.rootPart.flagURL;

            // Save properties that may be messed up by new colliders
            RigidbodyInertia rb_backup = new RigidbodyInertia(vessel.rootPart.rb);

            Part new_part = snapshot.Load(vessel, false);

            vessel.Parts.Add(new_part);

            if (vessel.packed)
            {
                GameEvents.onVesselWasModified.Fire(vessel);
            }
            else
            {
                // Request initialization as nonphysical to prevent explosions
                new_part.physicalSignificance = Part.PhysicalSignificance.NONE;

                // Disable all sub-objects with colliders
                List<Collider> re_enable = new List<Collider>();

                foreach (var collider in new_part.GetComponentsInChildren<Collider>())
                {
                    if (collider.gameObject.activeSelf)
                    {
                        re_enable.Add(collider);
                        collider.gameObject.SetActive(false);
                    }
                }

                new_part.StartCoroutine(WaitAndUnpack(new_part, re_enable));
            }

            rb_backup.Restore(vessel.rootPart.rb);

            return new_part;
        }

        /// <summary>
        /// Merges global and local config nodes for an engine layout<para/>
        /// Local node values have priority if they are present; any non-specified local values are defaulted
        /// to the global value
        /// </summary>
        /// <param name="global"></param>
        /// <param name="local"></param>
        /// <returns></returns>
        private ConfigNode mergeNodes(ConfigNode global, ConfigNode local)
        {
            ConfigNode output = new ConfigNode("MOUNT");
            global.CopyTo(output);
            if (local.HasValue("canAdjustSize"))
            {
                output.RemoveValues("canAdjustSize");
                output.AddValue("canAdjustSize", local.GetBoolValue("canAdjustSize"));
            }
            if (local.HasValue("size"))
            {
                output.RemoveValues("size");
                output.AddValue("size", local.GetFloatValue("size"));
            }
            if (local.HasValue("minSize"))
            {
                output.RemoveValues("minSize");
                output.AddValue("minSize", local.GetFloatValue("minSize"));
            }
            if (local.HasValue("maxSize"))
            {
                output.RemoveValues("maxSize");
                output.AddValue("maxSize", local.GetFloatValue("maxSize"));
            }
            if (local.HasValue("engineSpacing"))
            {
                output.RemoveValues("engineSpacing");
                output.AddValue("engineSpacing", local.GetFloatValue("engineSpacing"));
            }
            if (local.HasValue("rotateEngines"))
            {
                output.RemoveValues("rotateEngines");
                output.AddValue("rotateEngines", local.GetStringValue("rotateEngines"));
            }

            return output;
        }

        private static MethodInfo InstantiateHandler(ConfigNode node, RasterPropMonitor ourMonitor, out MonoBehaviour moduleInstance, out HandlerSupportMethods support)
        {
            moduleInstance = null;
            support.activate = null;
            support.buttonClick = null;
            support.buttonRelease = null;
            support.getHandlerReferences = null;
            if (node.HasValue("name") && node.HasValue("method"))
            {
                string moduleName = node.GetValue("name");
                string methodName = node.GetValue("method");

                var handlerConfiguration = new ConfigNode("MODULE");
                node.CopyTo(handlerConfiguration);

                MonoBehaviour thatModule = null;
                // Part modules are different in that they remain instantiated when you switch vessels, while the IVA doesn't.
                // Because of this RPM can't instantiate partmodule-based handlers itself -- there's no way to tell if this was done already or not.
                // Which means there can only be one instance of such a handler per pod, and it can't receive configuration values from RPM.
                if (node.HasValue("isPartModule"))
                {
                    foreach (PartModule potentialModule in ourMonitor.part.Modules)
                    {
                        if (potentialModule.ClassName == moduleName)
                        {
                            thatModule = potentialModule;
                            break;
                        }
                    }
                }
                else if (node.HasValue("multiHandler"))
                {

                    foreach (InternalModule potentialModule in ourMonitor.internalProp.internalModules)
                    {
                        if (potentialModule.ClassName == moduleName)
                        {
                            thatModule = potentialModule;
                            break;
                        }
                    }

                }

                if (thatModule == null && !node.HasValue("isPartModule"))
                {
                    try
                    {
                        thatModule = ourMonitor.internalProp.AddModule(handlerConfiguration);
                    }
                    catch
                    {
                        JUtil.LogErrorMessage(ourMonitor, "Caught exception when trying to instantiate module '{0}'. Something's fishy here", moduleName);
                    }
                }

                if (thatModule == null)
                {
                    JUtil.LogMessage(ourMonitor, "Warning, handler module \"{0}\" could not be loaded. This could be perfectly normal.", moduleName);
                    return null;
                }

                const string sigError = "Incorrect signature of the {0} method in {1}, ignoring option. If it doesn't work later, that's why.";

                if (node.HasValue("pageActiveMethod"))
                {
                    foreach (MethodInfo m in thatModule.GetType().GetMethods())
                    {
                        if (m.Name == node.GetValue("pageActiveMethod"))
                        {
                            try
                            {
                                support.activate = (Action<bool, int>)Delegate.CreateDelegate(typeof(Action<bool, int>), thatModule, m);
                            }
                            catch
                            {
                                JUtil.LogErrorMessage(ourMonitor, sigError, "page activation", moduleName);
                            }
                            break;
                        }
                    }
                }

                if (node.HasValue("buttonClickMethod"))
                {
                    foreach (MethodInfo m in thatModule.GetType().GetMethods())
                    {
                        if (m.Name == node.GetValue("buttonClickMethod"))
                        {
                            try
                            {
                                support.buttonClick = (Action<int>)Delegate.CreateDelegate(typeof(Action<int>), thatModule, m);
                            }
                            catch
                            {
                                JUtil.LogErrorMessage(ourMonitor, sigError, "button click", moduleName);
                            }
                            break;
                        }
                    }
//.........这里部分代码省略.........

        public static ProtoPartSnapshot LoadProtoPartSnapshot(ConfigNode node)
        {
            ConfigNode node_copy = new ConfigNode();
            node.CopyTo(node_copy);

            node_copy.RemoveValues("kas_total_mass");
            node_copy.RemoveValues("kas_total_cost");

            return new ProtoPartSnapshot(node_copy, null, HighLogic.CurrentGame);
        }

 public override void OnLoad(ConfigNode config)
 {
     if (this.config == null)
     {
         this.config = new ConfigNode();
         config.CopyTo(this.config);
     }
 }

        public override void OnLoad(ConfigNode node)
        {
            if (Global.Debug2) Utils.Log("OnLoad start");

            // save the original config
            originalConfig = new ConfigNode();
            node.CopyTo(originalConfig);

            loadConfig(node);
        }

            private static bool InstantiateHandler(ConfigNode node, PartModule ourComp, out Func<string,object> handlerFunction)
            {
                handlerFunction = null;
                var handlerConfiguration = new ConfigNode("MODULE");
                node.CopyTo(handlerConfiguration);
                string moduleName = node.GetValue("name");
                string methodName = node.GetValue("method");

                // Since we're working with part modules here, and starting in a pod config,
                // we'll keep one instance per pod, which will let them instantiate with their own config if needed.
                MonoBehaviour thatModule = null;
                foreach (PartModule potentialModule in ourComp.part.Modules) {
                    if (potentialModule.ClassName == moduleName) {
                        thatModule = potentialModule;
                        break;
                    }
                }
                if (thatModule == null) {
                    thatModule = ourComp.part.AddModule(handlerConfiguration);
                }
                if (thatModule == null) {
                    JUtil.LogMessage(ourComp, "Warning, variable handler module \"{0}\" could not be loaded. This could be perfectly normal.", moduleName);
                    return false;
                }
                foreach (MethodInfo m in thatModule.GetType().GetMethods()) {
                    if (m.Name == node.GetValue("method")) {
                        try {
                            handlerFunction = (Func<string,object>)Delegate.CreateDelegate(typeof(Func<string,object>), thatModule, m);
                        } catch {
                            JUtil.LogErrorMessage(ourComp, "Error, incorrect variable handler configuration for module {0}", moduleName);
                            return false;
                        }
                        break;
                    }
                }
                return true;
            }

        public RSSLoadInfo(ConfigNode RSSnode)
        {
            useEpoch = RSSnode.TryGetValue("Epoch", ref epoch);
            RSSnode.TryGetValue("wrap", ref doWrap);
            RSSnode.TryGetValue("compressNormals", ref compressNormals);
            RSSnode.TryGetValue("spheresOnly", ref spheresOnly);
            RSSnode.TryGetValue("orbitCalc", ref orbitCalc);
            RSSnode.TryGetValue("defaultAtmoScale", ref defaultAtmoScale);
            RSSnode.TryGetValue("SSAtmoScale", ref SSAtmoScale);

            node = new ConfigNode();
            RSSnode.CopyTo(node);
            // get spherical scaledspace mesh
            if (ScaledSpace.Instance != null)
            {
                //print("*RSS* Printing ScaledSpace Transforms");
                foreach (Transform t in ScaledSpace.Instance.scaledSpaceTransforms)
                {
                    /*print("***** TRANSFROM: " + t.name);
                    Utils.PrintTransformUp(t);
                    Utils.PrintTransformRecursive(t);*/
                    if (t.name.Equals("Jool"))
                        joolMesh = (MeshFilter)t.GetComponent(typeof(MeshFilter));
                }
                //print("*RSS* InverseScaleFactor = " + ScaledSpace.InverseScaleFactor);
            }
        }

        public override void OnLoad(ConfigNode config)
        {
            if (this.config == null)
            {
                this.config = new ConfigNode();
                config.CopyTo(this.config);
            }

            resources = this.config.GetNodes("Resource").Select(n => n.GetValue("Name")).ToList();
            if (resources.Count == 0)
            {
                resources = KethaneController.ResourceDefinitions.Select(r => r.Resource).ToList();
            }
        }

 public void Load(ConfigNode node)
 {
     if (node.name == "CONTENT" && node.HasValue("qty"))
     {
         pristine_count += int.Parse(node.GetValue("qty"));
     }
     else if (node.name == "CONTENT_PART" && node.HasValue("kas_total_mass"))
     {
         ConfigNode nodeD = new ConfigNode();
         node.CopyTo(nodeD);
         instance_mass += float.Parse(node.GetValue("kas_total_mass"));
         instances.Add(nodeD);
     }
 }

        private static bool InstantiateHandler(ConfigNode node, InternalModule ourSwitch, out Action<bool> actionCall, out Func<bool> stateCall)
        {
            actionCall = null;
            stateCall = null;
            var handlerConfiguration = new ConfigNode("MODULE");
            node.CopyTo(handlerConfiguration);
            string moduleName = node.GetValue("name");
            string stateMethod = string.Empty;
            if (node.HasValue("stateMethod"))
                stateMethod = node.GetValue("stateMethod");

            InternalModule thatModule = null;
            foreach (InternalModule potentialModule in ourSwitch.internalProp.internalModules)
                if (potentialModule.ClassName == moduleName) {
                    thatModule = potentialModule;
                    break;
                }

            if (thatModule == null)
                thatModule = ourSwitch.internalProp.AddModule(handlerConfiguration);
            if (thatModule == null)
                return false;
            foreach (MethodInfo m in thatModule.GetType().GetMethods()) {
                if (m.Name == node.GetValue("actionMethod")) {
                    actionCall = (Action<bool>)Delegate.CreateDelegate(typeof(Action<bool>), thatModule, m);
                }
                if (!string.IsNullOrEmpty(stateMethod) && m.Name == stateMethod) {
                    stateCall = (Func<bool>)Delegate.CreateDelegate(typeof(Func<bool>), thatModule, m);
                }
            }
            return actionCall != null;
        }

        //ModifyNode applies the ConfigNode mod as a 'patch' to ConfigNode original, then returns the patched ConfigNode.
        // it uses FindConfigNodeIn(src, nodeType, nodeName, nodeTag) to recurse.
        public static ConfigNode ModifyNode(ConfigNode original, ConfigNode mod)
        {
            ConfigNode newNode = new ConfigNode(original.name);
            original.CopyTo(newNode);

            foreach (ConfigNode.Value val in mod.values)
            {
                if (val.name[0] == '@')
                {
                    // Modifying a value: Format is @key = value or @key,index = value
                    string valName = val.name.Substring(1);
                    int index = 0;
                    if (valName.Contains(","))
                    {
                        int.TryParse(valName.Split(',')[1], out index);
                        valName = valName.Split(',')[0];
                    }
                    newNode.SetValue(valName, val.value, index);
                }
                else if (val.name[0] == '!')
                {
                    // Parsing: Format is @key = value or @key,index = value
                    string valName = val.name.Substring(1);
                    int index = 0;
                    if (valName.Contains(","))
                    {
                        int.TryParse(valName.Split(',')[1], out index);
                        valName = valName.Split(',')[0];
                    } // index is useless right now, but some day it might not be.
                    newNode.RemoveValue(valName);
                }
                else
                {
                    newNode.AddValue(val.name, val.value);
                }
            }

            foreach (ConfigNode subMod in mod.nodes)
            {
                if (subMod.name[0] == '@')
                {
                    // Modifying a node: Format is @NODETYPE {...}, @NODETYPE[Name] {...} or @NODETYPE[Name,Tag] {...}
                    ConfigNode subNode = null;

                    if (subMod.name.Contains("["))
                    { // format @NODETYPE[Name] {...} or @NODETYPE[Name, Tag] {...}
                        string nodeType = subMod.name.Substring(1).Split('[')[0].Trim();
                        string nodeName = subMod.name.Split('[')[1].Replace("]", "").Trim();
                        string nodeTag = null;
                        if (nodeName.Contains(","))
                        { //format @NODETYPE[Name, Tag] {...}
                            nodeTag = nodeName.Split(',')[1];
                            nodeName = nodeName.Split(',')[0];
                        }
                        subNode = FindConfigNodeIn(newNode, nodeType, nodeName, nodeTag);
                    }
                    else
                    { // format @NODETYPE {...}
                        string nodeType = subMod.name.Substring(1);
                        subNode = newNode.GetNode(nodeType);
                    }
                    // find the original subnode to modify, modify it, remove the original and add the modified.
                    if (subNode == null)
                    {
                        print("Could not find node to modify: " + subMod.name);
                    }
                    else
                    {
                        ConfigNode newSubNode = ModifyNode(subNode, subMod);
                        newNode.nodes.Remove(subNode);
                        newNode.nodes.Add(newSubNode);
                    }

                }
                else if (subMod.name[0] == '!')
                {
                    // Removing a node: Format is !NODETYPE {}, !NODETYPE[Name] {} or !NODETYPE[Name,Tag] {}

                    ConfigNode subNode;

                    if (subMod.name.Contains("["))
                    { // format !NODETYPE[Name] {} or !NODETYPE[Name, Tag] {}
                        string nodeType = subMod.name.Substring(1).Split('[')[0].Trim();
                        string nodeName = subMod.name.Split('[')[1].Replace("]", "").Trim();
                        string nodeTag = null;
                        if (nodeName.Contains(","))
                        { //format !NODETYPE[Name, Tag] {}
                            nodeTag = nodeName.Split(',')[1];
                            nodeName = nodeName.Split(',')[0];
                        }
                        subNode = FindConfigNodeIn(newNode, nodeType, nodeName, nodeTag);
                    }
                    else
                    { // format !NODETYPE {}
                        string nodeType = subMod.name.Substring(1);
                        subNode = newNode.GetNode(nodeType);
                    }
                    if (subNode != null)
//.........这里部分代码省略.........