Ejemplo n.º 1
0
        public override Job JobOnThing(Pawn pawn, Thing thing, bool forced = false)
        {
            Pawn targetPawn = thing as Pawn;

            //Get closest consumable source we can find.
            Thing closestEnergySource = TryFindBestEnergySource(pawn);

            if (closestEnergySource != null)
            {
                Need_Energy needEnergy = targetPawn.needs.TryGetNeed <Need_Energy>();

                EnergySourceComp energySourceComp = closestEnergySource.TryGetComp <EnergySourceComp>();

                //Consume for pawn.
                int thingCount = (int)Math.Ceiling((needEnergy.MaxLevel - needEnergy.CurLevel) / energySourceComp.EnergyProps.energyWhenConsumed);
                thingCount = Math.Min(thingCount, closestEnergySource.stackCount);

                if (thingCount > 0)
                {
                    return new Job(JobDefOf.ChJAndroidRechargeEnergyComp, new LocalTargetInfo(closestEnergySource), new LocalTargetInfo(targetPawn))
                           {
                               count = thingCount
                           }
                }
                ;
            }

            return(null);
        }
        // Token: 0x06000028 RID: 40 RVA: 0x00002E68 File Offset: 0x00001068
        public override Job JobOnThing(Pawn pawn, Thing thing, bool forced = false)
        {
            Pawn  pawn2  = thing as Pawn;
            Thing thing2 = this.TryFindBestEnergySource(pawn);
            bool  flag   = thing2 != null;

            if (flag)
            {
                Need_Energy      need_Energy      = pawn2.needs.TryGetNeed <Need_Energy>();
                EnergySourceComp energySourceComp = thing2.TryGetComp <EnergySourceComp>();
                int num = (int)Math.Ceiling((double)((need_Energy.MaxLevel - need_Energy.CurLevel) / energySourceComp.EnergyProps.energyWhenConsumed));
                num = Math.Min(num, thing2.stackCount);
                bool flag2 = num > 0;
                if (flag2)
                {
                    return(new Job(JobDefOf.ChJAndroidRechargeEnergyComp, new LocalTargetInfo(thing2), new LocalTargetInfo(pawn2))
                    {
                        count = num
                    });
                }
            }
            return(null);
        }
