public static bool ShouldIgnoreInventoryOf(Pawn pawn, IgnorePawnsInventoryMode ignoreMode)
        {
            switch (ignoreMode)
            {
            case IgnorePawnsInventoryMode.Ignore:
                return(true);

            case IgnorePawnsInventoryMode.IgnoreIfAssignedToUnload:
                if (pawn.Spawned)
                {
                    return(pawn.inventory.UnloadEverything);
                }
                return(false);

            case IgnorePawnsInventoryMode.IgnoreIfAssignedToUnloadOrPlayerPawn:
                if (!pawn.Spawned || !pawn.inventory.UnloadEverything)
                {
                    return(Dialog_FormCaravan.CanListInventorySeparately(pawn));
                }
                return(true);

            case IgnorePawnsInventoryMode.DontIgnore:
                return(false);

            default:
                throw new NotImplementedException("IgnorePawnsInventoryMode");
            }
        }
Esempio n. 2
0
        private void CalculateAndRecacheTransferables()
        {
            transferables = new List <TransferableOneWay>();
            AddPawnsToTransferables();
            AddItemsToTransferables();
            IEnumerable <TransferableOneWay> enumerable = null;
            string sourceLabel      = null;
            string destinationLabel = null;
            string sourceCountDesc  = "FormCaravanColonyThingCountTip".Translate();
            bool   drawMass         = true;
            IgnorePawnsInventoryMode ignorePawnInventoryMass = IgnorePawnsInventoryMode.IgnoreIfAssignedToUnload;
            bool         includePawnsMassInMassUsage         = true;
            Func <float> availableMassGetter = () => MassCapacity - MassUsage;
            int          tile = map.Tile;

            pawnsTransfer = new TransferableOneWayWidget(enumerable, sourceLabel, destinationLabel, sourceCountDesc, drawMass, ignorePawnInventoryMass, includePawnsMassInMassUsage, availableMassGetter, 0f, ignoreSpawnedCorpseGearAndInventoryMass: false, tile, drawMarketValue: true, drawEquippedWeapon: true, drawNutritionEatenPerDay: true, drawItemNutrition: false, drawForagedFoodPerDay: true);
            CaravanUIUtility.AddPawnsSections(pawnsTransfer, transferables);
            enumerable = from x in transferables
                         where x.ThingDef.category != ThingCategory.Pawn
                         select x;

            sourceCountDesc             = null;
            destinationLabel            = null;
            sourceLabel                 = "FormCaravanColonyThingCountTip".Translate();
            includePawnsMassInMassUsage = true;
            ignorePawnInventoryMass     = IgnorePawnsInventoryMode.IgnoreIfAssignedToUnload;
            drawMass            = true;
            availableMassGetter = (() => MassCapacity - MassUsage);
            tile          = map.Tile;
            itemsTransfer = new TransferableOneWayWidget(enumerable, sourceCountDesc, destinationLabel, sourceLabel, includePawnsMassInMassUsage, ignorePawnInventoryMass, drawMass, availableMassGetter, 0f, ignoreSpawnedCorpseGearAndInventoryMass: false, tile, drawMarketValue: true, drawEquippedWeapon: false, drawNutritionEatenPerDay: false, drawItemNutrition: true, drawForagedFoodPerDay: false, drawDaysUntilRot: true);
            CountToTransferChanged();
        }
        private void CalculateAndRecacheTransferables()
        {
            this.transferables = new List <TransferableOneWay>();
            this.AddPawnsToTransferables();
            this.AddItemsToTransferables();
            this.AddContentsToTransferables();
            IEnumerable <TransferableOneWay> enumerable = null;
            string text             = null;
            string destinationLabel = null;
            string text2            = "FormCaravanColonyThingCountTip".Translate();
            bool   flag             = true;
            IgnorePawnsInventoryMode ignorePawnInventoryMass = IgnorePawnsInventoryMode.IgnoreIfAssignedToUnload;
            bool         flag2 = true;
            Func <float> availableMassGetter = () => this.MassCapacity - this.MassUsage;
            int          tile = this.map.Tile;

            this.pawnsTransfer = new TransferableOneWayWidget(enumerable, text, destinationLabel, text2, flag, ignorePawnInventoryMass, flag2, availableMassGetter, 0f, false, tile, true, true, true, false, true, false, false);
            CaravanUIUtility.AddPawnsSections(this.pawnsTransfer, this.transferables);
            enumerable = from x in this.transferables
                         where x.ThingDef.category != ThingCategory.Pawn
                         select x;

            text2                   = null;
            destinationLabel        = null;
            text                    = "FormCaravanColonyThingCountTip".Translate();
            flag2                   = true;
            ignorePawnInventoryMass = IgnorePawnsInventoryMode.IgnoreIfAssignedToUnload;
            flag                    = true;
            availableMassGetter     = (() => this.MassCapacity - this.MassUsage);
            tile                    = this.map.Tile;
            this.itemsTransfer      = new TransferableOneWayWidget(enumerable, text2, destinationLabel, text, flag2, ignorePawnInventoryMass, flag, availableMassGetter, 0f, false, tile, true, false, false, true, false, true, false);
            this.CountToTransferChanged();
        }
        public static bool ShouldIgnoreInventoryOf(Pawn pawn, IgnorePawnsInventoryMode ignoreMode)
        {
            bool result;

            switch (ignoreMode)
            {
            case IgnorePawnsInventoryMode.Ignore:
                result = true;
                break;

            case IgnorePawnsInventoryMode.IgnoreIfAssignedToUnload:
                result = (pawn.Spawned && pawn.inventory.UnloadEverything);
                break;

            case IgnorePawnsInventoryMode.IgnoreIfAssignedToUnloadOrPlayerPawn:
                result = ((pawn.Spawned && pawn.inventory.UnloadEverything) || Dialog_FormCaravan.CanListInventorySeparately(pawn));
                break;

            case IgnorePawnsInventoryMode.DontIgnore:
                result = false;
                break;

            default:
                throw new NotImplementedException("IgnorePawnsInventoryMode");
            }
            return(result);
        }
        public static float MassUsage(List <ThingCount> thingCounts, IgnorePawnsInventoryMode ignoreInventory, bool includePawnsMass = false, bool ignoreSpawnedCorpsesGearAndInventory = false)
        {
            float num = 0f;

            for (int i = 0; i < thingCounts.Count; i++)
            {
                int count = thingCounts[i].Count;
                if (count <= 0)
                {
                    continue;
                }
                Thing thing = thingCounts[i].Thing;
                Pawn  pawn  = thing as Pawn;
                if (pawn != null)
                {
                    num = ((!includePawnsMass) ? (num + MassUtility.GearAndInventoryMass(pawn) * (float)count) : (num + pawn.GetStatValue(StatDefOf.Mass) * (float)count));
                    if (InventoryCalculatorsUtility.ShouldIgnoreInventoryOf(pawn, ignoreInventory))
                    {
                        num -= MassUtility.InventoryMass(pawn) * (float)count;
                    }
                    continue;
                }
                num += thing.GetStatValue(StatDefOf.Mass) * (float)count;
                if (ignoreSpawnedCorpsesGearAndInventory)
                {
                    Corpse corpse = thing as Corpse;
                    if (corpse != null && corpse.Spawned)
                    {
                        num -= MassUtility.GearAndInventoryMass(corpse.InnerPawn) * (float)count;
                    }
                }
            }
            return(Mathf.Max(num, 0f));
        }
