public static Job HopperFillFoodJob(Pawn pawn, ISlotGroupParent hopperSgp)
{
Building building = hopperSgp as Building;
if (!pawn.CanReserveAndReach(building.Position, PathEndMode.Touch, pawn.NormalMaxDanger(), 1))
{
return(null);
}
ThingDef thingDef = null;
Thing firstItem = building.Position.GetFirstItem();
if (firstItem != null)
{
if (firstItem.def.IsNutritionSource)
{
thingDef = firstItem.def;
}
else
{
if (firstItem.IsForbidden(pawn.Faction))
{
return(null);
}
return(HaulAIUtility.HaulAsideJobFor(pawn, firstItem));
}
}
List <Thing> list;
if (thingDef == null)
{
list = Find.Map.listerThings.ThingsInGroup(ThingRequestGroup.FoodNotPlantOrTree);
}
else
{
list = Find.Map.listerThings.ThingsOfDef(thingDef);
}
for (int i = 0; i < list.Count; i++)
{
Thing thing = list[i];
if (thing.def.ingestible.preferability == FoodPreferability.Raw)
{
if (HaulAIUtility.PawnCanAutomaticallyHaul(pawn, thing))
{
if (Find.SlotGroupManager.SlotGroupAt(building.Position).Settings.AllowedToAccept(thing))
{
StoragePriority storagePriority = HaulAIUtility.StoragePriorityAtFor(thing.Position, thing);
if (storagePriority < hopperSgp.GetSlotGroup().Settings.Priority)
{
Job job = HaulAIUtility.HaulMaxNumToCellJob(pawn, thing, building.Position, true);
if (job != null)
{
return(job);
}
}
}
}
}
}
return(null);
}
public override Job JobOnThing(Pawn pawn, Thing t, bool forced = false)
{
if (!t.def.mineable)
{
return(null);
}
if (pawn.Map.designationManager.DesignationAt(t.Position, DesignationDefOf.Mine) == null)
{
return(null);
}
if (!pawn.CanReserve(t, 1, -1, null, forced))
{
return(null);
}
bool flag = false;
for (int i = 0; i < 8; i++)
{
IntVec3 intVec = t.Position + GenAdj.AdjacentCells[i];
if (intVec.InBounds(pawn.Map) && intVec.Standable(pawn.Map) && ReachabilityImmediate.CanReachImmediate(intVec, t, pawn.Map, PathEndMode.Touch, pawn))
{
flag = true;
break;
}
}
if (!flag)
{
for (int j = 0; j < 8; j++)
{
IntVec3 intVec2 = t.Position + GenAdj.AdjacentCells[j];
if (!intVec2.InBounds(t.Map) || !ReachabilityImmediate.CanReachImmediate(intVec2, t, pawn.Map, PathEndMode.Touch, pawn) || !intVec2.Walkable(t.Map) || intVec2.Standable(t.Map))
{
continue;
}
Thing thing = null;
List <Thing> thingList = intVec2.GetThingList(t.Map);
for (int k = 0; k < thingList.Count; k++)
{
if (thingList[k].def.designateHaulable && thingList[k].def.passability == Traversability.PassThroughOnly)
{
thing = thingList[k];
break;
}
}
if (thing != null)
{
Job job = HaulAIUtility.HaulAsideJobFor(pawn, thing);
if (job != null)
{
return(job);
}
JobFailReason.Is(NoPathTrans);
return(null);
}
}
JobFailReason.Is(NoPathTrans);
return(null);
}
return(JobMaker.MakeJob(JobDefOf.Mine, t, 20000, checkOverrideOnExpiry: true));
}
public override Job JobOnCell(Pawn pawn, IntVec3 c, bool forced = false)
{
var job = base.JobOnCell(pawn, c, forced);
// plant has seeds, if there is a seed return a job, otherwise prevent it. Seeds with no category are forbidden.
var seed = job?.plantDefToSow?.blueprintDef;
if (seed != null && !seed.thingCategories.NullOrEmpty())
{
// Clear the area some...
var zone = c.GetZone(pawn.Map);
if (zone != null)
{
foreach (var corner in GenAdj.AdjacentCells8WayRandomized())
{
var cell = c + corner;
if (zone.ContainsCell(cell))
{
foreach (var thing in pawn.Map.thingGrid.ThingsAt(cell))
{
if (thing.def != job.plantDefToSow && thing.def.BlocksPlanting(true) && pawn.CanReserve(thing) && !thing.IsForbidden(pawn))
{
if (thing.def.category == ThingCategory.Plant)
{
return(new Job(JobDefOf.CutPlant, thing));
}
if (thing.def.EverHaulable)
{
return(HaulAIUtility.HaulAsideJobFor(pawn, thing));
}
}
}
}
}
}
Predicate <Thing> predicate = (Thing tempThing) =>
!ForbidUtility.IsForbidden(tempThing, pawn.Faction) &&
ForbidUtility.InAllowedArea(tempThing.Position, pawn) &&
PawnLocalAwareness.AnimalAwareOf(pawn, tempThing) &&
ReservationUtility.CanReserve(pawn, tempThing, 1);
Thing bestSeedThingForSowing = GenClosest.ClosestThingReachable(
c, pawn.Map, ThingRequest.ForDef(job.plantDefToSow.blueprintDef),
PathEndMode.ClosestTouch, TraverseParms.For(pawn, Danger.Deadly, TraverseMode.ByPawn, false), 9999,
predicate);
if (bestSeedThingForSowing != null)
{
return(new Job(ResourceBank.JobDefOf.SowWithSeeds, c, bestSeedThingForSowing)
{
plantDefToSow = job.plantDefToSow,
count = SEEDS_TO_CARRY
});
}
return(null);
}
return(job);
}
public static Job HandleBlockingThingJob(Thing constructible, Pawn worker, bool forced = false)
{
Thing thing = GenConstruct.FirstBlockingThing(constructible, worker);
Job result;
if (thing == null)
{
result = null;
}
else
{
if (thing.def.category == ThingCategory.Plant)
{
LocalTargetInfo target = thing;
PathEndMode peMode = PathEndMode.ClosestTouch;
Danger maxDanger = worker.NormalMaxDanger();
if (worker.CanReserveAndReach(target, peMode, maxDanger, 1, -1, null, forced))
{
return(new Job(JobDefOf.CutPlant, thing));
}
}
else if (thing.def.category == ThingCategory.Item)
{
if (thing.def.EverHaulable)
{
return(HaulAIUtility.HaulAsideJobFor(worker, thing));
}
Log.ErrorOnce(string.Concat(new object[]
{
"Never haulable ",
thing,
" blocking ",
constructible.ToStringSafe <Thing>(),
" at ",
constructible.Position
}), 6429262, false);
}
else if (thing.def.category == ThingCategory.Building)
{
if (worker.story != null && worker.story.WorkTypeIsDisabled(WorkTypeDefOf.Construction))
{
JobFailReason.Is(GenConstruct.IncapableOfDeconstruction, null);
return(null);
}
LocalTargetInfo target = thing;
PathEndMode peMode = PathEndMode.Touch;
Danger maxDanger = worker.NormalMaxDanger();
if (worker.CanReserveAndReach(target, peMode, maxDanger, 1, -1, null, forced))
{
return(new Job(JobDefOf.Deconstruct, thing)
{
ignoreDesignations = true
});
}
}
result = null;
}
return(result);
}
// Token: 0x060000EB RID: 235 RVA: 0x000083A0 File Offset: 0x000065A0
public static void HandleBlockingThingJob_Prefix(ref Job __result, Thing constructible, Pawn worker, bool forced = false)
{
Thing thing = GenConstruct.FirstBlockingThing(constructible, worker);
bool flag = thing == null;
if (flag)
{
__result = null;
}
bool flag2 = thing.def.category == ThingCategory.Plant && worker.RaceProps.Animal;
if (flag2)
{
bool flag3 = worker.CanReserveAndReach(thing, PathEndMode.ClosestTouch, worker.NormalMaxDanger(), 1, -1, null, forced);
if (flag3)
{
__result = new Job(JobDefOf.CutPlant, thing);
}
}
else
{
bool flag4 = thing.def.category == ThingCategory.Item && worker.RaceProps.Animal;
if (flag4)
{
bool everHaulable = thing.def.EverHaulable;
if (everHaulable)
{
__result = HaulAIUtility.HaulAsideJobFor(worker, thing);
}
Log.ErrorOnce(string.Concat(new object[]
{
"Never haulable ",
thing,
" blocking ",
constructible.ToStringSafe <Thing>(),
" at ",
constructible.Position
}), 6429262, false);
}
else
{
bool flag5 = thing.def.category == ThingCategory.Building && worker.RaceProps.Animal;
if (flag5)
{
bool flag6 = worker.CanReserveAndReach(thing, PathEndMode.Touch, worker.NormalMaxDanger(), 1, -1, null, forced);
if (flag6)
{
__result = new Job(WPJobDefOf.WPDeconstruct, thing)
{
ignoreDesignations = true
};
}
}
}
}
__result = null;
}
public static Job HandleBlockingThingJob(Thing constructible, Pawn worker, bool forced = false)
{
Thing thing = FirstBlockingThing(constructible, worker);
if (thing == null)
{
return(null);
}
if (thing.def.category == ThingCategory.Plant)
{
if (worker.CanReserveAndReach(thing, PathEndMode.ClosestTouch, worker.NormalMaxDanger(), 1, -1, null, forced))
{
return(JobMaker.MakeJob(JobDefOf.CutPlant, thing));
}
}
else if (thing.def.category == ThingCategory.Item)
{
if (thing.def.EverHaulable)
{
return(HaulAIUtility.HaulAsideJobFor(worker, thing));
}
Log.ErrorOnce("Never haulable " + thing + " blocking " + constructible.ToStringSafe() + " at " + constructible.Position, 6429262);
}
else if (thing.def.category == ThingCategory.Building)
{
if (((Building)thing).DeconstructibleBy(worker.Faction))
{
if (worker.WorkTypeIsDisabled(WorkTypeDefOf.Construction))
{
JobFailReason.Is(IncapableOfDeconstruction);
return(null);
}
if (worker.CanReserveAndReach(thing, PathEndMode.Touch, worker.NormalMaxDanger(), 1, -1, null, forced))
{
Job job = JobMaker.MakeJob(JobDefOf.Deconstruct, thing);
job.ignoreDesignations = true;
return(job);
}
}
if (thing.def.mineable)
{
if (worker.WorkTypeIsDisabled(WorkTypeDefOf.Mining))
{
JobFailReason.Is(IncapableOfMining);
return(null);
}
if (worker.CanReserveAndReach(thing, PathEndMode.Touch, worker.NormalMaxDanger(), 1, -1, null, forced))
{
Job job2 = JobMaker.MakeJob(JobDefOf.Mine, thing);
job2.ignoreDesignations = true;
return(job2);
}
}
}
return(null);
}
public static Job HaulStuffOffBillGiverJob(Pawn pawn, IBillGiver giver, Thing thingToIgnore)
{
foreach (IntVec3 ingredientStackCell in giver.IngredientStackCells)
{
Thing thing = pawn.Map.thingGrid.ThingAt(ingredientStackCell, ThingCategory.Item);
if (thing != null && thing != thingToIgnore)
{
return(HaulAIUtility.HaulAsideJobFor(pawn, thing));
}
}
return(null);
}
private static Job HaulStuffOffBillGiverJob(Pawn pawn, Building_ReligiousBuildingFacility giver, Thing thingToIgnore)
{
foreach (IntVec3 ingredientStackCell in giver.IngredientStackCells)
{
Thing t = pawn.Map.thingGrid.ThingAt(ingredientStackCell, ThingCategory.Item);
if (t != null && t != thingToIgnore)
{
return(HaulAIUtility.HaulAsideJobFor(pawn, t));
}
}
return((Job)null);
}
public static Job HopperFillFoodJob(Pawn pawn, ISlotGroupParent hopperSgp)
{
Building building = (Building)hopperSgp;
if (!pawn.CanReserveAndReach(building.Position, PathEndMode.Touch, pawn.NormalMaxDanger()))
{
return(null);
}
ThingDef thingDef = null;
Thing firstItem = building.Position.GetFirstItem(building.Map);
if (firstItem != null)
{
if (!Building_NutrientPasteDispenser.IsAcceptableFeedstock(firstItem.def))
{
if (firstItem.IsForbidden(pawn))
{
return(null);
}
return(HaulAIUtility.HaulAsideJobFor(pawn, firstItem));
}
thingDef = firstItem.def;
}
List <Thing> list = (thingDef != null) ? pawn.Map.listerThings.ThingsOfDef(thingDef) : pawn.Map.listerThings.ThingsInGroup(ThingRequestGroup.FoodSourceNotPlantOrTree);
bool flag = false;
for (int i = 0; i < list.Count; i++)
{
Thing thing = list[i];
if (thing.def.IsNutritionGivingIngestible && (thing.def.ingestible.preferability == FoodPreferability.RawBad || thing.def.ingestible.preferability == FoodPreferability.RawTasty) && HaulAIUtility.PawnCanAutomaticallyHaul(pawn, thing, forced: false) && pawn.Map.haulDestinationManager.SlotGroupAt(building.Position).Settings.AllowedToAccept(thing))
{
StoragePriority storagePriority = StoreUtility.CurrentStoragePriorityOf(thing);
if ((int)storagePriority >= (int)hopperSgp.GetSlotGroup().Settings.Priority)
{
flag = true;
JobFailReason.Is(TheOnlyAvailableFoodIsInStorageOfHigherPriorityTrans);
}
else
{
Job job = HaulAIUtility.HaulToCellStorageJob(pawn, thing, building.Position, fitInStoreCell: true);
if (job != null)
{
return(job);
}
}
}
}
if (!flag)
{
JobFailReason.Is(NoFoodToFillHopperTrans);
}
return(null);
}
public override Job JobOnCell(Pawn pawn, IntVec3 c, bool forced = false)
{
Job job = base.JobOnCell(pawn, c);
if (job == null || job.plantDefToSow == null || job.plantDefToSow.blueprintDef == null)
{
return(job);
}
Zone zone = GridsUtility.GetZone(c, pawn.Map);
if (zone != null)
{
foreach (IntVec3 current in GenAdj.AdjacentCells8WayRandomized())
{
IntVec3 intVec = c + current;
if (zone.ContainsCell(intVec))
{
foreach (Thing current2 in pawn.Map.thingGrid.ThingsAt(intVec))
{
if (current2.def != job.plantDefToSow && current2.def.BlockPlanting && ReservationUtility.CanReserve(pawn, current2, 1, -1, null, false) && !ForbidUtility.IsForbidden(current2, pawn))
{
if (current2.def.category == ThingCategory.Plant)
{
Job result = new Job(JobDefOf.CutPlant, current2);
return(result);
}
if (current2.def.EverHaulable)
{
Job result = HaulAIUtility.HaulAsideJobFor(pawn, current2);
return(result);
}
}
}
}
}
}
Predicate <Thing> predicate = (Thing tempThing) => !ForbidUtility.IsForbidden(tempThing, pawn.Faction) && PawnLocalAwareness.AnimalAwareOf(pawn, tempThing) && ReservationUtility.CanReserve(pawn, tempThing, 1, -1, null, false);
Thing thing = GenClosest.ClosestThingReachable(c, pawn.Map, ThingRequest.ForDef(job.plantDefToSow.blueprintDef), PathEndMode.ClosestTouch, TraverseParms.For(pawn, Danger.Deadly, 0, false), 9999f, predicate, null, 0, -1, false, RegionType.Set_Passable, false);
if (thing != null)
{
return(new Job(DefDatabase <JobDef> .GetNamed("SowWithSeeds"), c, thing)
{
plantDefToSow = job.plantDefToSow,
count = 25
});
}
return(null);
}
public Job JobOnThing(Pawn pawn, Thing t)
{
if (!t.def.mineable)
{
return(null);
}
if (Find.DesignationManager.DesignationAt(t.Position, DesignationDefOf.Mine) == null)
{
return(null);
}
if (!pawn.CanReserve(t, 1))
{
return(null);
}
bool flag = false;
for (int i = 0; i < 8; i++)
{
IntVec3 c = t.Position + GenAdj.AdjacentCells[i];
if (c.InBounds() && c.Standable())
{
flag = true;
break;
}
}
if (!flag)
{
for (int j = 0; j < 8; j++)
{
IntVec3 c2 = t.Position + GenAdj.AdjacentCells[j];
if (c2.InBounds())
{
if (c2.Walkable() && !c2.Standable())
{
Thing firstHaulable = c2.GetFirstHaulable();
if (firstHaulable != null && firstHaulable.def.passability == Traversability.PassThroughOnly)
{
return(HaulAIUtility.HaulAsideJobFor(pawn, firstHaulable));
}
}
}
}
return(null);
}
return(new Job(JobDefOf.Mine, t, 1500, true));
}
public override Job JobOnThing(Pawn pawn, Thing t, bool forced = false)
{
List <Thing> thingList = t.Position.GetThingList(t.Map);
for (int i = 0; i < thingList.Count; i++)
{
if (thingList[i] != t && thingList[i].def.category == ThingCategory.Item)
{
Job job = HaulAIUtility.HaulAsideJobFor(pawn, thingList[i]);
if (job != null)
{
return(job);
}
}
}
return(new Job(BetaTrapDefOf.RearmTrapJob, t));
}
/// <summary>
/// Check if a thing is standable beside. If not, set job to a
/// haul job to move something out of the way. Otherwise, job is null.
/// In some cases, when pawn can't stand by thing but there's no way to fix that by hauling,
/// job will still be null when CanStandBy is false.
/// </summary>
public static bool CanStandBy(Pawn pawn, Thing thing, out Job job)
{
if (CellUtilities.EnumerateAdjacentCells(thing.Position).Any(c => c.InBounds() && c.Standable()))
{
job = null;
return(true);
}
var impediment = CellUtilities.GetHaulableImpedimentBeside(thing.Position);
if (impediment != null)
{
job = HaulAIUtility.HaulAsideJobFor(pawn, impediment);
return(false);
}
job = null;
return(false);
}
/* RimWorld.GenConstruct.HandleBlockingThingJob
* Tweaked vanilla code to disregard construction and only cut plants if the hauler is a PlantCutter */
public static Job HandleBlockingThingJob(Thing firstBlocking, Pawn p, bool forced = false)
{
if (firstBlocking.def.category == ThingCategory.Plant)
{
if (p.workSettings.GetPriority(PlantCutting) > 0)
{
if (p.CanReserveAndReach(new LocalTargetInfo(firstBlocking), PathEndMode.ClosestTouch, p.NormalMaxDanger(), 1, -1, null, forced))
{
return(new Job(JobDefOf.CutPlant, firstBlocking));
}
}
}
else if (firstBlocking.def.category == ThingCategory.Item && firstBlocking.def.EverHaulable)
{
return(HaulAIUtility.HaulAsideJobFor(p, firstBlocking));
}
return(null);
}
public override Job JobOnThing(Pawn pawn, Thing t, bool forced = false)
{
// Move things off trap
var thingList = t.Position.GetThingList(t.Map);
for (int i = 0; i < thingList.Count; i++)
{
var thing = thingList[i];
if (thing != t && thing.def.category == ThingCategory.Item)
{
var haulAsideJob = HaulAIUtility.HaulAsideJobFor(pawn, thing);
if (haulAsideJob != null)
{
return(haulAsideJob);
}
}
}
// Rearm trap
return(new Job(JobDefOf.VFES_RearmTrap, t));
}
public static Job HandleBlockingThingJob(Thing constructible, Pawn worker, bool forced = false)
{
Thing thing = GenConstruct.FirstBlockingThing(constructible, worker);
if (thing == null)
{
return(null);
}
if (thing.def.category == ThingCategory.Plant)
{
LocalTargetInfo target = thing;
PathEndMode peMode = PathEndMode.ClosestTouch;
Danger maxDanger = worker.NormalMaxDanger();
if (worker.CanReserveAndReach(target, peMode, maxDanger, 1, -1, null, forced))
{
return(new Job(JobDefOf.CutPlant, thing));
}
}
else if (thing.def.category == ThingCategory.Item)
{
if (thing.def.EverHaulable)
{
return(HaulAIUtility.HaulAsideJobFor(worker, thing));
}
Log.ErrorOnce("Never haulable " + thing + " blocking " + constructible.ToStringSafe() + " at " + constructible.Position, 6429262);
}
else if (thing.def.category == ThingCategory.Building)
{
LocalTargetInfo target = thing;
PathEndMode peMode = PathEndMode.Touch;
Danger maxDanger = worker.NormalMaxDanger();
if (worker.CanReserveAndReach(target, peMode, maxDanger, 1, -1, null, forced))
{
Job job = new Job(JobDefOf.Deconstruct, thing);
job.ignoreDesignations = true;
return(job);
}
}
return(null);
}
public static Toil PlaceHauledThingInCell(TargetIndex cellInd, Toil nextToilOnPlaceFailOrIncomplete, bool storageMode)
{
Toil toil = new Toil();
toil.initAction = delegate()
{
Pawn actor = toil.actor;
Job curJob = actor.jobs.curJob;
IntVec3 cell = curJob.GetTarget(cellInd).Cell;
if (actor.carryTracker.CarriedThing == null)
{
Log.Error(actor + " tried to place hauled thing in cell but is not hauling anything.", false);
return;
}
SlotGroup slotGroup = actor.Map.haulDestinationManager.SlotGroupAt(cell);
if (slotGroup != null && slotGroup.Settings.AllowedToAccept(actor.carryTracker.CarriedThing))
{
actor.Map.designationManager.TryRemoveDesignationOn(actor.carryTracker.CarriedThing, DesignationDefOf.Haul);
}
Action <Thing, int> placedAction = null;
if (curJob.def == DissectionDefOf.DoDissectionBill)
{
placedAction = delegate(Thing th, int added)
{
if (curJob.placedThings == null)
{
curJob.placedThings = new List <ThingCountClass>();
}
ThingCountClass thingCountClass = curJob.placedThings.Find((ThingCountClass x) => x.thing == th);
if (thingCountClass != null)
{
thingCountClass.Count += added;
}
else
{
curJob.placedThings.Add(new ThingCountClass(th, added));
}
};
}
if (!actor.carryTracker.TryDropCarriedThing(cell, ThingPlaceMode.Direct, out Thing thing, placedAction))
{
if (storageMode)
{
if (nextToilOnPlaceFailOrIncomplete != null && StoreUtility.TryFindBestBetterStoreCellFor(actor.carryTracker.CarriedThing, actor, actor.Map, StoragePriority.Unstored, actor.Faction, out IntVec3 c, true))
{
if (actor.CanReserve(c, 1, -1, null, false))
{
actor.Reserve(c, actor.CurJob, 1, -1, null, true);
}
actor.CurJob.SetTarget(cellInd, c);
actor.jobs.curDriver.JumpToToil(nextToilOnPlaceFailOrIncomplete);
return;
}
Job job = HaulAIUtility.HaulAsideJobFor(actor, actor.carryTracker.CarriedThing);
if (job != null)
{
curJob.targetA = job.targetA;
curJob.targetB = job.targetB;
curJob.targetC = job.targetC;
curJob.count = job.count;
curJob.haulOpportunisticDuplicates = job.haulOpportunisticDuplicates;
curJob.haulMode = job.haulMode;
actor.jobs.curDriver.JumpToToil(nextToilOnPlaceFailOrIncomplete);
}
else
{
Log.Error(string.Concat(new object[]
{
"Incomplete haul for ",
actor,
": Could not find anywhere to put ",
actor.carryTracker.CarriedThing,
" near ",
actor.Position,
". Destroying. This should never happen!"
}), false);
actor.carryTracker.CarriedThing.Destroy(DestroyMode.Vanish);
}
}
else if (nextToilOnPlaceFailOrIncomplete != null)
{
actor.jobs.curDriver.JumpToToil(nextToilOnPlaceFailOrIncomplete);
return;
}
}
};
return(toil);
}
public override Job JobOnCell(Pawn pawn, IntVec3 c, bool forced = false)
{
Map map = pawn.Map;
if (c.IsForbidden(pawn))
{
return(null);
}
if (!PlantUtility.GrowthSeasonNow(c, map, true))
{
return(null);
}
if (WorkGiver_GrowerBotany.wantedPlantDef == null)
{
WorkGiver_GrowerBotany.wantedPlantDef = WorkGiver_GrowerBotany.CalculateWantedPlantDef(c, map);
if (WorkGiver_GrowerBotany.wantedPlantDef == null)
{
return(null);
}
}
List <Thing> thingList = c.GetThingList(map);
bool flag = false;
for (int i = 0; i < thingList.Count; i++)
{
Thing thing = thingList[i];
if (thing.def == WorkGiver_GrowerBotany.wantedPlantDef)
{
return(null);
}
if ((thing is Blueprint || thing is Frame) && thing.Faction == pawn.Faction)
{
flag = true;
}
}
if (flag)
{
Thing edifice = c.GetEdifice(map);
if (edifice == null || edifice.def.fertility < 0f)
{
return(null);
}
}
if (WorkGiver_GrowerBotany.wantedPlantDef.plant.cavePlant)
{
if (!c.Roofed(map))
{
JobFailReason.Is(WorkGiver_GrowerSowBotany.CantSowCavePlantBecauseUnroofedTrans, null);
return(null);
}
if (map.glowGrid.GameGlowAt(c, true) > 0f)
{
JobFailReason.Is(WorkGiver_GrowerSowBotany.CantSowCavePlantBecauseOfLightTrans, null);
return(null);
}
}
if (WorkGiver_GrowerBotany.wantedPlantDef.plant.interferesWithRoof && c.Roofed(pawn.Map))
{
return(null);
}
Plant plant = c.GetPlant(map);
if (plant != null && plant.def.plant.blockAdjacentSow)
{
LocalTargetInfo target = plant;
if (!pawn.CanReserve(target, 1, -1, null, forced) || plant.IsForbidden(pawn))
{
return(null);
}
return(new Job(JobDefOf.CutPlant, plant));
}
else
{
Thing thing2 = PlantUtility.AdjacentSowBlocker(WorkGiver_GrowerBotany.wantedPlantDef, c, map);
if (thing2 != null)
{
Plant plant2 = thing2 as Plant;
if (plant2 != null)
{
LocalTargetInfo target = plant2;
if (pawn.CanReserve(target, 1, -1, null, forced) && !plant2.IsForbidden(pawn))
{
IPlantToGrowSettable plantToGrowSettable = plant2.Position.GetPlantToGrowSettable(plant2.Map);
if (plantToGrowSettable == null || plantToGrowSettable.GetPlantDefToGrow() != plant2.def)
{
return(new Job(JobDefOf.CutPlant, plant2));
}
}
}
return(null);
}
if (WorkGiver_GrowerBotany.wantedPlantDef.plant.sowMinSkill > 0 && pawn.skills != null && pawn.skills.GetSkill(SkillDefOf.Plants).Level < WorkGiver_GrowerBotany.wantedPlantDef.plant.sowMinSkill)
{
return(null);
}
int j = 0;
while (j < thingList.Count)
{
Thing thing3 = thingList[j];
if (thing3.def.BlockPlanting)
{
LocalTargetInfo target = thing3;
if (!pawn.CanReserve(target, 1, -1, null, forced))
{
return(null);
}
if (thing3.def.category == ThingCategory.Plant)
{
if (!thing3.IsForbidden(pawn))
{
return(new Job(JobDefOf.CutPlant, thing3));
}
return(null);
}
else
{
if (thing3.def.EverHaulable)
{
return(HaulAIUtility.HaulAsideJobFor(pawn, thing3));
}
return(null);
}
}
else
{
j++;
}
}
if (WorkGiver_GrowerBotany.wantedPlantDef.CanEverPlantAt(c, map) && PlantUtility.GrowthSeasonNow(c, map, true))
{
LocalTargetInfo target = c;
if (pawn.CanReserve(target, 1, -1, null, forced))
{
return(new Job(JobDefOf.Sow, c)
{
plantDefToSow = WorkGiver_GrowerBotany.wantedPlantDef
});
}
}
return(null);
}
}
public override Job JobOnThing(Pawn pawn, Thing t)
{
if (t.Faction != pawn.Faction)
{
return(null);
}
Blueprint blueprint = t as Blueprint;
if (blueprint == null)
{
return(null);
}
Thing thingToIgnore = GenConstruct.MiniToInstallOrBuildingToReinstall(blueprint);
Thing thing = blueprint.FirstBlockingThing(pawn, thingToIgnore, false);
if (thing != null)
{
if (thing.def.category == ThingCategory.Plant)
{
// SINGLE CHANGE FROM VANILLA WorkGiver, make designation instead of immediate cutting plants
//return new Job(JobDefOf.CutPlant, thing);
if (Find.DesignationManager.DesignationOn(thing, DesignationDefOf.CutPlant) == null && Find.DesignationManager.DesignationOn(thing, DesignationDefOf.HarvestPlant) == null)
{
Find.DesignationManager.AddDesignation(new Designation(thing, DesignationDefOf.CutPlant));
}
return(null);
}
else if (thing.def.category == ThingCategory.Item)
{
if (thing.def.EverHaulable)
{
return(HaulAIUtility.HaulAsideJobFor(pawn, thing));
}
Log.ErrorOnce(string.Concat(new object[]
{
"Never haulable ",
thing,
" blocking ",
t,
" at ",
t.Position
}), 6429262);
}
return(null);
}
if (!GenConstruct.CanConstruct(blueprint, pawn))
{
return(null);
}
Job job = this.DeconstructExistingEdificeJob(pawn, blueprint);
if (job != null)
{
return(job);
}
Job job2 = base.ResourceDeliverJobFor(pawn, blueprint);
if (job2 != null)
{
return(job2);
}
Job job3 = this.NoCostFrameMakeJobFor(pawn, blueprint);
if (job3 != null)
{
return(job3);
}
return(null);
}
public override Job JobOnCell(Pawn pawn, IntVec3 c, bool forced = false)
{
Map map = pawn.Map;
if (c.IsForbidden(pawn))
{
return(null);
}
if (!PlantUtility.GrowthSeasonNow(c, map, forSowing: true))
{
return(null);
}
if (WorkGiver_Grower.wantedPlantDef == null)
{
WorkGiver_Grower.wantedPlantDef = WorkGiver_Grower.CalculateWantedPlantDef(c, map);
if (WorkGiver_Grower.wantedPlantDef == null)
{
return(null);
}
}
List <Thing> thingList = c.GetThingList(map);
bool flag = false;
for (int i = 0; i < thingList.Count; i++)
{
Thing thing = thingList[i];
if (thing.def == WorkGiver_Grower.wantedPlantDef)
{
return(null);
}
if ((thing is Blueprint || thing is Frame) && thing.Faction == pawn.Faction)
{
flag = true;
}
}
if (flag)
{
Thing edifice = c.GetEdifice(map);
if (edifice == null || edifice.def.fertility < 0f)
{
return(null);
}
}
if (WorkGiver_Grower.wantedPlantDef.plant.cavePlant)
{
if (!c.Roofed(map))
{
JobFailReason.Is(CantSowCavePlantBecauseUnroofedTrans);
return(null);
}
if (map.glowGrid.GameGlowAt(c, ignoreCavePlants: true) > 0f)
{
JobFailReason.Is(CantSowCavePlantBecauseOfLightTrans);
return(null);
}
}
if (WorkGiver_Grower.wantedPlantDef.plant.interferesWithRoof && c.Roofed(pawn.Map))
{
return(null);
}
Plant plant = c.GetPlant(map);
if (plant != null && plant.def.plant.blockAdjacentSow)
{
if (!pawn.CanReserve(plant, 1, -1, null, forced) || plant.IsForbidden(pawn))
{
return(null);
}
return(JobMaker.MakeJob(JobDefOf.CutPlant, plant));
}
Thing thing2 = PlantUtility.AdjacentSowBlocker(WorkGiver_Grower.wantedPlantDef, c, map);
if (thing2 != null)
{
Plant plant2 = thing2 as Plant;
if (plant2 != null && pawn.CanReserve(plant2, 1, -1, null, forced) && !plant2.IsForbidden(pawn))
{
IPlantToGrowSettable plantToGrowSettable = plant2.Position.GetPlantToGrowSettable(plant2.Map);
if (plantToGrowSettable == null || plantToGrowSettable.GetPlantDefToGrow() != plant2.def)
{
return(JobMaker.MakeJob(JobDefOf.CutPlant, plant2));
}
}
return(null);
}
if (WorkGiver_Grower.wantedPlantDef.plant.sowMinSkill > 0 && pawn.skills != null && pawn.skills.GetSkill(SkillDefOf.Plants).Level < WorkGiver_Grower.wantedPlantDef.plant.sowMinSkill)
{
JobFailReason.Is("UnderAllowedSkill".Translate(WorkGiver_Grower.wantedPlantDef.plant.sowMinSkill), def.label);
return(null);
}
for (int j = 0; j < thingList.Count; j++)
{
Thing thing3 = thingList[j];
if (!thing3.def.BlocksPlanting())
{
continue;
}
if (!pawn.CanReserve(thing3, 1, -1, null, forced))
{
return(null);
}
if (thing3.def.category == ThingCategory.Plant)
{
if (!thing3.IsForbidden(pawn))
{
return(JobMaker.MakeJob(JobDefOf.CutPlant, thing3));
}
return(null);
}
if (thing3.def.EverHaulable)
{
return(HaulAIUtility.HaulAsideJobFor(pawn, thing3));
}
return(null);
}
if (!WorkGiver_Grower.wantedPlantDef.CanEverPlantAt_NewTemp(c, map) || !PlantUtility.GrowthSeasonNow(c, map, forSowing: true) || !pawn.CanReserve(c, 1, -1, null, forced))
{
return(null);
}
Job job = JobMaker.MakeJob(JobDefOf.Sow, c);
job.plantDefToSow = WorkGiver_Grower.wantedPlantDef;
return(job);
}
public override Job JobOnCell(Pawn pawn, IntVec3 c, bool forced = false)
{
//if (!pawn.IsPrisoner)
// return null;
if (c.IsForbidden(pawn))
{
return(null);
}
if (!PlantUtility.GrowthSeasonNow(c, pawn.Map))
{
return(null);
}
if (wantedPlantDef == null)
{
wantedPlantDef = CalculateWantedPlantDef(c, pawn.Map);
if (wantedPlantDef == null)
{
return(null);
}
}
var thingList = c.GetThingList(pawn.Map);
for (var i = 0; i < thingList.Count; i++)
{
var thing = thingList[i];
if (thing.def == wantedPlantDef)
{
return(null);
}
if ((thing is Blueprint || thing is Frame) && thing.Faction == pawn.Faction)
{
return(null);
}
}
var plant = c.GetPlant(pawn.Map);
if (plant != null && plant.def.plant.blockAdjacentSow)
{
if (!pawn.CanReserve(plant, 1, -1, null, false) || plant.IsForbidden(pawn))
{
return(null);
}
return(new Job(JobDefOf.CutPlant, plant));
}
var thing2 = PlantUtility.AdjacentSowBlocker(wantedPlantDef, c, pawn.Map);
if (thing2 != null)
{
var plant2 = thing2 as Plant;
if (plant2 != null && pawn.CanReserve(plant2, 1, -1, null, false) && !plant2.IsForbidden(pawn))
{
var plantToGrowSettable = plant2.Position.GetPlantToGrowSettable(plant2.Map);
if (plantToGrowSettable == null || plantToGrowSettable.GetPlantDefToGrow() != plant2.def)
{
return(new Job(JobDefOf.CutPlant, plant2));
}
}
return(null);
}
if (wantedPlantDef.plant.sowMinSkill > 0 && pawn.skills != null && pawn.skills.GetSkill(SkillDefOf.Plants).Level < wantedPlantDef.plant.sowMinSkill)
{
return(null);
}
if (pawn.IsPrisoner && wantedPlantDef.plant.sowMinSkill > 6 && !PrisonLaborPrefs.AdvancedGrowing)
{
Tutorials.Growing();
return(null);
}
var j = 0;
while (j < thingList.Count)
{
var thing3 = thingList[j];
if (thing3.def.BlockPlanting)
{
if (!pawn.CanReserve(thing3, 1, -1, null, false))
{
return(null);
}
if (thing3.def.category == ThingCategory.Plant)
{
if (!thing3.IsForbidden(pawn))
{
return(new Job(JobDefOf.CutPlant, thing3));
}
return(null);
}
if (thing3.def.EverHaulable)
{
return(HaulAIUtility.HaulAsideJobFor(pawn, thing3));
}
return(null);
}
j++;
}
if (!wantedPlantDef.CanEverPlantAt(c, pawn.Map) || !PlantUtility.GrowthSeasonNow(c, pawn.Map) ||
!pawn.CanReserve(c, 1, -1, null, false))
{
return(null);
}
return(new Job(JobDefOf.Sow, c)
{
plantDefToSow = wantedPlantDef
});
}
private static Toil PlaceHauledThingInCell(TargetIndex cellInd, Toil nextToilOnPlaceFailOrIncomplete, bool storageMode)
{
Toil toil = new Toil();
toil.initAction = (Action)(() =>
{
Pawn actor = toil.actor;
Job curJob = actor.jobs.curJob;
IntVec3 cell = curJob.GetTarget(cellInd).Cell;
if (actor.carryTracker.CarriedThing == null)
{
Log.Error(actor.ToString() + " tried to place hauled thing in cell but is not hauling anything.", false);
}
else
{
SlotGroup slotGroup = actor.Map.haulDestinationManager.SlotGroupAt(cell);
if (slotGroup != null && slotGroup.Settings.AllowedToAccept(actor.carryTracker.CarriedThing))
{
actor.Map.designationManager.TryRemoveDesignationOn(actor.carryTracker.CarriedThing, DesignationDefOf.Haul);
}
Action <Thing, int> placedAction = (Action <Thing, int>)null;
placedAction = (Action <Thing, int>)((th, added) =>
{
if (curJob.placedThings == null)
{
curJob.placedThings = new List <ThingCountClass>();
}
ThingCountClass thingCountClass = curJob.placedThings.Find((Predicate <ThingCountClass>)(x => x.thing == th));
if (thingCountClass != null)
{
thingCountClass.Count += added;
}
else
{
curJob.placedThings.Add(new ThingCountClass(th, added));
}
});
Thing resultingThing;
if (actor.carryTracker.TryDropCarriedThing(cell, ThingPlaceMode.Direct, out resultingThing, placedAction))
{
return;
}
if (storageMode)
{
IntVec3 foundCell;
if (nextToilOnPlaceFailOrIncomplete != null && StoreUtility.TryFindBestBetterStoreCellFor(actor.carryTracker.CarriedThing, actor, actor.Map, StoragePriority.Unstored, actor.Faction, out foundCell, true))
{
if (actor.CanReserve((LocalTargetInfo)foundCell, 1, -1, (ReservationLayerDef)null, false))
{
actor.Reserve((LocalTargetInfo)foundCell, actor.CurJob, 1, -1, (ReservationLayerDef)null, true);
}
actor.CurJob.SetTarget(cellInd, (LocalTargetInfo)foundCell);
actor.jobs.curDriver.JumpToToil(nextToilOnPlaceFailOrIncomplete);
}
else
{
Job job = HaulAIUtility.HaulAsideJobFor(actor, actor.carryTracker.CarriedThing);
if (job != null)
{
curJob.targetA = job.targetA;
curJob.targetB = job.targetB;
curJob.targetC = job.targetC;
curJob.count = job.count;
curJob.haulOpportunisticDuplicates = job.haulOpportunisticDuplicates;
curJob.haulMode = job.haulMode;
actor.jobs.curDriver.JumpToToil(nextToilOnPlaceFailOrIncomplete);
}
else
{
Log.Error("Incomplete haul for " + (object)actor + ": Could not find anywhere to put " + (object)actor.carryTracker.CarriedThing + " near " + (object)actor.Position + ". Destroying. This should never happen!", false);
actor.carryTracker.CarriedThing.Destroy(DestroyMode.Vanish);
}
}
}
else
{
if (nextToilOnPlaceFailOrIncomplete == null)
{
return;
}
actor.jobs.curDriver.JumpToToil(nextToilOnPlaceFailOrIncomplete);
}
}
});
return(toil);
}
public Job JobOnCell(Pawn pawn, IntVec3 c)
{
if (c.IsForbidden(pawn))
{
return(null);
}
if (!GenPlant.GrowthSeasonNow(c))
{
return(null);
}
if (wantedPlantDef == null)
{
DetermineWantedPlantDef(c);
if (wantedPlantDef == null)
{
return(null);
}
}
Plant plant = c.GetPlant();
if (plant != null)
{
if (plant.def == wantedPlantDef)
{
return(null);
}
if (plant.def.plant.blockAdjacentSow)
{
if (!pawn.CanReserve(plant, 1) || plant.IsForbidden(pawn))
{
return(null);
}
return(new Job(JobDefOf.CutPlant, plant));
}
}
Thing thing = GenPlant.AdjacentSowBlocker(wantedPlantDef, c);
if (thing != null)
{
Plant plant2 = thing as Plant;
if (plant2 != null && pawn.CanReserve(plant2, 1) && !plant2.IsForbidden(pawn))
{
Zone_Growing zone_Growing = Find.ZoneManager.ZoneAt(plant2.Position) as Zone_Growing;
if (zone_Growing == null || zone_Growing.GetPlantDefToGrow() != plant2.def)
{
return(new Job(JobDefOf.CutPlant, plant2));
}
}
return(null);
}
List <Thing> list = Find.ThingGrid.ThingsListAt(c);
int i = 0;
while (i < list.Count)
{
Thing thing2 = list[i];
if (thing2.def == wantedPlantDef)
{
return(null);
}
if (thing2.def.BlockPlanting)
{
if (!pawn.CanReserve(thing2, 1))
{
return(null);
}
if (thing2.def.category == ThingCategory.Plant)
{
if (!thing2.IsForbidden(pawn))
{
return(new Job(JobDefOf.CutPlant, thing2));
}
return(null);
}
else
{
if (thing2.def.EverHaulable)
{
return(HaulAIUtility.HaulAsideJobFor(pawn, thing2));
}
return(null);
}
}
else
{
i++;
}
}
if (!wantedPlantDef.CanEverPlantAt(c) || !GenPlant.GrowthSeasonNow(c) || !pawn.CanReserve(c, 1))
{
return(null);
}
return(new Job(JobDefOf.Sow, c)
{
plantDefToSow = wantedPlantDef
});
}
public override Job JobOnThing(Pawn pawn, Thing t, bool forced = false)
{
if (!t.def.mineable)
{
return(null);
}
if (pawn.Map.designationManager.DesignationAt(t.Position, DesignationDefOf.Mine) == null)
{
return(null);
}
if (!pawn.CanReserve(t, 1, -1, null, false))
{
return(null);
}
bool flag = false;
for (int i = 0; i < 8; i++)
{
IntVec3 intVec = t.Position + GenAdj.AdjacentCells[i];
if (intVec.InBounds(pawn.Map) && intVec.Standable(pawn.Map) && ReachabilityImmediate.CanReachImmediate(intVec, t, pawn.Map, PathEndMode.Touch, pawn))
{
flag = true;
break;
}
}
if (!flag)
{
for (int j = 0; j < 8; j++)
{
IntVec3 intVec2 = t.Position + GenAdj.AdjacentCells[j];
if (intVec2.InBounds(t.Map) && ReachabilityImmediate.CanReachImmediate(intVec2, t, pawn.Map, PathEndMode.Touch, pawn) && intVec2.Walkable(t.Map) && !intVec2.Standable(t.Map))
{
Thing thing = null;
List <Thing> thingList = intVec2.GetThingList(t.Map);
int num = 0;
while (num < thingList.Count)
{
if (!thingList[num].def.designateHaulable || thingList[num].def.passability != Traversability.PassThroughOnly)
{
num++;
continue;
}
thing = thingList[num];
break;
}
if (thing != null)
{
Job job = HaulAIUtility.HaulAsideJobFor(pawn, thing);
if (job != null)
{
return(job);
}
JobFailReason.Is(WorkGiver_Miner.NoPathTrans);
return(null);
}
}
}
JobFailReason.Is(WorkGiver_Miner.NoPathTrans);
return(null);
}
return(new Job(JobDefOf.Mine, t, 1500, true));
}
public static Toil PlaceHauledThingAtDest(TargetIndex destInd, Toil nextToilIfNotDonePlacing = null)
{
Toil toil = new Toil();
toil.initAction = delegate
{
//get alllll the vars
Pawn actor = toil.actor;
Thing carriedItem = actor.carryTracker.CarriedThing;
if (carriedItem == null)
{
Log.Error(actor + " tried to place hauled thing in cell but is not hauling anything.");
return;
}
int carryBeforeCount = carriedItem.stackCount;
Job job = actor.CurJob;
var driver = (JobDriver_HaulExplicitly)actor.jobs.curDriver;
driver.init();//this fixes problems
Map map = driver.posting.map;
IntVec3 dest = job.GetTarget(destInd).Cell;
Thing floorItem = null;
foreach (Thing t in dest.GetThingList(map))
{
if (t.def.EverHaulable && t.CanStackWith(carriedItem))
{
floorItem = t;
}
}
//put it down now
Thing placedThing; //gets set if done
bool done = actor.carryTracker.TryDropCarriedThing(dest, ThingPlaceMode.Direct, out placedThing);
if (done)
{
job.count = 0;
driver.record.movedQuantity += carryBeforeCount;
driver.posting.TryRemoveItem(placedThing);
}
else
{
var placedCount = carryBeforeCount - carriedItem.stackCount;
job.count -= placedCount;
driver.record.movedQuantity += placedCount;
var destQueue = job.GetTargetQueue(destInd);
if (nextToilIfNotDonePlacing != null && destQueue.Count != 0)
{
//put the remainder in the next queued cell
job.SetTarget(destInd, destQueue[0]);
destQueue.RemoveAt(0);
driver.JumpToToil(nextToilIfNotDonePlacing);
}
else
{
//can't continue the job normally
job.count = 0;
Job haulAsideJob = HaulAIUtility.HaulAsideJobFor(actor, carriedItem);
if (haulAsideJob != null)
{
actor.jobs.StartJob(haulAsideJob);
}
else
{
Log.Error("Incomplete explicit haul for " + actor
+ ": Could not find anywhere to put "
+ carriedItem + " near " + actor.Position
+ ". Destroying. This should never happen!");
carriedItem.Destroy(DestroyMode.Vanish);
actor.jobs.EndCurrentJob(JobCondition.Incompletable);
}
}
}
};
return(toil);
}
internal static Job HopperFillFoodJob(Pawn pawn, Building hopper, Thing parent)
{
var hopperSgp = hopper as ISlotGroupParent;
if (
(!pawn.CanReserveAndReach(
hopper.Position,
PathEndMode.Touch,
pawn.NormalMaxDanger(),
1)
)
)
{
return(null);
}
ThingDef resourceDef = null;
var firstItem = hopper.Position.GetFirstItem();
if (firstItem != null)
{
if (
(
(parent is Building_NutrientPasteDispenser) &&
(Building_NutrientPasteDispenser.IsAcceptableFeedstock(firstItem.def))
) ||
(
(parent is Building_AutomatedFactory) &&
(((Building_AutomatedFactory)parent).CompHopperUser.ResourceSettings.AllowedToAccept(firstItem))
)
)
{
resourceDef = firstItem.def;
}
else
{
if (firstItem.IsForbidden(pawn))
{
return(( Job )null);
}
return(HaulAIUtility.HaulAsideJobFor(pawn, firstItem));
}
}
List <Thing> list =
resourceDef != null
? Find.Map.listerThings.ThingsOfDef(resourceDef)
: Find.Map.listerThings.ThingsInGroup(ThingRequestGroup.FoodSourceNotPlantOrTree);
for (int index = 0; index < list.Count; ++index)
{
Thing t = list[index];
if (
(t.def.IsNutritionGivingIngestible) &&
(
(t.def.ingestible.preferability == FoodPreferability.RawBad) ||
(t.def.ingestible.preferability == FoodPreferability.RawTasty)
) &&
(HaulAIUtility.PawnCanAutomaticallyHaul(pawn, t)) &&
(
(Find.SlotGroupManager.SlotGroupAt(hopper.Position).Settings.AllowedToAccept(t)) &&
(HaulAIUtility.StoragePriorityAtFor(t.Position, t) < hopperSgp.GetSlotGroup().Settings.Priority)
)
)
{
Job job = HaulAIUtility.HaulMaxNumToCellJob(pawn, t, hopper.Position, true);
if (job != null)
{
return(job);
}
}
}
return(null);
}
// duplicated to make changes
public Toil PlaceHauledThingInCell(TargetIndex cellInd, Toil nextToilOnPlaceFailOrIncomplete, bool storageMode)
{
Toil toil = new Toil();
toil.initAction = delegate
{
Pawn actor = toil.actor;
Job curJob = actor.jobs.curJob;
IntVec3 cell = curJob.GetTarget(cellInd).Cell;
SlotGroup slotGroup = Find.SlotGroupManager.SlotGroupAt(cell);
if (slotGroup != null && slotGroup.Settings.AllowedToAccept(actor.carrier.CarriedThing))
{
Find.DesignationManager.RemoveAllDesignationsOn(actor.carrier.CarriedThing, false);
}
Thing thing;
// call duplicated to make changes
if (TryDropCarriedThing(actor, cell, ThingPlaceMode.Direct, out thing))
{
if (curJob.def == JobDefOf.DoBill && thing != null)
{
if (curJob.placedTargets == null)
{
curJob.placedTargets = new List <TargetInfo>();
}
if (!curJob.placedTargets.Contains(thing))
{
curJob.placedTargets.Add(thing);
}
}
}
else if (storageMode)
{
IntVec3 vec;
// call duplicated to make changes
if (nextToilOnPlaceFailOrIncomplete != null && WorkGiver_HaulGeneral.TryFindBestBetterStoreCellFor(actor.carrier.CarriedThing, actor, StoragePriority.Unstored, actor.Faction, out vec, true))
{
actor.CurJob.SetTarget(cellInd, vec);
actor.jobs.curDriver.SetNextToil(nextToilOnPlaceFailOrIncomplete);
return;
}
Job job = HaulAIUtility.HaulAsideJobFor(actor, actor.carrier.CarriedThing);
if (job != null)
{
curJob.targetA = job.targetA;
curJob.targetB = job.targetB;
curJob.targetC = job.targetC;
curJob.maxNumToCarry = job.maxNumToCarry;
curJob.haulOpportunisticDuplicates = job.haulOpportunisticDuplicates;
curJob.haulMode = job.haulMode;
actor.jobs.curDriver.JumpToToil(nextToilOnPlaceFailOrIncomplete);
}
else
{
Log.Error(string.Concat(new object[]
{
"Incomplete haul for ",
actor,
": Could not find anywhere to put ",
actor.carrier.CarriedThing,
" near ",
actor.Position,
". Destroying. actor.carrier should never happen!"
}));
actor.carrier.CarriedThing.Destroy(DestroyMode.Vanish);
}
}
else if (nextToilOnPlaceFailOrIncomplete != null)
{
actor.jobs.curDriver.SetNextToil(nextToilOnPlaceFailOrIncomplete);
return;
}
};
return(toil);
}
public override Job JobOnThing(Pawn pawn, Thing t, bool forced = false)
{
if (!t.def.mineable)
{
return(null);
}
if (pawn.Map.designationManager.DesignationAt(t.Position, prospectDesig) == null)
{
return(null);
}
LocalTargetInfo target = t;
if (!pawn.CanReserve(target, 1, -1, null, forced))
{
return(null);
}
var reachable = false;
for (var i = 0; i < 8; i++)
{
var intVec = t.Position + GenAdj.AdjacentCells[i];
if (!intVec.InBounds(pawn.Map) || !intVec.Standable(pawn.Map) ||
!ReachabilityImmediate.CanReachImmediate(intVec, t, pawn.Map, PathEndMode.ClosestTouch, pawn))
{
continue;
}
reachable = true;
break;
}
if (reachable)
{
return(new Job(ProspectJob, t, 20000, true));
}
for (var j = 0; j < 8; j++)
{
var intVec2 = t.Position + GenAdj.AdjacentCells[j];
if (!intVec2.InBounds(t.Map) ||
!ReachabilityImmediate.CanReachImmediate(intVec2, t, pawn.Map, PathEndMode.Touch, pawn) ||
!intVec2.Walkable(t.Map) || intVec2.Standable(t.Map))
{
continue;
}
Thing thing = null;
var thingList = intVec2.GetThingList(t.Map);
foreach (var thing1 in thingList)
{
if (!thing1.def.designateHaulable || thing1.def.passability != Traversability.PassThroughOnly)
{
continue;
}
thing = thing1;
break;
}
if (thing == null)
{
continue;
}
var job = HaulAIUtility.HaulAsideJobFor(pawn, thing);
if (job != null)
{
return(job);
}
JobFailReason.Is(NoPathTrans);
return(null);
}
JobFailReason.Is(NoPathTrans);
return(null);
}
public static Job HopperFillFoodJob(Pawn pawn, ISlotGroupParent hopperSgp)
{
Building building = hopperSgp as Building;
if (!pawn.CanReserveAndReach(building.Position, PathEndMode.Touch, pawn.NormalMaxDanger(), 1, -1, null, false))
{
return(null);
}
ThingDef thingDef = null;
Thing firstItem = building.Position.GetFirstItem(building.Map);
if (firstItem != null)
{
if (Building_NutrientPasteDispenser.IsAcceptableFeedstock(firstItem.def))
{
thingDef = firstItem.def;
}
else
{
if (firstItem.IsForbidden(pawn))
{
return(null);
}
return(HaulAIUtility.HaulAsideJobFor(pawn, firstItem));
}
}
List <Thing> list;
if (thingDef == null)
{
list = pawn.Map.listerThings.ThingsInGroup(ThingRequestGroup.FoodSourceNotPlantOrTree);
}
else
{
list = pawn.Map.listerThings.ThingsOfDef(thingDef);
}
bool flag = false;
for (int i = 0; i < list.Count; i++)
{
Thing thing = list[i];
if (thing.def.IsNutritionGivingIngestible)
{
if (thing.def.ingestible.preferability == FoodPreferability.RawBad || thing.def.ingestible.preferability == FoodPreferability.RawTasty)
{
if (HaulAIUtility.PawnCanAutomaticallyHaul(pawn, thing, false))
{
if (pawn.Map.slotGroupManager.SlotGroupAt(building.Position).Settings.AllowedToAccept(thing))
{
StoragePriority storagePriority = HaulAIUtility.StoragePriorityAtFor(thing.Position, thing);
if (storagePriority >= hopperSgp.GetSlotGroup().Settings.Priority)
{
flag = true;
JobFailReason.Is(WorkGiver_CookFillHopper.TheOnlyAvailableFoodIsInStorageOfHigherPriorityTrans);
}
else
{
Job job = HaulAIUtility.HaulMaxNumToCellJob(pawn, thing, building.Position, true);
if (job != null)
{
return(job);
}
}
}
}
}
}
}
if (!flag)
{
JobFailReason.Is(WorkGiver_CookFillHopper.NoFoodToFillHopperTrans);
}
return(null);
}
// Token: 0x060000AB RID: 171 RVA: 0x00005B20 File Offset: 0x00003D20
public override Job JobOnCell(Pawn pawn, IntVec3 c, bool forced = false)
{
Map map = pawn.Map;
bool flag = c.IsForbidden(pawn);
Job result;
if (flag)
{
result = null;
}
else
{
bool flag2 = !PlantUtility.GrowthSeasonNow(c, map, false);
if (flag2)
{
result = null;
}
else
{
bool flag3 = WorkGiver_WPGrower.wantedPlantDef == null;
if (flag3)
{
WorkGiver_WPGrower.wantedPlantDef = WorkGiver_WPGrower.CalculateWantedPlantDef(c, map);
bool flag4 = WorkGiver_WPGrower.wantedPlantDef == null;
if (flag4)
{
return(null);
}
}
List <Thing> thingList = c.GetThingList(map);
bool flag5 = false;
for (int i = 0; i < thingList.Count; i++)
{
Thing thing = thingList[i];
bool flag6 = thing.def == WorkGiver_WPGrower.wantedPlantDef;
if (flag6)
{
return(null);
}
bool flag7 = (thing is Blueprint || thing is Frame) && thing.Faction == pawn.Faction;
if (flag7)
{
flag5 = true;
}
}
bool flag8 = flag5;
if (flag8)
{
Thing edifice = c.GetEdifice(map);
bool flag9 = edifice == null || edifice.def.fertility < 0f;
if (flag9)
{
return(null);
}
}
bool cavePlant = WorkGiver_WPGrower.wantedPlantDef.plant.cavePlant;
if (cavePlant)
{
bool flag10 = !c.Roofed(map);
if (flag10)
{
JobFailReason.Is(WorkGiver_WPGrowerSow.CantSowCavePlantBecauseUnroofedTrans, null);
return(null);
}
bool flag11 = map.glowGrid.GameGlowAt(c, true) > 0f;
if (flag11)
{
JobFailReason.Is(WorkGiver_WPGrowerSow.CantSowCavePlantBecauseOfLightTrans, null);
return(null);
}
}
Plant plant = c.GetPlant(map);
bool flag12 = plant != null && plant.def.plant.blockAdjacentSow;
if (flag12)
{
bool flag13 = !pawn.CanReserve(plant, 1, -1, null, false) || plant.IsForbidden(pawn);
if (flag13)
{
result = null;
}
else
{
result = new Job(JobDefOf.CutPlant, plant);
}
}
else
{
Thing thing2 = PlantUtility.AdjacentSowBlocker(WorkGiver_WPGrower.wantedPlantDef, c, map);
bool flag14 = thing2 != null;
if (flag14)
{
Plant plant2 = thing2 as Plant;
bool flag15 = plant2 != null && pawn.CanReserve(plant2, 1, -1, null, false) && !plant2.IsForbidden(pawn);
if (flag15)
{
IPlantToGrowSettable plantToGrowSettable = plant2.Position.GetPlantToGrowSettable(plant2.Map);
bool flag16 = plantToGrowSettable == null || plantToGrowSettable.GetPlantDefToGrow() != plant2.def;
if (flag16)
{
return(new Job(JobDefOf.CutPlant, plant2));
}
}
result = null;
}
else
{
bool flag17 = WorkGiver_WPGrower.wantedPlantDef.plant.sowMinSkill > 0 && pawn.skills != null && pawn.skills.GetSkill(SkillDefOf.Plants).Level < WorkGiver_WPGrower.wantedPlantDef.plant.sowMinSkill;
if (flag17)
{
result = null;
}
else
{
int j = 0;
while (j < thingList.Count)
{
Thing thing3 = thingList[j];
bool blockPlanting = thing3.def.BlockPlanting;
if (blockPlanting)
{
bool flag18 = !pawn.CanReserve(thing3, 1, -1, null, false);
if (flag18)
{
return(null);
}
bool flag19 = thing3.def.category == ThingCategory.Plant;
if (flag19)
{
bool flag20 = !thing3.IsForbidden(pawn);
if (flag20)
{
return(new Job(JobDefOf.CutPlant, thing3));
}
return(null);
}
else
{
bool everHaulable = thing3.def.EverHaulable;
if (everHaulable)
{
return(HaulAIUtility.HaulAsideJobFor(pawn, thing3));
}
return(null);
}
}
else
{
j++;
}
}
bool flag21 = !WorkGiver_WPGrower.wantedPlantDef.CanEverPlantAt(c, map) || !PlantUtility.GrowthSeasonNow(c, map, false) || !pawn.CanReserve(c, 1, -1, null, false);
if (flag21)
{
result = null;
}
else
{
result = new Job(WPJobDefOf.WPSow, c)
{
plantDefToSow = WorkGiver_WPGrower.wantedPlantDef
};
}
}
}
}
}
}
return(result);
}
