private IEnumerable <Toil> PrepareToIngestToils_ToolUser(Toil chewToil)
{
yield return(ReserveFood());
Toil gotoToPickup = Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.ClosestTouch).FailOnDespawnedNullOrForbidden(TargetIndex.A);
yield return(Toils_Jump.JumpIf(gotoToPickup, () => pawn.health.capacities.CapableOf(PawnCapacityDefOf.Manipulation)));
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch).FailOnDespawnedNullOrForbidden(TargetIndex.A));
yield return(Toils_Jump.Jump(chewToil));
yield return(gotoToPickup);
yield return(Toils_WendigoIngest.PickupIngestible(TargetIndex.A, pawn));
if (job.takeExtraIngestibles > 0)
{
foreach (Toil item in TakeExtraIngestibles())
{
yield return(item);
}
}
if (!pawn.Drafted)
{
yield return(Toils_WendigoIngest.CarryIngestibleToChewSpot(pawn, TargetIndex.A).FailOnDestroyedOrNull(TargetIndex.A));
}
yield return(Toils_WendigoIngest.FindAdjacentEatSurface(TargetIndex.B, TargetIndex.A));
}
protected override IEnumerable <Toil> MakeNewToils()
{
//FAIL CONDITIONS
ToilFailConditions.FailOnDestroyedOrNull <JobDriver_Training>(this, TargetIndex.A);
ToilFailConditions.FailOnDespawnedNullOrForbidden <JobDriver_Training>(this, TargetIndex.A);
this.FailOn(() =>
{
Pawn p = this.pawn;
if (this.IsContinuation(this.job) && this.CurToilIndex > 1)
{
if ((double)p.needs.food.CurLevel < 0.25)
{
Messages.Message(p.LabelCap + " has stopped training due hunger.", (GlobalTargetInfo)p, MessageTypeDefOf.NeutralEvent);
}
else if ((double)p.needs.rest.CurLevel < 0.25)
{
Messages.Message(p.LabelCap + " has stopped training due lack of sleep.", (GlobalTargetInfo)p, MessageTypeDefOf.NeutralEvent);
}
}
return((double)p.needs.food.CurLevel < 0.25 || (double)p.needs.rest.CurLevel < 0.25 || p.Drafted || p.jobs.jobQueue.Any());
});
//SEQUENZA AZIONI PAWN
yield return(Toils_Reserve.Reserve(TargetIndex.A, 1));
yield return(Toils_Goto.GotoCell(TargetIndex.B, PathEndMode.OnCell));
Toil Train = Toils_Training(TargetIndex.B);
yield return(Train);
yield return(Toils_General.Wait(100));
yield return(Toils_Jump.Jump(Train));
}
protected override IEnumerable <Toil> MakeNewToils()
{
this.FailOnDespawnedNullOrForbidden(TargetIndex.A);
Toil extract = Toils_JobTransforms.ExtractNextTargetFromQueue(TargetIndex.B);
yield return(extract);
yield return(Toils_Goto.GotoThing(TargetIndex.B, PathEndMode.ClosestTouch).FailOnDespawnedNullOrForbidden(TargetIndex.B).FailOnSomeonePhysicallyInteracting(TargetIndex.B));
yield return(Toils_Haul.StartCarryThing(TargetIndex.B, true, false, true));
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.ClosestTouch));
yield return(Toils_General.Wait(400).WithProgressBarToilDelay(TargetIndex.A).FailOnDestroyedNullOrForbidden(TargetIndex.A));
Toil finish = new Toil
{
initAction = delegate
{
if (item != null)
{
furnace.AddItemToFurnace(item);
}
},
defaultCompleteMode = ToilCompleteMode.Instant
};
yield return(finish);
yield return(Toils_Jump.JumpIfHaveTargetInQueue(TargetIndex.B, extract));
}
protected override IEnumerable <Toil> MakeNewToils()
{
if (TargetThingA is Building_Bed)
{
yield return(Toils_Bed.GotoBed(TargetIndex.A));
yield return(Toils_LayDownPower.LayDown(TargetIndex.A, true, false, false));
}
else
{
var gotoCell = Toils_Goto.GotoCell(TargetIndex.A, PathEndMode.OnCell);
var nothing = new Toil();
yield return(gotoCell);
var setSkin = new Toil {
initAction = delegate { pawn.Rotation = Rot4.South; }
};
yield return(setSkin);
yield return(nothing);
yield return(Toils_General.Wait(50));
yield return(Toils_Jump.JumpIf(nothing, () => pawn.needs.food.CurLevelPercentage < 1.0f &&
!job.targetB.ThingDestroyed && !((Building)job.targetB).IsBrokenDown() &&
((Building)job.targetB).TryGetComp <CompPowerTrader>().PowerOn));
}
}
//public override string GetReport()
//{
// //if (job?.plantDefToSow == null) return base.GetReport();
// return "JobDineGoReport".Translate();
//}
protected override IEnumerable <Toil> MakeNewToils()
{
var wait = Toils_General.Wait(50, IndexSpot).FailOnNotDiningQueued(IndexPatron);
var end = Toils_General.Wait(5);
this.FailOnNotDiningQueued(IndexPatron); // Careful never to use B for something else
yield return(Toils_Waiting.FindRandomAdjacentCell(IndexSpot, IndexStanding)); // A is first the dining spot, then where we'll stand
yield return(Toils_Goto.GotoCell(IndexStanding, PathEndMode.OnCell).FailOnRestaurantClosed());
yield return(Toils_Interpersonal.WaitToBeAbleToInteract(pawn));
yield return(wait);
yield return(Toils_Jump.JumpIf(wait, () => !(Patron?.jobs.curDriver is JobDriver_Dine))); // Not dining right now
yield return(Toils_Waiting.GetDiningSpot(IndexPatron, IndexSpot)); // A is dining spot again now
yield return(Toils_Waiting.GetSpecificDiningSpotCellForMakingTable(IndexSpot, IndexPatron, IndexChairPos));
yield return(Toils_Waiting.TakeOrder(IndexPatron));
yield return(Toils_Interpersonal.SetLastInteractTime(IndexPatron));
yield return(Toils_Jump.JumpIf(end, () => DiningSpot?.IsSpotReady(ChairPos) == true));
yield return(Toils_Goto.GotoCell(IndexSpot, PathEndMode.ClosestTouch));
yield return(Toils_Waiting.MakeTableReady(IndexSpot, IndexChairPos));
yield return(end);
}
// Token: 0x06000095 RID: 149 RVA: 0x000059E9 File Offset: 0x00003BE9
protected override IEnumerable <Toil> MakeNewToils()
{
var count = 0;
this.FailOn(() => job.GetTarget(TargetIndex.A).Thing.DestroyedOrNull());
this.FailOn(() => !HaywireData.IsHaywired(pawn));
var count1 = count;
this.FailOn(() => count1 > 4);
yield return(Toils_Combat.TrySetJobToUseAttackVerb(TargetIndex.A));
var gotoCastPos = Toils_Combat.GotoCastPosition(TargetIndex.A, TargetIndex.None, false, 0.95f);
yield return(gotoCastPos);
var count2 = count;
count = count2 + 1;
if (count > 8)
{
EndJobWith(JobCondition.Incompletable);
}
var jumpIfCannotHit = Toils_Jump.JumpIfTargetNotHittable(TargetIndex.A, gotoCastPos);
yield return(jumpIfCannotHit);
yield return(Toils_Combat.CastVerb(TargetIndex.A));
yield return(Toils_Jump.Jump(jumpIfCannotHit));
}
private IEnumerable <Toil> FeedToils()
{
yield return(new Toil
{
initAction = delegate
{
this.$this.feedNutritionLeft = JobDriver_InteractAnimal.RequiredNutritionPerFeed(this.$this.Animal);
},
defaultCompleteMode = ToilCompleteMode.Instant
});
Toil gotoAnimal = Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch);
yield return(gotoAnimal);
yield return(this.StartFeedAnimal(TargetIndex.A));
yield return(Toils_Ingest.FinalizeIngest(this.Animal, TargetIndex.B));
yield return(Toils_General.PutCarriedThingInInventory());
yield return(Toils_General.ClearTarget(TargetIndex.B));
yield return(Toils_Jump.JumpIf(gotoAnimal, () => this.$this.feedNutritionLeft > 0f));
}
protected override IEnumerable <Toil> MakeNewToils()
{
this.FailOnDespawnedNullOrForbidden <JobDriver_StabilizeHere>(TargetIndex.A);
this.FailOnAggroMentalState <JobDriver_StabilizeHere>(TargetIndex.A);
this.AddEndCondition(() => {
if (HealthAIUtility.ShouldBeTendedNowByPlayer(this.Patient) || this.Patient.health.HasHediffsNeedingTend(false))
{
return(JobCondition.Ongoing);
}
return(JobCondition.Succeeded);
});
Toil toil1 = Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.InteractionCell);
yield return(toil1);
Toil toil2 = Toils_General.Wait((int)(1f / this.Doctor.GetStatValue(StatDefOf.MedicalTendSpeed, true) * 600f), TargetIndex.None).FailOnCannotTouch <Toil>(TargetIndex.A, PathEndMode.InteractionCell).WithProgressBarToilDelay(TargetIndex.A, false, -0.5f).PlaySustainerOrSound(SoundDefOf.Interact_Tend);
toil2.activeSkill = () => SkillDefOf.Medicine;
yield return(toil2);
yield return(Toils_Tend.FinalizeTend(this.Patient));
yield return(Toils_Jump.Jump(toil1));
}
private IEnumerable <Toil> TakeExtraIngestibles()
{
if (!pawn.health.capacities.CapableOf(PawnCapacityDefOf.Manipulation))
{
yield break;
}
Toil reserveExtraFoodToCollect = Toils_WendigoIngest.ReserveFoodFromStackForIngesting(TargetIndex.C);
Toil findExtraFoodToCollect = new Toil
{
initAction = delegate
{
if (pawn.inventory.innerContainer.TotalStackCountOfDef(IngestibleSource.def) < job.takeExtraIngestibles)
{
Thing thing = GenClosest.ClosestThingReachable(pawn.Position, pawn.Map, ThingRequest.ForDef(IngestibleSource.def), PathEndMode.Touch, TraverseParms.For(pawn), 30f, (Thing x) => pawn.CanReserve(x, 10, 1) && !x.IsForbidden(pawn) && x.IsSociallyProper(pawn));
if (thing != null)
{
job.SetTarget(TargetIndex.C, thing);
JumpToToil(reserveExtraFoodToCollect);
}
}
},
defaultCompleteMode = ToilCompleteMode.Instant
};
yield return(Toils_Jump.Jump(findExtraFoodToCollect));
yield return(reserveExtraFoodToCollect);
yield return(Toils_Goto.GotoThing(TargetIndex.C, PathEndMode.Touch));
yield return(Toils_Haul.TakeToInventory(TargetIndex.C, () => job.takeExtraIngestibles - pawn.inventory.innerContainer.TotalStackCountOfDef(IngestibleSource.def)));
yield return(findExtraFoodToCollect);
}
protected override IEnumerable <Toil> MakeNewToils()
{
///
//Set fail conditions
///
this.FailOnDestroyedOrNull(TargetIndex.A);
this.AddEndCondition(() => { return(this.Deliveree.health.ShouldBeTendedNow ? JobCondition.Ongoing : JobCondition.Succeeded); });
//Note we only fail on forbidden if the target doesn't start that way
//This helps haul-aside jobs on forbidden items
///
//Define Toil
///
///
//Toils Start
///
//Reserve thing to be stored and storage cell
yield return(Toils_Reserve.Reserve(TargetIndex.A));
StatWorker statWorker = new StatWorker();
statWorker.InitSetStat(StatDefOf.BaseHealingQuality);
Toil toilApplyMedicine = new Toil();
toilApplyMedicine.initAction = () =>
{
Thing dummy;
Medicine.holder.TryDrop(Medicine, pawn.Position + IntVec3.North.RotatedBy(pawn.Rotation), ThingPlaceMode.Direct, out dummy);
};
yield return(toilApplyMedicine);
yield return(Toils_Tend.PickupMedicine(TargetIndex.B, Deliveree));
Toil toilGoTodeliveree = Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch);
yield return(toilGoTodeliveree);
int duration = (int)(1.0 / (double)StatExtension.GetStatValue((Thing)pawn, StatDefOf.HealingSpeed, true) * 600.0);
Toil toilDelivereeWait = new Toil();
toilDelivereeWait.initAction = () =>
{
Deliveree.drafter.TakeOrderedJob(new Job(JobDefOf.Wait, duration));
};
yield return(Toils_General.Wait(duration));
yield return(Toils_Tend.FinalizeTend(Deliveree));
yield return(Toils_Jump.Jump(toilGoTodeliveree));
}
protected override IEnumerable <Toil> MakeNewToils()
{
this.EndOnDespawnedOrNull(MountableInd);
if (TargetThingB.IsForbidden(pawn.Faction))
{
this.FailOnForbidden(MountableInd);
}
yield return(Toils_Reserve.Reserve(MountableInd, CurJob.def.joyMaxParticipants));
Toil toil = Toils_Goto.GotoCell(DrivePathInd, PathEndMode.OnCell);
toil.tickAction = delegate
{
if (Find.TickManager.TicksGame > startTick + CurJob.def.joyDuration)
{
EndJobWith(JobCondition.Succeeded);
return;
}
JoyUtility.JoyTickCheckEnd(pawn, JoyTickFullJoyAction.EndJob, 1f);
};
ThingWithComps cart = CurJob.GetTarget(MountableInd).Thing as ThingWithComps;
//JumpIf already mounted
yield return(Toils_Jump.JumpIf(toil, () =>
{
if (cart.TryGetComp <CompMountable>().Driver == pawn)
{
return true;
}
return false;
}));
//Mount on Target
yield return(Toils_Goto.GotoThing(MountableInd, PathEndMode.ClosestTouch)
.FailOnDestroyedOrNull(MountableInd));
yield return(Toils_Cart.MountOn(MountableInd));
yield return(toil);
yield return(new Toil
{
initAction = delegate
{
if (CurJob.targetQueueA.Count > 0)
{
TargetInfo targetA = CurJob.targetQueueA[0];
CurJob.targetQueueA.RemoveAt(0);
CurJob.targetA = targetA;
JumpToToil(toil);
return;
}
}
});
yield break;
}
protected override IEnumerable <Toil> MakeNewToils()
{
this.FailOnDespawnedNullOrForbidden(TargetIndex.A);
base.AddEndCondition(() => (!this.$this.RefuelableComp.IsFull) ? JobCondition.Ongoing : JobCondition.Succeeded);
base.AddFailCondition(() => !this.$this.job.playerForced && !this.$this.RefuelableComp.ShouldAutoRefuelNowIgnoringFuelPct);
yield return(Toils_General.DoAtomic(delegate
{
this.$this.job.count = this.$this.RefuelableComp.GetFuelCountToFullyRefuel();
}));
Toil getNextIngredient = Toils_General.Label();
yield return(getNextIngredient);
yield return(Toils_JobTransforms.ExtractNextTargetFromQueue(TargetIndex.B, true));
yield return(Toils_Goto.GotoThing(TargetIndex.B, PathEndMode.ClosestTouch).FailOnDespawnedNullOrForbidden(TargetIndex.B).FailOnSomeonePhysicallyInteracting(TargetIndex.B));
yield return(Toils_Haul.StartCarryThing(TargetIndex.B, false, true, false).FailOnDestroyedNullOrForbidden(TargetIndex.B));
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch));
Toil findPlaceTarget = Toils_JobTransforms.SetTargetToIngredientPlaceCell(TargetIndex.A, TargetIndex.B, TargetIndex.C);
yield return(findPlaceTarget);
yield return(Toils_Haul.PlaceHauledThingInCell(TargetIndex.C, findPlaceTarget, false));
yield return(Toils_Jump.JumpIf(getNextIngredient, () => !this.$this.job.GetTargetQueue(TargetIndex.B).NullOrEmpty <LocalTargetInfo>()));
yield return(Toils_General.Wait(240, TargetIndex.None).FailOnDestroyedNullOrForbidden(TargetIndex.A).FailOnCannotTouch(TargetIndex.A, PathEndMode.Touch).WithProgressBarToilDelay(TargetIndex.A, false, -0.5f));
yield return(Toils_Refuel.FinalizeRefueling(TargetIndex.A, TargetIndex.None));
}
protected override IEnumerable <Toil> MakeNewToils()
{
//Check si TargetIndex.A est un Bed si oui alors juste un Toil_Bed.GotoBed suivant d'un LayDownCustomFood
if (this.TargetThingA is Building_Bed)
{
Building_Bed pod = (Building_Bed)this.TargetThingA;
yield return(Toils_Bed.GotoBed(TargetIndex.A));
//yield return Toils_Goto.GotoCell(TargetIndex.A, PathEndMode.OnCell);
yield return(Toils_LayDownPower.LayDown(TargetIndex.A, true, false, false, true));
}
else
{
Toil gotoCell = Toils_Goto.GotoCell(TargetIndex.A, PathEndMode.OnCell);
Toil nothing = new Toil();
yield return(gotoCell);
Toil setSkin = new Toil();
setSkin.initAction = delegate
{
pawn.Rotation = Rot4.South;
};
yield return(setSkin);
yield return(nothing);
yield return(Toils_General.Wait(50));
yield return(Toils_Jump.JumpIf(nothing, () => this.pawn.needs.food.CurLevelPercentage < 1.0f &&
!this.job.targetB.ThingDestroyed && !((Building)this.job.targetB).IsBrokenDown() &&
((Building)this.job.targetB).TryGetComp <CompPowerTrader>().PowerOn));
}
}
protected override IEnumerable <Toil> MakeNewToils()
{
this.FailOnDespawnedNullOrForbidden(TargetIndex.A);
Toil getNextIngredient = Toils_General.Label();
yield return(getNextIngredient);
yield return(Toils_JobTransforms.ExtractNextTargetFromQueue(TargetIndex.B));
yield return(Toils_Goto.GotoThing(TargetIndex.B, PathEndMode.ClosestTouch).FailOnDespawnedNullOrForbidden(TargetIndex.B).FailOnSomeonePhysicallyInteracting(TargetIndex.B));
yield return(Toils_Haul.StartCarryThing(TargetIndex.B, putRemainderInQueue: false, subtractNumTakenFromJobCount: true).FailOnDestroyedNullOrForbidden(TargetIndex.B));
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch));
Toil findPlaceTarget = Toils_JobTransforms.SetTargetToIngredientPlaceCell(TargetIndex.A, TargetIndex.B, TargetIndex.C);
yield return(findPlaceTarget);
yield return(PlaceHauledThingInCell(TargetIndex.C, findPlaceTarget, storageMode: false));
yield return(Toils_Jump.JumpIf(getNextIngredient, () => !job.GetTargetQueue(TargetIndex.B).NullOrEmpty()));
yield return(Toils_General.Wait(240).FailOnDestroyedNullOrForbidden(TargetIndex.A).FailOnCannotTouch(TargetIndex.A, PathEndMode.Touch)
.WithProgressBarToilDelay(TargetIndex.A));
yield return(Finalize(TargetIndex.A, TargetIndex.B));
}
protected override IEnumerable <Toil> MakeNewToils()
{
this.FailOnDestroyedOrNull(CorpseInd);
Toil gotoCorpse = Toils_Goto.GotoThing(CorpseInd, PathEndMode.Touch).FailOnDespawnedOrNull(CorpseInd);
yield return(Toils_Jump.JumpIfTargetInvalid(GraveInd, gotoCorpse));
yield return(Toils_Goto.GotoThing(GraveInd, PathEndMode.InteractionCell).FailOnDespawnedOrNull(GraveInd));
yield return(Toils_General.Wait(300).WithProgressBarToilDelay(GraveInd, false, -0.5f).FailOnDespawnedOrNull(GraveInd).FailOnCannotTouch(GraveInd, PathEndMode.InteractionCell));
yield return(Toils_General.Open(GraveInd));
yield return(Toils_Reserve.Reserve(CorpseInd, 1, -1, null));
yield return(gotoCorpse);
yield return(Toils_Haul.StartCarryThing(CorpseInd, false, false, false));
yield return(this.FindCellToDropCorpseToil());
yield return(Toils_Reserve.Reserve(CellInd, 1, -1, null));
yield return(Toils_Goto.GotoCell(CellInd, PathEndMode.Touch));
yield return(Toils_Haul.PlaceHauledThingInCell(CellInd, null, false));
foreach (Toil t in this.Nibble())
{
yield return(t);
}
yield return(this.Forbid());
}
protected override IEnumerable <Toil> MakeNewToils()
{
this.FailOnDestroyedOrNull(TargetIndex.A);
Toil gotoCorpse = Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch).FailOnDespawnedOrNull(TargetIndex.A);
yield return(Toils_Jump.JumpIfTargetInvalid(TargetIndex.B, gotoCorpse));
yield return(Toils_Goto.GotoThing(TargetIndex.B, PathEndMode.InteractionCell).FailOnDespawnedOrNull(TargetIndex.B));
yield return(Toils_General.Wait(300, TargetIndex.None).WithProgressBarToilDelay(TargetIndex.B, false, -0.5f).FailOnDespawnedOrNull(TargetIndex.B).FailOnCannotTouch(TargetIndex.B, PathEndMode.InteractionCell));
yield return(Toils_General.Open(TargetIndex.B));
yield return(Toils_Reserve.Reserve(TargetIndex.A, 1, -1, null));
yield return(gotoCorpse);
yield return(Toils_Haul.StartCarryThing(TargetIndex.A, false, false, false));
yield return(this.FindCellToDropCorpseToil());
yield return(Toils_Reserve.Reserve(TargetIndex.C, 1, -1, null));
yield return(Toils_Goto.GotoCell(TargetIndex.C, PathEndMode.Touch));
yield return(Toils_Haul.PlaceHauledThingInCell(TargetIndex.C, null, false));
yield return(this.ForbidAndNotifyMentalStateToil());
yield break;
}
protected override IEnumerable <Toil> MakeNewToils()
{
var wait = Toils_General.Wait(50, TargetIndex.A).FailOnNotDiningQueued(TargetIndex.A);
//this.FailOnNotDining(TargetIndex.A);
this.FailOnDestroyedOrNull(TargetIndex.B);
this.FailOnForbidden(TargetIndex.B);
yield return(Toils_Goto.GotoThing(TargetIndex.B, PathEndMode.ClosestTouch));
yield return(Toils_Haul.StartCarryThing(TargetIndex.B));
yield return(Toils_Waiting.UpdateOrderConsumableTo(TargetIndex.A, TargetIndex.B));
yield return(Toils_Waiting.FindRandomAdjacentCell(TargetIndex.A, TargetIndex.C)); // A is the patron, C is the spot
yield return(Toils_Haul.CarryHauledThingToCell(TargetIndex.C));
yield return(wait);
yield return(Toils_Jump.JumpIf(wait, () => pawn.jobs.curJob?.GetTarget(TargetIndex.A).Pawn?.GetDriver <JobDriver_Dine>() == null)); // Driver not available
yield return(Toils_Waiting.GetDiningSpot(TargetIndex.A, TargetIndex.C));
yield return(Toils_Haul.CarryHauledThingToCell(TargetIndex.C));
yield return(Toils_Jump.JumpIf(wait, () => pawn.jobs.curJob?.GetTarget(TargetIndex.A).Pawn?.GetDriver <JobDriver_Dine>() == null)); // Driver not available
yield return(Toils_Waiting.ClearOrder(TargetIndex.A, TargetIndex.B));
yield return(Toils_Waiting.AnnounceServing(TargetIndex.A, TargetIndex.B));
}
protected override IEnumerable <Toil> MakeNewToils()
{
Apparel_Backpack backpack = CurJob.GetTarget(BackpackInd).Thing as Apparel_Backpack;
// no free slots
this.FailOn(() => backpack.slotsComp.slots.Count >= backpack.MaxItem);
// reserve resources
yield return(Toils_Reserve.ReserveQueue(HaulableInd));
// extract next target thing from targetQueue
Toil toilExtractNextTarget = Toils_JobTransforms.ExtractNextTargetFromQueue(HaulableInd);
yield return(toilExtractNextTarget);
Toil toilGoToThing = Toils_Goto.GotoThing(HaulableInd, PathEndMode.ClosestTouch)
.FailOnDespawnedOrNull(HaulableInd);
yield return(toilGoToThing);
Toil pickUpThingIntoSlot = new Toil
{
initAction = () =>
{
if (!backpack.slotsComp.slots.TryAdd(CurJob.targetA.Thing))
{
EndJobWith(JobCondition.Incompletable);
}
}
};
yield return(pickUpThingIntoSlot);
yield return(Toils_Jump.JumpIfHaveTargetInQueue(HaulableInd, toilExtractNextTarget));
}
protected override IEnumerable <Toil> MakeNewToils()
{
CompEatWeirdFood comp = pawn.TryGetComp <CompEatWeirdFood>();
if (comp == null)
{
yield break;
}
this.FailOn(() => this.IngestibleSource.Destroyed);
Toil chew = ChewAnything(this.pawn, 1f, TargetIndex.A, TargetIndex.B).FailOn((Toil x) => !this.IngestibleSource.Spawned && (this.pawn.carryTracker == null || this.pawn.carryTracker.CarriedThing != this.IngestibleSource)).FailOnCannotTouch(TargetIndex.A, PathEndMode.Touch);
foreach (Toil toil in this.PrepareToIngestToils(chew))
{
yield return(toil);
}
yield return(chew);
yield return(FinalizeIngestAnything(this.pawn, TargetIndex.A, comp));
yield return(Toils_Jump.JumpIf(chew, () => this.job.GetTarget(TargetIndex.A).Thing is Corpse && this.pawn.needs.food.CurLevelPercentage < 0.9f));
yield break;
}
protected override IEnumerable <Toil> MakeNewToils()
{
this.FailOnDespawnedNullOrForbidden(TargetIndex.A);
yield return(Toils_Reserve.Reserve(TargetIndex.A, 1));
var reserveSeeds = ReserveSeedsIfWillPlantWholeStack();
yield return(reserveSeeds);
yield return(Toils_Goto.GotoThing(TargetIndex.B, PathEndMode.ClosestTouch)
.FailOnDespawnedNullOrForbidden(TargetIndex.B)
.FailOnSomeonePhysicallyInteracting(TargetIndex.B));
yield return(Toils_Haul.StartCarryThing(TargetIndex.B, false, false)
.FailOnDestroyedNullOrForbidden(TargetIndex.B));
Toils_Haul.CheckForGetOpportunityDuplicate(reserveSeeds, TargetIndex.B, TargetIndex.None, false, null);
var toil = Toils_Goto.GotoCell(TargetIndex.A, PathEndMode.Touch);
yield return(toil);
yield return(SowSeedToil());
yield return(Toils_Reserve.Release(TargetIndex.A));
yield return(TryToSetAdditionalPlantingSite());
yield return(Toils_Reserve.Reserve(TargetIndex.A, 1));
yield return(Toils_Jump.Jump(toil));
}
private IEnumerable <Toil> FeedToils()
{
Toil toil = new Toil();
toil.initAction = delegate
{
feedNutritionLeft = RequiredNutritionPerFeed(Animal);
};
toil.defaultCompleteMode = ToilCompleteMode.Instant;
yield return(toil);
Toil gotoAnimal = Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch);
yield return(gotoAnimal);
yield return(StartFeedAnimal(TargetIndex.A));
yield return(Toils_Ingest.FinalizeIngest(Animal, TargetIndex.B));
yield return(Toils_General.PutCarriedThingInInventory());
yield return(Toils_General.ClearTarget(TargetIndex.B));
yield return(Toils_Jump.JumpIf(gotoAnimal, () => feedNutritionLeft > 0f));
}
// Token: 0x0600000A RID: 10 RVA: 0x000029D9 File Offset: 0x00000BD9
protected override IEnumerable <Toil> MakeNewToils()
{
this.FailOn(delegate
{
if (job.ignoreDesignations)
{
return(false);
}
var victim = Victim;
if (victim != null && !victim.Dead &&
Map.designationManager.DesignationOn(victim, DesignationDefOf.Hunt) == null)
{
return(true);
}
return(false);
});
yield return(new Toil
{
initAction = delegate { jobStartTick = Find.TickManager.TicksGame; }
});
yield return(Toils_Combat.TrySetJobToUseAttackVerb(TargetIndex.A));
var startCollectCorpse = StartCollectCorpseToil();
var gotoCastPos = MarvsGotoCastPosition(TargetIndex.A, true)
.JumpIfDespawnedOrNull(TargetIndex.A, startCollectCorpse)
.FailOn(() => Find.TickManager.TicksGame > jobStartTick + 5000);
yield return(gotoCastPos);
var moveIfCannotHit = MarvsJumpIfTargetNotHittable(TargetIndex.A, gotoCastPos);
yield return(moveIfCannotHit);
yield return(MarvsJumpIfTargetDownedDistant(TargetIndex.A, gotoCastPos));
yield return(Toils_Combat.CastVerb(TargetIndex.A, false)
.JumpIfDespawnedOrNull(TargetIndex.A, startCollectCorpse)
.FailOn(() => Find.TickManager.TicksGame > jobStartTick + 5000));
yield return(Toils_Jump.JumpIfTargetDespawnedOrNull(TargetIndex.A, startCollectCorpse));
yield return(Toils_Jump.Jump(moveIfCannotHit));
yield return(startCollectCorpse);
yield return(Toils_Goto.GotoCell(TargetIndex.A, PathEndMode.ClosestTouch)
.FailOnDespawnedNullOrForbidden(TargetIndex.A).FailOnSomeonePhysicallyInteracting(TargetIndex.A));
yield return(Toils_Haul.StartCarryThing(TargetIndex.A));
var carryToCell = Toils_Haul.CarryHauledThingToCell(TargetIndex.B);
yield return(carryToCell);
yield return(Toils_Haul.PlaceHauledThingInCell(TargetIndex.B, carryToCell, true));
}
public static IEnumerable <Toil> MakeNewToils(IEnumerable <Toil> __result, JobDriver_Hunt __instance)
{
var list = __result.ToList();
var setVerb = list[1];
list.Insert(4, Toils_Jump.JumpIf(setVerb, () => !__instance.job.verbToUse.Available()));
return(list);
}
protected override IEnumerable <Toil> MakeNewToils()
{
this.FailOnDestroyedOrNull(TargetIndex.A);
Toil gotoCorpse = Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch).FailOnDespawnedOrNull(TargetIndex.A);
yield return(Toils_Jump.JumpIfTargetInvalid(TargetIndex.B, gotoCorpse));
/*Error: Unable to find new state assignment for yield return*/;
}
protected override IEnumerable <Toil> MakeNewToils()
{
this.FailOn(() => Patient == null || Medicine == null);
this.FailOnDespawnedNullOrForbidden(TargetIndex.A);
this.FailOnDestroyedNullOrForbidden(TargetIndex.B);
this.FailOnNotDowned(TargetIndex.A);
this.AddEndCondition(delegate
{
if (Patient.health.hediffSet.GetHediffsTendable().Any(h => h.CanBeStabilized()))
{
return(JobCondition.Ongoing);
}
Medicine.Destroy();
return(JobCondition.Incompletable);
});
// Pick up medicine and haul to patient
yield return(Toils_Reserve.Reserve(TargetIndex.A));
yield return(Toils_Reserve.Reserve(TargetIndex.B));
yield return(Toils_Goto.GotoThing(TargetIndex.B, PathEndMode.ClosestTouch));
yield return(Toils_Haul.StartCarryThing(TargetIndex.B));
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.InteractionCell));
yield return(Toils_Haul.PlaceHauledThingInCell(TargetIndex.A, null, false));
// Stabilize patient
int duration = (int)(1f / this.pawn.GetStatValue(StatDefOf.MedicalTendSpeed, true) * baseTendDuration);
Toil waitToil = Toils_General.Wait(duration).WithProgressBarToilDelay(TargetIndex.A).PlaySustainerOrSound(SoundDefOf.Interact_Tend);
yield return(waitToil);
Toil stabilizeToil = new Toil();
stabilizeToil.initAction = delegate
{
float xp = (!Patient.RaceProps.Animal) ? 125f : 50f * Medicine.def.MedicineTendXpGainFactor;
pawn.skills.Learn(SkillDefOf.Medicine, xp);
foreach (Hediff curInjury in from x in Patient.health.hediffSet.GetHediffsTendable() orderby x.BleedRate descending select x)
{
if (curInjury.CanBeStabilized())
{
HediffComp_Stabilize comp = curInjury.TryGetComp <HediffComp_Stabilize>();
comp.Stabilize(pawn, Medicine);
break;
}
}
};
stabilizeToil.defaultCompleteMode = ToilCompleteMode.Instant;
yield return(stabilizeToil);
yield return(Toils_Jump.Jump(waitToil));
}
private IEnumerable <Toil> PrepareToIngestToils_ToolUser(Toil chewToil)
{
if (eatingFromInventory)
{
yield return(Toils_Misc.TakeItemFromInventoryToCarrier(pawn, TargetIndex.A));
}
else
{
yield return(ReserveFoodIfWillIngestWholeStack());
Toil gotoToPickup = Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.ClosestTouch).FailOnDespawnedNullOrForbidden(TargetIndex.A);
yield return(Toils_Jump.JumpIf(gotoToPickup, () => pawn.health.capacities.CapableOf(PawnCapacityDefOf.Manipulation)));
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch).FailOnDespawnedNullOrForbidden(TargetIndex.A));
yield return(Toils_Jump.Jump(chewToil));
yield return(gotoToPickup);
yield return(Toils_Ingest.PickupIngestible(TargetIndex.A, pawn));
Toil reserveExtraFoodToCollect = Toils_Reserve.Reserve(TargetIndex.C);
Toil findExtraFoodToCollect = new Toil();
findExtraFoodToCollect.initAction = delegate
{
if (pawn.inventory.innerContainer.TotalStackCountOfDef(IngestibleSource.def) < job.takeExtraIngestibles)
{
Predicate <Thing> validator = (Thing x) => pawn.CanReserve(x) &&
!x.IsForbidden(pawn) && x.IsSociallyProper(pawn);
Thing thing = GenClosest.ClosestThingReachable(pawn.Position, pawn.Map,
ThingRequest.ForDef(IngestibleSource.def), PathEndMode.Touch,
TraverseParms.For(pawn),
12f, validator);
if (thing != null)
{
pawn.CurJob.SetTarget(TargetIndex.C, thing);
JumpToToil(reserveExtraFoodToCollect);
}
}
};
findExtraFoodToCollect.defaultCompleteMode = ToilCompleteMode.Instant;
yield return(Toils_Jump.Jump(findExtraFoodToCollect));
yield return(reserveExtraFoodToCollect);
yield return(Toils_Goto.GotoThing(TargetIndex.C, PathEndMode.Touch));
yield return(Toils_Haul.TakeToInventory(TargetIndex.C,
() => job.takeExtraIngestibles - pawn.inventory.innerContainer.TotalStackCountOfDef(IngestibleSource.def)));
yield return(findExtraFoodToCollect);
}
yield return(Toils_Ingest.CarryIngestibleToChewSpot(pawn, TargetIndex.A).FailOnDestroyedOrNull(TargetIndex.A));
yield return(Toils_Ingest.FindAdjacentEatSurface(TargetIndex.B, TargetIndex.A));
}
protected override IEnumerable <Toil> MakeNewToils()
{
Toil waitLabel = Toils_General.Label();
Toil endLabel = Toils_General.Label();
yield return(Toils_Combat.TrySetJobToUseAttackVerb(TargetIndex.A));
Toil approach = new Toil();
approach.initAction = delegate
{
Job curJob = pawn.jobs.curJob;
if (pawn == Victim || Victim == null)
{
pawn.pather.StopDead();
ReadyForNextToil();
}
else
{
CastPositionRequest newReq = default(CastPositionRequest);
newReq.caster = pawn;
newReq.target = Victim;
newReq.verb = curJob.verbToUse;
newReq.maxRangeFromTarget = (!Victim.Downed ? Mathf.Max(curJob.verbToUse.verbProps.range * maxRangeFactor, 1.42f) : Mathf.Min(curJob.verbToUse.verbProps.range, Victim.RaceProps.executionRange));
newReq.wantCoverFromTarget = false;
if (CastPositionFinder.TryFindCastPosition(newReq, out var dest))
{
pawn.pather.StartPath(dest, PathEndMode.OnCell);
pawn.Map.pawnDestinationReservationManager.Reserve(pawn, curJob, dest);
}
//else if (pawn.PositionHeld.DistanceTo(Victim.PositionHeld) <= waitRange)
//{
// pawn.pather.StopDead();
// pawn.jobs.curDriver.JumpToToil(waitLabel);
//}
else
{
pawn.pather.StartPath(Victim, PathEndMode.Touch);
}
}
};
approach.FailOnDespawnedOrNull(VictimIndex);
approach.defaultCompleteMode = ToilCompleteMode.Delay;
approach.defaultDuration = 60;
yield return(approach);
yield return(Toils_Jump.Jump(endLabel));
yield return(waitLabel);
yield return(Toils_General.Wait(60));
yield return(endLabel);
}
protected override IEnumerable <Toil> MakeNewToils()
{
AddEndCondition(delegate
{
Thing thing = GetActor().jobs.curJob.GetTarget(TargetIndex.A).Thing;
if (thing is Building && !thing.Spawned)
{
return(JobCondition.Incompletable);
}
return(JobCondition.Ongoing);
});
this.FailOnBurningImmobile(TargetIndex.A);
this.FailOn(IsDeletedOrNotUsableForBills);
// Copied from JobDriver_DoBill (removed a few things that were not needed for dissecton)
Toil gotoBillGiver = Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.InteractionCell);
yield return(Toils_Jump.JumpIf(gotoBillGiver, () => job.GetTargetQueue(TargetIndex.B).NullOrEmpty()));
Toil extract = Toils_JobTransforms.ExtractNextTargetFromQueue(TargetIndex.B, true);
yield return(extract);
Toil getToHaulTarget = Toils_Goto.GotoThing(TargetIndex.B, PathEndMode.ClosestTouch).FailOnDespawnedNullOrForbidden(TargetIndex.B).FailOnSomeonePhysicallyInteracting(TargetIndex.B);
yield return(getToHaulTarget);
yield return(Toils_Haul.StartCarryThing(TargetIndex.B, true, false, true));
yield return(Toils_Dissection.JumpToCollectNextIntoHandsForBill(getToHaulTarget, TargetIndex.B));
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.InteractionCell).FailOnDestroyedOrNull(TargetIndex.B));
Toil findPlaceTarget = Toils_JobTransforms.SetTargetToIngredientPlaceCell(TargetIndex.A, TargetIndex.B, TargetIndex.C);
yield return(findPlaceTarget);
yield return(Toils_Dissection.PlaceHauledThingInCell(TargetIndex.C, findPlaceTarget, false));
yield return(Toils_Jump.JumpIfHaveTargetInQueue(TargetIndex.B, extract));
yield return(gotoBillGiver);
// Strip body
Toil doDissectionRecipeWork = Toils_Dissection.DoDissectionRecipeWork().FailOnDespawnedNullOrForbiddenPlacedThings().FailOnCannotTouch(TargetIndex.A, PathEndMode.InteractionCell);
yield return(Toils_Jump.JumpIf(doDissectionRecipeWork, () =>
{
LocalTargetInfo targetInfo = job.GetTarget(TargetIndex.B);
if (targetInfo.HasThing)
{
return !(targetInfo.Thing is Corpse corpse) || !corpse.AnythingToStrip();
}
protected override IEnumerable <Toil> MakeNewToils()
{
this.EndOnDespawnedOrNull(TargetIndex.A);
Toil chooseCell = Toils_Wrestling.FindRandomInsideReachableCell(TargetIndex.A, TargetIndex.B);
yield return(chooseCell);
yield return(Toils_Reserve.Reserve(TargetIndex.B));
yield return(Toils_Goto.GotoCell(TargetIndex.B, PathEndMode.OnCell));
Toil toil = new Toil();
toil.initAction = delegate
{
job.locomotionUrgency = LocomotionUrgency.Jog;
};
toil.tickAction = delegate
{
pawn.rotationTracker.FaceCell(base.TargetA.Thing.OccupiedRect().CenterCell);
if (ticksLeftThisToil == 150)
{
Random random = new System.Random();
if (random.NextDouble() > 0.7)
{
SoundDefOf.Corpse_Drop.PlayOneShot(new TargetInfo(pawn.Position, pawn.Map));
}
else
{
SoundDefOf.Pawn_Melee_Punch_HitPawn.PlayOneShot(new TargetInfo(pawn.Position, pawn.Map));
}
}
if (Find.TickManager.TicksGame > startTick + job.def.joyDuration)
{
EndJobWith(JobCondition.Succeeded);
}
else
{
JoyUtility.JoyTickCheckEnd(pawn, JoyTickFullJoyAction.EndJob, 1f, (Building)base.TargetThingA);
}
};
toil.handlingFacing = true;
toil.socialMode = RandomSocialMode.SuperActive;
toil.defaultCompleteMode = ToilCompleteMode.Delay;
toil.defaultDuration = MoveDuration;
toil.AddFinishAction(delegate
{
JoyUtility.TryGainRecRoomThought(pawn);
});
yield return(toil);
yield return(Toils_Reserve.Release(TargetIndex.B));
yield return(Toils_Jump.Jump(chooseCell));
}
protected override IEnumerable <Toil> MakeNewToils()
{
this.FailOnDespawnedNullOrForbidden(TargetIndex.A);
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.InteractionCell));
var manage = Manage(TargetIndex.A);
yield return(manage);
// if made to by player, keep doing that untill we're out of jobs
yield return(Toils_Jump.JumpIf(manage, () => GetActor().CurJob.playerForced&& Manager.For(Map).JobStack.NextJob != null));
}