Esempio n. 6
0
 public TransferableOneWayWidget(IEnumerable <TransferableOneWay> transferables, string sourceLabel, string destinationLabel, string sourceCountDesc, bool drawMass = false, IgnorePawnsInventoryMode ignorePawnInventoryMass = IgnorePawnsInventoryMode.DontIgnore, bool includePawnsMassInMassUsage = false, Func <float> availableMassGetter = null, float extraHeaderSpace = 0f, bool ignoreSpawnedCorpseGearAndInventoryMass = false, int tile = -1, bool drawMarketValue = false, bool drawEquippedWeapon = false, bool drawNutritionEatenPerDay = false, bool drawItemNutrition = false, bool drawForagedFoodPerDay = false, bool drawDaysUntilRot = false, bool playerPawnsReadOnly = false)
 {
     if (transferables != null)
     {
         this.AddSection(null, transferables);
     }
     this.sourceLabel                             = sourceLabel;
     this.destinationLabel                        = destinationLabel;
     this.sourceCountDesc                         = sourceCountDesc;
     this.drawMass                                = drawMass;
     this.ignorePawnInventoryMass                 = ignorePawnInventoryMass;
     this.includePawnsMassInMassUsage             = includePawnsMassInMassUsage;
     this.availableMassGetter                     = availableMassGetter;
     this.extraHeaderSpace                        = extraHeaderSpace;
     this.ignoreSpawnedCorpseGearAndInventoryMass = ignoreSpawnedCorpseGearAndInventoryMass;
     this.tile                     = tile;
     this.drawMarketValue          = drawMarketValue;
     this.drawEquippedWeapon       = drawEquippedWeapon;
     this.drawNutritionEatenPerDay = drawNutritionEatenPerDay;
     this.drawItemNutrition        = drawItemNutrition;
     this.drawForagedFoodPerDay    = drawForagedFoodPerDay;
     this.drawDaysUntilRot         = drawDaysUntilRot;
     this.playerPawnsReadOnly      = playerPawnsReadOnly;
     this.sorter1                  = TransferableSorterDefOf.Category;
     this.sorter2                  = TransferableSorterDefOf.MarketValue;
 }
        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);
        }
