protected override IEnumerable <Toil> MakeNewToils()
{
this.FailOnDestroyedOrNull(TargetIndex.A);
this.FailOnDespawnedOrNull(TargetIndex.B);
yield return(Toils_Reserve.Reserve(TargetIndex.A, 1, 1, null));
yield return(Toils_Reserve.ReserveQueue(TargetIndex.A, 1, 1, null));
//yield return Toils_Reserve.Reserve(TargetIndex.B, 10, 1, null);
//yield return Toils_Reserve.ReserveQueue(TargetIndex.B, 10, 1, null);
Toil toil = Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.ClosestTouch).FailOnSomeonePhysicallyInteracting(TargetIndex.A);
//toil.AddFailCondition(() => ShipFull(ship));
toil.tickAction += delegate
{
if (this.ShipFull(ship))
{
this.EndJobWith(JobCondition.Incompletable);
}
};
yield return(toil);
yield return(Toils_Construct.UninstallIfMinifiable(TargetIndex.A).FailOnSomeonePhysicallyInteracting(TargetIndex.A));
Toil toilPickup = Toils_Haul.StartCarryThing(TargetIndex.A, false, true);//.FailOn(() => this.ShipFull(ship));
yield return(toilPickup);
yield return(Toils_Haul.JumpIfAlsoCollectingNextTargetInQueue(toil, TargetIndex.A));
Toil toil2 = Toils_Haul.CarryHauledThingToContainer();
toil2.tickAction += delegate
{
if (this.ShipFull(ship, false))
{
this.EndJobWith(JobCondition.Incompletable);
}
};
yield return(toil2);
yield return(Toils_Goto.MoveOffTargetBlueprint(TargetIndex.B));
yield return(Toils_Construct.MakeSolidThingFromBlueprintIfNecessary(TargetIndex.B));
Toil toil3 = Toils_Haul.DepositHauledThingInContainer(TargetIndex.B, TargetIndex.C);
//toil3.AddFailCondition(() => this.ShipFull(ship));
yield return(toil3);
yield return(Toils_Haul.JumpToCarryToNextContainerIfPossible(toil2, TargetIndex.C));
yield break;
}
protected override IEnumerable <Toil> MakeNewToils()
{
this.FailOnDestroyedOrNull(TargetIndex.A);
this.FailOnDestroyedNullOrForbidden(TargetIndex.B);
ShipBase ship = (ShipBase)TargetB;
yield return(Toils_Reserve.Reserve(TargetIndex.A, 1));
yield return(Toils_Reserve.ReserveQueue(TargetIndex.A, 1));
yield return(Toils_Reserve.Reserve(TargetIndex.B, 10));
yield return(Toils_Reserve.ReserveQueue(TargetIndex.B, 10));
Toil toil = Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.ClosestTouch).FailOnSomeonePhysicallyInteracting(TargetIndex.A);
yield return(toil);
yield return(Toils_Construct.UninstallIfMinifiable(TargetIndex.A).FailOnSomeonePhysicallyInteracting(TargetIndex.A));
yield return(Toils_Haul.StartCarryThing(TargetIndex.A, false, true));
yield return(Toils_Haul.JumpIfAlsoCollectingNextTargetInQueue(toil, TargetIndex.A));
Toil toil2 = Toils_Haul.CarryHauledThingToContainer();
yield return(toil2);
yield return(Toils_Goto.MoveOffTargetBlueprint(TargetIndex.B));
yield return(Toils_Construct.MakeSolidThingFromBlueprintIfNecessary(TargetIndex.B));
Toil finalToil = Toils_Haul.DepositHauledThingInContainer(TargetIndex.B);
finalToil.AddFinishAction(delegate
{
ship.compShip.SubtractFromToLoadList(TargetA.Thing);
});
yield return(finalToil);
yield return(Toils_Haul.JumpToCarryToNextContainerIfPossible(toil2));
yield break;
}
protected override IEnumerable <Toil> MakeNewToils()
{
this.FailOnDestroyedOrNull(TargetIndex.A);
this.FailOnDespawnedOrNull(TargetIndex.B);
Toil toil = Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.ClosestTouch).FailOnSomeonePhysicallyInteracting(TargetIndex.A);
toil.AddFinishAction(delegate { Log.Message("Finished A"); });
//toil.AddFailCondition(() => ShipFull(ship));
toil.tickAction += delegate
{
if (this.ShipFull(ship))
{
this.EndJobWith(JobCondition.Incompletable);
}
};
yield return(toil);
yield return(Toils_Construct.UninstallIfMinifiable(TargetIndex.A).FailOnSomeonePhysicallyInteracting(TargetIndex.A));
Toil toilPickup = Toils_Haul.StartCarryThing(TargetIndex.A, false, true);//.FailOn(() => this.ShipFull(ship));
yield return(toilPickup);
yield return(Toils_Haul.JumpIfAlsoCollectingNextTargetInQueue(toil, TargetIndex.A));
Toil toil2 = Toils_Haul.CarryHauledThingToContainer();
toil2.tickAction += delegate
{
if (this.ShipFull(ship, false))
{
this.EndJobWith(JobCondition.Incompletable);
}
};
yield return(toil2);
Toil toil3 = Toils_Haul.DepositHauledThingInContainer(TargetIndex.B, TargetIndex.None);
//toil3.AddFailCondition(() => this.ShipFull(ship));
yield return(toil3);
yield break;
}
protected override IEnumerable <Toil> MakeNewToils()
{
// This is mostly the same list of toils as HaulToContainer, except without reserving the container,
// and also added some things from JobDriver_PrepareCaravan_GatherItems that handle coordination between
// colonists. Many of the toils here seem to be intended for construction jobs and are thus probably not
// necessary, but I'm leaving them in just in case. Possibly another mod will assume they're there, who knows.
this.FailOnDestroyedOrNull(TargetIndex.A);
this.FailOnDestroyedNullOrForbidden(TargetIndex.B);
this.FailOn(() => TransporterUtility.WasLoadingCanceled(this.Transporter));
Toil reserve = Toils_Reserve.Reserve(TargetIndex.A, 1, -1, null).FailOnDespawnedOrNull(TargetIndex.A);
yield return(reserve);
//yield return Toils_Reserve.ReserveQueue(TargetIndex.A, 1, -1, null);
Toil getToHaulTarget = Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.ClosestTouch).FailOnSomeonePhysicallyInteracting(TargetIndex.A);
yield return(getToHaulTarget);
yield return(DetermineNumToHaul());
yield return(Toils_Construct.UninstallIfMinifiable(TargetIndex.A).FailOnSomeonePhysicallyInteracting(TargetIndex.A));
yield return(Toils_Haul.StartCarryThing(TargetIndex.A, false, true));
yield return(AddCarriedThingToTransferables());
yield return(Toils_Haul.CheckForGetOpportunityDuplicate(reserve, TargetIndex.A, TargetIndex.None, true, (Thing x) => Transferable.things.Contains(x)));
yield return(Toils_Haul.JumpIfAlsoCollectingNextTargetInQueue(getToHaulTarget, TargetIndex.A));
Toil carryToContainer = Toils_Haul.CarryHauledThingToContainer();
yield return(carryToContainer);
yield return(Toils_Goto.MoveOffTargetBlueprint(TargetIndex.B));
yield return(Toils_Construct.MakeSolidThingFromBlueprintIfNecessary(TargetIndex.B, TargetIndex.C));
yield return(Toils_Haul.DepositHauledThingInContainer(TargetIndex.B, TargetIndex.C));
yield return(Toils_Haul.JumpToCarryToNextContainerIfPossible(carryToContainer, TargetIndex.C));
}
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_Haul.DepositHauledThingInContainer(TargetIndex.B, TargetIndex.A));
yield return(Toils_Reserve.Release(TargetIndex.A));
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.AnnounceServing(TargetIndex.A, TargetIndex.B));
yield return(Toils_Waiting.ClearOrder(TargetIndex.A, TargetIndex.B, TargetIndex.B, TargetIndex.C)); // Got no silver or register? Job successful
yield return(Toils_Misc.TakeItemFromInventoryToCarrier(pawn, TargetIndex.B));
yield return(Toils_Goto.GotoThing(TargetIndex.C, PathEndMode.Touch));
yield return(Toils_Haul.DepositHauledThingInContainer(TargetIndex.C, TargetIndex.None));
}
protected override IEnumerable <Toil> MakeNewToils()
{
base.AddEndCondition(delegate
{
Thing thing = base.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(delegate()
{
IBillGiver billGiver = this.job.GetTarget(TargetIndex.A).Thing as IBillGiver;
if (billGiver != null)
{
if (this.job.bill.DeletedOrDereferenced)
{
return(true);
}
if (!billGiver.CurrentlyUsableForBills())
{
return(true);
}
}
return(false);
});
Toil gotoBillGiver = Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.InteractionCell);
yield return(new Toil
{
initAction = delegate()
{
if (this.job.targetQueueB != null && this.job.targetQueueB.Count == 1)
{
UnfinishedThing unfinishedThing = this.job.targetQueueB[0].Thing as UnfinishedThing;
if (unfinishedThing != null)
{
unfinishedThing.BoundBill = (Bill_ProductionWithUft)this.job.bill;
}
}
}
});
//yield return Toils_Jump.JumpIf(gotoBillGiver, () => this.job.GetTargetQueue(TargetIndex.B).NullOrEmpty<LocalTargetInfo>());
Toil extract = Toils_JobTransforms.ExtractNextTargetFromQueue(TargetIndex.B, true);
yield return(extract);
yield return(new Toil
{
initAction = delegate()
{
var alien = TargetB.Thing;
var container = (Building_СontainmentBreach)TargetA.Thing;
if (container.innerContainer.Contains(alien) && ReservationUtility.CanReserveAndReach
(GetActor(), container, PathEndMode.ClosestTouch, DangerUtility.NormalMaxDanger(GetActor())
, 1, -1, null, false))
{
Log.Message(GetActor() + " JUMP");
//Toils_Reserve.Reserve(TargetIndex.A, 1);
this.JumpToToil(gotoBillGiver);
}
}
});
Toil getToHaulTarget = Toils_Goto.GotoThing(TargetIndex.B, PathEndMode.ClosestTouch);//.FailOnSomeonePhysicallyInteracting(TargetIndex.B);
yield return(getToHaulTarget);
yield return(new Toil {
initAction = delegate() { base.GetActor().CurJob.count = 1; }
});
yield return(Toils_Haul.StartCarryThing(TargetIndex.B, true, false, false));
yield return(JobDriver_PreciseVivisection.JumpToCollectNextIntoHandsForBill(getToHaulTarget, TargetIndex.B));
//yield return Toils_Haul.CarryHauledThingToCell(TargetIndex.B);
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.InteractionCell).FailOnDestroyedOrNull(TargetIndex.B));
yield return(Toils_Haul.DepositHauledThingInContainer(TargetIndex.A, TargetIndex.B));
Toil findPlaceTarget = Toils_JobTransforms.SetTargetToIngredientPlaceCell(TargetIndex.A, TargetIndex.B, TargetIndex.C);
yield return(findPlaceTarget);
//yield return Toils_Haul.PlaceHauledThingInCell(TargetIndex.C, findPlaceTarget, false, false);
yield return(Toils_Jump.JumpIfHaveTargetInQueue(TargetIndex.B, extract));
extract = null;
getToHaulTarget = null;
findPlaceTarget = null;
yield return(gotoBillGiver);
yield return(Toils_Recipe.MakeUnfinishedThingIfNeeded());
yield return(Toils_Recipe.DoRecipeWork().FailOnCannotTouch(TargetIndex.A, PathEndMode.InteractionCell));
yield return(new Toil
{
initAction = delegate()
{
var alien = TargetB.Thing;
foreach (var product in alien.ButcherProducts(base.GetActor(), 1f))
{
Log.Message(product.def.defName);
GenPlace.TryPlaceThing(product, base.GetActor().Position, base.GetActor().Map, ThingPlaceMode.Near);
}
var container = (Building_СontainmentBreach)TargetA.Thing;
container.innerContainer.Remove(alien);
alien.Destroy(DestroyMode.Vanish);
}
});
yield return(new Toil
{
initAction = delegate()
{
var container = (Building_СontainmentBreach)TargetA.Thing;
if (GetActor().Map.reservationManager.ReservedBy(container, GetActor(), GetActor().CurJob))
{
GetActor().Map.reservationManager.Release(container, GetActor(), GetActor().CurJob);
}
}
});
yield return(Toils_Recipe.FinishRecipeAndStartStoringProduct());
if (!this.job.bill.recipe.products.NullOrEmpty <ThingDefCountClass>() || !this.job.bill.recipe.specialProducts.NullOrEmpty <SpecialProductType>())
{
yield return(Toils_Reserve.Reserve(TargetIndex.B, 1, -1, null));
findPlaceTarget = Toils_Haul.CarryHauledThingToCell(TargetIndex.B);
yield return(findPlaceTarget);
//yield return Toils_Haul.PlaceHauledThingInCell(TargetIndex.B, findPlaceTarget, true, true);
Toil toil = new Toil();
toil.initAction = delegate()
{
this.Map.resourceCounter.UpdateResourceCounts();
};
yield return(toil);
toil = null;
findPlaceTarget = null;
}
yield return(new Toil
{
initAction = delegate()
{
Log.Message("Job ended");
}
});
yield break;
}
public 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(delegate()
{
IBillGiver billGiver = job.GetTarget(TargetIndex.A).Thing as IBillGiver;
if (billGiver != null)
{
if (job.bill.DeletedOrDereferenced)
{
return(true);
}
if (!billGiver.CurrentlyUsableForBills())
{
return(true);
}
}
if (inShelf && !bookOut && !shelf.innerContainer.Contains(book))
{
return(true);
}
return(false);
});
AddFinishAction(delegate
{
if (inShelf && bookOut)
{
shelf.CheckBookOut(book, true);
}
});
Toil gotoBillGiver = Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.InteractionCell);
yield return(Toils_Jump.JumpIf(gotoBillGiver, () => job.GetTargetQueue(TargetIndex.B).NullOrEmpty <LocalTargetInfo>()));
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(inShelf ? TakeFromShelf(TargetIndex.B) : Toils_Haul.StartCarryThing(TargetIndex.B, true, false, true));
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_Haul.PlaceHauledThingInCell(TargetIndex.C, findPlaceTarget, false, false));
extract = null;
getToHaulTarget = null;
findPlaceTarget = null;
yield return(gotoBillGiver);
yield return(Toils_Recipe.DoRecipeWork().FailOnDespawnedNullOrForbiddenPlacedThings().FailOnCannotTouch(TargetIndex.A, PathEndMode.InteractionCell));
Toil upload = new Toil();
upload.initAction = delegate()
{
Pawn actor = upload.actor;
Job curJob = actor.jobs.curJob;
JobDriver_DoBill jobDriver_DoBill = (JobDriver_DoBill)actor.jobs.curDriver;
if (curJob.RecipeDef.workSkill != null)
{
float xp = (float)jobDriver_DoBill.ticksSpentDoingRecipeWork * 0.1f * curJob.RecipeDef.workSkillLearnFactor;
actor.skills.GetSkill(curJob.RecipeDef.workSkill).Learn(xp, false);
}
project.Unlock(TargetThingA, false);
Thing scanned = TargetB.Thing;
if (scanned.def == TechDefOf.TechDrive)
{
Toils_Recipe_Patch.ConsumeIngredients(new List <Thing> {
scanned
}, curJob.RecipeDef, actor.Map);
}
curJob.bill.Notify_IterationCompleted(actor, new List <Thing>());
};
yield return(upload);
//Put it back!
if (inShelf)
{
yield return(Toils_Haul.StartCarryThing(TargetIndex.B, true, false, true));
yield return(Toils_JobTransforms.ExtractNextTargetFromQueue(TargetIndex.B, true));
yield return(Toils_Goto.GotoThing(TargetIndex.B, PathEndMode.Touch).FailOnDestroyedOrNull(TargetIndex.B));
Toil handOver = Toils_Haul.DepositHauledThingInContainer(TargetIndex.B, TargetIndex.A);
handOver.AddPreInitAction(delegate
{
bookOut = false;
});
yield return(handOver);
}
yield return(new Toil()
{
initAction = delegate()
{
pawn.jobs.EndCurrentJob(JobCondition.Succeeded, true, true);
}
});
yield break;
}
