private Thing FindIngredient(Pawn pawn, IItemProcessor workThing)
{
Predicate <Thing> validator;
if (workThing.ItemValidator(pawn) != null)
{
validator = workThing.ItemValidator(pawn);
}
else
{
validator = (Thing x) => !x.IsForbidden(pawn) && pawn.CanReserve(x);
}
return(GenClosest.ClosestThingReachable(pawn.Position, pawn.Map, workThing.InputRequest, PathEndMode.ClosestTouch, TraverseParms.For(pawn, Danger.Deadly, TraverseMode.ByPawn, false), 9999f, validator));
}
public override Job TryGiveJob(Pawn pawn)
{
if (!JoyUtility.EnjoyableOutsideNow(pawn, null))
{
return(null);
}
if (PawnUtility.WillSoonHaveBasicNeed(pawn))
{
return(null);
}
Predicate <IntVec3> cellValidator = (IntVec3 x) => !PawnUtility.KnownDangerAt(x, pawn.Map, pawn) && !x.GetTerrain(pawn.Map).avoidWander&& x.Standable(pawn.Map) && !x.Roofed(pawn.Map);
Predicate <Region> validator = delegate(Region x)
{
IntVec3 intVec;
return(x.Room.PsychologicallyOutdoors && !x.IsForbiddenEntirely(pawn) && x.TryFindRandomCellInRegionUnforbidden(pawn, cellValidator, out intVec));
};
Region reg;
if (!CellFinder.TryFindClosestRegionWith(pawn.GetRegion(RegionType.Set_Passable), TraverseParms.For(pawn, Danger.Deadly, TraverseMode.ByPawn, false), validator, 100, out reg, RegionType.Set_Passable))
{
return(null);
}
IntVec3 root;
if (!reg.TryFindRandomCellInRegionUnforbidden(pawn, cellValidator, out root))
{
return(null);
}
List <IntVec3> list;
if (!WalkPathFinder.TryFindWalkPath(pawn, root, out list))
{
return(null);
}
Job job = new Job(this.def.jobDef, list[0]);
job.targetQueueA = new List <LocalTargetInfo>();
for (int i = 1; i < list.Count; i++)
{
job.targetQueueA.Add(list[i]);
}
job.locomotionUrgency = LocomotionUrgency.Walk;
return(job);
}
private HoloEmitter FindEmitter(Pawn p, Corpse corpse)
{
IEnumerable <ThingDef> enumerable = from def in DefDatabase <ThingDef> .AllDefs
where typeof(HoloEmitter).IsAssignableFrom(def.thingClass)
select def;
foreach (ThingDef singleDef in enumerable)
{
Predicate <Thing> predicate = (Thing x) => ((HoloEmitter)x).GetComp <CompHoloEmitter>().SimPawn == null && ReservationUtility.CanReserve(p, x, 1, -1, null, false);
HoloEmitter holoEmitter = (HoloEmitter)GenClosest.ClosestThingReachable(p.Position, p.Map, ThingRequest.ForDef(singleDef), PathEndMode.InteractionCell, TraverseParms.For(p, Danger.Deadly, TraverseMode.ByPawn, false), 9999f, predicate, null, 0, -1, false, RegionType.Set_Passable, false);
if (holoEmitter != null)
{
return(holoEmitter);
}
}
return(null);
}
public override Job TryGiveJob(Pawn pawn)
{
//pawn.mindState.mentalStateHandler.TryStartMentalState(OGChaosDeamonDefOf.MentalState_OGChaosDeamon, null, false, false, null, false);
if (pawn.TryGetAttackVerb(null, false) == null)
{
return(null);
}
Pawn pawn2 = this.FindPawnTarget(pawn);
if (pawn2 != null && pawn.CanReach(pawn2, PathEndMode.Touch, Danger.Deadly, false, false, TraverseMode.ByPawn))
{
return(this.MeleeAttackJob(pawn2));
}
Building building = this.FindTurretTarget(pawn);
if (building != null)
{
return(this.MeleeAttackJob(building));
}
if (pawn2 != null)
{
using PawnPath pawnPath = pawn.Map.pathFinder.FindPath(pawn.Position, pawn2.Position, TraverseParms.For(pawn, Danger.Deadly, TraverseMode.PassDoors, false), PathEndMode.OnCell);
if (!pawnPath.Found)
{
return(null);
}
if (!pawnPath.TryFindLastCellBeforeBlockingDoor(pawn, out IntVec3 loc))
{
Log.Error(pawn + " did TryFindLastCellBeforeDoor but found none when it should have been one. Target: " + pawn2.LabelCap);
return(null);
}
IntVec3 randomCell = CellFinder.RandomRegionNear(loc.GetRegion(pawn.Map, RegionType.Set_Passable), WanderOutsideDoorRegions, TraverseParms.For(pawn, Danger.Deadly, TraverseMode.ByPawn, false), null, null, RegionType.Set_Passable).RandomCell;
if (randomCell == pawn.Position)
{
return(new Job(JobDefOf.Wait, WaitTicks, false));
}
return(new Job(JobDefOf.Goto, randomCell));
}
return(null);
}
private static bool CanReachARoom(Map map, IntVec3 root, List <Room> allRooms)
{
for (int i = 0; i < allRooms.Count; i++)
{
if (map.reachability.CanReach(root, allRooms[i].Cells.RandomElement(), PathEndMode.Touch, TraverseParms.For(TraverseMode.PassDoors, Danger.Deadly, false)))
{
return(true);
}
}
return(false);
}
private static bool TryFindBestBillIngredients(Bill bill, Pawn pawn, Thing billGiver, List <ThingCount> chosen)
{
chosen.Clear();
newRelevantThings.Clear();
if (bill.recipe.ingredients.Count == 0)
{
return(true);
}
IntVec3 rootCell = GetBillGiverRootCell(billGiver, pawn);
Region rootReg = rootCell.GetRegion(pawn.Map);
if (rootReg == null)
{
return(false);
}
MakeIngredientsListInProcessingOrder(ingredientsOrdered, bill);
relevantThings.Clear();
processedThings.Clear();
bool foundAll = false;
Predicate <Thing> baseValidator = (Thing t) => t.Spawned && !t.IsForbidden(pawn) && (float)(t.Position - billGiver.Position).LengthHorizontalSquared < bill.ingredientSearchRadius * bill.ingredientSearchRadius && bill.IsFixedOrAllowedIngredient(t) && bill.recipe.ingredients.Any((IngredientCount ingNeed) => ingNeed.filter.Allows(t)) && pawn.CanReserve(t);
bool billGiverIsPawn = billGiver is Pawn;
if (billGiverIsPawn)
{
AddEveryMedicineToRelevantThings(pawn, billGiver, relevantThings, baseValidator, pawn.Map);
if (TryFindBestBillIngredientsInSet(relevantThings, bill, chosen))
{
relevantThings.Clear();
ingredientsOrdered.Clear();
return(true);
}
}
TraverseParms traverseParams = TraverseParms.For(pawn);
RegionEntryPredicate entryCondition = (Region from, Region r) => r.Allows(traverseParams, isDestination: false);
int adjacentRegionsAvailable = rootReg.Neighbors.Count((Region region) => entryCondition(rootReg, region));
int regionsProcessed = 0;
processedThings.AddRange(relevantThings);
RegionProcessor regionProcessor = delegate(Region r)
{
List <Thing> list = r.ListerThings.ThingsMatching(ThingRequest.ForGroup(ThingRequestGroup.HaulableEver));
for (int i = 0; i < list.Count; i++)
{
Thing thing = list[i];
if (!processedThings.Contains(thing) && ReachabilityWithinRegion.ThingFromRegionListerReachable(thing, r, PathEndMode.ClosestTouch, pawn) && baseValidator(thing) && (!thing.def.IsMedicine || !billGiverIsPawn))
{
newRelevantThings.Add(thing);
processedThings.Add(thing);
}
}
regionsProcessed++;
if (newRelevantThings.Count > 0 && regionsProcessed > adjacentRegionsAvailable)
{
Comparison <Thing> comparison = delegate(Thing t1, Thing t2)
{
float num = (float)(t1.Position - rootCell).LengthHorizontalSquared;
float value = (float)(t2.Position - rootCell).LengthHorizontalSquared;
return(num.CompareTo(value));
};
newRelevantThings.Sort(comparison);
relevantThings.AddRange(newRelevantThings);
newRelevantThings.Clear();
if (TryFindBestBillIngredientsInSet(relevantThings, bill, chosen))
{
foundAll = true;
return(true);
}
}
return(false);
};
RegionTraverser.BreadthFirstTraverse(rootReg, entryCondition, regionProcessor, 99999);
relevantThings.Clear();
newRelevantThings.Clear();
processedThings.Clear();
ingredientsOrdered.Clear();
return(foundAll);
}
private static Thing FindBestAmmo(Pawn pawn, AmmoDef requestedAmmo)
{
Predicate <Thing> validator = (Thing potentialAmmo) =>
{
if (potentialAmmo.IsForbidden(pawn) || !pawn.CanReserve(potentialAmmo))
{
return(false);
}
return(GetPathCost(pawn, potentialAmmo) <= MaxPathCost);
};
return(GenClosest.ClosestThingReachable(pawn.Position, pawn.Map, ThingRequest.ForDef(requestedAmmo), PathEndMode.ClosestTouch, TraverseParms.For(pawn), 9999f, validator));
}
bool TryFindNewTarget()
{
Pawn target = (Pawn)GenClosest.ClosestThingReachable(this.Position, this.Map, ThingRequest.ForGroup(ThingRequestGroup.Pawn), PathEndMode.OnCell, TraverseParms.For(TraverseMode.NoPassClosedDoors, Danger.Deadly, false), 10, new Predicate <Thing>(this.IsValidTarget), null, 0, -1, false, RegionType.Set_Passable, false);
if (target != null)
{
return(true);
}
else
{
return(false);
}
}
public static Building_Bed FindCribFor(Pawn baby, Pawn traveler)
{
Building_Bed crib = null;
// Is a crib already assigned to the baby?
if (baby.ownership != null && baby.ownership.OwnedBed != null && ChildrenUtility.IsBedCrib(baby.ownership.OwnedBed))
{
Building_Bed bedThing = baby.ownership.OwnedBed;
if (RestUtility.IsValidBedFor(bedThing, baby, traveler, false, false))
{
crib = baby.ownership.OwnedBed;
}
}
// If not, let's look for one
else
{
foreach (var thingDef in RestUtility.AllBedDefBestToWorst)
{
if (RestUtility.CanUseBedEver(baby, thingDef) && thingDef.building.bed_maxBodySize <= 0.6f)
{
Building_Bed find_crib = (Building_Bed)GenClosest.ClosestThingReachable(baby.Position, baby.Map, ThingRequest.ForDef(thingDef), PathEndMode.OnCell, TraverseParms.For(traveler), 9999f, (Thing b) => (RestUtility.IsValidBedFor(b, baby, traveler, false, false)), null);
if (find_crib != null)
{
crib = find_crib;
}
}
}
}
return(crib);
}
protected Toil ToilGetWanderCell(Building_Pyre pyre)
{
Toil toil = new Toil()
{
initAction = () =>
{
IntVec3 cell;
bool validCellIsFound = CellFinder.TryFindRandomReachableCellNear(pyre.Position, pyre.Map, Building_Pyre.partyAreaRadius, TraverseParms.For(TraverseMode.NoPassClosedDoors, Danger.None), new Predicate <IntVec3>(this.IsValidCellToWander), null, out cell);
if (validCellIsFound)
{
this.CurJob.targetB = cell;
}
else
{
this.CurJob.targetB = this.pawn.Position;
}
},
defaultCompleteMode = ToilCompleteMode.Instant
};
return(toil);
}
protected override Job TryGiveJob(Pawn pawn)
{
Predicate <Thing> validator = delegate(Thing t)
{
Pawn pawn3 = (Pawn)t;
if (!pawn3.Downed || pawn3.Faction != pawn.Faction || pawn3.InBed() || !pawn.CanReserve(pawn3) || pawn3.IsForbidden(pawn) || GenAI.EnemyIsNear(pawn3, 25f))
{
return(false);
}
return(true);
};
Pawn pawn2 = (Pawn)GenClosest.ClosestThingReachable(pawn.Position, pawn.Map, ThingRequest.ForGroup(ThingRequestGroup.Pawn), PathEndMode.OnCell, TraverseParms.For(pawn), radius, validator);
if (pawn2 == null)
{
return(null);
}
Building_Bed building_Bed = RestUtility.FindBedFor(pawn2, pawn, pawn2.HostFaction == pawn.Faction, checkSocialProperness: false);
if (building_Bed == null || !pawn2.CanReserve(building_Bed))
{
return(null);
}
Job job = new Job(JobDefOf.Rescue, pawn2, building_Bed);
job.count = 1;
return(job);
}
public void SpawnPawnsUntilPoints(float points, Faction faction)
{
IEnumerable <PawnKindDef> source = from x in spawnablePawnKinds
where x.combatPower <= 500f
select x;
PawnKindDef kindDef;
for (int remaining = (int)points; remaining > 0;)
{
if (source.TryRandomElement(out kindDef))
{
Pawn pawn = PawnGenerator.GeneratePawn(kindDef, faction);
Thing spawnedCreature = GenSpawn.Spawn(pawn, CellFinder.RandomClosewalkCellNear(base.Position, base.Map, 2, (IntVec3 c) => c.Standable(base.Map) &&
base.Map.reachability.CanReach(c, this, PathEndMode.Touch, TraverseParms.For(TraverseMode.PassDoors, Danger.Deadly, false))),
base.Map, WipeMode.Vanish);
if (spawnedCreature != null)
{
this.lord.AddPawn(pawn);
}
remaining -= (int)kindDef.combatPower;
}
}
}
private void SpawnInitialPawns(Faction faction)
{
if (this.lord == null)
{
IntVec3 invalid;
if (!CellFinder.TryFindRandomCellNear(this.Position, this.Map, 5, (IntVec3 c) => c.Standable(this.Map) && this.Map.reachability.CanReach(c, this, PathEndMode.Touch, TraverseParms.For(TraverseMode.PassDoors, Danger.Deadly, false)), out invalid, -1))
{
Log.Error("Found no place for insects to spawn " + this, false);
invalid = IntVec3.Invalid;
}
LordJob_AssaultColony lordJob = new LordJob_AssaultColony(this.Faction, false, false, true, false, false);
this.lord = LordMaker.MakeNewLord(this.Faction, lordJob, this.Map, null);
this.SpawnPawnsUntilPoints(200f, faction);
}
}
public static Building_GuestBed FindBedFor(this Pawn pawn)
{
Predicate <Thing> bedValidator = delegate(Thing t) {
if (!(t is Building_GuestBed))
{
return(false);
}
if (!pawn.CanReserveAndReach(t, PathEndMode.OnCell, Danger.Some))
{
return(false);
}
var b = (Building_GuestBed)t;
if (b.CurOccupant != null)
{
return(false);
}
if (b.ForPrisoners)
{
return(false);
}
Find.Maps.ForEach(m => m.reservationManager.ReleaseAllForTarget(b)); // TODO: Put this somewhere smarter
return(!b.IsForbidden(pawn) && !b.IsBurning());
};
var bed = (Building_GuestBed)GenClosest.ClosestThingReachable(pawn.Position, pawn.MapHeld, ThingRequest.ForGroup(ThingRequestGroup.BuildingArtificial), PathEndMode.OnCell, TraverseParms.For(pawn), 500f, bedValidator);
return(bed);
}
// Token: 0x06002628 RID: 9768 RVA: 0x001222BC File Offset: 0x001206BC
public override void Tick()
{
if (base.Spawned)
{
this.sustainer.Maintain();
Vector3 vector = base.Position.ToVector3Shifted();
IntVec3 c;
// throws dust and filth
Rand.PushState();
if (Rand.MTBEventOccurs(TunnelRaidSpawner.FilthSpawnMTB, 1f, 1.TicksToSeconds()) && CellFinder.TryFindRandomReachableCellNear(base.Position, base.Map, TunnelRaidSpawner.FilthSpawnRadius, TraverseParms.For(TraverseMode.NoPassClosedDoors, Danger.Deadly, false), null, null, out c, 999999))
{
FilthMaker.TryMakeFilth(c, base.Map, TunnelRaidSpawner.filthTypes.RandomElement <ThingDef>(), 1);
}
if (Rand.MTBEventOccurs(TunnelRaidSpawner.DustMoteSpawnMTB, 1f, 1.TicksToSeconds()))
{
FleckMaker.ThrowDustPuffThick(new Vector3(vector.x, 0f, vector.z)
{
y = AltitudeLayer.MoteOverhead.AltitudeFor()
}, base.Map, Rand.Range(1.5f, 3f), new Color(1f, 1f, 1f, 2.5f));
}
Rand.PopState();
if (this.secondarySpawnTick <= Find.TickManager.TicksGame)
{
this.sustainer.End();
List <Pawn> list = new List <Pawn>();
SpawnThings(out list);
this.Destroy(DestroyMode.Vanish);
}
}
}
protected override Thing BestIngestItem(Pawn pawn, Predicate <Thing> extraValidator)
{
if (pawn.drugs == null)
{
return(null);
}
Predicate <Thing> predicate = delegate(Thing t)
{
if (!CanIngestForJoy(pawn, t))
{
return(false);
}
return((extraValidator == null || extraValidator(t)) ? true : false);
};
ThingOwner <Thing> innerContainer = pawn.inventory.innerContainer;
for (int i = 0; i < innerContainer.Count; i++)
{
if (predicate(innerContainer[i]))
{
return(innerContainer[i]);
}
}
bool flag = false;
if (pawn.story != null && (pawn.story.traits.DegreeOfTrait(TraitDefOf.DrugDesire) > 0 || pawn.InMentalState))
{
flag = true;
}
takeableDrugs.Clear();
DrugPolicy currentPolicy = pawn.drugs.CurrentPolicy;
for (int j = 0; j < currentPolicy.Count; j++)
{
if (flag || currentPolicy[j].allowedForJoy)
{
takeableDrugs.Add(currentPolicy[j].drug);
}
}
takeableDrugs.Shuffle();
for (int k = 0; k < takeableDrugs.Count; k++)
{
List <Thing> list = pawn.Map.listerThings.ThingsOfDef(takeableDrugs[k]);
if (list.Count > 0)
{
Thing thing = GenClosest.ClosestThing_Global_Reachable(pawn.Position, pawn.Map, list, PathEndMode.OnCell, TraverseParms.For(pawn), 9999f, predicate);
if (thing != null)
{
return(thing);
}
}
}
return(null);
}
public void EvaluateCell(IntVec3 c, CastPositionRequest req,
float maxRangeFromTargetSquared,
float maxRangeFromLocusSquared,
float maxRangeFromCasterSquared,
float rangeFromCasterToCellSquared,
int inRadiusMark
)
{
/////////////// EVALUATE CELL METHOD
if (maxRangeFromTargetSquared > 0.01f && maxRangeFromTargetSquared < 250000f && (c - this.TargetA.Cell).LengthHorizontalSquared > maxRangeFromTargetSquared)
{
if (DebugViewSettings.drawCastPositionSearch)
{
req.caster.Map.debugDrawer.FlashCell(c, 0f, "range target");
}
return;
}
if (maxRangeFromLocusSquared > 0.01 && (c - req.locus).LengthHorizontalSquared > maxRangeFromLocusSquared)
{
if (DebugViewSettings.drawCastPositionSearch)
{
req.caster.Map.debugDrawer.FlashCell(c, 0.1f, "range home");
}
return;
}
if (maxRangeFromCasterSquared > 0.01f)
{
rangeFromCasterToCellSquared = (c - req.caster.Position).LengthHorizontalSquared;
if (rangeFromCasterToCellSquared > maxRangeFromCasterSquared)
{
if (DebugViewSettings.drawCastPositionSearch)
{
req.caster.Map.debugDrawer.FlashCell(c, 0.2f, "range caster");
}
return;
}
}
if (!c.Walkable(req.caster.Map))
{
return;
}
if (req.maxRegionsRadius > 0 && c.GetRegion(req.caster.Map).mark != inRadiusMark)
{
if (DebugViewSettings.drawCastPositionSearch)
{
req.caster.Map.debugDrawer.FlashCell(c, 0.64f, "reg radius");
}
return;
}
if (!req.caster.Map.reachability.CanReach(req.caster.Position, c, PathEndMode.OnCell, TraverseParms.For(req.caster, Danger.Some, TraverseMode.ByPawn, false)))
{
if (DebugViewSettings.drawCastPositionSearch)
{
req.caster.Map.debugDrawer.FlashCell(c, 0.4f, "can't reach");
}
return;
}
}
public void TrySpawnFilth()
{
if (this.parent.Map != null)
{
IntVec3 c;
if (CellFinder.TryFindRandomReachableCellNear(this.parent.Position, this.parent.Map, this.Props.spawnRadius, TraverseParms.For(TraverseMode.NoPassClosedDoors, Danger.Deadly, false), (IntVec3 x) => x.Standable(this.parent.Map), (Region x) => true, out c, 999999))
{
FilthMaker.MakeFilth(c, this.parent.Map, this.Props.filthDef, 1);
}
}
}
protected override Job TryGiveJob(Pawn pawn)
{
if (pawn.Downed || pawn.Dead || !pawn.Spawned)
{
return(null);
}
if (pawn.TryGetAttackVerb(null) == null)
{
return(null);
}
Predicate <Thing> validator = t => ((t != pawn) && t.Spawned) && (t is Building_Turret);
var pawn2 = pawn as CosmicHorrorPawn;
var targetA = GenClosest.ClosestThingReachable(pawn.Position, pawn.MapHeld, ThingRequest.ForGroup(ThingRequestGroup.BuildingArtificial), PathEndMode.ClosestTouch, TraverseParms.For(pawn2, Danger.Deadly, TraverseMode.PassDoors, true), 999f, validator, null);
if (targetA != null)
{
//if (pawnSelf.canReveal()) { pawnSelf.Reveal(); }
return(new Job(JobDefOf.AttackMelee, targetA)
{
//maxNumMeleeAttacks = 1,
expiryInterval = Rand.Range(420, 900)
});
}
bool Predicate2(Thing t)
{
if (t == pawn)
{
return(false);
}
Pawn pawn1 = t as Pawn;
if ((pawn1 == null) || (!t.Spawned) || (pawn1.kindDef.ToString() == "ROM_StarVampire"))
{
return(false);
}
if (pawn1.RaceProps.Animal)
{
return(false);
}
return(true);
}
var thing2 = GenClosest.ClosestThingReachable(pawn.Position, pawn.MapHeld, ThingRequest.ForGroup(ThingRequestGroup.Pawn), PathEndMode.OnCell, TraverseParms.For(pawn2, Danger.Deadly, TraverseMode.PassDoors, false), notRaidingAttackRange, Predicate2);
var pawnTarget = thing2 as Pawn;
if (thing2 == null)
{
return(null);
}
Thing thing3;
using (var path = pawn.Map.pathFinder.FindPath(pawn.Position, thing2.Position, TraverseParms.For(pawn, Danger.Deadly, TraverseMode.PassDoors, false), PathEndMode.OnCell))
{
thing3 = path.FirstBlockingBuilding(out IntVec3 vec, pawn);
}
if (thing3 != null)
{
return(new Job(JobDefOf.AttackMelee, thing3)
{
//maxNumMeleeAttacks = 1,
expiryInterval = Rand.Range(420, 900),
locomotionUrgency = LocomotionUrgency.Sprint
});
}
if (pawnTarget == null)
{
return(null);
}
if (pawnTarget.Downed)
{
return new Job(JobDefOf.AttackMelee, thing2)
{
expiryInterval = Rand.Range(57420, 57900),
locomotionUrgency = LocomotionUrgency.Sprint
}
}
;
return(pawnTarget.Dead
? new Job(JobDefOf.Ingest, thing2)
{
//maxNumMeleeAttacks = 1,
expiryInterval = Rand.Range(57420, 57900),
locomotionUrgency = LocomotionUrgency.Sprint
}
: new Job(JobDefOf.PredatorHunt, thing2)
{
//maxNumMeleeAttacks = 1,
expiryInterval = Rand.Range(57420, 57900),
locomotionUrgency = LocomotionUrgency.Sprint,
killIncappedTarget = true
});
//if (pawnSelf.canReveal()) { pawnSelf.Reveal(); }
//pawnSelf.Hide();
}
}
public static bool TryIssueJobPackage(JobGiver_Work __instance, ref ThinkResult __result, Pawn pawn, JobIssueParams jobParams)
{
if (__instance.emergency && pawn.mindState.priorityWork.IsPrioritized)
{
List <WorkGiverDef> workGiversByPriority = pawn.mindState.priorityWork.WorkGiver.workType.workGiversByPriority;
for (int i = 0; i < workGiversByPriority.Count; i++)
{
WorkGiver worker = workGiversByPriority[i].Worker;
if (WorkGiversRelated(pawn.mindState.priorityWork.WorkGiver, worker.def))
{
Job job = GiverTryGiveJobPrioritized(pawn, worker, pawn.mindState.priorityWork.Cell);
if (job != null)
{
job.playerForced = true;
__result = new ThinkResult(job, __instance, workGiversByPriority[i].tagToGive);
return(false);
}
}
}
pawn.mindState.priorityWork.Clear();
}
List <WorkGiver> list = (!__instance.emergency) ? pawn.workSettings.WorkGiversInOrderNormal : pawn.workSettings.WorkGiversInOrderEmergency;
int num = -999;
TargetInfo bestTargetOfLastPriority = TargetInfo.Invalid;
WorkGiver_Scanner scannerWhoProvidedTarget = null;
WorkGiver_Scanner scanner;
IntVec3 pawnPosition;
float closestDistSquared;
float bestPriority;
bool prioritized;
bool allowUnreachable;
Danger maxPathDanger;
for (int j = 0; j < list.Count; j++)
{
WorkGiver workGiver = list[j];
if (workGiver.def.priorityInType != num && bestTargetOfLastPriority.IsValid)
{
break;
}
if (!PawnCanUseWorkGiver(pawn, workGiver))
{
continue;
}
try
{
Job job2 = workGiver.NonScanJob(pawn);
if (job2 != null)
{
__result = new ThinkResult(job2, __instance, list[j].def.tagToGive);
return(false);
}
scanner = (workGiver as WorkGiver_Scanner);
if (scanner != null)
{
if (scanner.def.scanThings)
{
Predicate <Thing> validator = (Thing t) => !t.IsForbidden(pawn) && scanner.HasJobOnThing(pawn, t);
IEnumerable <Thing> enumerable = scanner.PotentialWorkThingsGlobal(pawn);
Thing thing;
if (scanner.Prioritized)
{
IEnumerable <Thing> enumerable2 = enumerable;
if (enumerable2 == null)
{
enumerable2 = pawn.Map.listerThings.ThingsMatching(scanner.PotentialWorkThingRequest);
}
thing = ((!scanner.AllowUnreachable) ? GenClosest.ClosestThing_Global_Reachable(pawn.Position, pawn.Map, enumerable2, scanner.PathEndMode, TraverseParms.For(pawn, scanner.MaxPathDanger(pawn)), 9999f, validator, (Thing x) => scanner.GetPriority(pawn, x)) : GenClosest.ClosestThing_Global(pawn.Position, enumerable2, 99999f, validator, (Thing x) => scanner.GetPriority(pawn, x)));
}
else if (scanner.AllowUnreachable)
{
IEnumerable <Thing> enumerable3 = enumerable;
if (enumerable3 == null)
{
enumerable3 = pawn.Map.listerThings.ThingsMatching(scanner.PotentialWorkThingRequest);
}
thing = GenClosest.ClosestThing_Global(pawn.Position, enumerable3, 99999f, validator);
}
else
{
thing = GenClosest.ClosestThingReachable(pawn.Position, pawn.Map, scanner.PotentialWorkThingRequest, scanner.PathEndMode, TraverseParms.For(pawn, scanner.MaxPathDanger(pawn)), 9999f, validator, enumerable, 0, scanner.MaxRegionsToScanBeforeGlobalSearch, enumerable != null);
}
if (thing != null)
{
bestTargetOfLastPriority = thing;
scannerWhoProvidedTarget = scanner;
}
}
if (scanner.def.scanCells)
{
pawnPosition = pawn.Position;
closestDistSquared = 99999f;
bestPriority = float.MinValue;
prioritized = scanner.Prioritized;
allowUnreachable = scanner.AllowUnreachable;
maxPathDanger = scanner.MaxPathDanger(pawn);
IEnumerable <IntVec3> enumerable4 = scanner.PotentialWorkCellsGlobal(pawn);
IList <IntVec3> list2;
if ((list2 = (enumerable4 as IList <IntVec3>)) != null)
{
for (int k = 0; k < list2.Count; k++)
{
ProcessCell(list2[k]);
}
}
else
{
foreach (IntVec3 item in enumerable4)
{
ProcessCell(item);
}
}
}
}
void ProcessCell(IntVec3 c)
{
bool flag = false;
float num2 = (c - pawnPosition).LengthHorizontalSquared;
float num3 = 0f;
if (prioritized)
{
if (!c.IsForbidden(pawn) && scanner.HasJobOnCell(pawn, c))
{
if (!allowUnreachable && !pawn.CanReach(c, scanner.PathEndMode, maxPathDanger))
{
return;
}
num3 = scanner.GetPriority(pawn, c);
if (num3 > bestPriority || (num3 == bestPriority && num2 < closestDistSquared))
{
flag = true;
}
}
}
else if (num2 < closestDistSquared && !c.IsForbidden(pawn) && scanner.HasJobOnCell(pawn, c))
{
if (!allowUnreachable && !pawn.CanReach(c, scanner.PathEndMode, maxPathDanger))
{
return;
}
flag = true;
}
if (flag)
{
bestTargetOfLastPriority = new TargetInfo(c, pawn.Map);
scannerWhoProvidedTarget = scanner;
closestDistSquared = num2;
bestPriority = num3;
}
}
}
catch (Exception ex)
{
Log.Error(string.Concat(pawn, " threw exception in WorkGiver ", workGiver.def.defName, ": ", ex.ToString()));
}
finally
{
}
if (bestTargetOfLastPriority.IsValid)
{
Job job3 = (!bestTargetOfLastPriority.HasThing) ? scannerWhoProvidedTarget.JobOnCell(pawn, bestTargetOfLastPriority.Cell) : scannerWhoProvidedTarget.JobOnThing(pawn, bestTargetOfLastPriority.Thing);
if (job3 != null)
{
job3.workGiverDef = scannerWhoProvidedTarget.def;
__result = new ThinkResult(job3, __instance, list[j].def.tagToGive);
return(false);
}
//HACK - I know. I'm awful.
//Log.ErrorOnce(string.Concat(scannerWhoProvidedTarget, " provided target ", bestTargetOfLastPriority, " but yielded no actual job for pawn ", pawn, ". The CanGiveJob and JobOnX methods may not be synchronized."), 6112651);
Log.Warning(string.Concat(scannerWhoProvidedTarget, " provided target ", bestTargetOfLastPriority, " but yielded no actual job for pawn ", pawn, ". The CanGiveJob and JobOnX methods may not be synchronized."));
}
num = workGiver.def.priorityInType;
}
__result = ThinkResult.NoJob;
return(false);
}
protected override Job TryGiveJob(Pawn pawn)
{
if (pawn.gender == Gender.Male && pawn.ageTracker.CurLifeStage.reproductive)
{
Predicate <Thing> validator = delegate(Thing t)
{
Pawn pawn3 = t as Pawn;
if (pawn3.Downed)
{
return(false);
}
if (pawn3.CanCasuallyInteractNow(false) && !pawn3.IsForbidden(pawn))
{
if (pawn3.Faction != pawn.Faction)
{
return(false);
}
if (!PawnUtility.FertileMateTarget(pawn, pawn3))
{
return(false);
}
return(true);
}
return(false);
};
Pawn pawn2 = (Pawn)GenClosest.ClosestThingReachable(pawn.Position, pawn.Map, ThingRequest.ForDef(pawn.def), PathEndMode.Touch, TraverseParms.For(pawn, Danger.Deadly, TraverseMode.ByPawn, false), 30f, validator, null, 0, -1, false, RegionType.Set_Passable, false);
if (pawn2 == null)
{
return(null);
}
return(new Job(JobDefOf.Mate, pawn2));
}
return(null);
}
private bool TryToDefendClosestCarrier(Pawn p, float escortRadius)
{
Pawn closestCarrier = this.GetClosestCarrier(p);
Thing thing = GenClosest.ClosestThingReachable(p.Position, p.Map, ThingRequest.ForGroup(ThingRequestGroup.Corpse), PathEndMode.ClosestTouch, TraverseParms.For(p, Danger.Deadly, TraverseMode.ByPawn, false), 20f, delegate(Thing x)
{
Pawn innerPawn = ((Corpse)x).InnerPawn;
return(innerPawn.Faction == p.Faction && innerPawn.RaceProps.packAnimal);
}, null, 0, 15, false, RegionType.Set_Passable, false);
Thing thing2 = GenClosest.ClosestThingReachable(p.Position, p.Map, ThingRequest.ForGroup(ThingRequestGroup.Pawn), PathEndMode.ClosestTouch, TraverseParms.For(p, Danger.Deadly, TraverseMode.ByPawn, false), 20f, delegate(Thing x)
{
Pawn pawn = (Pawn)x;
return(pawn.Downed && pawn.Faction == p.Faction && pawn.GetTraderCaravanRole() == TraderCaravanRole.Carrier);
}, null, 0, 15, false, RegionType.Set_Passable, false);
Thing thing3 = null;
if (closestCarrier != null)
{
thing3 = closestCarrier;
}
if (thing != null && (thing3 == null || thing.Position.DistanceToSquared(p.Position) < thing3.Position.DistanceToSquared(p.Position)))
{
thing3 = thing;
}
if (thing2 != null && (thing3 == null || thing2.Position.DistanceToSquared(p.Position) < thing3.Position.DistanceToSquared(p.Position)))
{
thing3 = thing2;
}
if (thing3 == null)
{
return(false);
}
if (thing3 is Pawn && !((Pawn)thing3).Downed)
{
p.mindState.duty = new PawnDuty(DutyDefOf.Escort, thing3, escortRadius);
return(true);
}
if (!GenHostility.AnyHostileActiveThreatTo(base.Map, this.lord.faction))
{
return(false);
}
p.mindState.duty = new PawnDuty(DutyDefOf.Defend, thing3.Position, 16f);
return(true);
}
// Token: 0x0600001E RID: 30 RVA: 0x00002C2C File Offset: 0x00001C2C
private Thing Findmech_oil(Pawn pawn, Building_sd_luciprod_distillery barrel)
{
Predicate <Thing> predicate = (Thing x) => !x.IsForbidden(pawn) && pawn.CanReserve(x, 1, -1, null, false);
Predicate <Thing> validator = predicate;
return(GenClosest.ClosestThingReachable(pawn.Position, pawn.Map, ThingRequest.ForDef(ThingDefOf.sd_luciprod_mechanite_oil), PathEndMode.ClosestTouch, TraverseParms.For(pawn, Danger.Deadly, TraverseMode.ByPawn, false), 9999f, validator, null, 0, -1, false, RegionType.Set_Passable, false));
}
protected override Job TryGiveJob(Pawn pawn)
{
if (pawn == null)
{
return(null);
}
if (pawn?.CurJob?.def == VampDefOf.ROMV_Feed)
{
return(null);
}
if (pawn?.TryGetAttackVerb() == null)
{
return(null);
}
Pawn pawn2 = FindPawnTarget(pawn);
if (pawn2 != null && pawn.CanReach(pawn2, PathEndMode.Touch, Danger.Deadly))
{
if (pawn2.InAggroMentalState)
{
return(MeleeAttackJob(pawn2));
}
else
{
return(FeedJob(pawn2));
}
}
Building building = FindTurretTarget(pawn);
if (building != null)
{
return(MeleeAttackJob(building));
}
if (pawn2 != null)
{
using (PawnPath pawnPath = pawn.MapHeld.pathFinder.FindPath(pawn.Position, pawn2.Position, TraverseParms.For(pawn, Danger.Deadly, TraverseMode.PassAllDestroyableThings)))
{
if (!pawnPath.Found)
{
return(null);
}
IntVec3 cellBeforeBlocker;
Thing thing = pawnPath.FirstBlockingBuilding(out cellBeforeBlocker, pawn);
if (thing != null)
{
//Job job = DigUtility.PassBlockerJob(pawn, thing, cellBeforeBlocker, true);
//if (job != null)
//{
return(MeleeAttackJob(thing));
//}
}
IntVec3 loc = pawnPath.LastCellBeforeBlockerOrFinalCell(pawn.MapHeld);
IntVec3 randomCell = CellFinder.RandomRegionNear(loc.GetRegion(pawn.Map), 9, TraverseParms.For(pawn)).RandomCell;
if (randomCell == pawn.PositionHeld)
{
return(new Job(JobDefOf.Wait, 30));
}
return(new Job(JobDefOf.Goto, randomCell));
}
}
Building buildingDoor = FindDoorTarget(pawn);
if (buildingDoor != null)
{
return(MeleeAttackJob(buildingDoor));
}
return(null);
}
public static bool FetchAmmo(Pawn pawn, ThingDef ammoType)
{
bool validator(Thing t)
{
if (t.IsForbidden(pawn))
{
return(false);
}
return(true);
}
Thing thing = GenClosest.ClosestThing_Global_Reachable(pawn.Position, pawn.Map, pawn.Map.listerThings.ThingsOfDef(ammoType), PathEndMode.OnCell, TraverseParms.For(pawn), 9999f, validator);
if (thing != null)
{
if (MassUtility.CountToPickUpUntilOverEncumbered(pawn, thing) > SettingsHelper.LatestVersion.LeastAmmoFetch)
{
Job job = new Job(JobDefOf.FetchAmmunitionCase, thing, pawn.Position);
return(pawn.jobs.TryTakeOrderedJob(job));
}
}
return(false);
}
public static Job TryGiveJobStatic(Pawn pawn, bool inCombat)
{
if (RestraintsUtility.InRestraints(pawn))
{
return(null);
}
else
{
if (!pawn.IsValidSidearmsCarrier())
{
return(null);
}
CompSidearmMemory pawnMemory = CompSidearmMemory.GetMemoryCompForPawn(pawn);
if (pawnMemory == null)
{
return(null);
}
//if (pawnMemory.IsUsingAutotool(true))
// return null;
//WeaponAssingment.equipBestWeaponFromInventoryByPreference(pawn, Globals.DroppingModeEnum.Calm);
if (pawnMemory.RememberedWeapons is null)
{
Log.Warning("pawnMemory of " + pawn.Label + " is missing remembered weapons");
}
Dictionary <ThingDefStuffDefPair, int> dupeCounters = new Dictionary <ThingDefStuffDefPair, int>();
foreach (ThingDefStuffDefPair weaponMemory in pawnMemory.RememberedWeapons)
{
if (!dupeCounters.ContainsKey(weaponMemory))
{
dupeCounters[weaponMemory] = 0;
}
if (!pawn.hasWeaponType(weaponMemory, dupeCounters[weaponMemory]))
{
float maxDist = 1000f;
if (pawn.Faction != Faction.OfPlayer)
{
maxDist = 30f;
}
if (inCombat)
{
maxDist = 12f;
}
bool bladelinkable = weaponMemory.thing.HasComp(typeof(CompBladelinkWeapon));
bool biocodeable = weaponMemory.thing.HasComp(typeof(CompBiocodableWeapon));
IEnumerable <ThingWithComps> matchingWeapons = pawn.Map.listerThings.ThingsOfDef(weaponMemory.thing).OfType <ThingWithComps>().Where(t => t.Stuff == weaponMemory.stuff);
if (bladelinkable)
{
matchingWeapons = matchingWeapons.Where(t =>
{
CompBladelinkWeapon bladelink = t.GetComp <CompBladelinkWeapon>();
return(bladelink != null && bladelink.bondedPawn == pawn);
});
}
if (biocodeable)
{
matchingWeapons = matchingWeapons.Where(t =>
{
CompBiocodableWeapon biocode = t.GetComp <CompBiocodableWeapon>();
if (biocode == null)
{
return(true); //not sure how this could ever happen...
}
if (biocode.Biocoded && biocode.CodedPawn != pawn)
{
return(false);
}
return(true);
});
}
Thing thing = GenClosest.ClosestThing_Global_Reachable(pawn.Position, pawn.Map, matchingWeapons, PathEndMode.OnCell, TraverseParms.For(pawn), maxDist,
(Thing t) => !t.IsForbidden(pawn) && pawn.CanReserve(t),
(Thing t) => SimpleSidearms.ReEquipBest ? t.GetStatValue(StatDefOf.MeleeWeapon_AverageDPS, false) : 0);
//this works properly because better ranged weapons also happen to be better at pistolwhipping
//okay past me, WHAT? Why?
if (thing == null)
{
continue;
}
if (!inCombat)
{
return(JobMaker.MakeJob(SidearmsDefOf.ReequipSecondary, thing));
}
else
{
return(JobMaker.MakeJob(SidearmsDefOf.ReequipSecondaryCombat, thing, pawn.Position));
}
}
dupeCounters[weaponMemory]++;
}
return(null);
}
}
private bool CheckForErrors(List <Pawn> pawns)
{
if (!this.transferables.Any((TransferableOneWay x) => x.CountToTransfer != 0))
{
Messages.Message("CantSendEmptyTransportPods".Translate(), MessageTypeDefOf.RejectInput);
return(false);
}
if (this.MassUsage > this.MassCapacity)
{
this.FlashMass();
Messages.Message("TooBigTransportersMassUsage".Translate(), MessageTypeDefOf.RejectInput);
return(false);
}
if (pawns.Count > PawnCapacity)
{
Messages.Message("OverPawnRiderLimit".Translate(
PawnCapacity.ToString()
), MessageTypeDefOf.RejectInput);
return(false);
}
Pawn pawn = pawns.Find((Pawn x) => !x.MapHeld.reachability.CanReach(x.PositionHeld,
this.transporters[0].parent, PathEndMode.Touch,
TraverseParms.For(TraverseMode.PassDoors, Danger.Deadly, false)));
if (pawn != null)
{
Messages.Message("PawnCantReachTransporters".Translate(
pawn.LabelShort
).CapitalizeFirst(), MessageTypeDefOf.RejectInput);
return(false);
}
Map map = this.transporters[0].parent.Map;
for (int i = 0; i < this.transferables.Count; i++)
{
if (this.transferables[i].ThingDef.category == ThingCategory.Item)
{
int countToTransfer = this.transferables[i].CountToTransfer;
int num = 0;
if (countToTransfer > 0)
{
for (int j = 0; j < this.transferables[i].things.Count; j++)
{
Thing thing = this.transferables[i].things[j];
if (map.reachability.CanReach(thing.Position, this.transporters[0].parent,
PathEndMode.Touch, TraverseParms.For(TraverseMode.PassDoors, Danger.Deadly, false)))
{
num += thing.stackCount;
if (num >= countToTransfer)
{
break;
}
}
}
if (num < countToTransfer)
{
if (countToTransfer == 1)
{
Messages.Message("TransporterItemIsUnreachableSingle".Translate(
this.transferables[i].ThingDef.label
), MessageTypeDefOf.RejectInput);
}
else
{
Messages.Message("TransporterItemIsUnreachableMulti".Translate(
countToTransfer,
this.transferables[i].ThingDef.label
), MessageTypeDefOf.RejectInput);
}
return(false);
}
}
}
}
return(true);
}
public Pawn ClosestCharacter(Pawn pawn)
{
//return (Pawn)AttackTargetFinder.BestAttackTarget(pawn, TargetScanFlags.NeedLOSToPawns | TargetScanFlags.NeedLOSToNonPawns | TargetScanFlags.NeedReachableIfCantHitFromMyPos, x => x is Pawn && !(x is PawnMistCreature), 0f, 12f, default(IntVec3), 3.40282347E+38f, false);
return((Pawn)GenClosest.ClosestThingReachable(pawn.Position, pawn.Map, ThingRequest.ForGroup(ThingRequestGroup.Pawn), PathEndMode.Touch, TraverseParms.For(pawn, Danger.Deadly, TraverseMode.ByPawn, false), 30f, (Thing x) => x is Pawn p && !(x is PawnMistCreature) && !x.DestroyedOrNull() && !p.RaceProps.Animal, null, 0, 30, false, RegionType.Set_Passable, false));
}
protected override Job TryGiveTerminalJob(Pawn pawn)
{
WorkGiver_Scanner scanner = new WorkGiver_Milk();
TargetInfo targetInfo = TargetInfo.Invalid;
Predicate <Thing> predicate = (Thing t) => !t.IsForbidden(pawn) && scanner.HasJobOnThing(pawn, t);
IEnumerable <Thing> enumerable = scanner.PotentialWorkThingsGlobal(pawn);
Thing thing;
if (scanner.Prioritized)
{
IEnumerable <Thing> enumerable2 = enumerable;
if (enumerable2 == null)
{
enumerable2 = Find.ListerThings.ThingsMatching(scanner.PotentialWorkThingRequest);
}
Predicate <Thing> validator = predicate;
thing = GenClosest.ClosestThing_Global_Reachable(pawn.Position, enumerable2, scanner.PathEndMode, TraverseParms.For(pawn, Danger.Deadly, TraverseMode.ByPawn, false), 9999f, validator, (Thing x) => scanner.GetPriority(pawn, x));
}
else
{
Predicate <Thing> validator = predicate;
thing = GenClosest.ClosestThingReachable(pawn.Position, scanner.PotentialWorkThingRequest, scanner.PathEndMode, TraverseParms.For(pawn, Danger.Deadly, TraverseMode.ByPawn, false), 9999f, validator, enumerable, scanner.LocalRegionsToScanFirst, enumerable != null);
}
if (thing != null)
{
targetInfo = thing;
//workGiver_Scanner = scanner;
}
if (targetInfo.HasThing)
{
WorkGiver_Milk milker = new WorkGiver_Milk();
return(milker.JobOnThing(pawn, targetInfo.Thing));
}
return(null);
}
public static bool EnemiesAreNearby(Pawn pawn, int regionsToScan = 9, bool passDoors = false)
{
TraverseParms tp = (!passDoors) ? TraverseParms.For(pawn, Danger.Deadly, TraverseMode.ByPawn, false) : TraverseParms.For(TraverseMode.PassDoors, Danger.Deadly, false);
bool foundEnemy = false;
RegionTraverser.BreadthFirstTraverse(pawn.Position, pawn.Map, (Region from, Region to) => to.Allows(tp, false), delegate(Region r)
{
List <Thing> list = r.ListerThings.ThingsInGroup(ThingRequestGroup.AttackTarget);
for (int i = 0; i < list.Count; i++)
{
if (list[i].HostileTo(pawn))
{
foundEnemy = true;
return(true);
}
}
return(foundEnemy);
}, regionsToScan, RegionType.Set_Passable);
return(foundEnemy);
}
