public static float ApproxDaysWorthOfFoodLeftAfterTradeableTransfer(List <Thing> allCurrentThings, List <Tradeable> tradeables, bool assumeCanEatLocalPlants, IgnorePawnsInventoryMode ignoreInventory)
{
TransferableUtility.SimulateTradeableTransfer(allCurrentThings, tradeables, DaysWorthOfFoodCalculator.tmpThingStackParts);
DaysWorthOfFoodCalculator.tmpPawns.Clear();
DaysWorthOfFoodCalculator.tmpThingCounts.Clear();
for (int num = DaysWorthOfFoodCalculator.tmpThingStackParts.Count - 1; num >= 0; num--)
{
Pawn pawn = DaysWorthOfFoodCalculator.tmpThingStackParts[num].Thing as Pawn;
if (pawn != null)
{
if (pawn.RaceProps.EatsFood && (!assumeCanEatLocalPlants || !VirtualPlantsUtility.CanEverEatVirtualPlants(pawn)))
{
DaysWorthOfFoodCalculator.tmpPawns.Add(pawn);
}
}
else
{
DaysWorthOfFoodCalculator.tmpThingCounts.Add(new ThingCount(DaysWorthOfFoodCalculator.tmpThingStackParts[num].Thing.def, DaysWorthOfFoodCalculator.tmpThingStackParts[num].Count));
}
}
DaysWorthOfFoodCalculator.tmpThingStackParts.Clear();
float result = DaysWorthOfFoodCalculator.ApproxDaysWorthOfFood(DaysWorthOfFoodCalculator.tmpPawns, DaysWorthOfFoodCalculator.tmpThingCounts, assumeCanEatLocalPlants, ignoreInventory);
DaysWorthOfFoodCalculator.tmpPawns.Clear();
DaysWorthOfFoodCalculator.tmpThingCounts.Clear();
return(result);
}
public static float ApproxDaysUntilRotLeftAfterTradeableTransfer(List <Thing> allCurrentThings, List <Tradeable> tradeables, int tile, IgnorePawnsInventoryMode ignoreInventory)
{
DaysUntilRotCalculator.tmpThingCountsFromTradeables.Clear();
TransferableUtility.SimulateTradeableTransfer(allCurrentThings, tradeables, DaysUntilRotCalculator.tmpThingCountsFromTradeables);
DaysUntilRotCalculator.tmpThingCounts.Clear();
for (int i = DaysUntilRotCalculator.tmpThingCountsFromTradeables.Count - 1; i >= 0; i--)
{
if (DaysUntilRotCalculator.tmpThingCountsFromTradeables[i].Count > 0)
{
Pawn pawn = DaysUntilRotCalculator.tmpThingCountsFromTradeables[i].Thing as Pawn;
if (pawn != null)
{
if (!InventoryCalculatorsUtility.ShouldIgnoreInventoryOf(pawn, ignoreInventory))
{
ThingOwner <Thing> innerContainer = pawn.inventory.innerContainer;
for (int j = 0; j < innerContainer.Count; j++)
{
DaysUntilRotCalculator.tmpThingCounts.Add(new ThingCount(innerContainer[j], innerContainer[j].stackCount));
}
}
}
else
{
DaysUntilRotCalculator.tmpThingCounts.Add(DaysUntilRotCalculator.tmpThingCountsFromTradeables[i]);
}
}
}
DaysUntilRotCalculator.tmpThingCountsFromTradeables.Clear();
float result = DaysUntilRotCalculator.ApproxDaysUntilRot(DaysUntilRotCalculator.tmpThingCounts, tile, null, 0f, 3300);
DaysUntilRotCalculator.tmpThingCounts.Clear();
return(result);
}
public static float ApproxDaysWorthOfFoodLeftAfterTradeableTransfer(List <Thing> allCurrentThings, List <Tradeable> tradeables, int tile, IgnorePawnsInventoryMode ignoreInventory, Faction faction)
{
DaysWorthOfFoodCalculator.tmpThingCounts.Clear();
TransferableUtility.SimulateTradeableTransfer(allCurrentThings, tradeables, DaysWorthOfFoodCalculator.tmpThingCounts);
DaysWorthOfFoodCalculator.tmpPawns.Clear();
DaysWorthOfFoodCalculator.tmpThingDefCounts.Clear();
for (int i = DaysWorthOfFoodCalculator.tmpThingCounts.Count - 1; i >= 0; i--)
{
if (DaysWorthOfFoodCalculator.tmpThingCounts[i].Count > 0)
{
Pawn pawn = DaysWorthOfFoodCalculator.tmpThingCounts[i].Thing as Pawn;
if (pawn != null)
{
if (pawn.RaceProps.EatsFood)
{
DaysWorthOfFoodCalculator.tmpPawns.Add(pawn);
}
}
else
{
DaysWorthOfFoodCalculator.tmpThingDefCounts.Add(new ThingDefCount(DaysWorthOfFoodCalculator.tmpThingCounts[i].Thing.def, DaysWorthOfFoodCalculator.tmpThingCounts[i].Count));
}
}
}
DaysWorthOfFoodCalculator.tmpThingCounts.Clear();
float result = DaysWorthOfFoodCalculator.ApproxDaysWorthOfFood(DaysWorthOfFoodCalculator.tmpPawns, DaysWorthOfFoodCalculator.tmpThingDefCounts, tile, ignoreInventory, faction, null, 0f, 3300, true);
DaysWorthOfFoodCalculator.tmpPawns.Clear();
DaysWorthOfFoodCalculator.tmpThingDefCounts.Clear();
return(result);
}
public static float ApproxDaysWorthOfFoodLeftAfterTradeableTransfer(List <Thing> allCurrentThings, List <Tradeable> tradeables, int tile, IgnorePawnsInventoryMode ignoreInventory, Faction faction)
{
tmpThingCounts.Clear();
TransferableUtility.SimulateTradeableTransfer(allCurrentThings, tradeables, tmpThingCounts);
tmpPawns.Clear();
tmpThingDefCounts.Clear();
for (int num = tmpThingCounts.Count - 1; num >= 0; num--)
{
if (tmpThingCounts[num].Count > 0)
{
Pawn pawn = tmpThingCounts[num].Thing as Pawn;
if (pawn != null)
{
if (pawn.RaceProps.EatsFood)
{
tmpPawns.Add(pawn);
}
}
else
{
tmpThingDefCounts.Add(new ThingDefCount(tmpThingCounts[num].Thing.def, tmpThingCounts[num].Count));
}
}
}
tmpThingCounts.Clear();
float result = ApproxDaysWorthOfFood(tmpPawns, tmpThingDefCounts, tile, ignoreInventory, faction);
tmpPawns.Clear();
tmpThingDefCounts.Clear();
return(result);
}
public static float ApproxDaysUntilRotLeftAfterTradeableTransfer(List <Thing> allCurrentThings, List <Tradeable> tradeables, int tile, IgnorePawnsInventoryMode ignoreInventory)
{
tmpThingCountsFromTradeables.Clear();
TransferableUtility.SimulateTradeableTransfer(allCurrentThings, tradeables, tmpThingCountsFromTradeables);
tmpThingCounts.Clear();
for (int num = tmpThingCountsFromTradeables.Count - 1; num >= 0; num--)
{
if (tmpThingCountsFromTradeables[num].Count > 0)
{
Pawn pawn = tmpThingCountsFromTradeables[num].Thing as Pawn;
if (pawn != null)
{
if (!InventoryCalculatorsUtility.ShouldIgnoreInventoryOf(pawn, ignoreInventory))
{
ThingOwner <Thing> innerContainer = pawn.inventory.innerContainer;
for (int i = 0; i < innerContainer.Count; i++)
{
tmpThingCounts.Add(new ThingCount(innerContainer[i], innerContainer[i].stackCount));
}
}
}
else
{
tmpThingCounts.Add(tmpThingCountsFromTradeables[num]);
}
}
}
tmpThingCountsFromTradeables.Clear();
float result = ApproxDaysUntilRot(tmpThingCounts, tile);
tmpThingCounts.Clear();
return(result);
}
public static float ApproxDaysWorthOfWaterLeftAfterTradeableTransfer(
List <Thing> allCurrentThings,
List <Tradeable> tradeables,
IgnorePawnsInventoryMode ignoreInventory)
{
TransferableUtility.SimulateTradeableTransfer(allCurrentThings, tradeables, tmpThingStackParts);
tmpPawns.Clear();
tmpThingDefCounts.Clear();
for (var i = tmpThingStackParts.Count - 1; i >= 0; i--)
{
if (tmpThingStackParts[i].Thing is Pawn pawn)
{
tmpPawns.Add(pawn);
}
else
{
tmpThingDefCounts.Add(
new ThingDefCount(tmpThingStackParts[i].Thing.def, tmpThingStackParts[i].Count));
}
}
tmpThingStackParts.Clear();
var result = ApproxDaysWorthOfWater(tmpPawns, tmpThingDefCounts, ignoreInventory);
tmpPawns.Clear();
tmpThingDefCounts.Clear();
return(result);
}
public static float ApproxDaysUntilRotLeftAfterTradeableTransfer(List <Thing> allCurrentThings, List <Tradeable> tradeables, int assumingTile, IgnorePawnsInventoryMode ignoreInventory)
{
TransferableUtility.SimulateTradeableTransfer(allCurrentThings, tradeables, DaysUntilRotCalculator.tmpThingStackParts);
DaysUntilRotCalculator.tmpThings.Clear();
for (int num = DaysUntilRotCalculator.tmpThingStackParts.Count - 1; num >= 0; num--)
{
if (DaysUntilRotCalculator.tmpThingStackParts[num].Count > 0)
{
Pawn pawn = DaysUntilRotCalculator.tmpThingStackParts[num].Thing as Pawn;
if (pawn != null)
{
if (!InventoryCalculatorsUtility.ShouldIgnoreInventoryOf(pawn, ignoreInventory))
{
ThingOwner <Thing> innerContainer = pawn.inventory.innerContainer;
for (int i = 0; i < innerContainer.Count; i++)
{
DaysUntilRotCalculator.tmpThings.Add(innerContainer[i]);
}
}
}
else
{
DaysUntilRotCalculator.tmpThings.Add(DaysUntilRotCalculator.tmpThingStackParts[num].Thing);
}
}
}
DaysUntilRotCalculator.tmpThingStackParts.Clear();
float result = DaysUntilRotCalculator.ApproxDaysUntilRot(DaysUntilRotCalculator.tmpThings, assumingTile);
DaysUntilRotCalculator.tmpThings.Clear();
return(result);
}
public static Pair <ThingDef, float> ForagedFoodPerDayLeftAfterTradeableTransfer(List <Thing> allCurrentThings, List <Tradeable> tradeables, BiomeDef biome, Faction faction, StringBuilder explanation = null)
{
ForagedFoodPerDayCalculator.tmpThingCounts.Clear();
TransferableUtility.SimulateTradeableTransfer(allCurrentThings, tradeables, ForagedFoodPerDayCalculator.tmpThingCounts);
Pair <ThingDef, float> result = ForagedFoodPerDayCalculator.ForagedFoodPerDay(ForagedFoodPerDayCalculator.tmpThingCounts, biome, faction, explanation);
ForagedFoodPerDayCalculator.tmpThingCounts.Clear();
return(result);
}
public static float ApproxTilesPerDayLeftAfterTradeableTransfer(List <Thing> allCurrentThings, List <Tradeable> tradeables, float massUsageLeftAfterTradeableTransfer, float massCapacityLeftAfterTradeableTransfer, int tile, int nextTile, StringBuilder explanation = null)
{
tmpThingCounts.Clear();
TransferableUtility.SimulateTradeableTransfer(allCurrentThings, tradeables, tmpThingCounts);
float result = ApproxTilesPerDay(tmpThingCounts, massUsageLeftAfterTradeableTransfer, massCapacityLeftAfterTradeableTransfer, tile, nextTile, explanation);
tmpThingCounts.Clear();
return(result);
}
public static float VisibilityLeftAfterTradeableTransfer(List <Thing> allCurrentThings, List <Tradeable> tradeables, StringBuilder explanation = null)
{
CaravanVisibilityCalculator.tmpThingCounts.Clear();
TransferableUtility.SimulateTradeableTransfer(allCurrentThings, tradeables, CaravanVisibilityCalculator.tmpThingCounts);
float result = CaravanVisibilityCalculator.Visibility(CaravanVisibilityCalculator.tmpThingCounts, explanation);
CaravanVisibilityCalculator.tmpThingCounts.Clear();
return(result);
}
