protected override IEnumerable <Toil> MakeNewToils() { this.FailOnDestroyedOrNull(TargetIndex.A); this.FailOnBurningImmobile(TargetIndex.B); this.FailOnDowned(TargetIndex.A); this.FailOnAggroMentalState(TargetIndex.A); yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.ClosestTouch).FailOn(() => !Prisoner.IsPrisonerOfColony || !Prisoner.guest.PrisonerIsSecure).FailOnSomeonePhysicallyInteracting(TargetIndex.A)); yield return(Toils_Haul.StartCarryThing(TargetIndex.A, false, false, false)); Toil carryToCell = Toils_Haul.CarryHauledThingToCell(TargetIndex.B); yield return(carryToCell); yield return(Toils_Haul.PlaceHauledThingInCell(TargetIndex.B, carryToCell, false)); Toil setupIrradiation = new Toil() { initAction = delegate() { pawn.ClearReservationsForJob(job); Job prisonerJob = new Job(JobDefOf.RadiologyIrradiate, Chamber, 1500, true); Prisoner.jobs.StartJob(prisonerJob); } }; yield return(setupIrradiation); yield break; }
// Token: 0x0600012B RID: 299 RVA: 0x0000C0A4 File Offset: 0x0000A4A4 protected override IEnumerable <Toil> MakeNewToils() { yield return(Toils_Reserve.Reserve((Verse.AI.TargetIndex) 1, 1, -1, null)); yield return(Toils_Reserve.Reserve((Verse.AI.TargetIndex) 2, 1, -1, null)); yield return(Toils_Goto.GotoThing((Verse.AI.TargetIndex) 1, (Verse.AI.PathEndMode) 3)); yield return(Toils_Haul.StartCarryThing((Verse.AI.TargetIndex) 1, false, false)); yield return(Toils_Haul.CarryHauledThingToCell((Verse.AI.TargetIndex) 2)); Toil t2 = Toils_General.Wait(1000); t2.AddFailCondition(() => !this.Emitter.GetComp <CompPowerTrader>().PowerOn); t2 = ToilEffects.WithProgressBar(t2, (Verse.AI.TargetIndex) 1, () => (1000f - (float)this.ticksLeftThisToil) / 1000f, false, -0.5f); yield return(t2); yield return(new Toil { defaultCompleteMode = (Verse.AI.ToilCompleteMode) 1, initAction = delegate() { this.Emitter.GetComp <CompHoloEmitter>().Scan(this.Corpse); } }); yield return(Toils_Reserve.Release((Verse.AI.TargetIndex) 2)); yield break; }
protected override IEnumerable <Toil> MakeNewToils() { // Set up fail conditions this.FailOn(delegate { return(Quarry == null || Quarry.IsForbidden(pawn) || Quarry.Depleted); }); // Go to the quarry yield return(Toils_Goto.Goto(CellInd, PathEndMode.OnCell)); // Mine at the quarry. This is only for the delay yield return(Mine()); // Collect resources from the quarry yield return(Collect()); // Reserve the resource yield return(Toils_Reserve.Reserve(TargetIndex.B)); // Reserve the storage cell yield return(Toils_Reserve.Reserve(TargetIndex.C)); // Go to the resource yield return(Toils_Goto.GotoThing(TargetIndex.B, PathEndMode.ClosestTouch)); // Pick up the resource yield return(Toils_Haul.StartCarryThing(TargetIndex.B)); // Carry the resource to the storage cell, then place it down Toil carry = Toils_Haul.CarryHauledThingToCell(TargetIndex.C); yield return(carry); yield return(Toils_Haul.PlaceHauledThingInCell(TargetIndex.C, carry, true)); }
protected override IEnumerable <Toil> MakeNewToils() { this.FailOnDestroyedOrNull(TargetIndex.A); this.FailOnBurningImmobile(TargetIndex.B); this.FailOn(() => ((Pawn)((Thing)GetActor().CurJob.GetTarget(TargetIndex.A))).guest.interactionMode != PrisonerInteractionModeDefOf.Release); this.FailOnDowned(TargetIndex.A); this.FailOnAggroMentalState(TargetIndex.A); yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.ClosestTouch).FailOn(() => !Prisoner.IsPrisonerOfColony || !Prisoner.guest.PrisonerIsSecure).FailOnSomeonePhysicallyInteracting(TargetIndex.A)); yield return(Toils_Haul.StartCarryThing(TargetIndex.A, false, false, false)); Toil carryToCell = Toils_Haul.CarryHauledThingToCell(TargetIndex.B); yield return(carryToCell); yield return(Toils_Haul.PlaceHauledThingInCell(TargetIndex.B, carryToCell, false)); Toil setReleased = new Toil(); setReleased.initAction = delegate { Pawn actor = setReleased.actor; Job curJob = actor.jobs.curJob; Pawn p = curJob.targetA.Thing as Pawn; GenGuest.PrisonerRelease(p); }; yield return(setReleased); }
protected override IEnumerable <Toil> MakeNewToils() { yield return(Toils_Reserve.Reserve(TargetIndex.A, 1, -1, null)); yield return(Toils_Reserve.Reserve(TargetIndex.B, 1, -1, null)); yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.ClosestTouch)); yield return(Toils_Haul.StartCarryThing(TargetIndex.A, false, false)); yield return(Toils_Haul.CarryHauledThingToCell(TargetIndex.B)); Toil t2 = Toils_General.Wait(1000); t2.AddFailCondition(() => !this.Emitter.GetComp <CompPowerTrader>().PowerOn); t2 = t2.WithProgressBar(TargetIndex.A, () => (1000f - (float)this.ticksLeftThisToil) / 1000f, false, -0.5f); yield return(t2); yield return(new Toil { defaultCompleteMode = ToilCompleteMode.Instant, initAction = delegate() { Pawn simPawn = this.MakeGeniusPawn(); this.Emitter.GetComp <CompHoloEmitter>().SimPawn = simPawn; this.Emitter.GetComp <CompHoloEmitter>().SetUpPawn(); this.Disk.Destroy(DestroyMode.Vanish); } }); yield return(Toils_Reserve.Release(TargetIndex.B)); yield break; }
// Token: 0x0600003D RID: 61 RVA: 0x0000347A File Offset: 0x0000167A protected override IEnumerable <Toil> MakeNewToils() { yield return(Toils_Goto.GotoThing(TargetIndex.B, PathEndMode.ClosestTouch)); yield return(Toils_Haul.StartCarryThing(TargetIndex.B, false, false, false)); yield return(Toils_Haul.CarryHauledThingToCell(TargetIndex.A)); yield return(new Toil { initAction = delegate() { Venue.rehearsing = true; CompArt compArt = Art.TryGetComp <CompArt>(); CompQuality compQuality = Art.TryGetComp <CompQuality>(); if (compArt != null && compQuality != null) { Venue.artistName = compArt.AuthorName; Venue.artTitle = compArt.Title; Venue.artQuality = compQuality.Quality; } Art.Destroy(DestroyMode.Vanish); }, defaultCompleteMode = ToilCompleteMode.Instant }); yield break; }
protected override IEnumerable <Toil> MakeNewToils() { yield return(Toils_Reserve.Reserve(TargetIndex.A, 1, 1, null)); yield return(Toils_Reserve.Reserve(TargetIndex.B, 1, 1, null)); yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.ClosestTouch)); yield return(Toils_Haul.StartCarryThing(TargetIndex.A, false, false)); yield return(Toils_Haul.CarryHauledThingToCell(TargetIndex.B)); yield return(Toils_General.Wait(1500).WithProgressBar(TargetIndex.B, () => 1f - 1f * (float)this.ticksLeftThisToil / 1500f, false, -0.5f)); yield return(new Toil { defaultCompleteMode = ToilCompleteMode.Instant, initAction = delegate() { DamageInfo value = new DamageInfo(DamageDefOf.ExecutionCut, 500, -1f, -1f, base.GetActor(), null, null, 0); this.Animal.Kill(new DamageInfo?(value)); this.Altar.GetComp <CompPsionicEmanator>().DoPsychicShockwave(); } }); yield return(Toils_Reserve.Release(TargetIndex.B)); 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() { Building_AquacultureBasin aquacultureBasin = this.TargetThingA as Building_AquacultureBasin; yield return(Toils_Goto.GotoThing(aquacultureBasinIndex, PathEndMode.InteractionCell)); yield return(Toils_General.Wait(120).WithProgressBarToilDelay(aquacultureBasinIndex)); Toil getAquacultureBasinProduction = new Toil() { initAction = () => { Job curJob = this.pawn.jobs.curJob; Thing product = aquacultureBasin.GetProduction(); if (product == null) { this.pawn.jobs.EndCurrentJob(JobCondition.Succeeded); } else { while (product.stackCount > product.def.stackLimit) { Thing meatStack = ThingMaker.MakeThing(product.def); meatStack.stackCount = product.def.stackLimit; GenPlace.TryPlaceThing(meatStack, this.GetActor().Position, this.Map, ThingPlaceMode.Near); product.stackCount -= product.def.stackLimit; } GenSpawn.Spawn(product, aquacultureBasin.InteractionCell, this.Map); IntVec3 storageCell; if (StoreUtility.TryFindBestBetterStoreCellFor(product, this.pawn, this.Map, StoragePriority.Unstored, this.pawn.Faction, out storageCell, true)) { this.pawn.Reserve(product, this.job); this.pawn.Reserve(storageCell, this.job, 1); this.pawn.CurJob.SetTarget(TargetIndex.B, storageCell); this.pawn.CurJob.SetTarget(TargetIndex.A, product); this.pawn.CurJob.count = 99999; this.pawn.CurJob.haulMode = HaulMode.ToCellStorage; } else { this.pawn.jobs.EndCurrentJob(JobCondition.Succeeded); } } } }; yield return(getAquacultureBasinProduction); yield return(Toils_Reserve.Release(aquacultureBasinIndex)); yield return(Toils_Haul.StartCarryThing(TargetIndex.A)); Toil carryToCell = Toils_Haul.CarryHauledThingToCell(TargetIndex.B); yield return(carryToCell); yield return(Toils_Haul.PlaceHauledThingInCell(TargetIndex.B, carryToCell, true)); }
protected override IEnumerable <Toil> MakeNewToils() { this.FailOnDestroyedNullOrForbidden(tableTI); this.FailOnBurningImmobile(objectTI); this.FailOnDestroyedNullOrForbidden(objectTI); this.FailOnBurningImmobile(objectTI); yield return(Toils_Reserve.Reserve(tableTI)); yield return(Toils_Reserve.Reserve(objectTI)); yield return(Toils_Goto.GotoThing(objectTI, PathEndMode.Touch)); yield return(Toils_Haul.StartCarryThing(objectTI)); yield return(Toils_Goto.GotoThing(tableTI, PathEndMode.InteractionCell)); yield return(Toils_Haul.PlaceHauledThingInCell(tableTI, null, false)); yield return(DoBill()); yield return(Store()); yield return(Toils_Reserve.Reserve(haulTI)); yield return(Toils_Haul.CarryHauledThingToCell(haulTI)); yield return(Toils_Haul.PlaceHauledThingInCell(haulTI, null, false)); yield return(Toils_Reserve.Release(objectTI)); yield return(Toils_Reserve.Release(haulTI)); yield return(Toils_Reserve.Release(tableTI)); }
// Token: 0x06000053 RID: 83 RVA: 0x00004200 File Offset: 0x00002400 protected override IEnumerable <Toil> MakeNewToils() { this.FailOnDespawnedNullOrForbidden(TargetIndex.A); yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch)); yield return(Toils_General.Wait(600, TargetIndex.None).FailOnDestroyedNullOrForbidden(TargetIndex.A).FailOnCannotTouch(TargetIndex.A, PathEndMode.Touch).WithProgressBarToilDelay(TargetIndex.A, false, -0.5f)); yield return(Toils_AQRemoving.FinalizeRemoving(TargetIndex.A)); yield return(Toils_Reserve.Reserve(TargetIndex.B, 1, -1, null)); yield return(Toils_Reserve.Reserve(TargetIndex.C, 1, -1, null)); yield return(Toils_Goto.GotoThing(TargetIndex.B, PathEndMode.ClosestTouch)); yield return(Toils_Haul.StartCarryThing(TargetIndex.B, false, false, false)); Toil carry = Toils_Haul.CarryHauledThingToCell(TargetIndex.C); yield return(carry); yield return(Toils_Haul.PlaceHauledThingInCell(TargetIndex.C, carry, true, false)); yield break; }
protected override IEnumerable <Toil> MakeNewToils() { this.FailOnDestroyedOrNull(TargetIndex.A); yield return(Toils_General.Wait(this.duration, TargetIndex.None).WithProgressBarToilDelay(TargetIndex.A, false, -0.5f)); yield return(Toils_General.Do(delegate { if (this.pawn.apparel.WornApparel.Contains(this.Apparel)) { Apparel apparel; if (this.pawn.apparel.TryDrop(this.Apparel, out apparel)) { this.job.targetA = apparel; if (this.job.haulDroppedApparel) { apparel.SetForbidden(false, false); StoragePriority currentPriority = StoreUtility.CurrentStoragePriorityOf(apparel); IntVec3 c; if (StoreUtility.TryFindBestBetterStoreCellFor(apparel, this.pawn, base.Map, currentPriority, this.pawn.Faction, out c, true)) { this.job.count = apparel.stackCount; this.job.targetB = c; } else { base.EndJobWith(JobCondition.Incompletable); } } else { base.EndJobWith(JobCondition.Succeeded); } } else { base.EndJobWith(JobCondition.Incompletable); } } else { base.EndJobWith(JobCondition.Incompletable); } })); if (this.job.haulDroppedApparel) { yield return(Toils_Reserve.Reserve(TargetIndex.B, 1, -1, null)); yield return(Toils_Reserve.Reserve(TargetIndex.A, 1, -1, null)); yield return(Toils_Haul.StartCarryThing(TargetIndex.A, false, false, false).FailOn(() => !this.pawn.health.capacities.CapableOf(PawnCapacityDefOf.Manipulation))); Toil carryToCell = Toils_Haul.CarryHauledThingToCell(TargetIndex.B); yield return(carryToCell); yield return(Toils_Haul.PlaceHauledThingInCell(TargetIndex.B, carryToCell, true)); } yield break; }
// 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)); }
protected override IEnumerable <Toil> MakeNewToils() { this.FailOnDestroyedOrNull(TargetIndex.A); this.FailOnBurningImmobile(TargetIndex.B); if (!forbiddenInitially) { this.FailOnForbidden(TargetIndex.A); } Toil reserveTargetA = Toils_Reserve.Reserve(TargetIndex.A, 1, -1, null); yield return(reserveTargetA); Toil toilGoto = null; toilGoto = Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.ClosestTouch).FailOnSomeonePhysicallyInteracting(TargetIndex.A); toilGoto.AddFailCondition(delegate { Pawn actor = toilGoto.actor; Job curJob = actor.jobs.curJob; if (curJob.haulMode == HaulMode.ToCellStorage) { Thing thing = curJob.GetTarget(TargetIndex.A).Thing; IntVec3 cell = actor.jobs.curJob.GetTarget(TargetIndex.B).Cell; if (!cell.IsValidStorageFor(Map, thing)) { return(true); } } return(false); }); yield return(toilGoto); yield return(Toils_Haul.StartCarryThing(TargetIndex.A, false, true, false)); if (job.haulOpportunisticDuplicates) { yield return(Toils_Haul.CheckForGetOpportunityDuplicate(reserveTargetA, TargetIndex.A, TargetIndex.B, false, null)); } if (job.expiryInterval != -1) { yield return(CheckExpiry()); } Insect insect = toilGoto.actor as Insect; if (insect != null && insect.targetColonyFood) { yield return(ResetTargetColonyFoodFlag(insect)); } Toil carryToCell = Toils_Haul.CarryHauledThingToCell(TargetIndex.B); yield return(carryToCell); yield return(Toils_Haul.PlaceHauledThingInCell(TargetIndex.B, carryToCell, true)); if (insect != null && insect.stealFood) { yield return(ResetStealFoodFlag(insect)); } }
protected override IEnumerable <Toil> MakeNewToils() { Toil carryToCell = Toils_Haul.CarryHauledThingToCell(TargetIndex.A); yield return(carryToCell); yield return(Toils_Haul.PlaceHauledThingInCell(TargetIndex.A, carryToCell, true)); }
protected override IEnumerable <Toil> MakeNewToils() { this.FailOnDestroyedOrNull(TakeeIndex); this.FailOnDestroyedOrNull(AlterIndex); this.FailOnAggroMentalStateAndHostile(TakeeIndex); yield return(Toils_Goto.GotoThing(TakeeIndex, PathEndMode.ClosestTouch) .FailOnDespawnedNullOrForbidden(TakeeIndex) .FailOnDespawnedNullOrForbidden(AlterIndex) .FailOn(() => !pawn.CanReach(Alter, PathEndMode.OnCell, Danger.Deadly))); Toil toil2 = Toils_Haul.StartCarryThing(TakeeIndex); yield return(toil2); var carryToil = Toils_Haul.CarryHauledThingToCell(AlterIndex); yield return(carryToil); var eToil = Toils_Haul.PlaceHauledThingInCell(AlterIndex, carryToil, false); yield return(eToil); Toil toil4 = new Toil(); void DropTarget() { IntVec3 position = Alter.Position; pawn.carryTracker.TryDropCarriedThing(position, ThingPlaceMode.Direct, out Thing target); try { var pTarget = (Pawn)target; if (pTarget == null) { return; } var hediff = HediffMaker.MakeHediff(HediffDefOf.Anesthetic, pTarget); //hacky, but will stop the target from moving around pTarget.health.hediffSet.AddDirect(hediff); //now add the transformation hediff var tfHediff = HediffMaker.MakeHediff(PSHediffDefOf.SkavenRitualEffect, pTarget); pTarget.health.hediffSet.AddDirect(tfHediff); } catch (Exception e) { Log.Error($"caught {e.GetType().Name} while finishing TakeToAlter action!\n{e} "); } } toil4.initAction = DropTarget; toil4.defaultCompleteMode = ToilCompleteMode.Instant; yield return(toil4); }
protected override IEnumerable <Toil> MakeNewToils() { yield return(Toils_Reserve.Reserve(aquacultureBasinIndex)); Building_AquacultureBasin aquacultureBasin = this.TargetThingA as Building_AquacultureBasin; yield return(Toils_Goto.GotoThing(aquacultureBasinIndex, PathEndMode.InteractionCell)); yield return(Toils_General.Wait(120).WithProgressBarToilDelay(aquacultureBasinIndex)); Toil getAquacultureBasinProduction = new Toil() { initAction = () => { Job curJob = this.pawn.jobs.curJob; Thing product = aquacultureBasin.GetProduction(); if (product == null) { this.pawn.jobs.EndCurrentJob(JobCondition.Succeeded); } else { GenSpawn.Spawn(product, aquacultureBasin.InteractionCell, this.Map); IntVec3 storageCell; if (StoreUtility.TryFindBestBetterStoreCellFor(product, this.pawn, this.Map, StoragePriority.Unstored, this.pawn.Faction, out storageCell, true)) { this.pawn.carryTracker.TryStartCarry(product); curJob.targetB = storageCell; curJob.targetC = product; curJob.count = 99999; } else { this.pawn.jobs.EndCurrentJob(JobCondition.Succeeded); } } } }; yield return(getAquacultureBasinProduction); // Reserve the product and storage cell. yield return(Toils_Reserve.Reserve(TargetIndex.B)); yield return(Toils_Reserve.Reserve(TargetIndex.C)); yield return(Toils_Reserve.Release(aquacultureBasinIndex)); Toil carryToCell = Toils_Haul.CarryHauledThingToCell(TargetIndex.B); yield return(carryToCell); yield return(Toils_Haul.PlaceHauledThingInCell(TargetIndex.B, carryToCell, true)); }
protected override IEnumerable <Toil> MakeNewToils() { CompUniversalFermenter comp = Fermenter.TryGetComp <CompUniversalFermenter>(); // Verify fermenter and ingredient validity this.FailOn(() => comp.SpaceLeftForIngredient <= 0); this.FailOnDespawnedNullOrForbidden(FermenterInd); this.FailOnBurningImmobile(FermenterInd); this.FailOnDestroyedNullOrForbidden(IngredientInd); // Reserve resources // Creating the toil before yielding allows for CheckForGetOpportunityDuplicate Toil ingrToil = Toils_Reserve.Reserve(IngredientInd); yield return(ingrToil); // Reserve fermenter yield return(Toils_Reserve.Reserve(FermenterInd)); // Go to the ingredient yield return(Toils_Goto.GotoThing(IngredientInd, PathEndMode.ClosestTouch) .FailOnSomeonePhysicallyInteracting(IngredientInd) .FailOnDestroyedNullOrForbidden(IngredientInd)); // Haul the ingredients yield return(Toils_Haul.StartCarryThing(IngredientInd, false, true).FailOnDestroyedNullOrForbidden(IngredientInd)); yield return(Toils_Haul.CheckForGetOpportunityDuplicate(ingrToil, IngredientInd, TargetIndex.None, true)); // Carry ingredients to the fermenter yield return(Toils_Haul.CarryHauledThingToCell(FermenterInd)); // Add delay for adding ingredients to the fermenter yield return(Toils_General.Wait(Duration).FailOnDestroyedNullOrForbidden(FermenterInd).WithProgressBarToilDelay(FermenterInd)); // Use ingredients // The UniversalFermenter automatically destroys held ingredients Toil add = new Toil(); add.initAction = () => { if (!comp.AddIngredient(Ingredient)) { // The ingredient is not allowed, end the job EndJobWith(JobCondition.Incompletable); Log.Message("JobCondition.Incompletable"); } }; add.defaultCompleteMode = ToilCompleteMode.Instant; yield return(add); // End the current job yield break; }
protected override IEnumerable <Toil> MakeNewToils() { Pawn downedPawn = this.TargetThingA as Pawn; Toil gotoDownedPawnToil = Toils_Goto.GotoCell(downedPawnIndex, PathEndMode.OnCell).FailOn(delegate() { return(downedPawn.DestroyedOrNull() || (downedPawn.Downed == false)); }); yield return(gotoDownedPawnToil); yield return(Toils_Haul.StartCarryThing(downedPawnIndex)); Toil gotoTravelDestToil = Toils_Haul.CarryHauledThingToCell(travelDestCellIndex).FailOn(delegate() { return(this.pawn.carryTracker.CarriedThing.DestroyedOrNull() || (this.pawn.CanReach(this.pawn.jobs.curJob.targetB.Cell, PathEndMode.OnCell, Danger.Some) == false)); }); yield return(gotoTravelDestToil); Toil arrivedToil = new Toil() { initAction = () => { Building_Spaceship spaceship = null; List <Thing> thingList = this.pawn.Position.GetThingList(this.pawn.Map); foreach (Thing thing in thingList) { if (thing is Building_Spaceship) { spaceship = thing as Building_Spaceship; break; } } Thing carriedPawn = null; this.pawn.carryTracker.TryDropCarriedThing(this.pawn.Position, ThingPlaceMode.Near, out carriedPawn); if (spaceship != null) { spaceship.Notify_PawnBoarding(carriedPawn as Pawn, false); } else if (this.pawn.Position.CloseToEdge(this.pawn.Map, 5)) { carriedPawn.Destroy(); Util_Faction.AffectGoodwillWith(this.pawn.Faction, Faction.OfPlayer, LordJob_MiningCoBase.pawnExitedGoodwillImpact); } }, defaultCompleteMode = ToilCompleteMode.Instant }; yield return(arrivedToil); }
// Token: 0x06000373 RID: 883 RVA: 0x0001EF58 File Offset: 0x0001D358 protected override IEnumerable <Toil> MakeNewToils() { this.FailOnIncapable(PawnCapacityDefOf.Manipulation); yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.InteractionCell)); yield return(Toils_Haul.StartCarryThing(TargetIndex.A, false, true, false)); Toil carryToCell = Toils_Haul.CarryHauledThingToCell(TargetIndex.C); yield return(carryToCell); /* * yield return new Toil * { * initAction = delegate () * { * if (this.pawn.Position.OnEdge(this.pawn.Map) || this.pawn.Map.exitMapGrid.IsExitCell(this.pawn.Position)) * { * this.pawn.ExitMap(true, CellRect.WholeMap(base.Map).GetClosestEdge(this.pawn.Position)); * } * }, * defaultCompleteMode = ToilCompleteMode.Instant * }; */ // yield return Toils_Goto.GotoCell(TargetIndex.C, PathEndMode.OnCell); if (Takee == null || Takee.Dead) { yield break; } yield return(Toils_Haul.PlaceHauledThingInCell(TargetIndex.B, carryToCell, false)); Toil prepare = Toils_General.Wait(this.useDuration, TargetIndex.A); prepare.NPCWithProgressBarToilDelay(TargetIndex.A, false, -0.5f); prepare.FailOnDespawnedNullOrForbidden(TargetIndex.A); // prepare.FailOnCannotTouch(TargetIndex.A, PathEndMode.InteractionCell); prepare.WithEffect(EffecterDefOf.Vomit, TargetIndex.A); prepare.PlaySustainerOrSound(() => SoundDefOf.Vomit); yield return(prepare); Toil use = new Toil(); use.initAction = delegate() { Pawn actor = use.actor; Pawn Infectable = (Pawn)actor.CurJob.targetA.Thing; Infectable.health.AddHediff(heCocDeff); }; use.defaultCompleteMode = ToilCompleteMode.Instant; yield return(use); yield break; }
protected override IEnumerable <Toil> MakeNewToils() { this.FailOnDespawnedOrNull(TargetIndex.A); yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch)); yield return(Toils_General.Wait(10, TargetIndex.None)); yield return(new Toil { initAction = delegate() { Pawn otherPawn = this.OtherPawn; if (!otherPawn.inventory.UnloadEverything) { base.EndJobWith(JobCondition.Succeeded); } else { ThingCount firstUnloadableThing = otherPawn.inventory.FirstUnloadableThing; IntVec3 c; if (!firstUnloadableThing.Thing.def.EverStorable(false) || !this.pawn.health.capacities.CapableOf(PawnCapacityDefOf.Manipulation) || !StoreUtility.TryFindStoreCellNearColonyDesperate(firstUnloadableThing.Thing, this.pawn, out c)) { Thing thing; otherPawn.inventory.innerContainer.TryDrop(firstUnloadableThing.Thing, ThingPlaceMode.Near, firstUnloadableThing.Count, out thing, null, null); base.EndJobWith(JobCondition.Succeeded); if (thing != null) { thing.SetForbidden(false, false); } } else { Thing thing2; otherPawn.inventory.innerContainer.TryTransferToContainer(firstUnloadableThing.Thing, this.pawn.carryTracker.innerContainer, firstUnloadableThing.Count, out thing2, true); this.job.count = thing2.stackCount; this.job.SetTarget(TargetIndex.B, thing2); this.job.SetTarget(TargetIndex.C, c); firstUnloadableThing.Thing.SetForbidden(false, false); } } } }); yield return(Toils_Reserve.Reserve(TargetIndex.C, 1, -1, null)); Toil carryToCell = Toils_Haul.CarryHauledThingToCell(TargetIndex.C); yield return(carryToCell); yield return(Toils_Haul.PlaceHauledThingInCell(TargetIndex.C, carryToCell, true)); yield break; }
// Token: 0x06000045 RID: 69 RVA: 0x0000409D File Offset: 0x0000229D protected override IEnumerable <Toil> MakeNewToils() { this.FailOnDespawnedNullOrForbidden(Feedable); AddEndCondition(delegate { if (AQComp.foodPct > 0.95f) { return(JobCondition.Succeeded); } return(JobCondition.Ongoing); }); yield return(Toils_General.DoAtomic(delegate { job.count = AQUtility.GetFoodNumToFullyFeed(AQComp); })); Toil reserveFood = Toils_Reserve.Reserve(Foodybits, 1, -1, null); yield return(reserveFood); yield return(Toils_Goto.GotoThing(Foodybits, PathEndMode.ClosestTouch).FailOnDespawnedNullOrForbidden(Foodybits).FailOnSomeonePhysicallyInteracting(Foodybits)); yield return(Toils_Haul.StartCarryThing(Foodybits, false, true, false).FailOnDestroyedNullOrForbidden(Foodybits)); yield return(Toils_Haul.CheckForGetOpportunityDuplicate(reserveFood, Foodybits, TargetIndex.None, true, null)); yield return(Toils_Goto.GotoThing(Feedable, PathEndMode.Touch)); yield return(Toils_General.Wait(FeedDuration, TargetIndex.None).FailOnDestroyedNullOrForbidden(Foodybits).FailOnDestroyedNullOrForbidden(Feedable).FailOnCannotTouch(Feedable, PathEndMode.Touch).WithProgressBarToilDelay(Feedable, false, -0.5f)); yield return(Toils_AQFeed.FinalizeFeeding(Feedable, Foodybits)); if (!job.GetTarget(Foodybits).HasThing) { EndJobWith(JobCondition.Incompletable); } yield return(Toils_Reserve.Reserve(Foodybits, 1, -1, null)); yield return(Toils_Reserve.Reserve(TargetIndex.C, 1, -1, null)); yield return(Toils_Goto.GotoThing(Foodybits, PathEndMode.ClosestTouch)); yield return(Toils_Haul.StartCarryThing(Foodybits, false, false, false)); Toil carry = Toils_Haul.CarryHauledThingToCell(TargetIndex.C); yield return(carry); yield return(Toils_Haul.PlaceHauledThingInCell(TargetIndex.C, carry, true, false)); yield break; }
protected override IEnumerable <Toil> MakeNewToils() { this.pawn.jobs.curJob.count = 1; this.FailOnDestroyedOrNull(TargetIndex.A); if (!base.TargetThingA.IsForbidden(this.pawn)) { this.FailOnForbidden(TargetIndex.A); } yield return(Toils_Reserve.Reserve(TargetIndex.B, 1)); Toil toil = Toils_Reserve.Reserve(TargetIndex.A, 1); yield return(toil); yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch)); yield return(Toils_Haul.StartCarryThing(TargetIndex.A, false, false)); if (base.CurJob.haulOpportunisticDuplicates) { yield return(Toils_Haul.CheckForGetOpportunityDuplicate(toil, TargetIndex.A, TargetIndex.B, false, null)); } Toil toil3 = Toils_Haul.CarryHauledThingToCell(TargetIndex.B); yield return(toil3); yield return(Toils_Haul.PlaceHauledThingInCell(TargetIndex.B, toil3, true)); Toil toil2 = new Toil(); toil2.defaultCompleteMode = ToilCompleteMode.Delay; toil2.defaultDuration = 100; toil2.WithProgressBarToilDelay(TargetIndex.A, false, -0.5f); toil2.FailOnDespawnedNullOrForbidden(TargetIndex.A); yield return(toil2); yield return(new Toil { initAction = delegate { Pawn actor = this.pawn; CompUsable compUsable = actor.CurJob.targetA.Thing.TryGetComp <CompUsable>(); compUsable.UsedBy(actor); }, defaultCompleteMode = ToilCompleteMode.Instant }); yield break; }
protected override IEnumerable <Toil> MakeNewToils() { Pawn downedPawn = this.TargetThingA as Pawn; Toil gotoDownedPawnToil = Toils_Goto.GotoCell(downedPawnIndex, PathEndMode.OnCell).FailOn(delegate() { return(downedPawn.DestroyedOrNull() || (downedPawn.Downed == false)); }); yield return(gotoDownedPawnToil); yield return(Toils_Haul.StartCarryThing(downedPawnIndex)); Toil gotoTravelDestToil = Toils_Haul.CarryHauledThingToCell(medicalSPaceshipCellIndex).FailOn(delegate() { return(this.pawn.carryTracker.CarriedThing.DestroyedOrNull() || (this.pawn.CanReach(this.pawn.jobs.curJob.targetB.Cell, PathEndMode.OnCell, Danger.Some) == false)); }); yield return(gotoTravelDestToil); Toil arrivedToil = new Toil() { initAction = () => { Thing carriedPawn = null; this.pawn.carryTracker.TryDropCarriedThing(this.pawn.Position, ThingPlaceMode.Near, out carriedPawn); Building_SpaceshipMedical medicalSpaceship = this.pawn.Position.GetFirstThing(this.pawn.Map, Util_Spaceship.SpaceshipMedical) as Building_SpaceshipMedical; if (medicalSpaceship != null) { if (medicalSpaceship.orbitalHealingPawnsAboardCount >= Building_SpaceshipMedical.orbitalHealingPawnsAboardMaxCount) { Messages.Message((carriedPawn as Pawn).Name.ToStringShort + " cannot board MiningCo. medical spaceship.. There is no more any free slot.", carriedPawn, MessageTypeDefOf.RejectInput); } else if (TradeUtility.ColonyHasEnoughSilver(this.pawn.Map, Util_Spaceship.orbitalHealingCost)) { TradeUtility.LaunchSilver(this.pawn.Map, Util_Spaceship.orbitalHealingCost); medicalSpaceship.Notify_PawnBoarding(carriedPawn as Pawn, false); } else { Messages.Message((carriedPawn as Pawn).Name.ToStringShort + " cannot board MiningCo. medical spaceship.. You have not enough silver to pay for " + this.pawn.gender.GetPossessive() + " orbital healing.", carriedPawn, MessageTypeDefOf.RejectInput); } } }, defaultCompleteMode = ToilCompleteMode.Instant }; yield return(arrivedToil); }
protected override IEnumerable <Toil> MakeNewToils() { this.FailOnDespawnedNullOrForbidden(TargetIndex.A); this.FailOnBurningImmobile(TargetIndex.A); yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch)); yield return(Toils_General.Wait(240).FailOnDestroyedNullOrForbidden(TargetIndex.A).FailOnCannotTouch(TargetIndex.A, PathEndMode.Touch).WithProgressBarToilDelay(TargetIndex.A, false, -0.5f)); yield return(new Toil { initAction = delegate { Building_Beehouse buildingbeehouse = (Building_Beehouse)this.job.GetTarget(TargetIndex.A).Thing; buildingbeehouse.BeehouseIsFull = false; Thing newComb = ThingMaker.MakeThing(DecideRandomComb()); GenSpawn.Spawn(newComb, buildingbeehouse.Position - GenAdj.CardinalDirections[0], buildingbeehouse.Map); StoragePriority currentPriority = StoreUtility.CurrentStoragePriorityOf(newComb); IntVec3 c; if (StoreUtility.TryFindBestBetterStoreCellFor(newComb, this.pawn, this.Map, currentPriority, this.pawn.Faction, out c, true)) { this.job.SetTarget(TargetIndex.C, c); this.job.SetTarget(TargetIndex.B, newComb); this.job.count = newComb.stackCount; buildingbeehouse.tickCounter = 0; } else { this.EndJobWith(JobCondition.Incompletable); buildingbeehouse.BeehouseIsFull = false; buildingbeehouse.tickCounter = 0; } }, defaultCompleteMode = ToilCompleteMode.Instant }); yield return(Toils_Reserve.Reserve(TargetIndex.B, 1, -1, null)); yield return(Toils_Reserve.Reserve(TargetIndex.C, 1, -1, null)); yield return(Toils_Goto.GotoThing(TargetIndex.B, PathEndMode.ClosestTouch)); yield return(Toils_Haul.StartCarryThing(TargetIndex.B, false, false, false)); Toil carryToCell = Toils_Haul.CarryHauledThingToCell(TargetIndex.C); yield return(carryToCell); yield return(Toils_Haul.PlaceHauledThingInCell(TargetIndex.C, carryToCell, true)); }
protected override IEnumerable <Toil> MakeNewToils() { this.FailOnDestroyedNullOrForbidden(PrisonerInd); this.FailOnBurningImmobile(HaulToInd); if (!pawn.CurJob.GetTarget(PrisonerInd).Thing.IsForbidden(pawn)) { this.FailOnForbidden(PrisonerInd); } this.AddEndCondition(() => { // Cancel out if the prisoner enters the target room on their own var prisonerRoom = pawn.jobs.curJob.GetTarget(PrisonerInd).Thing.Position.GetRoom(); var targetRoom = pawn.jobs.curJob.GetTarget(HaulToInd).Cell.GetRoom(); return(prisonerRoom == targetRoom ? JobCondition.Succeeded : JobCondition.Ongoing); }); yield return(Toils_Reserve.Reserve(HaulToInd, 1)); yield return(Toils_Reserve.Reserve(PrisonerInd, 1)); var toilGoto = Toils_Goto.GotoThing(PrisonerInd, PathEndMode.ClosestTouch) .FailOn(() => { Job job = pawn.jobs.curJob; if (job.haulMode == HaulMode.ToCellStorage) { Thing prisoner = job.GetTarget(PrisonerInd).Thing; if (!pawn.jobs.curJob.GetTarget(HaulToInd).Cell.IsValidStorageFor(prisoner)) { return(true); } } return(false); }); yield return(toilGoto); yield return(Toils_Haul.StartCarryThing(PrisonerInd)); var carryToCell = Toils_Haul.CarryHauledThingToCell(HaulToInd); yield return(carryToCell); yield return(Toils_Haul.PlaceHauledThingInCell(HaulToInd, carryToCell, true)); yield return(Toils_Prisoner.NoLongerNeedsHauling(PrisonerInd)); yield return(Toils_Reserve.Release(HaulToInd)); yield return(Toils_Reserve.Release(PrisonerInd)); }
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); //send pawn to grower yield return(Toils_Reserve.Reserve(TargetIndex.A)); yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.InteractionCell)); yield return(Toils_General.WaitWith(TargetIndex.A, 200, true)); //Try to drop the product on the floor, if specified by the active Bill. If successful, end Job. yield return(QEEToils.TryDropProductOnFloor(TargetThingA as Building_GrowerBase_WorkTable)); //The product is going to a stockpile. Create product, decrement bill counter, and start carrying it. //If target stockpile full, drop on ground and end Job, as a fallback. yield return(QEEToils.StartCarryProductToStockpile(TargetThingA as Building_GrowerBase_WorkTable)); //if we've reached this far, an output stockpile was specified in the Bill options and a valid cell was found // in the toil above yield return(Toils_Reserve.Reserve(TargetIndex.B)); Toil carryToCell = Toils_Haul.CarryHauledThingToCell(TargetIndex.B); yield return(carryToCell); yield return(Toils_Haul.PlaceHauledThingInCell(TargetIndex.B, carryToCell, storageMode: true)); Toil recount = new Toil(); recount.initAction = delegate { Bill_Production bill_Production = recount.actor.jobs.curJob.bill as Bill_Production; if (bill_Production != null && bill_Production.repeatMode == BillRepeatModeDefOf.TargetCount) { Map.resourceCounter.UpdateResourceCounts(); } }; yield return(recount); }
// Token: 0x0600002E RID: 46 RVA: 0x000035B0 File Offset: 0x000025B0 protected override IEnumerable <Toil> MakeNewToils() { this.FailOnDespawnedNullOrForbidden(TargetIndex.A); this.FailOnBurningImmobile(TargetIndex.A); yield return(Toils_Reserve.Reserve(TargetIndex.A, 1, -1, null)); yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch)); yield return(Toils_General.Wait(200, TargetIndex.None).FailOnDestroyedNullOrForbidden(TargetIndex.A).FailOn(() => !this.Barrel.Distilled).WithProgressBarToilDelay(TargetIndex.A, false, -0.5f)); yield return(new Toil { initAction = delegate() { Thing thing = this.Barrel.TakeOutrawlucibatch(); GenPlace.TryPlaceThing(thing, this.pawn.Position, base.Map, ThingPlaceMode.Near, null, null); StoragePriority currentPriority = StoreUtility.CurrentStoragePriorityOf(thing); IntVec3 c; if (StoreUtility.TryFindBestBetterStoreCellFor(thing, this.pawn, base.Map, currentPriority, this.pawn.Faction, out c, true)) { this.job.SetTarget(TargetIndex.C, c); this.job.SetTarget(TargetIndex.B, thing); this.job.count = thing.stackCount; } else { base.EndJobWith(JobCondition.Incompletable); } }, defaultCompleteMode = ToilCompleteMode.Instant }); yield return(Toils_Reserve.Reserve(TargetIndex.B, 1, -1, null)); yield return(Toils_Reserve.Reserve(TargetIndex.C, 1, -1, null)); yield return(Toils_Goto.GotoThing(TargetIndex.B, PathEndMode.ClosestTouch)); yield return(Toils_Haul.StartCarryThing(TargetIndex.B, false, false, false)); Toil toil = Toils_Haul.CarryHauledThingToCell(TargetIndex.C); yield return(toil); yield return(Toils_Haul.PlaceHauledThingInCell(TargetIndex.C, toil, true)); yield break; }
// Token: 0x06000030 RID: 48 RVA: 0x00002C83 File Offset: 0x00000E83 protected override IEnumerable <Toil> MakeNewToils() { CompUniversalFermenter comp = ThingCompUtility.TryGetComp <CompUniversalFermenter>(this.Fermenter); ToilFailConditions.FailOn <JobDriver_TakeProductOutOfUniversalFermenter>(this, () => !comp.Fermented); ToilFailConditions.FailOnDestroyedNullOrForbidden <JobDriver_TakeProductOutOfUniversalFermenter>(this, (TargetIndex)1); yield return(Toils_Reserve.Reserve((TargetIndex)1, 1, -1, null)); yield return(Toils_Goto.GotoThing((TargetIndex)1, (PathEndMode)3)); yield return(ToilEffects.WithProgressBarToilDelay(ToilFailConditions.FailOnDestroyedNullOrForbidden <Toil>(Toils_General.Wait(200, 0), (TargetIndex)1), (TargetIndex)1, false, -0.5f)); yield return(new Toil { initAction = delegate() { Thing thing = comp.TakeOutProduct(); GenPlace.TryPlaceThing(thing, this.pawn.Position, this.Map, (ThingPlaceMode)1, null, null); StoragePriority storagePriority = StoreUtility.CurrentStoragePriorityOf(thing); IntVec3 intVec; if (StoreUtility.TryFindBestBetterStoreCellFor(thing, this.pawn, this.Map, storagePriority, this.pawn.Faction, out intVec, true)) { this.job.SetTarget((TargetIndex)2, thing); this.job.count = thing.stackCount; this.job.SetTarget((TargetIndex)3, intVec); return; } this.EndJobWith((JobCondition)3); }, defaultCompleteMode = (ToilCompleteMode)1 }); yield return(Toils_Reserve.Reserve((TargetIndex)2, 1, -1, null)); yield return(Toils_Reserve.Reserve((TargetIndex)3, 1, -1, null)); yield return(Toils_Goto.GotoThing((TargetIndex)2, (PathEndMode)3)); yield return(Toils_Haul.StartCarryThing((TargetIndex)2, false, false, false)); Toil carry = Toils_Haul.CarryHauledThingToCell((TargetIndex)3); yield return(carry); yield return(Toils_Haul.PlaceHauledThingInCell((TargetIndex)3, carry, true)); yield break; }
protected override IEnumerable <Toil> MakeNewToils() { //Set fail conditions this.FailOnDestroyedOrNull(HaulableInd); this.FailOnBurningImmobile(CellInd); //Note we only fail on forbidden if the target doesn't start that way //This helps haul-aside jobs on forbidden items if (!this.forbiddenInitially) { this.FailOnForbidden(HaulableInd); } //Reserve target storage cell, if it is a storage bool targetIsStorage = StoreUtility.GetSlotGroup(pawn.jobs.curJob.GetTarget(CellInd).Cell, Map) != null; if (targetIsStorage) { yield return(Toils_Reserve.Reserve(CellInd, 1)); } //Reserve thing to be stored Toil reserveTargetA = Toils_Reserve.Reserve(HaulableInd, 1, 1, null); yield return(reserveTargetA); //yield return toilGoto; yield return(Toils_Goto.GotoThing(HaulableInd, PathEndMode.ClosestTouch).FailOnSomeonePhysicallyInteracting(HaulableInd)); // Start hauling to yield return(Toils_Haul.StartCarryThing(HaulableInd, false, false)); if (this.job.haulOpportunisticDuplicates) { yield return(Toils_Haul.CheckForGetOpportunityDuplicate(reserveTargetA, HaulableInd, CellInd)); } Toil carryToCell = Toils_Haul.CarryHauledThingToCell(CellInd); yield return(carryToCell); // start work on target yield return(Toils_WaitWithSoundAndEffect(180, "Interact_ConstructMetal", "ConstructMetal", CellInd)); yield return(Toils_TryToAttachToWeaponBase(pawn, HaulableInd, CellInd)); }