private bool KeepRoomUnlockedForTending(Pawn patient)
{
if ((Settings.KeepUnlockedForUrgentTending && HealthAIUtility.ShouldBeTendedNowByPlayerUrgent(patient)) ||
(Settings.KeepUnlockedForSurgery && HealthAIUtility.ShouldHaveSurgeryDoneNow(patient)) ||
(Settings.KeepUnlockedForAnyTending && HealthAIUtility.ShouldBeTendedNowByPlayer(patient)))
{
return(true);
}
return(false);
}
protected override bool Satisfied(Pawn pawn)
{
if (pawn.Faction == Faction.OfPlayer && pawn.IsHacked() && !pawn.IsActivated() && !pawn.CanStartWorkNow())
{
return(true);
}
else if (HealthAIUtility.ShouldHaveSurgeryDoneNow(pawn) && pawn.OnHackingTable())
{
return(true);
}
return(false);
}
public override float GetPriority(Pawn pawn)
{
if (HealthAIUtility.ShouldHaveSurgeryDoneNow(pawn))
{
return(15f);
}
if (pawn.timetable != null && pawn.timetable.CurrentAssignment == TimeAssignmentDefOf.Sleep)
{
return(10f);
}
return(0f);
}
protected override Job TryGiveJob(Pawn pawn)
{
var food = pawn.needs.food;
if (food == null || food.CurCategory < minCategory)
{
return(null);
}
if (HealthAIUtility.ShouldHaveSurgeryDoneNow(pawn))
{
return(null);
}
var need = pawn.needs.TryGetNeed <Need_Motivation>();
if (need != null)
{
need.IsPrisonerWorking = false;
}
return(base.TryGiveJob(pawn));
}
public static bool get_SpawnedPawnsWhoShouldHaveSurgeryDoneNow(MapPawns __instance, ref List <Pawn> __result)
{
if (spawnedPawnsWhoShouldHaveSurgeryDoneNowResult == null)
{
spawnedPawnsWhoShouldHaveSurgeryDoneNowResult = new List <Pawn>();
}
else
{
spawnedPawnsWhoShouldHaveSurgeryDoneNowResult.Clear();
}
List <Pawn> allPawnsSpawned = __instance.AllPawnsSpawned;
for (int i = 0; i < allPawnsSpawned.Count; i++)
{
if (HealthAIUtility.ShouldHaveSurgeryDoneNow(allPawnsSpawned[i]))
{
spawnedPawnsWhoShouldHaveSurgeryDoneNowResult.Add(allPawnsSpawned[i]);
}
}
__result = spawnedPawnsWhoShouldHaveSurgeryDoneNowResult;
return(false);
}
public override IEnumerable <Thing> PotentialWorkThingsGlobal(Pawn pawn)
{
return(pawn.Map.mapPawns.AllPawns.Where((Pawn p) => p.RaceProps.IsMechanoid && HealthAIUtility.ShouldHaveSurgeryDoneNow(p)).Cast <Thing>());
}
public override ThinkResult TryIssueJobPackage(Pawn pawn, JobIssueParams jobParams)
{
var need = pawn.needs.TryGetNeed <Need_Motivation>();
if (pawn.timetable == null)
{
WorkSettings.InitWorkSettings(pawn);
}
if (HealthAIUtility.ShouldHaveSurgeryDoneNow(pawn))
{
return(ThinkResult.NoJob);
}
if (PrisonLaborPrefs.EnableFullHealRest && (HealthAIUtility.ShouldBeTendedNowByPlayer(pawn) || HealthAIUtility.ShouldSeekMedicalRest(pawn)))
{
return(ThinkResult.NoJob);
}
//Check medical assistance, fed, and rest if not override
if (!PrisonLaborUtility.WorkTime(pawn))
{
Other.Tutorials.Timetable();
if (need != null)
{
need.IsPrisonerWorking = false;
}
return(ThinkResult.NoJob);
}
//Check motivation
if (PrisonLaborPrefs.EnableMotivationMechanics && (need == null || need.IsLazy))
{
return(ThinkResult.NoJob);
}
//Work prisoners will do
WorkSettings.InitWorkSettings(pawn);
var workList = pawn.workSettings.WorkGiversInOrderNormal;
//TODO check this
//workList.RemoveAll(workGiver => workGiver.def.defName == "GrowerSow");
if (need != null)
{
need.IsPrisonerWorking = false;
}
var num = -999;
var targetInfo = TargetInfo.Invalid;
WorkGiver_Scanner workGiver_Scanner = null;
for (var j = 0; j < workList.Count; j++)
{
var workGiver = workList[j];
if (workGiver.def.priorityInType != num && targetInfo.IsValid)
{
break;
}
if (PawnCanUseWorkGiver(pawn, workGiver))
{
try
{
var job2 = workGiver.NonScanJob(pawn);
if (job2 != null)
{
if (need != null)
{
need.IsPrisonerWorking = true;
}
return(new ThinkResult(job2, this, workList[j].def.tagToGive));
}
var scanner = workGiver as WorkGiver_Scanner;
if (scanner != null)
{
if (workGiver.def.scanThings)
{
Predicate <Thing> predicate = t =>
!t.IsForbidden(pawn) && scanner.HasJobOnThing(pawn, t, false);
var enumerable = scanner.PotentialWorkThingsGlobal(pawn);
Thing thing;
if (scanner.Prioritized)
{
var enumerable2 = enumerable;
if (enumerable2 == null)
{
enumerable2 =
pawn.Map.listerThings.ThingsMatching(scanner.PotentialWorkThingRequest);
}
var validator = predicate;
thing = GenClosest.ClosestThing_Global_Reachable(pawn.Position, pawn.Map,
enumerable2, scanner.PathEndMode,
TraverseParms.For(pawn, Danger.Deadly, TraverseMode.ByPawn, false), 9999f,
validator, x => scanner.GetPriority(pawn, x));
}
else
{
var validator = predicate;
var forceGlobalSearch = enumerable != null;
thing = GenClosest.ClosestThingReachable(pawn.Position, pawn.Map,
scanner.PotentialWorkThingRequest, scanner.PathEndMode,
TraverseParms.For(pawn, Danger.Deadly, TraverseMode.ByPawn, false), 9999f,
validator, enumerable, 0, scanner.MaxRegionsToScanBeforeGlobalSearch, forceGlobalSearch,
RegionType.Set_Passable, false);
}
if (thing != null)
{
targetInfo = thing;
workGiver_Scanner = scanner;
}
}
if (workGiver.def.scanCells)
{
var position = pawn.Position;
var num2 = 99999f;
var num3 = -3.40282347E+38f;
var prioritized = scanner.Prioritized;
foreach (var current in scanner.PotentialWorkCellsGlobal(pawn))
{
var flag = false;
float num4 = (current - position).LengthHorizontalSquared;
if (prioritized)
{
if (!current.IsForbidden(pawn) && scanner.HasJobOnCell(pawn, current))
{
var priority = scanner.GetPriority(pawn, current);
if (priority > num3 || priority == num3 && num4 < num2)
{
flag = true;
num3 = priority;
}
}
}
else if (num4 < num2 && !current.IsForbidden(pawn) &&
scanner.HasJobOnCell(pawn, current))
{
flag = true;
}
if (flag)
{
targetInfo = new TargetInfo(current, pawn.Map, false);
workGiver_Scanner = scanner;
num2 = num4;
}
}
}
}
}
catch (Exception ex)
{
Log.Error(string.Concat(pawn, " threw exception in WorkGiver ", workGiver.def.defName, ": ",
ex.ToString()));
}
finally
{
}
if (targetInfo.IsValid)
{
Job job3;
if (targetInfo.HasThing)
{
job3 = workGiver_Scanner.JobOnThing(pawn, targetInfo.Thing, false);
}
else
{
job3 = workGiver_Scanner.JobOnCell(pawn, targetInfo.Cell);
}
if (job3 != null)
{
job3.workGiverDef = workGiver.def;
if (need != null)
{
need.IsPrisonerWorking = true;
}
return(new ThinkResult(job3, this, workList[j].def.tagToGive));
}
Log.ErrorOnce(
string.Concat(workGiver_Scanner, " provided target ", targetInfo,
" but yielded no actual job for pawn ", pawn,
". The CanGiveJob and JobOnX methods may not be synchronized."), 6112651);
}
num = workGiver.def.priorityInType;
}
}
return(ThinkResult.NoJob);
}
public static bool OnHackingTable(this Pawn pawn)
{
if (pawn.CurrentBed() != null && pawn.CurrentBed() is Building_HackingTable && HealthAIUtility.ShouldHaveSurgeryDoneNow(pawn))
{
return(true);
}
return(false);
}
protected override IEnumerable <Toil> MakeNewToils()
{
this.FailOnDespawnedOrNull(TargetIndex.A);
Toil goToPlatform = Toils_Bed.GotoBed(TargetIndex.A);
yield return(goToPlatform);
Toil layDownToil = Toils_LayDown.LayDown(TargetIndex.A, true, false, false, false);
layDownToil.defaultCompleteMode = ToilCompleteMode.Never;
layDownToil.initAction = new Action(delegate {
pawn.ClearAllReservations();
});
layDownToil.AddPreTickAction(delegate
{
if (!(pawn.health.hediffSet.HasNaturallyHealingInjury() || (pawn.OnHackingTable() && HealthAIUtility.ShouldHaveSurgeryDoneNow(pawn))))
{
ReadyForNextToil();
}
if (pawn.jobs.posture == PawnPosture.Standing)
{
RotateToSouth();
}
});
yield return(layDownToil);
Toil toil = new Toil();
toil.defaultCompleteMode = ToilCompleteMode.Never;
toil.initAction = delegate
{
pawn.jobs.posture = PawnPosture.Standing;
pawn.Position = RestingPlace.GetSleepingSlotPos(RestingPlace is Building_HackingTable ? Building_HackingTable.SLOTINDEX : Building_BaseMechanoidPlatform.SLOTINDEX);
RotateToSouth();
};
yield return(toil);
}
protected override IEnumerable <Toil> MakeNewToils()
{
//this.AddFinishAction(new Action(delegate { Log.Message("finish action called for job!"); }));
this.FailOnDespawnedOrNull(TargetIndex.A);
if (RestingPlace is Building_BaseMechanoidPlatform)
{
Log.Message("RestingPlace is Building_BaseMechanoidPlatform");
yield return(Toils_Bed.ClaimBedIfNonMedical(TargetIndex.A));
}
yield return(GoToPlatform(TargetIndex.A));
//goToPlatform.AddPreInitAction(new Action(delegate { Log.Message("first toil pre-initaction"); }));
Toil toil = new Toil();
toil.defaultCompleteMode = ToilCompleteMode.Never;
toil.initAction = delegate
{
if ((pawn.health.hediffSet.HasNaturallyHealingInjury() || pawn.OnHackingTable()))
{
pawn.jobs.posture = PawnPosture.LayingInBed;
}
this.job.expiryInterval = 50;
this.job.checkOverrideOnExpire = true;
pawn.ClearAllReservations();
pawn.Position = RestingPlace.GetSleepingSlotPos(RestingPlace is Building_HackingTable ? Building_HackingTable.SLOTINDEX : Building_BaseMechanoidPlatform.SLOTINDEX);
};
toil.tickAction = delegate
{
if (RestingPlace is Building_BaseMechanoidPlatform && pawn.ownership.OwnedBed != RestingPlace)
{
ReadyForNextToil();
}
if ((pawn.health.hediffSet.HasNaturallyHealingInjury() || (pawn.OnHackingTable() && HealthAIUtility.ShouldHaveSurgeryDoneNow(pawn))))
{
pawn.jobs.posture = PawnPosture.LayingInBed;
}
else
{
pawn.jobs.posture = PawnPosture.Standing;
RotateToSouth();
}
};
yield return(toil);
}
