/// <summary>
/// Other mods need to call this to start processing a ProtoVessel.
/// Will write this into an API in future version.
/// </summary>
/// <param name="vessel"></param>
public void AddInterestedVessel(ProtoVessel vessel)
{
if (!InterestedVessels.Contains(vessel))
{
InterestedVessel iVessel = new InterestedVessel(vessel.vesselRef, vessel);
InterestedVessels.Add(vessel, iVessel);
CacheResources.CreatecachedVesselResources(vessel);
}
}
/// <summary>
/// Looks for a CachedResources entry for the passed in ProtoVessel. If one doesn't exist it will create one.
/// Then it will search the CachedResources for the ProtoVessel for the passed in resourceName and return the amount and maxAmount available
/// on the ProtoVessel.
/// </summary>
/// <param name="vessel"></param>
/// <param name="resourceName"></param>
/// <param name="amount"></param>
/// <param name="maxAmount"></param>
public static void GetResourceTotals(ProtoVessel vessel, string resourceName, out double amount, out double maxAmount)
{
amount = 0d;
maxAmount = 0d;
if (UnloadedResources.InterestedVessels == null)
{
UnloadedResources.InterestedVessels = new DictionaryValueList <ProtoVessel, InterestedVessel>();
}
if (!UnloadedResources.InterestedVessels.Contains(vessel))
{
CacheResources.CreatecachedVesselResources(vessel);
}
//If there are no cachedResources for the vessel create one.
if (UnloadedResources.InterestedVessels[vessel].CachedResources == null)
{
CacheResources.CreatecachedVesselResources(vessel);
}
//If BackgroundProcessing is installed and our cache hasn't been refreshed in 3 mins. Then refresh it.
if (UnloadedResources.BackgroundProcessingInstalled &&
(Time.time - UnloadedResources.InterestedVessels[vessel].TimeLastRefresh > 180))
{
CacheResources.CreatecachedVesselResources(vessel);
}
//Double check, not really necessary. Now find the resource amounts if in the vessel.
if (UnloadedResources.InterestedVessels.Contains(vessel))
{
List <CacheResources.CacheResource> vslresources = UnloadedResources.InterestedVessels[vessel].CachedResources;
for (int i = 0; i < vslresources.Count; i++)
{
if (vslresources[i].resourceName == resourceName)
{
amount = vslresources[i].amount;
maxAmount = vslresources[i].maxAmount;
if (vslresources[i].timeWarpOverflow.totalAmount > 0 && TimeWarp.fetch != null && TimeWarp.CurrentRateIndex > CacheResources.timeWarpStep) //If we have timewarp Overflow check that first.
{
amount += vslresources[i].timeWarpOverflow.totalAmount;
maxAmount += vslresources[i].timeWarpOverflow.totalAmount;
}
}
}
}
}
/// <summary>
/// Request Resource processing on a ProtoVessel.
/// If the ProtoVessel is not known or resources not cached for the ProtoVessel will automatically add them to the Cached data.
/// </summary>
/// <param name="vessel">ProtoVessel reference</param>
/// <param name="resourceName">Name of the Resource we want to process</param>
/// <param name="amount">The amount of the resource we want to process</param>
/// <param name="amountReceived">returns the amount processed for the request in this variable</param>
/// <param name="pushing">default of false (which means take resource). If true will push (put resource)</param>
public static void RequestResource(ProtoVessel vessel, string resourceName, double amount, out double amountReceived, bool pushing = false)
{
amountReceived = 0d;
if (UnloadedResources.InterestedVessels == null)
{
UnloadedResources.InterestedVessels = new DictionaryValueList <ProtoVessel, InterestedVessel>();
}
//If there are no cachedResources for the vessel create one.
if (!UnloadedResources.InterestedVessels.Contains(vessel))
{
CacheResources.CreatecachedVesselResources(vessel);
}
//Double check, not really necessary. Now find the resource amounts if in the vessel.
if (UnloadedResources.InterestedVessels.Contains(vessel))
{
List <CacheResources.CacheResource> vslresources = UnloadedResources.InterestedVessels[vessel].CachedResources;
for (int i = 0; i < vslresources.Count; i++)
{
CacheResources.CacheResource cacheResource = vslresources[i];
if (cacheResource.resourceName == resourceName)
{
if (!pushing) //We are taking resource
{
if (cacheResource.amount > 0 || cacheResource.timeWarpOverflow.totalAmount > 0)
{
if (cacheResource.timeWarpOverflow.totalAmount > 0 && TimeWarp.fetch != null && TimeWarp.CurrentRateIndex > CacheResources.timeWarpStep) //If we have timewarp Overflow check that first.
{
double amountTaken = 0;
cacheResource.timeWarpOverflow.Take(amount, out amountTaken);
amountReceived += amountTaken;
amount -= amountTaken;
if (amount <= 0) //Did we get all we need already? If so return.
{
return;
}
}
//TimewarpOverflow didn't have enough or didn't have what we need. so now the partResrouceSnapshot
Dictionary <string, ProtoPartResourceSnapshot> .Enumerator ppRSenumerator = cacheResource.protoPartResourceSnapshot.GetDictEnumerator();
while (ppRSenumerator.MoveNext())
{
ProtoPartResourceSnapshot partResourceSnapshot = ppRSenumerator.Current.Value;
if (partResourceSnapshot.amount > 0)
{
if (partResourceSnapshot.amount <= amount) //Not enough but take what it has
{
amountReceived += partResourceSnapshot.amount;
amount -= partResourceSnapshot.amount;
cacheResource.amount -= partResourceSnapshot.amount;
partResourceSnapshot.amount = 0;
}
else //this part has more than we need.
{
amountReceived += amount;
cacheResource.amount -= amount;
partResourceSnapshot.amount -= amount;
amount = 0;
}
}
if (amount <= 0) //Did we get all we wanted? if so return.
{
ppRSenumerator.Dispose();
return;
}
}
ppRSenumerator.Dispose();
}
}
else //We are putting a resource
{
//Get how much space there is in this part.
double spaceAvailable = cacheResource.maxAmount - cacheResource.amount;
if (spaceAvailable > 0) //If we have space put some in.
{
Dictionary <string, ProtoPartResourceSnapshot> .Enumerator ppRSenumerator = cacheResource.protoPartResourceSnapshot.GetDictEnumerator();
while (ppRSenumerator.MoveNext())
{
ProtoPartResourceSnapshot partResourceSnapshot = ppRSenumerator.Current.Value;
double partspaceAvailable = partResourceSnapshot.maxAmount - partResourceSnapshot.amount;
if (partspaceAvailable > 0)
{
if (amount > partspaceAvailable) //If we can't fit it all in this part. Put what we can.
{
partResourceSnapshot.amount = partResourceSnapshot.maxAmount;
cacheResource.amount += partspaceAvailable;
amount -= partspaceAvailable;
amountReceived += partspaceAvailable;
}
else //If we can fit it all in this part, put it in.
{
partResourceSnapshot.amount += amount;
cacheResource.amount += amount;
amountReceived += amount;
amount = 0;
}
if (amount <= 0) //Did we get all we wanted? if so return.
{
return;
}
}
}
}
//If we get here we had more than can fit in the parts... But if TimeWarp is too high, we put it in the overflow.
if (TimeWarp.fetch != null && amount > 0)
{
if (TimeWarp.CurrentRateIndex > CacheResources.timeWarpStep) //But only if timewarp rate is high enough.
{
cacheResource.timeWarpOverflow.Add(amount);
amountReceived += amount;
amount = 0;
return;
}
}
}
}
} //End For loop all vessel resources.
}
}