public override bool Load(ConfigNode configNode) { // Load base class bool valid = base.Load(configNode); if (configNode.HasValue("passengerName")) { LoggingUtil.LogWarning(this, "The passengerName and gender attributes are obsolete since Contract Configurator 1.9.0, use kerbal instead."); valid &= ConfigNodeUtil.ParseValue<List<string>>(configNode, "passengerName", x => passengerName = x, this, new List<string>()); valid &= ConfigNodeUtil.ParseValue<ProtoCrewMember.Gender>(configNode, "gender", x => gender = x, this, Kerbal.RandomGender()); valid &= ConfigNodeUtil.ParseValue<string>(configNode, "experienceTrait", x => experienceTrait = x, this, Kerbal.RandomExperienceTrait()); legacy = true; } else { valid &= ConfigNodeUtil.ParseValue<List<Kerbal>>(configNode, "kerbal", x => kerbals = x, this, new List<Kerbal>()); legacy = false; } valid &= ConfigNodeUtil.ParseValue<int>(configNode, "count", x => count = x, this, 1, x => Validation.GE(x, 1)); valid &= ConfigNodeUtil.ParseValue<ProtoCrewMember.KerbalType>(configNode, "kerbalType", x => kerbalType = x, this, ProtoCrewMember.KerbalType.Tourist); return valid; }
public MappedVariable(ConfigNode node, RasterPropMonitorComputer rpmComp) { if (!node.HasValue("mappedVariable") || !node.HasValue("mappedRange") || !node.HasValue("sourceVariable") || !node.HasValue("sourceRange")) { throw new ArgumentException("MappedVariable missing required values"); } string sourceVariableStr = node.GetValue("sourceVariable"); string sourceRange = node.GetValue("sourceRange"); string[] sources = sourceRange.Split(','); if (sources.Length != 2) { throw new ArgumentException("MappedVariable sourceRange does not have exactly two values"); } sourceVariable = new VariableOrNumberRange(rpmComp, sourceVariableStr, sources[0], sources[1]); mappedVariable = node.GetValue("mappedVariable"); string[] destinations = node.GetValue("mappedRange").Split(','); if (destinations.Length != 2) { throw new ArgumentException("MappedVariable mappedRange does not have exactly two values"); } mappedExtent1 = rpmComp.InstantiateVariableOrNumber(destinations[0]); mappedExtent2 = rpmComp.InstantiateVariableOrNumber(destinations[1]); }
public ScriptV1() { exception_raised = false; tool = new ExternalApp(); files_to_glue = new List<FileName>(); replace_list = new Dictionary<string, string>(); tools_blocks = new Dictionary<string, ConfigNode>(); practices_block = null; tool_fillmatrix_info = null; tool_interpolate_info = null; tool_glue_info = null; tool_jointimeseries_info = null; meteo_block = null; meteo_sources_blocks = null; meteo_file_name = null; meteo_backup_files = false; meteo_store_path = null; meteo_backup_interpolated_files = false; meteo_store_int_path = null; meteo_interpolation_path = null; meteo_max_contiguous_skips = 8; meteo_task = false; tool_glue = new HDFGlue(); standard_names = true; }
public override void OnRedecorateModule(ConfigNode templateNode, bool payForRedecoration) { Log("OnRedecorateModule called"); //Load the modules loadModulesFromTemplate(templateNode); }
/// <summary> /// Save settings to the underlying storage /// </summary> public void Save() { ConfigNode node = AsConfigNode; var clsNode = new ConfigNode (GetType ().Name); clsNode.AddNode (node); clsNode.Save (filePath); }
/// <summary> /// Creates a new ChuteTemplate from the given ProceduralChute /// </summary> /// <param name="pChute">Module to create the object from</param> /// <param name="node">ConfigNode to load the data from</param> /// <param name="id">Index of the ChuteTemplate</param> public ChuteTemplate(ProceduralChute pChute, ConfigNode node, int id) { this.pChute = pChute; this.id = id; this.templateGUI = new TemplateGUI(this); if (node != null) { Load(node); } }
public void Load(ConfigNode node) { unlocked = false; node.TryGetValue("name", ref name); double cost = 0d; node.TryGetValue("cost", ref cost); node.TryGetValue("entryCost", ref entryCost); if(double.IsNaN(entryCost)) entryCost = Math.Max(0d, cost * RFSettings.Instance.configEntryCostMultiplier); node.TryGetValue("sciEntryCost", ref sciEntryCost); if(double.IsNaN(sciEntryCost)) sciEntryCost = Math.Max(0d, cost * RFSettings.Instance.configScienceCostMultiplier); node.TryGetValue("unlocked", ref unlocked); node.TryGetValue("techRequired", ref techRequired); if (node.HasNode("entryCostMultipliers")) LoadMultipliers(node.GetNode("entryCostMultipliers")); if (node.HasNode("entryCostSubtractors")) LoadSubtractors(node.GetNode("entryCostSubtractors")); node.TryGetValue("maxSubtraction", ref maxSubtraction); }
public static string GetValueDefault(ConfigNode node, string name, string vale) { if (node.HasValue(name)) vale = (node.GetValue(name)); //else Debug.Log("*MCEPC key not found: " + name); return vale; }
protected override void OnParameterLoad(ConfigNode node) { duration = Convert.ToDouble(node.GetValue("duration")); endTime = Convert.ToDouble(node.GetValue("endTime")); timerType = ConfigNodeUtil.ParseValue<TimerType>(node, "timerType", TimerType.CONTRACT_ACCEPTANCE); parameter = ConfigNodeUtil.ParseValue<string>(node, "parameter", ""); }
protected sealed override void OnSave(ConfigNode node) { try { if (Root != null) { node.AddValue("ContractIdentifier", Root.ToString()); } node.AddValue("title", title ?? ""); node.AddValue("notes", notes ?? ""); node.AddValue("completedMessage", completedMessage ?? ""); if (completeInSequence) { node.AddValue("completeInSequence", completeInSequence); } if (hidden) { node.AddValue("hidden", hidden); } if (hideChildren) { node.AddValue("hideChildren", hideChildren); } if (fakeFailures) { node.AddValue("fakeFailures", fakeFailures); } OnParameterSave(node); } catch (Exception e) { LoggingUtil.LogException(e); ExceptionLogWindow.DisplayFatalException(ExceptionLogWindow.ExceptionSituation.PARAMETER_SAVE, e, Root.ToString(), ID); } }
public static int GetValueDefault(ConfigNode node, string name, int val) { if (node.HasValue(name)) val = atoi(node.GetValue(name)); //else Debug.Log("*MCEPC key not found: " + name); return val; }
public override bool Load(ConfigNode configNode) { // Load base class bool valid = base.Load(configNode); valid &= ConfigNodeUtil.ParseValue<List<VesselIdentifier>>(configNode, "vessel", x => vessels = x, this, new List<VesselIdentifier>()); valid &= ConfigNodeUtil.ParseValue<VesselIdentifier>(configNode, "defineDockedVessel", x => defineDockedVessel = x, this, (VesselIdentifier)null); // Validate using the config node instead of the list as it may undergo deferred loading if (parent is VesselParameterGroupFactory) { if (configNode.GetValues("vessel").Count() > 1) { LoggingUtil.LogError(this, ErrorPrefix() + ": When used under a VesselParameterGroup, no more than one vessel may be specified for the Docking parameter."); valid = false; } } else { if (configNode.GetValues("vessel").Count() == 0) { LoggingUtil.LogError(this, ErrorPrefix() + ": Need at least one vessel specified for the Docking parameter."); valid = false; } if (configNode.GetValues("vessel").Count() > 2) { LoggingUtil.LogError(this, ErrorPrefix() + ": Cannot specify more than two vessels for the Docking parameter."); valid = false; } } return valid; }
public override void OnLoad(ConfigNode node) { base.OnLoad(node); ConfigNode[] efficiencyNodes = node.GetNodes(kEfficiencyData); ConfigNode[] toolTipsShown = node.GetNodes(kToolTip); string value = node.GetValue("reputationIndex"); if (string.IsNullOrEmpty(value) == false) reputationIndex = int.Parse(value); foreach (ConfigNode efficiencyNode in efficiencyNodes) { EfficiencyData efficiencyData = new EfficiencyData(); efficiencyData.Load(efficiencyNode); efficiencyDataMap.Add(efficiencyData.Key, efficiencyData); } foreach (ConfigNode toolTipNode in toolTipsShown) { if (toolTipNode.HasValue("name") == false) continue; value = toolTipNode.GetValue("name"); if (toolTips.ContainsKey(value)) toolTips[value] = toolTipNode; else toolTips.Add(value, toolTipNode); } }
public override void OnSave(ConfigNode node) { base.OnSave(node); node.AddValue("selectedObject", selectedObject.ToString()); node.AddValue("showGui", showGui.ToString()); }
protected override void OnLoadFromConfig(ConfigNode node) { base.OnLoadFromConfig(node); rewardFunds = ConfigNodeUtil.ParseValue<double>(node, "rewardFunds"); explorationType = ConfigNodeUtil.ParseValue<ExplorationType>(node, "explorationType"); }
public static ConfigNode ToConfigNode(this HarddiskFile file, string nodeName) { var node = new ConfigNode(nodeName); node.AddValue(FilenameValueString, file.Name); FileContent content = file.ReadAll(); if (content.Category == FileCategory.KSM) { node.AddValue("binary", PersistenceUtilities.EncodeBase64(content.Bytes)); } else if (content.Category == FileCategory.BINARY) { node.AddValue("binary", PersistenceUtilities.EncodeBase64(content.Bytes)); } else { if (SafeHouse.Config.UseCompressedPersistence) { node.AddValue("binary", EncodeBase64(content.String)); } else { node.AddValue("ascii", PersistenceUtilities.EncodeLine(content.String)); } } return node; }
public override bool Load(ConfigNode configNode) { // Load base class bool valid = base.Load(configNode); valid &= ConfigNodeUtil.ParseValue<Vessel.Situations>(configNode, "situation", x => situation = x, this, Vessel.Situations.ORBITING, ValidateSituations); valid &= ConfigNodeUtil.ParseValue<double>(configNode, "minAltitude", x => minAltitude = x, this, 0.0, x => Validation.GE(x, 0.0)); valid &= ConfigNodeUtil.ParseValue<double>(configNode, "maxAltitude", x => maxAltitude = x, this, double.MaxValue, x => Validation.GE(x, 0.0)); valid &= ConfigNodeUtil.ParseValue<double>(configNode, "minApA", x => minApoapsis = x, this, 0.0, x => Validation.GE(x, 0.0)); valid &= ConfigNodeUtil.ParseValue<double>(configNode, "maxApA", x => maxApoapsis = x, this, double.MaxValue, x => Validation.GE(x, 0.0)); valid &= ConfigNodeUtil.ParseValue<double>(configNode, "minPeA", x => minPeriapsis = x, this, 0.0, x => Validation.GE(x, 0.0)); valid &= ConfigNodeUtil.ParseValue<double>(configNode, "maxPeA", x => maxPeriapsis = x, this, double.MaxValue, x => Validation.GE(x, 0.0)); valid &= ConfigNodeUtil.ParseValue<double>(configNode, "minEccentricity", x => minEccentricity = x, this, 0.0, x => Validation.GE(x, 0.0)); valid &= ConfigNodeUtil.ParseValue<double>(configNode, "maxEccentricity", x => maxEccentricity = x, this, double.MaxValue, x => Validation.GE(x, 0.0)); valid &= ConfigNodeUtil.ParseValue<double>(configNode, "minInclination", x => minInclination = x, this, 0.0, x => Validation.Between(x, 0.0, 180.0)); valid &= ConfigNodeUtil.ParseValue<double>(configNode, "maxInclination", x => maxInclination = x, this, 180.0, x => Validation.Between(x, 0.0, 180.0)); valid &= ConfigNodeUtil.ParseValue<Duration>(configNode, "minPeriod", x => minPeriod = x, this, new Duration(0.0)); valid &= ConfigNodeUtil.ParseValue<Duration>(configNode, "maxPeriod", x => maxPeriod = x, this, new Duration(double.MaxValue)); // Validate target body valid &= ValidateTargetBody(configNode); // Validation minimum and groupings valid &= ConfigNodeUtil.AtLeastOne(configNode, new string[] { "minAltitude", "maxAltitude", "minApA", "maxApA", "minPeA", "maxPeA", "minEccentricity", "maxEccentricity", "minInclination", "maxInclination", "minPeriod", "maxPeriod" }, this); valid &= ConfigNodeUtil.MutuallyExclusive(configNode, new string[] { "minAltitude", "maxAltitude" }, new string[] { "minApA", "maxApA", "minPeA", "maxPeA" }, this); return valid; }
internal static AlarmInfo Load(ConfigNode node) { Guid vesselID = Utilities.GetNodeValue(node, "vesselID"); string Name = Utilities.GetNodeValue(node, "Name", string.Empty); AlarmInfo info = new AlarmInfo(Name, vesselID); info.AlarmType = Utilities.GetNodeValue(node, "AlarmType", KACWrapper.KACAPI.AlarmTypeEnum.Raw); info.Notes = Utilities.GetNodeValue(node, "Notes", string.Empty); info.AlarmTime = Utilities.GetNodeValue(node, "AlarmTime", 0d); info.AlarmMargin = Utilities.GetNodeValue(node, "AlarmMargin", 0d); info.AlarmExecute = Utilities.GetNodeValue(node, "AlarmExecute", false); string frzkbllst = Utilities.GetNodeValue(node, "FrzKerbals", string.Empty); string thwkbllst = Utilities.GetNodeValue(node, "ThwKerbals", string.Empty); string[] frzStrings = frzkbllst.Split(','); if (frzStrings.Length > 0) { for (int i = 0; i < frzStrings.Length; i++) { info.FrzKerbals.Add(frzStrings[i]); } } string[] thwStrings = thwkbllst.Split(','); if (thwStrings.Length > 0) { for (int i = 0; i < thwStrings.Length; i++) { if (thwStrings[i].Length > 0) info.ThwKerbals.Add(thwStrings[i]); } } return info; }
public CustomVariable(ConfigNode node) { name = node.GetValue("name"); foreach (ConfigNode sourceVarNode in node.GetNodes("SOURCE_VARIABLE")) { SourceVariable sourceVar = new SourceVariable(sourceVarNode); sourceVariables.Add(sourceVar); } if(sourceVariables.Count == 0) { throw new ArgumentException("Did not find any SOURCE_VARIABLE nodes in RPM_CUSTOM_VARIABLE", name); } string oper = node.GetValue("operator"); if (oper == Operator.NONE.ToString()) { op = Operator.NONE; } else if (oper == Operator.AND.ToString()) { op = Operator.AND; } else if (oper == Operator.OR.ToString()) { op = Operator.OR; } else if (oper == Operator.XOR.ToString()) { op = Operator.XOR; } else { throw new ArgumentException("Found an invalid operator type in RPM_CUSTOM_VARIABLE", oper); } }
public BodyDeposits(GeneratorConfiguration resource, ConfigNode node) { if (node == null) { node = new ConfigNode(); } this.deposits = new List<Deposit>(); this.seed = Misc.Parse(node.GetValue("Seed"), seedGenerator.Next()); var random = new System.Random(seed); for (int i = 0; i < resource.DepositCount; i++) { float R = random.Range(resource.MinRadius, resource.MaxRadius); for (int j = 0; j < resource.NumberOfTries; j++) { Vector2 Pos = new Vector2(random.Range(R, 360 - R), random.Range(R, 180 - R)); var deposit = Deposit.Generate(Pos, R, random, resource); if (!deposits.Any(d => d.Shape.Vertices.Any(v => deposit.Shape.PointInPolygon(new Vector2(v.x, v.y)))) && !deposit.Shape.Vertices.Any(v => deposits.Any(d => d.Shape.PointInPolygon(new Vector2(v.x, v.y))))) { deposits.Add(deposit); break; } } } var depositValues = node.GetValues("Deposit"); for (int i = 0; i < Math.Min(deposits.Count, depositValues.Length); i++) { deposits[i].Quantity = Misc.Parse(depositValues[i], deposits[i].InitialQuantity); } MaxQuantity = resource.MaxQuantity; }
/// <summary> /// Load the saved TargetCommand. Open a new ITargetable object by /// the objects id. /// </summary> /// <param name="n">Node with the command infos</param> /// <param name="fc">Current flightcomputer</param> /// <returns>true - loaded successfull</returns> public override bool Load(ConfigNode n, FlightComputer fc) { if(base.Load(n, fc)) { switch (TargetType) { case "Vessel": { Guid Vesselid = new Guid(TargetId); Target = RTUtil.GetVesselById(Vesselid); break; } case "CelestialBody": { Target = FlightGlobals.Bodies.ElementAt(int.Parse(TargetId)); break; } default: { Target = null; break; } } return true; } return false; }
public void CreateNode(int size, ConfigNodeSubType subType, ConfigNodeType nType, int terminal, [MarshalAs(UnmanagedType.LPWStr)] string text, int textLength, int prefixLength) { if (nType == ConfigNodeType.Element) { this.lastProcessed = "<" + text + ">"; if ((this.parsing || (this.bNoSearchPath && (string.Compare(text, this.treeRootPath[0], StringComparison.OrdinalIgnoreCase) == 0))) || (((this.depth == this.searchDepth) && (this.searchDepth == this.pathDepth)) && (string.Compare(text, this.treeRootPath[this.pathDepth], StringComparison.OrdinalIgnoreCase) == 0))) { this.parsing = true; ConfigNode currentNode = this.currentNode; this.currentNode = new ConfigNode(text, currentNode); if (this.rootNode == null) { this.rootNode = this.currentNode; } else { currentNode.AddChild(this.currentNode); } } else { this.depth++; } } else if ((nType == ConfigNodeType.PCData) && (this.currentNode != null)) { this.currentNode.Value = text; } }
public override void OnSave(ConfigNode node) { base.OnSave(node); ConfigNode saveNode; if (addedPartModules == null) { Log("addedPartModules is null"); return; } foreach (PartModule addedModule in addedPartModules) { //Create a node for the module saveNode = ConfigNode.CreateConfigFromObject(addedModule); if (saveNode == null) { Log("save node is null"); continue; } //Tell the module to save its data saveNode.name = "WBIMODULE"; addedModule.Save(saveNode); //Add it to our node node.AddNode(saveNode); } }
/*************************************************************************************************************** * new persistence model ***************************************************************************************************************/ public static void SaveHallOfFame(List<LogbookEntry> logbook, ConfigNode node) { Log.Info("saving hall of fame (" + logbook.Count + " logbook entries)"); List<LogbookEntry> logbookCopy = new List<LogbookEntry>(logbook); Stopwatch sw = new Stopwatch(); sw.Start(); try { foreach (LogbookEntry entry in logbookCopy) { ConfigNode entryNode = new ConfigNode(PERSISTENCE_NODE_ENTRY_NAME); if (Log.IsLogable(Log.LEVEL.DETAIL)) Log.Detail("saving logbook entry " + entry); entryNode.AddValue(Constants.CONFIGNODE_KEY_TIME, entry.UniversalTime.ToString()); entryNode.AddValue(Constants.CONFIGNODE_KEY_NAME, entry.Name); entryNode.AddValue(Constants.CONFIGNODE_KEY_CODE, entry.Code); entryNode.AddValue(Constants.CONFIGNODE_KEY_DATA, entry.Data); node.AddNode(entryNode); } } catch { Log.Error("exception while saving hall of fame detected; hall of fame may be corrupt"); } finally { sw.Stop(); Log.Info("hall of fame saved in " + sw.ElapsedMilliseconds + "ms"); } }
public static bool ReceiveDataExec(ConfigNode data) { RTLog.Verbose("Received Data via Api.ReceiveDataExec", RTLogLevel.API); RTLog.Notify("Data: {0}", data); return bool.Parse(data.GetValue("AbortCommand")); }
public BitmapFont(ConfigNode node, string nodeUrl) { id = node.GetValue("id"); name = node.GetValue("name"); displayName = node.GetValue("displayName"); size = int.Parse(node.GetValue("size")); UnityEngine.Texture2D texture = Utils.LoadTexture("GameData/" + nodeUrl + ".pngmap", false); characterMap = new Dictionary<char, BitmapChar>(); float h = 0; foreach(ConfigNode n in node.GetNodes("ASP_BITMAP_CHAR")) { BitmapChar cMap = new BitmapChar(n, texture); characterMap[cMap.character] = cMap; // vh is -ve if (cMap.vh < height) h = cMap.vh; } height = (int) Math.Abs(h); UnityEngine.Object.Destroy(texture); }
public override bool Load(ConfigNode configNode) { // Load base class bool valid = base.Load(configNode); valid &= ConfigNodeUtil.ParseValue<string>(configNode, "basename", x => basename = x, this); int index = 0; foreach (ConfigNode child in ConfigNodeUtil.GetChildNodes(configNode, "CONDITION")) { DataNode childDataNode = new DataNode("CONDITION_" + index++, dataNode, this); try { ConfigNodeUtil.SetCurrentDataNode(childDataNode); OpenBase.ConditionDetail cd = new OpenBase.ConditionDetail(); valid &= ConfigNodeUtil.ParseValue<OpenBase.ConditionDetail.Condition>(child, "condition", x => cd.condition = x, this); valid &= ConfigNodeUtil.ParseValue<string>(child, "parameter", x => cd.parameter = x, this, "", x => ValidateMandatoryParameter(x, cd.condition)); conditions.Add(cd); } finally { ConfigNodeUtil.SetCurrentDataNode(dataNode); } } valid &= ConfigNodeUtil.ValidateMandatoryChild(configNode, "CONDITION", this); return valid; }
public override bool Load(ConfigNode configNode) { // Load base class bool valid = base.Load(configNode); // Check on active contracts too checkOnActiveContract = configNode.HasValue("checkOnActiveContract") ? checkOnActiveContract : true; valid &= ConfigNodeUtil.ParseValue<List<string>>(configNode, "tech", x => techs = x, this, new List<string>()); if (configNode.HasValue("part")) { List<AvailablePart> parts = new List<AvailablePart>(); valid &= ConfigNodeUtil.ParseValue<List<AvailablePart>>(configNode, "part", x => parts = x, this); foreach (AvailablePart part in parts) { techs.AddUnique(part.TechRequired); } } valid &= ConfigNodeUtil.AtLeastOne(configNode, new string[] { "tech", "part" }, this); return valid; }
public override void OnLoad(ConfigNode node) { base.OnLoad(node); //get settings node and kerbal node try { ConfigNode DataNode = node.GetNode("TerminusData"); if (DataNode != null) { ConfigNode TLS_Kerbals = DataNode.GetNode("TLS_Kerbals"); if (TLS_Kerbals != null) { Terminus_Life_Support.TrackedKerbals.Clear(); foreach (ConfigNode kiNode in TLS_Kerbals.GetNodes("KerbalInfo")) { KerbalInfo ki = new KerbalInfo(); ki.FromConfigNode(kiNode); if (ki.Name != "") Terminus_Life_Support.TrackedKerbals.Add(ki); } Terminus_Life_Support.UpdateKerbalList(true); } } } catch (Exception e) { UnityEngine.Debug.LogException(e); } }
public ProtoAntenna(Vessel v, ProtoPartSnapshot p, ProtoPartModuleSnapshot ppms) { ConfigNode n = new ConfigNode(); ppms.Save(n); Name = p.partInfo.title; try { mTarget = new Guid(n.GetValue("RTAntennaTarget")); DishRange = Single.Parse(n.GetValue("RTDishRange")); DishFactor = Double.Parse(n.GetValue("RTDishFactor")); OmniRange = Single.Parse(n.GetValue("RTOmniRange")); } catch (ArgumentException) { mTarget = Guid.Empty; DishRange = 0.0f; DishFactor = 1.0f; OmniRange = 0.0f; RTUtil.Log("ProtoAntenna parsing error. Default values assumed."); } mProtoPart = p; mProtoModule = ppms; Vessel = v; RTUtil.Log("ProtoAntenna: DishRange: {0}, OmniRange: {1}, Name: {2}, DishTarget: {3})", DishRange, OmniRange, Vessel.vesselName, DishTarget); }