public static ThinkResult TryIssueJobPackage2(ThinkNode_Priority __instance, Pawn pawn, JobIssueParams jobParams)
{
int count = __instance.subNodes.Count;
for (int index = 0; index < count; ++index)
{
ThinkResult thinkResult = ThinkResult.NoJob;
try
{
ThinkNode thinkNode = __instance.subNodes[index];
if (thinkNode == null)
{
return(thinkResult);
}
thinkResult = thinkNode.TryIssueJobPackage(pawn, jobParams);
}
catch (Exception ex)
{
Log.Error("Exception in " + __instance.GetType() + " TryIssueJobPackage: " + ex.ToString());
}
if (thinkResult.IsValid)
{
return(thinkResult);
}
}
return(ThinkResult.NoJob);
}
/*
* If the mech has no reason to leave a platform, or if it should go to a platform, override the job it intended to do with a mechanoid_rest job.
*/
public override ThinkResult TryIssueJobPackage(Pawn pawn, JobIssueParams jobParams)
{
ThinkResult result = base.TryIssueJobPackage(pawn, jobParams);
//Log.Message("result JobDef: " + result.Job.def.defName);
if (result.Job == null && !pawn.IsActivated())
{
Job job = null;
if (pawn.OnBaseMechanoidPlatform())//If the mech is already on a platform, let it stay on it.
{
job = new Job(WTH_DefOf.WTH_Mechanoid_Rest, pawn.CurrentBed());
}
else//Else, let if find another platform. If it can't find one, let it continue work or idling.
{
Building_BaseMechanoidPlatform closestAvailablePlatform = Utilities.GetAvailableMechanoidPlatform(pawn, pawn);
if (closestAvailablePlatform != null && pawn.CanReserve(closestAvailablePlatform))
{
if (pawn.CurJob != null)
{
pawn.jobs.EndCurrentJob(JobCondition.InterruptForced);
}
job = new Job(WTH_DefOf.WTH_Mechanoid_Rest, closestAvailablePlatform);
}
}
if (job != null)
{
result = new ThinkResult(job, this);
}
}
return(result);
}
private Toil ChainJob()
{
return(new Toil
{
initAction = delegate
{
if (RetrievedWorkFlow.tryToChainJobGiver.FirstOrFallback() is ThinkNode_JobGiver JG)
{
if (MyDebug)
{
Log.Warning("trying to thinknode: " + JG.ToString());
}
ThinkResult TR = JG.TryIssueJobPackage(pawn, default(JobIssueParams));
if (MyDebug)
{
Log.Warning(TR.ToString());
}
if (TR != ThinkResult.NoJob)
{
pawn.jobs.jobQueue.EnqueueFirst(TR.Job);
}
else if (MyDebug)
{
Log.Warning("failed to chain job");
}
}
else
{
if (MyDebug)
{
Log.Warning("no thinknode");
}
}
}
});
public static bool TryIssueJobPackage(ThinkNode_Priority __instance, ref ThinkResult __result, Pawn pawn, JobIssueParams jobParams)
{
ThinkNode subNode;
for (int index = 0; index < __instance.subNodes.Count; ++index)
{
try
{
subNode = __instance.subNodes[index];
}
catch (ArgumentOutOfRangeException) { break; }
try
{
if (subNode != null)
{
ThinkResult thinkResult = subNode.TryIssueJobPackage(pawn, jobParams);
if (null == thinkResult)
{
break;
}
if (thinkResult.IsValid)
{
__result = thinkResult;
return(false);
}
}
}
catch (Exception ex)
{
Log.Error("Exception in " + (object)__instance.GetType() + " TryIssueJobPackage: " + ex.ToString());
}
}
__result = ThinkResult.NoJob;
return(false);
}
public override ThinkResult TryIssueJobPackage(Pawn pawn, JobIssueParams jobParams)
{
ThinkResult result;
if (!HealthAIUtility.ShouldSeekMedicalRest(pawn))
{
result = ThinkResult.NoJob;
}
else if (this.respectTimetable && RestUtility.TimetablePreventsLayDown(pawn) && !HealthAIUtility.ShouldHaveSurgeryDoneNow(pawn) && !HealthAIUtility.ShouldBeTendedNowByPlayer(pawn))
{
result = ThinkResult.NoJob;
}
else if (RestUtility.DisturbancePreventsLyingDown(pawn))
{
result = ThinkResult.NoJob;
}
else
{
Thing thing = RestUtility.FindPatientBedFor(pawn);
if (thing == null)
{
result = ThinkResult.NoJob;
}
else
{
Job job = new Job(JobDefOf.LayDown, thing);
result = new ThinkResult(job, this, null, false);
}
}
return(result);
}
static void Postfix(ref Pawn_JobTracker __instance, ref ThinkResult __result)
{
Pawn pawn = Traverse.Create(__instance).Field("pawn").GetValue <Pawn>();
if (!pawn.RaceProps.IsMechanoid)
{
return;
}
ExtendedDataStorage store = Base.Instance.GetExtendedDataStorage();
if (store != null)
{
//de-activate if should auto recharge and power is very low.
ExtendedPawnData pawnData = store.GetExtendedDataFor(pawn);
if (pawn.ShouldRecharge() &&
pawn.IsActivated()
)
{
pawn.drafter.Drafted = false;
pawnData.isActive = false;
}
}
if (pawn.Downed)
{
return;
}
if (pawn.IsHacked() && pawn.IsActivated() && pawn.health.hediffSet.HasHediff(WTH_DefOf.WTH_TargetingHackedPoorly))
{
HackedPoorlyEvent(pawn);
}
}
private static ThinkResult DetermineNextJob2(Pawn_JobTracker __instance, out ThinkTreeDef thinkTree)
{
ThinkResult result = __instance.DetermineNextConstantThinkTreeJob();
if (result.Job != null)
{
thinkTree = __instance.pawn.thinker.ConstantThinkTree;
return(result);
}
ThinkResult result2 = ThinkResult.NoJob;
try
{
result2 = __instance.pawn.thinker.MainThinkNodeRoot.TryIssueJobPackage(__instance.pawn, default);
}
catch (Exception exception)
{
JobUtility.TryStartErrorRecoverJob(__instance.pawn, __instance.pawn.ToStringSafe() + " threw exception while determining job (main)", exception);
thinkTree = null;
return(ThinkResult.NoJob);
}
finally
{
}
thinkTree = __instance.pawn.thinker.MainThinkTree;
return(result2);
}
private void Button_CallBotForShutdown()
{
this.SpawnRobotAfterRecharge = false;
bool flag = this.robot == null || this.robotIsDestroyed;
if (!flag)
{
bool flag2 = !this.robot.Spawned;
if (!flag2)
{
bool flag3 = this.robot.jobs == null;
if (flag3)
{
Log.Error("Robot has no job driver!");
}
JobGiver_RechargeEnergy x2_JobGiver_RechargeEnergy = new JobGiver_RechargeEnergy();
ThinkResult thinkResult = x2_JobGiver_RechargeEnergy.TryIssueJobPackage(this.robot, default(JobIssueParams));
bool flag4 = thinkResult.Job == null || this.robot.CurJob.def == thinkResult.Job.def;
if (!flag4)
{
this.robot.jobs.StopAll(false);
bool flag5 = this.robot.drafter == null;
if (flag5)
{
this.robot.drafter = new Pawn_DraftController(this.robot);
}
this.robot.drafter.Drafted = false;
this.robot.jobs.StartJob(thinkResult.Job, 0, null, false, true, null, null);
}
}
}
}
private void DoWork_ForceOwnerToSleep()
{
for (int i = 0; i < owners.Count; i++)
{
// preparation: stop all other jobs
if (owners[i].jobs != null)
{
owners[i].jobs.StopAll();
}
// Do Job with JobGiver -> Force owner to sleep
JobGiver_GetRest getRest = new JobGiver_GetRest();
JobIssueParams jobParms = new JobIssueParams();
ThinkResult thinkResult = getRest.TryIssueJobPackage(owners[i], jobParms);
owners[i].jobs.StartJob(thinkResult.Job);
// Alternate: If you want to send the pawn somewhere...
//// Do Job with JobDriver -> Call owner to bed
//JobDriver_GotoTarget jobDriver = new JobDriver_GotoTarget(owner);
//// Alternate: (JobDriver_GotoTarget)MakeDriver(owner, typeof(JobDriver_GotoTarget));
//jobDriver.TargetCell = Position;
//jobDriver.StartJob();
}
}
static void Postfix(ref Pawn_JobTracker __instance, ref ThinkResult __result, ref Pawn ___pawn)
{
if (___pawn.IsHacked() && ___pawn.IsActivated() && ___pawn.health.hediffSet.HasHediff(WTH_DefOf.WTH_TargetingHackedPoorly))
{
HackedPoorlyEvent(___pawn);
}
}
private static void Postfix(ThinkNode_JobGiver __instance, ThinkResult __result, Pawn pawn, JobIssueParams jobParams)
{
if (pawn is Wendigo && __result.Job != null)
{
Log.Message(pawn + " gets " + __result.Job + " from " + __instance);
}
}
public static bool TryIssueJobPackage(ThinkNode_SubtreesByTag __instance, ref ThinkResult __result, Pawn pawn, JobIssueParams jobParams)
{
List <ThinkTreeDef> matchedTrees = new List <ThinkTreeDef>();
foreach (ThinkTreeDef allDef in DefDatabase <ThinkTreeDef> .AllDefs)
{
if (allDef.insertTag == __instance.insertTag)
{
matchedTrees.Add(allDef);
}
}
matchedTrees = matchedTrees.OrderByDescending((ThinkTreeDef tDef) => tDef.insertPriority).ToList();
ThinkTreeDef thinkTreeDef;
for (int i = 0; i < matchedTrees.Count; i++)
{
thinkTreeDef = matchedTrees[i];
ThinkResult result = thinkTreeDef.thinkRoot.TryIssueJobPackage(pawn, jobParams);
if (result.IsValid)
{
__result = result;
return(false);
}
}
__result = ThinkResult.NoJob;
return(false);
}
static void Postfix(Pawn_JobTracker __instance, ref ThinkResult __result)
{
Pawn pawn = Traverse.Create(__instance).Field("pawn").GetValue <Pawn>();
if (!pawn.IsColonistPlayerControlled)
{
return;
}
ExtendedDataStorage store = Base.Instance.GetExtendedDataStorage();
ExtendedPawnData pawnData = store.GetExtendedDataFor(pawn);
if (store == null || pawnData == null)
{
return;
}
if (pawnData.owning == null || !pawnData.owning.Spawned || pawnData.owning.Downed || pawnData.owning.Dead || pawnData.mount != null)
{
return;
}
LocalTargetInfo target = DistanceUtility.GetFirstTarget(__result.Job, TargetIndex.A);
float pawnTargetDistance = DistanceUtility.QuickDistance(pawnData.owning.Position, target.Cell);
if (pawnTargetDistance > 10 || __result.Job.def == JobDefOf.LayDown || __result.Job.def == JobDefOf.Research || pawn.InMentalState || pawn.Dead || pawn.Downed)
{
if (pawnData.owning.jobs.curJob != null && pawnData.owning.jobs.curJob.def == JobDefOf.Wait)
{
pawnData.owning.jobs.EndCurrentJob(JobCondition.InterruptForced);
}
ExtendedPawnData animalData = store.GetExtendedDataFor(pawnData.owning);
pawnData.owning = null;
animalData.ownedBy = null;
}
}
static void Postfix(Pawn_JobTracker __instance, ref ThinkResult __result)
{
Pawn pawn = Traverse.Create(__instance).Field("pawn").GetValue <Pawn>();
//If a hostile pawn owns an animal, make sure it mounts it whenever possible
if (pawn.RaceProps.Humanlike && pawn.Faction != null && pawn.Faction.HostileTo(Faction.OfPlayer) && !pawn.Downed && !pawn.IsBurning() && !pawn.IsPrisoner)
{
ExtendedPawnData pawnData = Base.Instance.GetExtendedDataStorage().GetExtendedDataFor(pawn);
if (pawnData.owning == null || pawnData.owning.Faction != pawn.Faction || pawnData.mount != null || pawnData.owning.Downed || pawnData.owning.Dead || !pawnData.owning.Spawned || pawnData.owning.IsBurning())
{
return;
}
QueuedJob qJob = pawn.jobs.jobQueue.FirstOrFallback(null);
if (qJob != null && (qJob.job.def == GUC_JobDefOf.Mount))
{
return;
}
if (__result.Job.def == GUC_JobDefOf.Mount)
{
return;
}
Job mountJob = new Job(GUC_JobDefOf.Mount, pawnData.owning);
mountJob.count = 1;
__instance.jobQueue.EnqueueFirst(mountJob);
}
}
private static ThinkResult InsertMountingJobs(Pawn pawn, Pawn closestAnimal, LocalTargetInfo target, LocalTargetInfo secondTarget, ref ExtendedPawnData pawnData, ExtendedPawnData animalData, Pawn_JobTracker __instance, ThinkResult __result)
{
ExtendedDataStorage store = Base.Instance.GetExtendedDataStorage();
//__instance.jobQueue.EnqueueFirst(dismountJob);
if (pawn.CanReserve(target) && pawn.CanReserve(closestAnimal))
{
Job oldJob = __result.Job;
ExtendedPawnData pawnDataTest = store.GetExtendedDataFor(pawn);
pawnDataTest.targetJob = oldJob;
Job mountJob = new Job(GUC_JobDefOf.Mount, closestAnimal);
Job rideToJob = new Job(GU_RR_JobDefOf.RideToJob, closestAnimal, target);
if (pawnData.mount != null)
{
__instance.jobQueue.EnqueueFirst(oldJob);
__result = new ThinkResult(rideToJob, __result.SourceNode, __result.Tag, false);
}
else
{
__instance.jobQueue.EnqueueFirst(oldJob);
__instance.jobQueue.EnqueueFirst(rideToJob);
__result = new ThinkResult(mountJob, __result.SourceNode, __result.Tag, false);
}
}
return(__result);
}
//public override void PostLoad()
//{
// subNodes.Add(giverRechargeEnergy);
//}F
public override ThinkResult TryIssueJobPackage(Pawn pawn, JobIssueParams jobIssueParams)
{
statuses.Clear();
if (pawn.needs != null && pawn.needs.rest != null && pawn.needs.rest.CurLevel <= 0.25)
{
statuses.Add(pawn.needs.rest);
}
for (int i = 0; i < this.statuses.Count; i++)
{
ThinkResult jobPackage = new ThinkResult();
if (this.statuses[i] is Need_Rest)
{
jobPackage = this.giverRechargeEnergy.TryIssueJobPackage(pawn, jobIssueParams);
}
if (jobPackage.IsValid)
{
if (this.maxDistToSquadFlag > 0f)
{
IntVec3 cell = jobPackage.Job.targetA.Cell;
if ((pawn.Position - cell).LengthHorizontalSquared > this.maxDistToSquadFlag * this.maxDistToSquadFlag)
{
return(ThinkResult.NoJob);
}
}
return(jobPackage);
}
}
return(ThinkResult.NoJob);
}
public static bool Fringe(MethodBase __originalMethod, ThinkNode_Priority __instance, Pawn pawn, JobIssueParams jobParams, ref string __state, ref ThinkResult __result)
{
if (Active)
{
int count = __instance.subNodes.Count;
for (int i = 0; i < count; i++)
{
ThinkResult result = ThinkResult.NoJob;
Profiler prof = null;
try
{
__state = $"ThinkNode_Priority SubNode [{__instance.subNodes[i].GetType()}]";
prof = ProfileController.Start(__state, null, null, __originalMethod);
result = __instance.subNodes[i].TryIssueJobPackage(pawn, jobParams);
prof.Stop();
}
catch (Exception)
{
prof?.Stop();
}
if (result.IsValid)
{
__result = result;
return(false);
}
}
__result = ThinkResult.NoJob;
return(false);
}
return(true);
}
private static ThinkResult DetermineNextJob2(Pawn_JobTracker __instance, out ThinkTreeDef thinkTree)
{
ThinkResult result = funcDetermineNextConstantThinkTreeJob(__instance);
if (result.Job != null)
{
thinkTree = pawnFieldRef(__instance).thinker.ConstantThinkTree;
return(result);
}
ThinkResult result2 = ThinkResult.NoJob;
try
{
result2 = pawnFieldRef(__instance).thinker.MainThinkNodeRoot.TryIssueJobPackage(pawnFieldRef(__instance), default(JobIssueParams));
}
catch (Exception exception)
{
JobUtility.TryStartErrorRecoverJob(pawnFieldRef(__instance), pawnFieldRef(__instance).ToStringSafe() + " threw exception while determining job (main)", exception);
thinkTree = null;
return(ThinkResult.NoJob);
}
thinkTree = pawnFieldRef(__instance).thinker.MainThinkTree;
return(result2);
}
public static bool DetermineNextJob(Pawn_JobTracker __instance, ref ThinkResult __result, out ThinkTreeDef thinkTree)
{
ThinkResult constantThinkTreeJob = __instance.DetermineNextConstantThinkTreeJob();
if (constantThinkTreeJob.Job != null)
{
thinkTree = __instance.pawn.thinker.ConstantThinkTree;
__result = constantThinkTreeJob;
return(false);
}
ThinkResult thinkResult = ThinkResult.NoJob;
try
{
thinkResult = __instance.pawn.thinker.MainThinkNodeRoot.TryIssueJobPackage(__instance.pawn, new JobIssueParams());
}
catch (Exception ex)
{
JobUtility.TryStartErrorRecoverJob(__instance.pawn, __instance.pawn.ToStringSafe <Pawn>() + " threw exception while determining job (main)", ex);
thinkTree = null;
__result = ThinkResult.NoJob;
return(false);
}
finally
{
}
thinkTree = __instance?.pawn?.thinker?.MainThinkTree; //changed
if (thinkTree == null) //changed
{
thinkResult = ThinkResult.NoJob; //changed
}
__result = thinkResult;
return(false);
}
private static bool IsForbidden(ThinkResult result)
{
if (!result.Job.targetA.HasThing)
{
return(false);
}
return(result.Job.targetA.Thing.IsForbidden(Faction.OfPlayer));
}
private static void mountAnimal(Pawn_JobTracker __instance, Pawn pawn, ExtendedPawnData pawnData, ref ThinkResult __result)
{
Job mountJob = new Job(GUC_JobDefOf.Mount, pawnData.owning);
__result = new ThinkResult(mountJob, __result.SourceNode, __result.Tag, false);
__instance.jobQueue.EnqueueFirst(mountJob);
pawn.mindState.duty = new PawnDuty(DutyDefOf.ExitMapBest);
}
static void Postfix(Pawn_JobTracker __instance, ref ThinkResult __result)
{
Pawn pawn = Traverse.Create(__instance).Field("pawn").GetValue <Pawn>();
if (pawn.IsColonistPlayerControlled || pawn.RaceProps.Animal)
{
return;
}
LocalTargetInfo target = DistanceUtility.GetFirstTarget(__result.Job, TargetIndex.A);
if (!target.IsValid)
{
return;
}
ExtendedDataStorage store = Base.Instance.GetExtendedDataStorage();
if (store == null)
{
return;
}
//Log.Message("wrong duty");
ExtendedPawnData PawnData = store.GetExtendedDataFor(pawn);
Lord lord = pawn.GetLord();
if (lord == null)
{
return;
}
QueuedJob qJob = pawn.jobs.jobQueue.FirstOrFallback(null);
if (qJob != null && (qJob.job.def == GUC_JobDefOf.Dismount))
{
return;
}
Log.Message("curLordToil: " + pawn.GetLord().CurLordToil.ToString() + ", pawn name: " + pawn.Name);
Log.Message("lordJob: " + pawn.GetLord().LordJob + ", pawn name: " + pawn.Name);
Log.Message("lord.CurLordToil.GetType().Name" + lord.CurLordToil.GetType().Name);
if (lord.CurLordToil is LordToil_ExitMapAndEscortCarriers)
{
if (PawnData.owning != null && PawnData.mount == null && !PawnData.owning.Downed && PawnData.owning.Spawned)
{
mountAnimal(__instance, pawn, PawnData, ref __result);
}
}
else if (lord.CurLordToil.GetType().Name == "LordToil_DefendTraderCaravan" || lord.CurLordToil is LordToil_DefendPoint) //first option is internal class, hence this way of accessing.
{
if (PawnData.mount != null)
{
parkAnimal(__instance, pawn, PawnData);
}
}
}
private static void mountAnimal(Pawn_JobTracker __instance, Pawn pawn, ExtendedPawnData pawnData, ref ThinkResult __result)
{
Job oldJob = __result.Job;
Job mountJob = new Job(GUC_JobDefOf.Mount, pawnData.owning);
mountJob.count = 1;
__result = new ThinkResult(mountJob, __result.SourceNode, __result.Tag, false);
__instance.jobQueue.EnqueueFirst(oldJob);
}
protected override bool TryExecuteWorker(IncidentParms parms)
{
Map map = (Map)parms.target;
PawnKindDef elderDragon = WyvernUtility.GetRandomElderDragonForEvent(map);
if (elderDragon == null)
{
return(false);
}
IntVec3 intVec;
if (!RCellFinder.TryFindRandomPawnEntryCell(out intVec, map, CellFinder.EdgeRoadChance_Animal, false, null))
{
return(false);
}
IntVec3 loc = CellFinder.RandomClosewalkCellNear(intVec, map, 10, null);
Pawn newThing = PawnGenerator.GeneratePawn(elderDragon, null);
Pawn newElderDragon = (Pawn)GenSpawn.Spawn(newThing, loc, map, WipeMode.Vanish);
newElderDragon.needs.food.CurLevelPercentage = 1f;
List <Pawn> wildlifeAnimals = map.mapPawns.AllPawnsSpawned.FindAll(p => p != newElderDragon && p.Faction == null && p.RaceProps.Animal && !p.health.Dead);
foreach (Pawn wildlifeAnimal in wildlifeAnimals)
{
if (WyvernUtility.IsElderDragon(wildlifeAnimal))
{
if (!WyvernUtility.IsSameSpecies(newElderDragon, wildlifeAnimal))
{
if (wildlifeAnimal.IsFighting())
{
continue;
}
if (newElderDragon.jobs.TryTakeOrderedJob(new Job(JobDefOf.AttackMelee, wildlifeAnimal)))
{
Messages.Message("TurfWarLabel".Translate().CapitalizeFirst(), newElderDragon, MessageTypeDefOf.NeutralEvent);
}
if (wildlifeAnimal.jobs.TryTakeOrderedJob(new Job(JobDefOf.AttackMelee, newElderDragon)))
{
Messages.Message("TurfWarLabel".Translate().CapitalizeFirst(), wildlifeAnimal, MessageTypeDefOf.NeutralEvent);
}
}
continue;
}
if (Rand.Chance(0.2f) || LoadedModManager.GetMod <MonsterHunterRimworldMod>().GetSettings <MonsterHunterRimworldModSettings>().elderDragonScareAnimals)
{
continue; // animals will flee with a 80% chance
}
JobGiver_ExitMapPanic jobFlee = new JobGiver_ExitMapPanic();
ThinkResult thinkResult = jobFlee.TryIssueJobPackage(wildlifeAnimal, new JobIssueParams()
{
maxDistToSquadFlag = 500
});
wildlifeAnimal.jobs.TryTakeOrderedJob(thinkResult.Job);
}
Find.LetterStack.ReceiveLetter("LetterLabelElderDragonAppear".Translate(), "LetterTextElderDragonAppear".Translate(newElderDragon.Label.CapitalizeFirst()), LetterDefOf.ThreatSmall, new TargetInfo(intVec, map, false), null, null);
return(true);
}
static void Postfix(ref Pawn_JobTracker __instance, ref ThinkResult __result)
{
Pawn pawn = Traverse.Create(__instance).Field("pawn").GetValue <Pawn>();
if (pawn.IsHacked() && pawn.IsActivated() && pawn.health.hediffSet.HasHediff(WTH_DefOf.WTH_TargetingHackedPoorly))
{
HackedPoorlyEvent(pawn);
}
}
public static bool JobGiver_Labor_TryIssueJobPackage_Prefix(ref ThinkResult __result, Pawn pawn)
{
if (!PeacekeeperUtility.IsPeacekeeper(pawn))
{
return(true);
}
__result = ThinkResult.NoJob;
return(false);
}
public override ThinkResult TryIssueJobPackage(Pawn pawn)
{
ThinkResult result = base.TryIssueJobPackage(pawn);
if (result.IsValid)
{
if (IsForbidden(result))
{
return(ThinkResult.NoJob);
}
Map map = pawn.MapHeld;
// Order doesn't matter here
if (result.Job.targetA.Cell.GetRoom(map) == null)
{
return(result);
}
if (result.Job.targetA.Cell.GetRoom(map).Role == RoomRoleDefOf.DiningRoom)
{
return(result);
}
if (result.Job.targetA.Cell.GetRoom(map).Role == RoomRoleDefOf.Hospital)
{
return(result);
}
if (result.Job.targetA.Cell.GetRoom(map).Role == RoomRoleDefOf.RecRoom)
{
return(result);
}
if (result.Job.targetA.Cell.GetRoom(map).Role == RoomRoleDefOf.None)
{
return(result);
}
if (result.Job.targetA.Cell.GetRoom(map).Role == RoomRoleDefOf.Laboratory)
{
return(result);
}
if (result.Job.targetA.Cell.GetRoom(map).Role == RoomRoleDefOf.Barracks)
{
return(result);
}
if (result.Job.targetA.Cell.GetRoom(map).Role == guestroom)
{
return(result);
}
if (result.Job.targetA.Cell.GetRoom(map).Role == kitchen)
{
return(result);
}
if (result.Job.targetA.Cell.GetRoom(map).Role == room)
{
return(result);
}
}
return(ThinkResult.NoJob);
}
private static bool Prefix(JobGiver_Work __instance, Pawn pawn, ref ThinkResult __result)
{
if (!Active)
{
return(true);
}
__result = Detour(__instance, pawn);
return(false);
}
// Token: 0x0600002D RID: 45 RVA: 0x00002758 File Offset: 0x00000958
public override ThinkResult TryIssueJobPackage(Pawn pawn, JobIssueParams jobParm)
{
bool flag = !HealthAIUtility.ShouldSeekMedicalRest(pawn);
ThinkResult result;
if (flag)
{
result = ThinkResult.NoJob;
}
else
{
bool flag2 = !HealthAIUtility.ShouldBeTendedNowByPlayer(pawn);
if (flag2)
{
result = ThinkResult.NoJob;
}
else
{
bool flag3 = !GenCollection.Any <Apparel>(pawn.apparel.WornApparel, (Apparel x) => x.def.defName.Contains("RRY_Equipment_HunterGauntlet"));
if (flag3)
{
result = ThinkResult.NoJob;
}
else
{
Thing thing = RestUtility.FindPatientBedFor(pawn);
bool flag4 = thing == null;
if (flag4)
{
result = ThinkResult.NoJob;
}
else
{
Thing thing2 = null;
bool flag5 = Medicine.GetMedicineCountToFullyHeal(pawn) > 0;
if (flag5)
{
thing2 = HealthAIUtility.FindBestMedicine(pawn, pawn);
}
bool flag6 = thing2 != null;
Job job;
if (flag6)
{
job = new Job(YautjaDefOf.RRY_Yautja_TendSelf, thing, thing2);
}
else
{
job = new Job(YautjaDefOf.RRY_Yautja_TendSelf, thing);
}
result = new ThinkResult(job, this, null, false);
}
}
}
}
return(result);
}
public static bool TryIssueJobPackage(ThinkNode_PrioritySorter __instance, ref ThinkResult __result, Pawn pawn, JobIssueParams jobParams)
{
List <ThinkNode> workingNodes = new List <ThinkNode>();
int count = __instance.subNodes.Count;
for (int index = 0; index < count; ++index)
{
workingNodes.Insert(Rand.Range(0, workingNodes.Count - 1), __instance.subNodes[index]);
}
while (workingNodes.Count > 0)
{
float num1 = 0.0f;
int index1 = -1;
for (int index2 = 0; index2 < workingNodes.Count; ++index2)
{
float num2 = 0.0f;
try
{
num2 = workingNodes[index2].GetPriority(pawn);
}
catch (Exception ex)
{
Log.Error("Exception in " + __instance.GetType() + " GetPriority: " + ex.ToString(), false);
}
if (num2 > 0.0 && (double)num2 >= __instance.minPriority && num2 > num1)
{
num1 = num2;
index1 = index2;
}
}
if (index1 != -1)
{
ThinkResult thinkResult = ThinkResult.NoJob;
try
{
thinkResult = workingNodes[index1].TryIssueJobPackage(pawn, jobParams);
}
catch (Exception ex)
{
Log.Error("Exception in " + __instance.GetType() + " TryIssueJobPackage: " + ex.ToString(), false);
}
if (thinkResult.IsValid)
{
__result = thinkResult;
return(false);
}
workingNodes.RemoveAt(index1);
}
else
{
break;
}
}
__result = ThinkResult.NoJob;
return(false);
}
