public virtual float GiveTo(UrbAgent Target, UrbSubstanceTag Substance) { if (!Target.HasBody) { return(0); } float Amount = 0; UrbAction HoldAction = mAgent.PickAction(UrbTestCategory.Hold); if (HoldAction != null) { Amount = HoldAction.Execute(mAgent, Target); if (Target.IsGrasper) { Target.Grasper.TakeFrom(mAgent, Substance); } else if (Target.IsEater) { Amount = HeldComposition.TransferTo(Target.Eater.Stomach, Substance, Amount); } else { Amount = HeldComposition.TransferTo(Target.mBody.BodyComposition, Substance, Amount); } } return(Amount); }
// Intended to be called when the agent is deceased-- A "magical" //means of mass disappearing into the void, and therefore, a bit //of a compromise to the system's integrity. // Deceased bodies will get removed from the map over time. //In the future, this should be replaced with actual decay mechanisms //FOR EXAMPLE: Fur/teeth are not eaten by sneks. // Could solve that loophole by having fur first in the ordering? public void DecaySubstances(int decay = 2) { Assert.IsTrue(decay > 0, "decay must be > 0"); ContainingComposition?.DecaySubstances(); UrbSubstanceTag[] subs = Substances.Keys.ToArray(); float[] values = Substances.Values.ToArray(); float val; for (int i = 0; i < subs.Length; i++) { val = values[i]; if (val <= 0) { continue; } UrbSubstanceTag tag = subs[i]; if (val <= 1) { UsedCapacity -= val; Substances[tag] -= val; break; } float reduction = val / decay; Substances[tag] -= reduction; UsedCapacity -= reduction; //I was going to have the break; } }
public static bool Remove(UrbSubstanceTag Tag) { if (Properties == null || !Properties.ContainsKey(Tag)) { return(false); } return(Properties.Remove(Tag)); }
public static bool CheckScent(UrbSubstanceTag Substance, UrbScentTag Scent) { if (SubstanceByScent.ContainsKey(Scent)) { return(SubstanceByScent[Scent].Contains(Substance)); } return(false); }
public float Impact(UrbComposition ImpactSource, UrbSubstanceTag ImpactSubstance, float Force) { float Result = ImpactSource[ImpactSubstance]; Result = PenetrationCheck(ImpactSubstance, Result, Force); return(Result); }
public static UrbSubstanceProperty Get(UrbSubstanceTag Tag) { if (Properties == null || !Properties.ContainsKey(Tag)) { return(Default); } return(Properties[Tag]); }
protected static bool UnregisterScent(UrbSubstanceTag Substance, UrbScentTag Scent) { if (SubstanceByScent.ContainsKey(Scent)) { if (SubstanceByScent[Scent].Contains(Substance)) { return(SubstanceByScent[Scent].Remove(Substance)); } } return(false); }
public override bool SetComponentData(UrbComponentData Data) { EnergyDebt = UrbEncoder.GetField("EnergyDebt", Data); BodyEnergyReserveStorage = UrbEncoder.GetEnum <UrbSubstanceTag>("BodyEnergyReserveStorage", Data); BodyGrowthRecipe = UrbEncoder.GetSubstancesFromArray("BodyGrowthRecipe", Data); InitializeGrowthRecipes(); if (IsEater) { InitializeReserveRecipes(); } return(true); }
public float RemoveSubstance(UrbSubstanceTag Tag, float Amount) { if (Amount <= 0.0f) { return(0.0f); } if (ContainingComposition != null) { MaxCapacity = ContainingComposition.AvailableCapacity + UsedCapacity; } float TransferAmount = Amount; //Debug.Log("Attempting Transfer " + TransferAmount + " from " + Tag.ToString()); //Is this Supposed to be addition? float CapacityAfter = UsedCapacity + Amount; if (CapacityAfter < 0) { TransferAmount += CapacityAfter; } //Debug.Log("After Capacity Check Transfer " + TransferAmount); if (Substances.ContainsKey(Tag)) { if (Substances[Tag] >= TransferAmount) { Substances[Tag] -= TransferAmount; } else { TransferAmount += Substances[Tag] - TransferAmount; Substances[Tag] = 0; Dirty = true; } // Debug.Log("After Quantity Check " + TransferAmount); } else { TransferAmount = 0; } UsedCapacity -= TransferAmount; if (ContainingComposition != null) { ContainingComposition.UsedCapacity -= TransferAmount; } Assert.IsFalse(float.IsInfinity(TransferAmount) || float.IsNaN(TransferAmount)); return(TransferAmount); }
public float GetProportionOf(UrbSubstanceTag Tag) { if (Tag == UrbSubstanceTag.None || UsedCapacity <= 0) { return(0.0f); } else if (Tag == UrbSubstanceTag.All) { return(1.0f); } return(this[Tag] / UsedCapacity); }
public float this[UrbSubstanceTag Tag] { get { if (Tag == UrbSubstanceTag.All) { return(UsedCapacity); } if (Substances.TryGetValue(Tag, out float val)) { return(val); } return(0.0f); } }
protected static bool RegisterScent(UrbSubstanceTag Substance, UrbScentTag Scent) { if (!SubstanceByScent.ContainsKey(Scent)) { SubstanceByScent.Add(Scent, new List <UrbSubstanceTag>()); } if (SubstanceByScent[Scent].Contains(Substance)) { return(false); } SubstanceByScent[Scent].Add(Substance); return(true); }
public static void Set(UrbSubstanceTag Tag, UrbSubstanceProperty Property) { if (Properties == null) { Properties = new Dictionary <UrbSubstanceTag, UrbSubstanceProperty>(); } if (Properties.ContainsKey(Tag)) { if (Property.Hardness > -1) { Properties[Tag].Hardness = Property.Hardness; } if (Property.Flexibility > -1) { Properties[Tag].Flexibility = Property.Flexibility; } if (Property.Maleability > -1) { Properties[Tag].Flexibility = Property.Maleability; } if (Property.PersonalScent.Length > 0) { for (int i = 0; i < Properties[Tag].Scent.Length; i++) { UnregisterScent(Tag, Properties[Tag].Scent[i]); } Properties[Tag].Scent = Property.PersonalScent; } if (Property.Components.Length > 0) { Properties[Tag].Components = Property.Components; } } else { Properties.Add(Tag, Property); } for (int i = 0; i < Properties[Tag].Scent.Length; i++) { RegisterScent(Tag, Properties[Tag].Scent[i]); } return; }
public float this[UrbSubstanceTag Tag] { get { if (Occupants.Count <= 0) { return(0); } float Amount = 0; for (int i = 0; i < Occupants.Count; i++) { if (Occupants[i].HasBody) { Amount += Occupants[i].mBody.BodyComposition[Tag]; } } return(Amount); } }
public float AddSubstance(UrbSubstanceTag Tag, float Amount) { if (ContainingComposition != null) { MaxCapacity = ContainingComposition.AvailableCapacity + UsedCapacity; } if (Amount <= 0.0f) { return(0.0f); } float TransferAmount = Amount; float CapacityAfter = UsedCapacity + Amount; if (CapacityAfter > MaxCapacity) { TransferAmount -= CapacityAfter - MaxCapacity; } if (Substances.ContainsKey(Tag)) { Substances[Tag] += TransferAmount; } else { Substances.Add(Tag, TransferAmount); Dirty = true; } UsedCapacity += TransferAmount; if (ContainingComposition != null) { ContainingComposition.UsedCapacity += TransferAmount; } Assert.IsFalse(float.IsInfinity(TransferAmount) || float.IsNaN(TransferAmount)); return(TransferAmount); }
public float PenetrationCheck(UrbSubstanceTag Penetrator, float Amount, float Force) { if (Layers == null || Layers.Length == 0) { return(Amount); } float Result = 0; float Depth = Force; float PenHardness = UrbSubstanceProperties.Get(Penetrator).Hardness; for (int i = 0; i < Layers.Length; i++) { float LayerThickness = Thickness(Layers[i]); float LayerHardness = UrbSubstanceProperties.Get(Layers[i]).Hardness; float LayerFlexibility = UrbSubstanceProperties.Get(Layers[i]).Flexibility; Depth *= PenHardness / LayerHardness; if (Depth > LayerThickness) { float Damage = LayerFlexibility > 0 ? (Amount * LayerThickness) / LayerFlexibility : Amount * LayerThickness; LayerDamage[i] += Damage; Result += Damage; Depth -= LayerThickness; } else { float Damage = LayerFlexibility > 0 ? (Amount * Depth) / LayerFlexibility : Amount * Depth; LayerDamage[i] += Damage; Result += Damage; break; } } return(Result); }
public float EmptyInto(UrbComposition Target) { float Result = 0; UrbSubstanceTag[] tags = new UrbSubstanceTag[Substances.Keys.Count]; int i = 0; foreach (UrbSubstanceTag tag in Substances.Keys) { tags[i] = tag; i++; } for (int t = 0; t < tags.Length; t++) { float Amount = Substances[tags[t]]; Result += TransferTo(Target, tags[t], Amount); } Assert.IsFalse(float.IsInfinity(Result) || float.IsNaN(Result)); return(Result); }
public float TransferTo(UrbComposition Target, UrbSubstanceTag Tag, float Amount) { if (Amount <= 0.0f) { return(0.0f); } //float TransferAmount = Mathf.Min(Amount, Target.AvailableCapacity); float TransferAmount = RemoveSubstance(Tag, Amount); if (TransferAmount > 0) { Target.AddSubstance(Tag, TransferAmount); } else { //Debug.Log( Tag.ToString() + " Not Available to Transfer."); } Assert.IsFalse(float.IsInfinity(TransferAmount) || float.IsNaN(TransferAmount)); return(TransferAmount); }
public static bool SubstanceSmellsLike(UrbSubstanceTag Substance, UrbScentTag Scent) { return(UrbSubstanceProperties.CheckScent(Substance, Scent)); }
public static UrbScentTag[] Scent(UrbSubstanceTag input) { return(UrbSubstanceProperties.Get(input).Scent); }
public float Thickness(UrbSubstanceTag Tag) { return(ContainingComposition.GetProportionOf(Tag) * Radius); }