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));
}