Ejemplo n.º 3
0
        protected override Job TryGiveJob(Pawn pawn)
        {
            if (pawn.Downed)
            {
                return(null);
            }

            Need_Energy energy = pawn.needs.TryGetNeed <Need_Energy>();

            if (energy == null)
            {
                return(null);
            }

            if (energy.CurLevelPercentage >= Need_Energy.rechargePercentage)
            {
                return(null);
            }

            if (Find.TickManager.TicksGame < GetLastTryTick(pawn) + 2500)
            {
                return(null);
            }
            SetLastTryTick(pawn, Find.TickManager.TicksGame);

            //See if we got a nearby powernet to tap into.
            Thing closestPowerSource = EnergyNeedUtility.ClosestPowerSource(pawn);

            if (closestPowerSource != null)
            {
                Building building = closestPowerSource as Building;
                if (closestPowerSource != null && building != null && building.PowerComp != null && building.PowerComp.PowerNet.CurrentStoredEnergy() > 50f)
                {
                    //Find a suitable spot to drain from.
                    IntVec3 drainSpot = closestPowerSource.Position;

                    //Give out job to go out and tap it.
                    if (drainSpot.Walkable(pawn.Map) && drainSpot.InAllowedArea(pawn) && pawn.CanReserve(new LocalTargetInfo(drainSpot)) && pawn.CanReach(drainSpot, PathEndMode.OnCell, Danger.Deadly))
                    {
                        return(new Job(JobDefOf.ChJAndroidRecharge, closestPowerSource));
                    }

                    //Check surrounding cells.
                    foreach (IntVec3 adjCell in GenAdj.CellsAdjacentCardinal(building).OrderByDescending(selector => selector.DistanceTo(pawn.Position)))
                    {
                        if (adjCell.Walkable(pawn.Map) && adjCell.InAllowedArea(pawn) && pawn.CanReserve(new LocalTargetInfo(adjCell)) && pawn.CanReach(adjCell, PathEndMode.OnCell, Danger.Deadly))
                        {
                            return(new Job(JobDefOf.ChJAndroidRecharge, closestPowerSource, adjCell));
                        }
                    }
                }
            }

            //No power source? Try looking for a consumable resource.

            //In the inventory. (Or being carried)
            if (pawn.carryTracker is Pawn_CarryTracker carryTracker && carryTracker.CarriedThing is Thing carriedThing && carriedThing.TryGetComp <EnergySourceComp>() is EnergySourceComp carriedThingComp && carriedThingComp.EnergyProps.isConsumable)
            {
                if (carriedThing.stackCount > 0)
                {
                    return(new Job(JobDefOf.ChJAndroidRechargeEnergyComp, new LocalTargetInfo(carriedThing))
                    {
                        count = carriedThing.stackCount
                    });
                }
            }
            if (pawn.inventory is Pawn_InventoryTracker inventory && inventory.innerContainer.Any(thing => thing.TryGetComp <EnergySourceComp>() is EnergySourceComp comp && comp.EnergyProps.isConsumable))
            {
                Thing validEnergySource =
                    inventory.innerContainer.FirstOrDefault(
                        thing =>
                        thing.TryGetComp <EnergySourceComp>() is EnergySourceComp energySource &&
                        energySource.EnergyProps.isConsumable
                        );
                if (validEnergySource != null)
                {
                    //Use enough to get satisfied.
                    EnergySourceComp energySourceComp = validEnergySource.TryGetComp <EnergySourceComp>();

                    int thingCount = (int)Math.Ceiling((energy.MaxLevel - energy.CurLevel) / energySourceComp.EnergyProps.energyWhenConsumed);
                    thingCount = Math.Min(thingCount, validEnergySource.stackCount);

                    if (thingCount > 0)
                    {
                        return(new Job(JobDefOf.ChJAndroidRechargeEnergyComp, new LocalTargetInfo(validEnergySource))
                        {
                            count = thingCount
                        });
                    }
                }
            }

            //On the map.
            Thing closestConsumablePowerSource =
                GenClosest.ClosestThingReachable(
                    pawn.Position, pawn.Map, ThingRequest.ForGroup(ThingRequestGroup.HaulableEver), PathEndMode.OnCell, TraverseParms.For(pawn), 9999f,
                    thing => thing.TryGetComp <EnergySourceComp>() != null && !thing.IsForbidden(pawn) && pawn.CanReserve(new LocalTargetInfo(thing)) && thing.Position.InAllowedArea(pawn) && pawn.CanReach(new LocalTargetInfo(thing), PathEndMode.OnCell, Danger.Deadly));

            if (closestConsumablePowerSource != null)
            {
                EnergySourceComp energySourceComp = closestConsumablePowerSource.TryGetComp <EnergySourceComp>();
                if (energySourceComp != null)
                {
                    int thingCount = (int)Math.Ceiling((energy.MaxLevel - energy.CurLevel) / energySourceComp.EnergyProps.energyWhenConsumed);
                    if (thingCount > 0)
                    {
                        return(new Job(JobDefOf.ChJAndroidRechargeEnergyComp, new LocalTargetInfo(closestConsumablePowerSource))
                        {
                            count = thingCount
                        });
                    }
                }
            }

            return(null);
        }
        // Token: 0x0600001A RID: 26 RVA: 0x0000247C File Offset: 0x0000067C
        protected override Job TryGiveJob(Pawn pawn)
        {
            bool downed = pawn.Downed;
            Job  result;

            if (downed)
            {
                result = null;
            }
            else
            {
                Need_Energy need_Energy = pawn.needs.TryGetNeed <Need_Energy>();
                bool        flag        = need_Energy == null;
                if (flag)
                {
                    result = null;
                }
                else
                {
                    bool flag2 = need_Energy.CurLevelPercentage >= Need_Energy.rechargePercentage;
                    if (flag2)
                    {
                        result = null;
                    }
                    else
                    {
                        Thing thing3 = GenClosest.ClosestThingReachable(pawn.Position, pawn.Map, ThingRequest.ForGroup(ThingRequestGroup.BuildingArtificial), PathEndMode.ClosestTouch, TraverseParms.For(pawn, Danger.Deadly, TraverseMode.ByPawn, false), 9999f, (Thing thing) => this.BestClosestPowerSource(pawn, thing), null, 0, -1, false, RegionType.Set_Passable, false);
                        bool  flag3  = thing3 != null;
                        if (flag3)
                        {
                            Building building = thing3 as Building;
                            bool     flag4    = thing3 != null && building != null && building.PowerComp != null && building.PowerComp.PowerNet.CurrentStoredEnergy() > 50f;
                            if (flag4)
                            {
                                IntVec3 position = thing3.Position;
                                bool    flag5    = position.Walkable(pawn.Map) && position.InAllowedArea(pawn) && pawn.CanReserve(new LocalTargetInfo(position), 1, -1, null, false) && pawn.CanReach(position, PathEndMode.OnCell, Danger.Deadly, false, TraverseMode.ByPawn);
                                if (flag5)
                                {
                                    return(new Job(JobDefOf.ChJAndroidRecharge, thing3));
                                }
                                IEnumerable <IntVec3> source = GenAdj.CellsAdjacentCardinal(building);
                                Func <IntVec3, float> < > 9__1;
                                Func <IntVec3, float> keySelector;
                                if ((keySelector = < > 9__1) == null)
                                {
                                    keySelector = (< > 9__1 = ((IntVec3 selector) => selector.DistanceTo(pawn.Position)));
                                }
                                foreach (IntVec3 intVec in source.OrderByDescending(keySelector))
                                {
                                    bool flag6 = intVec.Walkable(pawn.Map) && intVec.InAllowedArea(pawn) && pawn.CanReserve(new LocalTargetInfo(intVec), 1, -1, null, false) && pawn.CanReach(intVec, PathEndMode.OnCell, Danger.Deadly, false, TraverseMode.ByPawn);
                                    if (flag6)
                                    {
                                        return(new Job(JobDefOf.ChJAndroidRecharge, thing3, intVec));
                                    }
                                }
                            }
                        }
                        Thing thing2 = GenClosest.ClosestThingReachable(pawn.Position, pawn.Map, ThingRequest.ForGroup(ThingRequestGroup.HaulableEver), PathEndMode.ClosestTouch, TraverseParms.For(pawn, Danger.Deadly, TraverseMode.ByPawn, false), 9999f, (Thing thing) => thing.TryGetComp <EnergySourceComp>() != null && !thing.IsForbidden(pawn) && pawn.CanReserve(new LocalTargetInfo(thing), 1, -1, null, false) && thing.Position.InAllowedArea(pawn) && pawn.CanReach(new LocalTargetInfo(thing), PathEndMode.OnCell, Danger.Deadly, false, TraverseMode.ByPawn), null, 0, -1, false, RegionType.Set_Passable, false);
                        bool  flag7  = thing2 != null;
                        if (flag7)
                        {
                            EnergySourceComp energySourceComp = thing2.TryGetComp <EnergySourceComp>();
                            bool             flag8            = energySourceComp != null;
                            if (flag8)
                            {
                                int  num   = (int)Math.Ceiling((double)((need_Energy.MaxLevel - need_Energy.CurLevel) / energySourceComp.EnergyProps.energyWhenConsumed));
                                bool flag9 = num > 0;
                                if (flag9)
                                {
                                    return(new Job(JobDefOf.ChJAndroidRechargeEnergyComp, new LocalTargetInfo(thing2))
                                    {
                                        count = num
                                    });
                                }
                            }
                        }
                        result = null;
                    }
                }
            }
            return(result);
        }
        protected override IEnumerable <Toil> MakeNewToils()
        {
            this.FailOnDestroyedNullOrForbidden(PowerDestIndex);
            if (!TargetB.IsValid)
            {
                AddFailCondition(() => energyNeed == null);
            }

            if (!isUsedFromInventory)
            {
                yield return(Toils_Reserve.Reserve(PowerDestIndex));

                if (TargetB.IsValid)
                {
                    yield return(Toils_Reserve.Reserve(OtherPawnIndex));
                }

                yield return(Toils_Goto.GotoThing(PowerDestIndex, PathEndMode.OnCell).FailOnSomeonePhysicallyInteracting(PowerDestIndex));

                yield return(Toils_Reserve.Release(PowerDestIndex));
            }
            else
            {
                yield return(new Toil()
                {
                    initAction = delegate()
                    {
                        if (!thingIsSplitOff && pawn.carryTracker.CarriedThing != TargetThingA)
                        {
                            Thing splitOffThing = TargetThingA.SplitOff(job.count);
                            thingIsSplitOff = true;
                            GenPlace.TryPlaceThing(splitOffThing, pawn.Position, pawn.Map, ThingPlaceMode.Near);

                            TargetThingA = splitOffThing;
                        }
                    }
                });
            }

            yield return(Toils_Haul.StartCarryThing(TargetIndex.A, false, true, false));

            this.AddFinishAction(delegate()
            {
                if (pawn.carryTracker is Pawn_CarryTracker carryTracker && carryTracker.CarriedThing is Thing thing)
                {
                    if (isUsedFromInventory)
                    {
                        //Thing takenThing = carryTracker.innerContainer.Take(thing);
                        pawn.inventory.innerContainer.TryAddOrTransfer(thing, true);
                    }
                    else
                    {
                        carryTracker.TryDropCarriedThing(pawn.Position, ThingPlaceMode.Near, out Thing resultThing);
                    }
                }
            });

            if (TargetB.IsValid)
            {
                //Recharge someone else.
                yield return(Toils_Goto.GotoThing(OtherPawnIndex, PathEndMode.Touch).FailOnForbidden(OtherPawnIndex));

                yield return(Toils_General.Wait(100).WithProgressBarToilDelay(TargetIndex.A, false));

                Toil rechargeToil = new Toil();
                rechargeToil.AddFinishAction(delegate()
                {
                    //Use up the carried stack
                    Thing carriedThing = pawn.carryTracker.CarriedThing;
                    if (carriedThing != null)
                    {
                        EnergySourceComp energyComp = carriedThing.TryGetComp <EnergySourceComp>();
                        if (energyComp != null)
                        {
                            energyComp.RechargeEnergyNeed((Pawn)TargetB.Thing);
                        }

                        pawn.carryTracker.DestroyCarriedThing();
                    }
                });

                yield return(rechargeToil);

                yield return(Toils_Reserve.Release(OtherPawnIndex));
            }
            else
            {
                yield return(Toils_General.Wait(100).WithProgressBarToilDelay(TargetIndex.A, false));

                //Recharge user.
                Toil rechargeToil = new Toil();
                rechargeToil.AddFinishAction(delegate()
                {
                    //Use up the carried stack
                    Thing carriedThing = pawn.carryTracker.CarriedThing;
                    if (carriedThing != null)
                    {
                        EnergySourceComp energyComp = carriedThing.TryGetComp <EnergySourceComp>();
                        if (energyComp != null)
                        {
                            energyComp.RechargeEnergyNeed(pawn);
                        }

                        pawn.carryTracker.DestroyCarriedThing();
                    }
                });

                yield return(rechargeToil);
            }
        }
        // Token: 0x06000013 RID: 19 RVA: 0x00002336 File Offset: 0x00000536
        protected override IEnumerable <Toil> MakeNewToils()
        {
            this.FailOnDestroyedNullOrForbidden(TargetIndex.A);
            bool flag = !base.TargetB.IsValid;

            if (flag)
            {
                base.AddFailCondition(() => this.energyNeed == null);
            }
            yield return(Toils_Reserve.Reserve(TargetIndex.A, 1, -1, null));

            bool isValid = base.TargetB.IsValid;

            if (isValid)
            {
                yield return(Toils_Reserve.Reserve(TargetIndex.B, 1, -1, null));
            }
            yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.ClosestTouch).FailOnSomeonePhysicallyInteracting(TargetIndex.A));

            yield return(Toils_Reserve.Release(TargetIndex.A));

            yield return(Toils_Haul.StartCarryThing(TargetIndex.A, false, true, false));

            bool isValid2 = base.TargetB.IsValid;

            if (isValid2)
            {
                yield return(Toils_Goto.GotoThing(TargetIndex.B, PathEndMode.Touch).FailOnForbidden(TargetIndex.B));

                yield return(Toils_General.Wait(100).WithProgressBarToilDelay(TargetIndex.A, false, -0.5f));

                Toil rechargeToil = new Toil();
                rechargeToil.AddFinishAction(delegate
                {
                    Thing carriedThing = this.pawn.carryTracker.CarriedThing;
                    bool flag2         = carriedThing != null;
                    if (flag2)
                    {
                        EnergySourceComp energySourceComp = carriedThing.TryGetComp <EnergySourceComp>();
                        bool flag3 = energySourceComp != null;
                        if (flag3)
                        {
                            energySourceComp.RechargeEnergyNeed((Pawn)base.TargetB.Thing);
                        }
                        this.pawn.carryTracker.DestroyCarriedThing();
                    }
                });
                yield return(rechargeToil);

                yield return(Toils_Reserve.Release(TargetIndex.B));

                rechargeToil = null;
            }
            else
            {
                yield return(Toils_General.Wait(100).WithProgressBarToilDelay(TargetIndex.A, false, -0.5f));

                Toil rechargeToil2 = new Toil();
                rechargeToil2.AddFinishAction(delegate
                {
                    Thing carriedThing = this.pawn.carryTracker.CarriedThing;
                    bool flag2         = carriedThing != null;
                    if (flag2)
                    {
                        EnergySourceComp energySourceComp = carriedThing.TryGetComp <EnergySourceComp>();
                        bool flag3 = energySourceComp != null;
                        if (flag3)
                        {
                            energySourceComp.RechargeEnergyNeed(this.pawn);
                        }
                        this.pawn.carryTracker.DestroyCarriedThing();
                    }
                });
                yield return(rechargeToil2);

                rechargeToil2 = null;
            }
            yield break;
        }