Esempio n. 8
0
        private void CalculateAndRecacheTransferables()
        {
            this.transferables = new List <TransferableOneWay>();
            this.AddItemsToTransferables();
            IEnumerable <TransferableOneWay> enumerable = null;
            string text  = null;
            string text2 = null;
            string text3 = "FormCaravanColonyThingCountTip".Translate();
            bool   flag  = true;
            IgnorePawnsInventoryMode ignorePawnsInventoryMode = (IgnorePawnsInventoryMode)1;
            bool         flag2 = true;
            Func <float> func  = () => this.MassCapacity - this.MassUsage;
            int          tile  = this.map.Tile;

            this.pawnsTransfer = new TransferableOneWayWidget(enumerable, text, text2, text3, flag, ignorePawnsInventoryMode, flag2, func, 0f, false, tile, true, true, true, false, true, false, false);
            CaravanUIUtility.AddPawnsSections(this.pawnsTransfer, this.transferables);
            enumerable = from x in this.transferables
                         where x.ThingDef.category != ThingCategory.Pawn
                         select x;

            text3 = null;
            text2 = null;
            text  = "FormCaravanColonyThingCountTip".Translate();
            flag2 = true;
            ignorePawnsInventoryMode = (IgnorePawnsInventoryMode)1;
            flag = true;
            func = (() => this.MassCapacity - this.MassUsage);
            tile = this.map.Tile;
            this.itemsTransfer = new TransferableOneWayWidget(enumerable, text3, text2, text, flag2, ignorePawnsInventoryMode, flag, func, 0f, false, tile, true, false, false, true, false, true, false);
            this.CountToTransferChanged();
        }
        public static float ApproxDaysWorthOfWater(
            List <TransferableOneWay> transferables,
            IgnorePawnsInventoryMode ignoreInventory)
        {
            tmpThingDefCounts.Clear();
            tmpPawns.Clear();

            foreach (var transferableOneWay in transferables)
            {
                if (!transferableOneWay.HasAnyThing)
                {
                    continue;
                }

                if (transferableOneWay.AnyThing is Pawn)
                {
                    for (var j = 0; j < transferableOneWay.CountToTransfer; j++)
                    {
                        tmpPawns.Add((Pawn)transferableOneWay.things[j]);
                    }
                }
                else
                {
                    tmpThingDefCounts.Add(
                        new ThingDefCount(transferableOneWay.ThingDef, transferableOneWay.CountToTransfer));
                }
            }

            var result = ApproxDaysWorthOfWater(tmpPawns, tmpThingDefCounts, ignoreInventory);

            tmpThingDefCounts.Clear();
            tmpPawns.Clear();
            return(result);
        }
Esempio n. 10
0
 public static void CreateCaravanTransferableWidgets(List <TransferableOneWay> transferables
                                                     , out TransferableOneWayWidget itemsTransfer, string sourceLabel, string destLabel, string thingCountTip
                                                     , IgnorePawnsInventoryMode ignorePawnInventoryMass, Func <float> availableMassGetter, bool ignoreCorpsesGearAndInventoryMass)
 {
     //метод из CaravanUIUtility с удалением лишнего
     itemsTransfer = new TransferableOneWayWidget(from x in transferables
                                                  //where x.ThingDef.category != ThingCategory.Pawn
                                                  select x, sourceLabel, destLabel, thingCountTip, true, ignorePawnInventoryMass, false, availableMassGetter, 24f, ignoreCorpsesGearAndInventoryMass);
 }
Esempio n. 11
0
        //public static class DaysWorthOfFoodCalculator
        //{
        public static void ApproxDaysWorthOfFoodPawns_PostFix(ref List <Pawn> pawns, List <ThingDefCount> extraFood,
                                                              int tile, IgnorePawnsInventoryMode ignoreInventory, Faction faction, WorldPath path,
                                                              float nextTileCostLeft, int caravanTicksPerMove, bool assumeCaravanMoving)
        {
            if (pawns == null)
            {
                pawns = new List <Pawn>();
            }

            pawns.AddRange(caravanVampires);
        }
