protected void ChangeParts(Condition currentCondition) { foreach (ChangeInventoryPartsHandler handler in _handlers) { if (handler.TriggerCondition == currentCondition) //if it's the right condition, do the thing { foreach (IntermediateInventoryPart iip in handler.InventoryParts) { foreach (InventoryPart ip in iip.ToInventoryParts()) { if (handler.Adding) { ip.TrackerModule.TimesRecovered = Math.Max(0, ip.TrackerModule.TimesRecovered); ScrapYard.ScrapYard.Instance.TheInventory.AddPart(ip); } else { ComparisonStrength compareStrength = ip.TrackerModule.TimesRecovered < 0 ? ComparisonStrength.MODULES : ComparisonStrength.TRACKER; //if negative, just care about modules. If 0+ then be strict ScrapYard.ScrapYard.Instance.TheInventory.RemovePart(ip, compareStrength); } } } } } }
/// <summary> /// Finds a part in the inventory for the given part /// </summary> /// <param name="part">The part to search for</param> /// <param name="strictness">The strictness to use when searching for the part. Defaults to MODULES.</param> /// <returns>A ConfigNode representing the InventoryPart, or null if none found.</returns> public static ConfigNode FindInventoryPart(ConfigNode part, ComparisonStrength strictness = ComparisonStrength.MODULES) { if (!Available) { return(null); } return(invokeMethod("FindInventoryPart_Node", part, strictness.ToString()) as ConfigNode); }
/// <summary> /// Removes a part from the Inventory using the given strictness for finding the part /// </summary> /// <param name="part">The part to remove</param> /// <param name="strictness">The strictenss to use when searching for the part. Defaults to MODULES</param> /// <returns>True if removed, false otherwise.</returns> public static bool RemovePartFromInventory(ConfigNode part, ComparisonStrength strictness = ComparisonStrength.MODULES) { if (!Available) { return(false); } return((bool)invokeMethod("RemovePartFromInventory_Node", part, strictness.ToString())); }
/// <summary> /// Finds an InventoryPart for a given part /// </summary> /// <param name="sourcePart">The part to search for</param> /// <param name="strictness">The strictness to use when searching for the part</param> /// <returns>The ConfigNode for the InventoryPart, or null if not found</returns> public ConfigNode FindInventoryPart_Node(ConfigNode sourcePart, string strictness) { if (!ScrapYard.Instance.TheInventory.InventoryEnabled) { return(null); } ComparisonStrength actualStrictness = parseStrictnessString(strictness); return(ScrapYard.Instance.TheInventory.FindPart(new InventoryPart(sourcePart), actualStrictness)?.State); }
/// <summary> /// Removes a single part from the inventory. /// </summary> /// <param name="sourcePart">The part to remove.</param> /// <param name="strictness">The strictness to use when searching for the appropriate part.</param> /// <returns>True if removed, false otherwise.</returns> public bool RemovePartFromInventory_Node(ConfigNode sourcePart, string strictness) { if (!ScrapYard.Instance.TheInventory.InventoryEnabled) { return(false); } ComparisonStrength actualStrictness = parseStrictnessString(strictness); return(ScrapYard.Instance.TheInventory.RemovePart(new InventoryPart(sourcePart), actualStrictness) != null); }
private ComparisonStrength parseStrictnessString(string strictness) { try { ComparisonStrength actualStrictness = (ComparisonStrength)Enum.Parse(typeof(ComparisonStrength), strictness); return(actualStrictness); } catch { return(ComparisonStrength.MODULES); } }
/// <summary> /// Finds a part in the inventory for the given InventoryPart and a strictness of comparison /// </summary> /// <param name="part">The source part to find a match for</param> /// <param name="strength">The strictness of the comparison. Defaults to MODULES.</param> /// <returns>The InventoryPart or null if not found.</returns> public InventoryPart FindPart(InventoryPart part, ComparisonStrength strength = ComparisonStrength.MODULES) { if (!InventoryEnabled) { return(null); } if (strength == ComparisonStrength.STRICT) { InventoryPart found = internalInventory.FirstOrDefault(ip => ip == part); if (found != null) { return(found); } } return(internalInventory.FirstOrDefault(ip => ip.IsSameAs(part, strength))); }
/// <summary> /// Removes a part from the inventory given an InventoryPart to compare and the strictness of comparison /// </summary> /// <param name="part">The source part to find a match for</param> /// <param name="strength">The strictness of the comparison. Defaults to MODULES</param> /// <returns>The removed InventoryPart, or null if none found</returns> public InventoryPart RemovePart(InventoryPart part, ComparisonStrength strength = ComparisonStrength.MODULES) { if (!InventoryEnabled) { return(null); } InventoryPart found = FindPart(part, strength); if (found != null && internalInventory.Remove(found)) { if (!disableEvents) { ScrapYardEvents.OnSYInventoryChanged.Fire(found, false); } return(found); } return(null); }
/// <summary> /// Takes a List of part ConfigNodes and returns the ConfigNodes that are present in the inventory. /// Assumes the default strictness. /// </summary> /// <param name="sourceParts">Source list of parts</param> /// <returns>List of part ConfigNodes that are in the inventory</returns> public IList <ConfigNode> GetPartsInInventory_ConfigNodes(IEnumerable <ConfigNode> sourceParts, string strictness) { if (!ScrapYard.Instance.TheInventory.InventoryEnabled) { return(new List <ConfigNode>()); } ComparisonStrength actualStrictness = parseStrictnessString(strictness); List <ConfigNode> inInventory = new List <ConfigNode>(); PartInventory InventoryCopy = ScrapYard.Instance.TheInventory.Copy(); foreach (ConfigNode part in sourceParts) { InventoryPart inputPart = new InventoryPart(part); if (InventoryCopy.RemovePart(inputPart, actualStrictness) != null) { inInventory.Add(part); } } return(inInventory); }
/// <summary> /// Finds all parts in the inventory for the given InventoryPart and the provided strictness /// </summary> /// <param name="part">The source part to find a match for</param> /// <param name="strength">The strictness of the comparison. Defaults to MODULES.</param> /// <returns>An IEnumerable of InventoryParts that match</returns> public IEnumerable <InventoryPart> FindParts(InventoryPart part, ComparisonStrength strength = ComparisonStrength.MODULES) { if (!InventoryEnabled) { return(null); } List <InventoryPart> foundParts = new List <InventoryPart>(); PartInventory copy = Copy(); InventoryPart found = null; do { found = copy.RemovePart(part, strength); if (found != null) { foundParts.Add(found); } } while (found != null); return(foundParts); }
/// <summary> /// Checks to see if the passed InventoryPart is identical to this one, for a given strictness of "identical" /// </summary> /// <param name="comparedPart">The part to compare to</param> /// <param name="strictness">The strength of the comparison (just name? modules? everything?)</param> /// <returns>True if mathing, false otherwise</returns> public bool IsSameAs(InventoryPart comparedPart, ComparisonStrength strictness) { //Test that the name is the same if (Name != comparedPart.Name) { return(false); } if (strictness == ComparisonStrength.NAME) //If we're just comparing name then we're done { return(true); } //Verify the costs are within 1 funds if (Math.Abs(DryCost - comparedPart.DryCost) > 1.0) { return(false); } if (strictness == ComparisonStrength.COSTS) { return(true); } if (strictness == ComparisonStrength.STRICT) //Strict comparison, the ids must be the same { //Compare IDs now so we can avoid the full module comparison if they don't have the same ID if (comparedPart.ID != ID) { return(false); } } //Test to ensure the number of saved modules are identical if (savedModules.Count == comparedPart.savedModules.Count) { //Compare the saved modules to ensure they are identical for (int index = 0; index < savedModules.Count; ++index) { if (!savedModules[index].IsIdenticalTo(comparedPart.savedModules[index])) { return(false); } } //If everything has passed, they are considered equal } else { return(false); } if (strictness == ComparisonStrength.MODULES) { return(true); } //Tracker comparison, the times used must match if (TrackerModule.TimesRecovered != comparedPart.TrackerModule.TimesRecovered) { return(false); } if (TrackerModule.Inventoried != comparedPart.TrackerModule.Inventoried) { return(false); } if (strictness == ComparisonStrength.TRACKER) { return(true); } //Everything must match, they are the same return(true); }
/// <summary> /// Takes a List of Parts and returns the Parts that are present in the inventory. /// </summary> /// <param name="sourceParts">Source list of parts</param> /// <param name="strictness">How strict of a comparison to use. Defaults to MODULES</param> /// <returns>List of Parts that are in the inventory</returns> public static IList <Part> GetPartsInInventory(IEnumerable <Part> sourceParts, ComparisonStrength strictness = ComparisonStrength.MODULES) { if (!Available) { return(null); } return((IList <Part>)invokeMethod("GetPartsInInventory_Parts", sourceParts, strictness.ToString())); //Why do a ToString on an enum instead of casting to int? Because if the internal enum changes then the intended strictness is kept. }