protected override IEnumerable <Toil> MakeNewToils()
{
// Verify processor validity
this.FailOnDespawnedNullOrForbidden(ProcessorInd);
this.FailOn(() => !Processor.Finished);
// Go to the processor
yield return(Toils_Goto.GotoThing(ProcessorInd, PathEndMode.ClosestTouch));
// Add delay for collecting items from the processor
yield return(Toils_General.Wait(Static.GenericWaitDuration)
.FailOnDestroyedNullOrForbidden(ProcessorInd)
.WithProgressBarToilDelay(ProcessorInd));
// Collect items
yield return(new Toil()
{
initAction = () =>
{
Thing item = Processor.TakeOutProduct();
GenPlace.TryPlaceThing(item, pawn.Position, Map, ThingPlaceMode.Near);
StoragePriority storagePriority = StoreUtility.StoragePriorityAtFor(item.Position, item);
// Try to find a suitable storage spot for the item
if (StoreUtility.TryFindBestBetterStoreCellFor(item, pawn, Map, storagePriority, pawn.Faction, out IntVec3 c))
{
job.SetTarget(TargetIndex.C, c);
job.SetTarget(TargetIndex.B, item);
job.count = item.stackCount;
}
// If there is no spot to store the item, end this job
else
{
EndJobWith(JobCondition.Incompletable);
}
},
defaultCompleteMode = ToilCompleteMode.Instant
});
protected override IEnumerable <Toil> MakeNewToils()
{
this.FailOnDespawnedNullOrForbidden(TargetIndex.A);
this.FailOnBurningImmobile(TargetIndex.A);
yield return(Toils_Reserve.Reserve(TargetIndex.A, 1));
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch));
yield return(Toils_General.Wait(200).FailOnDestroyedNullOrForbidden(TargetIndex.A).FailOn(() => !Vat.Fermented).WithProgressBarToilDelay(TargetIndex.A, false, -0.5f));
yield return(new Toil
{
initAction = delegate
{
Thing thing = Vat.TakeOutThing();
GenPlace.TryPlaceThing(thing, pawn.Position, Map, ThingPlaceMode.Near, null);
StoragePriority currentPriority = StoreUtility.StoragePriorityAtFor(thing.Position, thing);;
if (StoreUtility.TryFindBestBetterStoreCellFor(thing, pawn, Map, currentPriority, pawn.Faction, out IntVec3 c, true))
{
job.SetTarget(TargetIndex.C, c);
job.SetTarget(TargetIndex.B, thing);
job.count = thing.stackCount;
}
public static void SetCountLimit(Pawn p, Thing t, ref Job __result, IntVec3 storeCell)
{
SlotGroup toSlotGroup = p.Map.haulDestinationManager.SlotGroupAt(storeCell); // ?? __result.targetB.Thing?.GetSlotGroup();
if (toSlotGroup == null)
{
//It is a haul destination without a SlotGroup, e.g. a grave
return;
}
int toLimit = Limits.GetLimit(toSlotGroup.Settings);
//int currentStack = __result.count < 0 ? t.stackCount : __result.count;
int stackCount = __result.targetA.Thing.stackCount;
if (stackCount < 1)
{
stackCount = int.MaxValue;
}
int currentStack = Math.Min(__result.count, stackCount);
currentStack = Math.Min(currentStack, p.carryTracker.AvailableStackSpace(__result.targetA.Thing.def));
bool hasSetFirstLimit = false;
SlotGroup fromSlotGroup = StoreUtility.GetSlotGroup(t.Position, t.Map);
if (fromSlotGroup != null)
{
int fromLimit = Limits.GetLimit(fromSlotGroup.Settings);
if (fromLimit > 0 && StoreUtility.CurrentStoragePriorityOf(t) > StoreUtility.StoragePriorityAtFor(storeCell, t))
{
//Hauling from limited high priority to low priority. Only haul the minimum necessary to go to exact limit.
int stockpileStack1 = fromSlotGroup.TotalPrecalculatedItemsStack();
__result.count = stockpileStack1 - fromLimit;
hasSetFirstLimit = true;
}
}
if (toLimit < 0)
{
return;
}
int stockpileStack = toSlotGroup.TotalPrecalculatedItemsStack();
if (stockpileStack >= toLimit)
{
//Say no spot availible
JobFailReason.Is(GetNoEmptyPlaceLowerTransString(), null);
__result = null;
}
else if (stockpileStack + currentStack > toLimit) //It will go over the limit
{
int newLimit = toLimit - stockpileStack;
__result.count = hasSetFirstLimit ? Math.Min(newLimit, __result.count < 0 ? int.MaxValue : __result.count) : newLimit;
}
if (__result != null && __result.count <= 0)
{
JobFailReason.Is(GetNoEmptyPlaceLowerTransString(), null);
__result = null;
}
}