Esempio n. 12
0
 //public static class DaysWorthOfFoodCalculator
 //{
 public static void ApproxDaysWorthOfFoodPawns_PreFix(ref List <Pawn> pawns, List <ThingDefCount> extraFood,
                                                      int tile, IgnorePawnsInventoryMode ignoreInventory, Faction faction, WorldPath path,
                                                      float nextTileCostLeft, int caravanTicksPerMove, bool assumeCaravanMoving)
 {
     if (!pawns.NullOrEmpty())
     {
         caravanVampires = new List <Pawn>();
         caravanVampires.AddRange(pawns.FindAll(x => x.IsVampire()));
         pawns.RemoveAll(x => x.IsVampire());
     }
 }
Esempio n. 13
0
        //public static class DaysWorthOfFoodCalculator
        //{
        public static void ApproxDaysWorthOfFood_PostFix(ref List <TransferableOneWay> transferables, int tile,
                                                         IgnorePawnsInventoryMode ignoreInventory, Faction faction, WorldPath path = null,
                                                         float nextTileCostLeft = 0f, int caravanTicksPerMove = 3300)
        {
            if (transferables == null)
            {
                transferables = new List <TransferableOneWay>();
            }

            transferables.AddRange(caravanTransferrables);
        }
        public static float MassUsage <T>(List <T> things, IgnorePawnsInventoryMode ignoreInventory, bool includePawnsMass = false, bool ignoreCorpsesGearAndInventory = false) where T : Thing
        {
            CollectionsMassCalculator.tmpThingStackParts.Clear();
            for (int i = 0; i < things.Count; i++)
            {
                CollectionsMassCalculator.tmpThingStackParts.Add(new ThingStackPart((Thing)(object)things[i], ((Thing)(object)things[i]).stackCount));
            }
            float result = CollectionsMassCalculator.MassUsage(CollectionsMassCalculator.tmpThingStackParts, ignoreInventory, includePawnsMass, ignoreCorpsesGearAndInventory);

            CollectionsMassCalculator.tmpThingStackParts.Clear();
            return(result);
        }
Esempio n. 15
0
 //public static class DaysWorthOfFoodCalculator
 //{
 public static void ApproxDaysWorthOfFood_PreFix(ref List <TransferableOneWay> transferables, int tile,
                                                 IgnorePawnsInventoryMode ignoreInventory, Faction faction, WorldPath path = null,
                                                 float nextTileCostLeft = 0f, int caravanTicksPerMove = 3300)
 {
     if (!transferables.NullOrEmpty())
     {
         caravanTransferrables = new List <TransferableOneWay>();
         caravanTransferrables.AddRange(transferables.FindAll(x =>
                                                              x.HasAnyThing && x.AnyThing is Pawn y && y.IsVampire()));
         transferables.RemoveAll(x => x.HasAnyThing && x.AnyThing is Pawn y && y.IsVampire());
     }
 }
        public static float MassUsage <T>(List <T> things, IgnorePawnsInventoryMode ignoreInventory, bool includePawnsMass = false, bool ignoreSpawnedCorpsesGearAndInventory = false) where T : Thing
        {
            tmpThingCounts.Clear();
            for (int i = 0; i < things.Count; i++)
            {
                tmpThingCounts.Add(new ThingCount(things[i], things[i].stackCount));
            }
            float result = MassUsage(tmpThingCounts, ignoreInventory, includePawnsMass, ignoreSpawnedCorpsesGearAndInventory);

            tmpThingCounts.Clear();
            return(result);
        }
        public static void Postfix(List <TransferableOneWay> transferables, ref TransferableOneWayWidget pawnsTransfer,
                                   ref TransferableOneWayWidget itemsTransfer, string thingCountTip,
                                   IgnorePawnsInventoryMode ignorePawnInventoryMass, Func <float> availableMassGetter,
                                   bool ignoreSpawnedCorpsesGearAndInventoryMass, int tile, bool playerPawnsReadOnly)
        {
            var modifiedTransferables = transferables.Where(x => x.ThingDef.category != ThingCategory.Pawn).ToList();

            modifiedTransferables = modifiedTransferables
                                    .Where(x => !x.ThingDef.IsWithinCategory(ThingCategoryDef.Named("RoadEquipment"))).ToList();
            itemsTransfer = new TransferableOneWayWidget(modifiedTransferables, null, null, thingCountTip, true,
                                                         ignorePawnInventoryMass, false, availableMassGetter, 0f, ignoreSpawnedCorpsesGearAndInventoryMass, tile,
                                                         true, false, false, true, false, true);
        }
        public static bool ShouldIgnoreInventoryOf(Pawn pawn, IgnorePawnsInventoryMode ignoreMode)
        {
            switch (ignoreMode)
            {
            case IgnorePawnsInventoryMode.Ignore:
                return(true);

            case IgnorePawnsInventoryMode.IgnoreIfAssignedToUnload:
                return(pawn.Spawned && pawn.inventory.UnloadEverything);

            case IgnorePawnsInventoryMode.DontIgnore:
                return(false);

            default:
                throw new NotImplementedException("IgnorePawnsInventoryMode");
            }
        }
        public static float MassUsage(List <ThingStackPart> stackParts, IgnorePawnsInventoryMode ignoreInventory, bool includePawnsMass = false, bool ignoreCorpsesGearAndInventory = false)
        {
            float num = 0f;

            for (int i = 0; i < stackParts.Count; i++)
            {
                int count = stackParts[i].Count;
                if (count > 0)
                {
                    Thing thing = stackParts[i].Thing;
                    Pawn  pawn  = thing as Pawn;
                    if (pawn != null)
                    {
                        if (includePawnsMass)
                        {
                            num += pawn.GetStatValue(StatDefOf.Mass, true) * (float)count;
                        }
                        else
                        {
                            num += MassUtility.GearAndInventoryMass(pawn) * (float)count;
                        }
                        if (InventoryCalculatorsUtility.ShouldIgnoreInventoryOf(pawn, ignoreInventory))
                        {
                            num -= MassUtility.InventoryMass(pawn) * (float)count;
                        }
                    }
                    else
                    {
                        num += thing.GetStatValue(StatDefOf.Mass, true) * (float)count;
                        if (ignoreCorpsesGearAndInventory)
                        {
                            Corpse corpse = thing as Corpse;
                            if (corpse != null)
                            {
                                num -= MassUtility.GearAndInventoryMass(corpse.InnerPawn) * (float)count;
                            }
                        }
                    }
                }
            }
            return(Mathf.Max(num, 0f));
        }
