/// <summary>Updates the part's resource.</summary> /// <param name="partNode"> /// The part's config or a persistent state. It can be a top-level node or the <c>PART</c> node. /// </param> /// <param name="name">The name of the resource.</param> /// <param name="amount">The new amount or the delta.</param> /// <param name="isAmountRelative"> /// Tells if the amount must be added to the current item's amount instead of simply replacing it. /// </param> /// <returns>The new amount or <c>null</c> if the resource was not found.</returns> public double?UpdateResource(ConfigNode partNode, string name, double amount, bool isAmountRelative = false) { if (partNode.HasNode("PART")) { partNode = partNode.GetNode("PART"); } var node = partNode.GetNodes("RESOURCE") .FirstOrDefault(r => r.GetValue("name") == name); double?setAmount = null; if (node != null) { setAmount = amount; if (isAmountRelative) { setAmount += ConfigAccessor.GetValueByPath <double>(node, "amount") ?? 0.0; } ConfigAccessor.SetValueByPath(node, "amount", setAmount.Value); } else { DebugEx.Error("Cannot find resource '{0}' in config:\n{1}", name, partNode); } return(setAmount); }
/// <summary>Calculates part's dry cost given the config and the variant.</summary> /// <param name="avPart">The part's proto.</param> /// <param name="variant"> /// The part's variant. If it's <c>null</c>, then the variant will be attempted to read from /// <paramref name="partNode"/>. /// </param> /// <param name="partNode"> /// The part's persistent config. It will be looked up for the various cost modifiers. /// </param> /// <returns>The dry cost of the part.</returns> public double GetPartDryCost( AvailablePart avPart, PartVariant variant = null, ConfigNode partNode = null) { // TweakScale compatibility if (partNode != null) { var tweakScale = KISAPI.PartNodeUtils.GetTweakScaleModule(partNode); if (tweakScale != null) { var tweakedCost = ConfigAccessor.GetValueByPath <double>(tweakScale, "DryCost"); if (tweakedCost.HasValue) { // TODO(ihsoft): Get back to this code once TweakScale supports variants. return(tweakedCost.Value); } DebugEx.Error("No dry cost specified in a tweaked part {0}:\n{1}", avPart.name, tweakScale); } } var itemCost = avPart.cost; if (variant == null && partNode != null) { variant = VariantsUtils.GetCurrentPartVariant(avPart, partNode); } VariantsUtils.ExecuteAtPartVariant(avPart, variant, p => itemCost += p.GetModuleCosts(avPart.cost)); return(itemCost); }
/// <summary>Returns external part's scale given a config.</summary> /// <remarks>This is a scale applied on the module by the other mods. I.e. it's a "runtime" scale, /// not the one specified in the common part's config. /// <para>The only mod supported till now is <c>TweakScale</c>.</para> /// </remarks> /// <param name="partNode">A config to get values from.</param> /// <returns>Multiplier to a model's scale on one axis.</returns> public static float GetPartExternalScaleModifier(ConfigNode partNode) { // TweakScale compatibility. foreach (var node in partNode.GetNodes("MODULE")) { if (node.GetValue("name") == "TweakScale") { double defaultScale = 1.0f; ConfigAccessor.GetValueByPath(node, "defaultScale", ref defaultScale); double currentScale = 1.0f; ConfigAccessor.GetValueByPath(node, "currentScale", ref currentScale); return((float)(currentScale / defaultScale)); } } return(1.0f); }
/// <summary>Creates an item, restored form the save file.</summary> /// <param name="itemNode">The item config node to load the data from.</param> /// <param name="inventory">The owner inventory of the item.</param> /// <returns>The item instance.</returns> public static KIS_Item RestoreItemFromNode(ConfigNode itemNode, ModuleKISInventory inventory) { var qty = ConfigAccessor.GetValueByPath <int>(itemNode, "quantity") ?? 0; var partName = itemNode.GetValue("partName"); AvailablePart avPart = null; if (partName != null) { avPart = PartLoader.getPartInfoByName(partName); } if (qty == 0 || partName == null || avPart == null) { DebugEx.Error("Bad item config:\n{0}", itemNode); throw new ArgumentException("Bad item config node", "itemNode"); } return(new KIS_Item(avPart, itemNode, inventory, qty)); }
/// <summary>Gets scale modifier, applied by TweakScale mod.</summary> /// <param name="partNode">The part's persistent state config.</param> /// <returns>The scale ratio.</returns> public double GetTweakScaleSizeModifier(ConfigNode partNode) { var ratio = 1.0; var tweakScaleNode = GetTweakScaleModule(partNode); if (tweakScaleNode != null) { var defaultScale = ConfigAccessor.GetValueByPath <double>(tweakScaleNode, "defaultScale"); var currentScale = ConfigAccessor.GetValueByPath <double>(tweakScaleNode, "currentScale"); if (defaultScale.HasValue && currentScale.HasValue) { ratio = currentScale.Value / defaultScale.Value; } else { DebugEx.Error("Bad TweakScale config:\n{0}", tweakScaleNode); } } return(ratio); }
/// <summary>Loads a persisted switch binding.</summary> /// <param name="node">The node to get values from.</param> /// <seealso cref="PersistentFieldAttribute"/> /// <include file="KSPAPI_HelpIndex.xml" path="//item[@name='T:KSPField']"/> public virtual void Load(ConfigNode node) { ConfigAccessor.GetValueByPath(node, "keyCode", ref keyCode); }