Esempio n. 20
0
 public TransferableOneWayWidget(IEnumerable <TransferableOneWay> transferables, string sourceLabel, string destinationLabel, string sourceCountDesc, bool drawMass = false, IgnorePawnsInventoryMode ignorePawnInventoryMass = IgnorePawnsInventoryMode.DontIgnore, bool includePawnsMassInMassUsage = false, Func <float> availableMassGetter = null, float extraHeaderSpace = 0f, bool ignoreCorpseGearAndInventoryMass = false, bool drawMarketValue = false, int drawDaysUntilRotForTile = -1)
 {
     if (transferables != null)
     {
         this.AddSection(null, transferables);
     }
     this.sourceLabel                      = sourceLabel;
     this.destinationLabel                 = destinationLabel;
     this.sourceCountDesc                  = sourceCountDesc;
     this.drawMass                         = drawMass;
     this.ignorePawnInventoryMass          = ignorePawnInventoryMass;
     this.includePawnsMassInMassUsage      = includePawnsMassInMassUsage;
     this.availableMassGetter              = availableMassGetter;
     this.extraHeaderSpace                 = extraHeaderSpace;
     this.ignoreCorpseGearAndInventoryMass = ignoreCorpseGearAndInventoryMass;
     this.drawMarketValue                  = drawMarketValue;
     this.drawDaysUntilRotForTile          = drawDaysUntilRotForTile;
     this.sorter1 = TransferableSorterDefOf.Category;
     this.sorter2 = TransferableSorterDefOf.MarketValue;
 }
Esempio n. 21
0
        public static void CreateCaravanTransferableWidgets(List <TransferableOneWay> transferables, out TransferableOneWayWidget pawnsTransfer, out TransferableOneWayWidget itemsTransfer, string thingCountTip, IgnorePawnsInventoryMode ignorePawnInventoryMass, Func <float> availableMassGetter, bool ignoreSpawnedCorpsesGearAndInventoryMass, int tile, bool playerPawnsReadOnly = false)
        {
            IEnumerable <TransferableOneWay> transferables2 = null;
            string sourceLabel                             = null;
            string destinationLabel                        = null;
            bool   drawMass                                = true;
            bool   includePawnsMassInMassUsage             = false;
            bool   ignoreSpawnedCorpseGearAndInventoryMass = ignoreSpawnedCorpsesGearAndInventoryMass;
            bool   playerPawnsReadOnly2                    = playerPawnsReadOnly;

            pawnsTransfer = new TransferableOneWayWidget(transferables2, sourceLabel, destinationLabel, thingCountTip, drawMass, ignorePawnInventoryMass, includePawnsMassInMassUsage, availableMassGetter, 0f, ignoreSpawnedCorpseGearAndInventoryMass, tile, drawMarketValue: true, drawEquippedWeapon: true, drawNutritionEatenPerDay: true, drawItemNutrition: false, drawForagedFoodPerDay: true, drawDaysUntilRot: false, playerPawnsReadOnly2);
            AddPawnsSections(pawnsTransfer, transferables);
            transferables2 = from x in transferables
                             where x.ThingDef.category != ThingCategory.Pawn
                             select x;
            string sourceLabel2 = null;

            destinationLabel     = null;
            playerPawnsReadOnly2 = true;
            ignoreSpawnedCorpseGearAndInventoryMass = false;
            includePawnsMassInMassUsage             = ignoreSpawnedCorpsesGearAndInventoryMass;
            itemsTransfer = new TransferableOneWayWidget(transferables2, sourceLabel2, destinationLabel, thingCountTip, playerPawnsReadOnly2, ignorePawnInventoryMass, ignoreSpawnedCorpseGearAndInventoryMass, availableMassGetter, 0f, includePawnsMassInMassUsage, tile, drawMarketValue: true, drawEquippedWeapon: false, drawNutritionEatenPerDay: false, drawItemNutrition: true, drawForagedFoodPerDay: false, drawDaysUntilRot: true);
        }
        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);
        }
        private static float ApproxDaysWorthOfFood(List <Pawn> pawns, List <ThingCount> extraFood, bool assumeCanEatLocalPlants, IgnorePawnsInventoryMode ignoreInventory)
        {
            if (!DaysWorthOfFoodCalculator.AnyNonLocalPlantsEatingPawn(pawns, assumeCanEatLocalPlants))
            {
                return(1000f);
            }
            DaysWorthOfFoodCalculator.tmpFood.Clear();
            if (extraFood != null)
            {
                for (int i = 0; i < extraFood.Count; i++)
                {
                    if (extraFood[i].ThingDef.IsNutritionGivingIngestible && extraFood[i].Count > 0)
                    {
                        DaysWorthOfFoodCalculator.tmpFood.Add(extraFood[i]);
                    }
                }
            }
            for (int j = 0; j < pawns.Count; j++)
            {
                if (!InventoryCalculatorsUtility.ShouldIgnoreInventoryOf(pawns[j], ignoreInventory))
                {
                    ThingOwner <Thing> innerContainer = pawns[j].inventory.innerContainer;
                    for (int k = 0; k < innerContainer.Count; k++)
                    {
                        if (innerContainer[k].def.IsNutritionGivingIngestible)
                        {
                            DaysWorthOfFoodCalculator.tmpFood.Add(new ThingCount(innerContainer[k].def, innerContainer[k].stackCount));
                        }
                    }
                }
            }
            if (!DaysWorthOfFoodCalculator.tmpFood.Any())
            {
                return(0f);
            }
            DaysWorthOfFoodCalculator.tmpDaysWorthOfFoodPerPawn.Clear();
            DaysWorthOfFoodCalculator.tmpAnyFoodLeftIngestibleByPawn.Clear();
            for (int l = 0; l < pawns.Count; l++)
            {
                DaysWorthOfFoodCalculator.tmpDaysWorthOfFoodPerPawn.Add(0f);
                DaysWorthOfFoodCalculator.tmpAnyFoodLeftIngestibleByPawn.Add(true);
            }
            float num = 0f;

            while (true)
            {
                bool flag = false;
                for (int m = 0; m < pawns.Count; m++)
                {
                    Pawn pawn = pawns[m];
                    if (DaysWorthOfFoodCalculator.tmpAnyFoodLeftIngestibleByPawn[m] && pawn.RaceProps.EatsFood && (!assumeCanEatLocalPlants || !VirtualPlantsUtility.CanEverEatVirtualPlants(pawn)))
                    {
                        while (true)
                        {
                            int num2 = DaysWorthOfFoodCalculator.BestEverEdibleFoodIndexFor(pawns[m], DaysWorthOfFoodCalculator.tmpFood);
                            if (num2 < 0)
                            {
                                DaysWorthOfFoodCalculator.tmpAnyFoodLeftIngestibleByPawn[m] = false;
                                break;
                            }
                            float        num3 = Mathf.Min(DaysWorthOfFoodCalculator.tmpFood[num2].ThingDef.ingestible.nutrition, pawn.needs.food.NutritionBetweenHungryAndFed);
                            float        num4 = (float)(num3 / pawn.needs.food.NutritionBetweenHungryAndFed * (float)pawn.needs.food.TicksUntilHungryWhenFed / 60000.0);
                            List <float> list;
                            int          index;
                            (list = DaysWorthOfFoodCalculator.tmpDaysWorthOfFoodPerPawn)[index = m] = list[index] + num4;
                            DaysWorthOfFoodCalculator.tmpFood[num2] = DaysWorthOfFoodCalculator.tmpFood[num2].WithCount(DaysWorthOfFoodCalculator.tmpFood[num2].Count - 1);
                            flag = true;
                            if (!(DaysWorthOfFoodCalculator.tmpDaysWorthOfFoodPerPawn[m] < num))
                            {
                                break;
                            }
                        }
                        num = Mathf.Max(num, DaysWorthOfFoodCalculator.tmpDaysWorthOfFoodPerPawn[m]);
                    }
                }
                if (!flag)
                {
                    break;
                }
            }
            float num5 = 1000f;

            for (int n = 0; n < pawns.Count; n++)
            {
                if (pawns[n].RaceProps.EatsFood && (!assumeCanEatLocalPlants || !VirtualPlantsUtility.CanEverEatVirtualPlants(pawns[n])))
                {
                    num5 = Mathf.Min(num5, DaysWorthOfFoodCalculator.tmpDaysWorthOfFoodPerPawn[n]);
                }
            }
            return(num5);
        }
        public static float ApproxDaysWorthOfFood(List <Pawn> pawns, List <ThingStackPart> potentiallyFood, bool assumeCanEatLocalPlants, IgnorePawnsInventoryMode ignoreInventory)
        {
            DaysWorthOfFoodCalculator.tmpThingCounts.Clear();
            for (int i = 0; i < potentiallyFood.Count; i++)
            {
                DaysWorthOfFoodCalculator.tmpThingCounts.Add(new ThingCount(potentiallyFood[i].Thing.def, potentiallyFood[i].Count));
            }
            float result = DaysWorthOfFoodCalculator.ApproxDaysWorthOfFood(pawns, DaysWorthOfFoodCalculator.tmpThingCounts, assumeCanEatLocalPlants, ignoreInventory);

            DaysWorthOfFoodCalculator.tmpThingCounts.Clear();
            return(result);
        }
        public static float ApproxDaysWorthOfFood(List <Pawn> pawns, List <Thing> potentiallyFood, bool assumeCanEatLocalPlants, IgnorePawnsInventoryMode ignoreInventory)
        {
            DaysWorthOfFoodCalculator.tmpThingCounts.Clear();
            DaysWorthOfFoodCalculator.tmpPawns.Clear();
            for (int i = 0; i < pawns.Count; i++)
            {
                Pawn pawn = pawns[i];
                if (pawn.RaceProps.EatsFood && (!assumeCanEatLocalPlants || !VirtualPlantsUtility.CanEverEatVirtualPlants(pawn)))
                {
                    DaysWorthOfFoodCalculator.tmpPawns.Add(pawn);
                }
            }
            for (int j = 0; j < potentiallyFood.Count; j++)
            {
                DaysWorthOfFoodCalculator.tmpThingCounts.Add(new ThingCount(potentiallyFood[j].def, potentiallyFood[j].stackCount));
            }
            float result = DaysWorthOfFoodCalculator.ApproxDaysWorthOfFood(DaysWorthOfFoodCalculator.tmpPawns, DaysWorthOfFoodCalculator.tmpThingCounts, assumeCanEatLocalPlants, ignoreInventory);

            DaysWorthOfFoodCalculator.tmpThingCounts.Clear();
            DaysWorthOfFoodCalculator.tmpPawns.Clear();
            return(result);
        }
        public static float ApproxDaysWorthOfFoodLeftAfterTransfer(List <TransferableOneWay> transferables, bool assumeCanEatLocalPlants, IgnorePawnsInventoryMode ignoreInventory)
        {
            DaysWorthOfFoodCalculator.tmpThingCounts.Clear();
            DaysWorthOfFoodCalculator.tmpPawns.Clear();
            for (int i = 0; i < transferables.Count; i++)
            {
                TransferableOneWay transferableOneWay = transferables[i];
                if (transferableOneWay.HasAnyThing)
                {
                    if (transferableOneWay.AnyThing is Pawn)
                    {
                        for (int num = transferableOneWay.things.Count - 1; num >= transferableOneWay.CountToTransfer; num--)
                        {
                            Pawn pawn = (Pawn)transferableOneWay.things[num];
                            if (pawn.RaceProps.EatsFood && (!assumeCanEatLocalPlants || !VirtualPlantsUtility.CanEverEatVirtualPlants(pawn)))
                            {
                                DaysWorthOfFoodCalculator.tmpPawns.Add(pawn);
                            }
                        }
                    }
                    else
                    {
                        DaysWorthOfFoodCalculator.tmpThingCounts.Add(new ThingCount(transferableOneWay.ThingDef, transferableOneWay.MaxCount - transferableOneWay.CountToTransfer));
                    }
                }
            }
            float result = DaysWorthOfFoodCalculator.ApproxDaysWorthOfFood(DaysWorthOfFoodCalculator.tmpPawns, DaysWorthOfFoodCalculator.tmpThingCounts, assumeCanEatLocalPlants, ignoreInventory);

            DaysWorthOfFoodCalculator.tmpThingCounts.Clear();
            DaysWorthOfFoodCalculator.tmpPawns.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 ApproxDaysUntilRotLeftAfterTransfer(List <TransferableOneWay> transferables, int tile, IgnorePawnsInventoryMode ignoreInventory, WorldPath path = null, float nextTileCostLeft = 0f, int caravanTicksPerMove = 3300)
        {
            DaysUntilRotCalculator.tmpThingCounts.Clear();
            for (int i = 0; i < transferables.Count; i++)
            {
                TransferableOneWay transferableOneWay = transferables[i];
                if (transferableOneWay.HasAnyThing)
                {
                    if (transferableOneWay.AnyThing is Pawn)
                    {
                        for (int j = transferableOneWay.things.Count - 1; j >= transferableOneWay.CountToTransfer; j--)
                        {
                            Pawn pawn = (Pawn)transferableOneWay.things[j];
                            if (!InventoryCalculatorsUtility.ShouldIgnoreInventoryOf(pawn, ignoreInventory))
                            {
                                ThingOwner <Thing> innerContainer = pawn.inventory.innerContainer;
                                for (int k = 0; k < innerContainer.Count; k++)
                                {
                                    DaysUntilRotCalculator.tmpThingCounts.Add(new ThingCount(innerContainer[k], innerContainer[k].stackCount));
                                }
                            }
                        }
                    }
                    else if (transferableOneWay.MaxCount - transferableOneWay.CountToTransfer > 0)
                    {
                        DaysUntilRotCalculator.thingsInReverse.Clear();
                        DaysUntilRotCalculator.thingsInReverse.AddRange(transferableOneWay.things);
                        DaysUntilRotCalculator.thingsInReverse.Reverse();
                        TransferableUtility.TransferNoSplit(DaysUntilRotCalculator.thingsInReverse, transferableOneWay.MaxCount - transferableOneWay.CountToTransfer, delegate(Thing thing, int count)
                        {
                            DaysUntilRotCalculator.tmpThingCounts.Add(new ThingCount(thing, count));
                        }, false, false);
                    }
                }
            }
            DaysUntilRotCalculator.thingsInReverse.Clear();
            float result = DaysUntilRotCalculator.ApproxDaysUntilRot(DaysUntilRotCalculator.tmpThingCounts, tile, path, nextTileCostLeft, caravanTicksPerMove);

            DaysUntilRotCalculator.tmpThingCounts.Clear();
            return(result);
        }
        public static float MassUsageLeftAfterTransfer(List <TransferableOneWay> transferables, IgnorePawnsInventoryMode ignoreInventory, bool includePawnsMass = false, bool ignoreSpawnedCorpsesGearAndInventory = false)
        {
            tmpThingCounts.Clear();
            for (int i = 0; i < transferables.Count; i++)
            {
                thingsInReverse.Clear();
                thingsInReverse.AddRange(transferables[i].things);
                thingsInReverse.Reverse();
                TransferableUtility.TransferNoSplit(thingsInReverse, transferables[i].MaxCount - transferables[i].CountToTransfer, delegate(Thing originalThing, int toTake)
                {
                    tmpThingCounts.Add(new ThingCount(originalThing, toTake));
                }, removeIfTakingEntireThing: false, errorIfNotEnoughThings: false);
            }
            float result = MassUsage(tmpThingCounts, ignoreInventory, includePawnsMass, ignoreSpawnedCorpsesGearAndInventory);

            tmpThingCounts.Clear();
            return(result);
        }
        public static float MassUsageLeftAfterTradeableTransfer(List <Thing> allCurrentThings, List <Tradeable> tradeables, IgnorePawnsInventoryMode ignoreInventory, bool includePawnsMass = false, bool ignoreSpawnedCorpsesGearAndInventory = false)
        {
            tmpThingCounts.Clear();
            TransferableUtility.SimulateTradeableTransfer(allCurrentThings, tradeables, tmpThingCounts);
            float result = MassUsage(tmpThingCounts, ignoreInventory, includePawnsMass, ignoreSpawnedCorpsesGearAndInventory);

            tmpThingCounts.Clear();
            return(result);
        }