public static Thing GetAttacker(Pawn pawn, Thing target, bool attackingHive)
{
Pawn pawnTarget = target as Pawn;
Insect enemyBug = target as Insect;
Building_Turret turretTarget = target as Building_Turret;
bool recentAttack = false;
if (pawnTarget != null)
{
recentAttack = pawnTarget.mindState.lastAttackTargetTick <= Find.TickManager.TicksGame && pawnTarget.mindState.lastAttackTargetTick > Find.TickManager.TicksGame - ticksInAttackMode;
}
else if (turretTarget != null)
{
recentAttack = turretTarget.LastAttackTargetTick <= Find.TickManager.TicksGame && turretTarget.LastAttackTargetTick > Find.TickManager.TicksGame - ticksInAttackMode;
}
int dist = IntVec3Utility.ManhattanDistanceFlat(pawn.PositionHeld, target.PositionHeld);
bool withinHiveAndInVisual = JobGiver_InsectGather.WithinHive(pawn, target, false) && GenSight.LineOfSight(pawn.Position, target.Position, pawn.Map, true, null, 0, 0);
bool enemyPawnThreat = (withinHiveAndInVisual || (attackingHive && recentAttack)) && dist < maxAttackDistance;
bool enemyInsectThreat = enemyBug != null && enemyBug.Faction != pawn.Faction && GenSight.LineOfSight(pawn.Position, enemyBug.Position, pawn.Map, true, null, 0, 0) && dist < 30;
if (enemyPawnThreat || enemyInsectThreat)
{
if (pawn.CanReach(target, PathEndMode.Touch, Danger.Deadly, true, TraverseMode.PassDoors))
{
return(target);
}
}
return(null);
}
public override bool HasJobOnThing(Pawn pawn, Thing t, bool forced = false)
{
if (!(t is Fire fire))
{
return(false);
}
if (fire.parent is Pawn pawn2)
{
if (pawn2 == pawn)
{
return(false);
}
if ((pawn2.Faction == pawn.Faction || pawn2.HostFaction == pawn.Faction ||
pawn2.HostFaction == pawn.HostFaction) && !pawn.Map.areaManager.Home[fire.Position] &&
IntVec3Utility.ManhattanDistanceFlat(pawn.Position, pawn2.Position) > MaxReservationCheckDistance)
{
return(false);
}
if (!pawn.CanReach(pawn2, PathEndMode.Touch, Danger.Deadly))
{
return(false);
}
}
else
{
if (pawn.story.DisabledWorkTagsBackstoryAndTraits.OverlapsWithOnAnyWorkType(WorkTags.Firefighting))
{
return(false);
}
if (!pawn.Map.areaManager.Home[fire.Position])
{
JobFailReason.Is(WorkGiver_FixBrokenDownBuilding.NotInHomeAreaTrans);
return(false);
}
}
if (Designator_AreaNoFireFighting.NoFireFightingArea(pawn.Map.areaManager)[fire.Position])
{
return(false);
}
if ((pawn.Position - fire.Position).LengthHorizontalSquared <=
MaxReservationCheckDistance * NearbyPawnRadius)
{
return(!FireIsBeingHandled(fire, pawn));
}
LocalTargetInfo target = fire;
if (!pawn.CanReserve(target, 1, -1, null, forced))
{
return(false);
}
return(!FireIsBeingHandled(fire, pawn));
}
public override bool HasJobOnThing(Pawn pawn, Thing t)
{
Fire fire = t as Fire;
if (fire == null)
{
return(false);
}
Area outpostArea = OG_Util.FindOutpostArea();
Pawn pawn2 = fire.parent as Pawn;
if (pawn2 != null)
{
if (pawn2 == pawn)
{
return(false);
}
if ((pawn2.Faction == pawn.Faction || pawn2.HostFaction == pawn.Faction || pawn2.HostFaction == pawn.HostFaction) &&
((outpostArea == null) || (outpostArea.ActiveCells.Contains(t.Position) == false)) &&
IntVec3Utility.ManhattanDistanceFlat(pawn.Position, pawn2.Position) > 15)
{
return(false);
}
}
else if ((outpostArea == null) ||
(outpostArea.ActiveCells.Contains(t.Position) == false))
{
return(false);
}
return(((pawn.Position - fire.Position).LengthHorizontalSquared <= 225f || pawn.CanReserve(fire, 1)) && !WorkGiver_FightFiresOutpost.FireIsBeingHandled(fire, pawn));
}
private static MinifiedThing GetClosestCandidate(BuildableDef sourceDef, IntVec3 center, Map map, Faction faction, ThingDef stuff)
{
var settings = UseMinifiedBuildings.Settings;
var matches = map.listerThings.ThingsOfDef(ThingDefOf.MinifiedThing).OfType <MinifiedThing>()
.Where(m => m.InnerThing.def == sourceDef && m.InnerThing.Stuff == stuff &&
!m.IsForbidden(faction) &&
InstallBlueprintUtility.ExistingBlueprintFor(m) == null &&
(!m.TryGetQuality(out QualityCategory qc) || (settings.EnableForQualityBuildings && qc >= settings.GetMinQuality(sourceDef.frameDef, map))))
.ToList();
var minDist = int.MaxValue;
MinifiedThing closest = null;
foreach (var t in matches)
{
var dist = IntVec3Utility.ManhattanDistanceFlat(center, t.Position);
if (dist < minDist)
{
minDist = dist;
closest = t;
}
}
return(settings.IsTooFar(minDist) ? null : closest);
}
protected override Job TryGiveJob(Pawn pawn)
{
if (HiveUtility.JobGivenRecentTick(pawn, "Mine"))
{
return(null);
}
Region region = pawn.GetRegion(RegionType.Set_Passable);
if (region == null)
{
return(null);
}
Queen queen = HiveUtility.FindQueen(pawn);
if (queen == null)
{
return(null);
}
IntVec3 pos = IntVec3.Invalid;
List <Egg> eggs = queen.spawnedEggs;
if (eggs != null && eggs.Any())
{
pos = eggs.RandomElement().Position;
}
else
{
pos = queen.hiveLocation;
}
for (int i = 0; i < 40; i++)
{
IntVec3 randomCell = region.RandomCell;
for (int j = 0; j < 4; j++)
{
IntVec3 c = randomCell + GenAdj.CardinalDirections[j];
int dist = IntVec3Utility.ManhattanDistanceFlat(c, pos);
if (dist > 3)
{
continue;
}
if (!c.InBounds(pawn.Map))
{
continue;
}
Building edifice = c.GetEdifice(pawn.Map);
if (edifice != null && (edifice.def.passability == Traversability.Impassable || edifice.def.IsDoor) && edifice.def.size == IntVec2.One && edifice.def != ThingDefOf.CollapsedRocks && pawn.CanReserve(edifice, 1, -1, null, false))
{
return(new Job(JobDefOf.Mine, edifice)
{
ignoreDesignations = true
});
}
}
}
return(null);
}
public override bool HasJobOnThing(Pawn pawn, Thing t, bool forced = false)
{
Fire fire = t as Fire;
bool result;
if (fire == null)
{
result = false;
}
else
{
Pawn pawn2 = fire.parent as Pawn;
if (pawn2 != null)
{
if (pawn2 == pawn)
{
return(false);
}
if (pawn2.Faction == pawn.Faction || pawn2.HostFaction == pawn.Faction || pawn2.HostFaction == pawn.HostFaction)
{
if (!pawn.Map.areaManager.Home[fire.Position] && IntVec3Utility.ManhattanDistanceFlat(pawn.Position, pawn2.Position) > 15)
{
return(false);
}
}
if (!pawn.CanReach(pawn2, PathEndMode.Touch, Danger.Deadly, false, TraverseMode.ByPawn))
{
return(false);
}
}
else
{
if (pawn.story.WorkTagIsDisabled(WorkTags.Firefighting))
{
return(false);
}
if (!pawn.Map.areaManager.Home[fire.Position])
{
JobFailReason.Is(WorkGiver_FixBrokenDownBuilding.NotInHomeAreaTrans, null);
return(false);
}
}
if ((pawn.Position - fire.Position).LengthHorizontalSquared > 225)
{
LocalTargetInfo target = fire;
if (!pawn.CanReserve(target, 1, -1, null, forced))
{
return(false);
}
}
result = !WorkGiver_FightFires.FireIsBeingHandled(fire, pawn);
}
return(result);
}
public virtual Pawn FindVictim(Pawn rapist, Map m, float targetAcquireRadius)
{
if (rapist == null || m == null)
{
return(null);
}
if (!xxx.can_rape(rapist) && requierCanRape)
{
return(null);
}
Pawn best_rapee = null;
var best_fuckability = 0.20f; // Don't rape prisoners with <20% fuckability
foreach (var target in m.mapPawns.AllPawns)
{
//if (target.Faction != Faction.OfPlayer) continue;
//if (rapist.Faction == target.Faction || (!FactionUtility.HostileTo(rapist.Faction, target.Faction) && rapist.Faction != null)) continue;
if (!rapist.HostileTo(target))
{
continue;
}
if (IntVec3Utility.ManhattanDistanceFlat(target.Position, rapist.Position) >= targetAcquireRadius)
{
continue; //Too far to f**k i think.
}
//--Log.Message("[ABF]"+this.GetType().ToString()+"::TryGiveJob( " + rapist.NameStringShort + " -> " + target.NameStringShort + " ) - checking\nCanReserve:"+ rapist.CanReserve(target, comfort_prisoners.max_rapists_per_prisoner, 0) + "\nTargetPositionForbidden:"+ target.Position.IsForbidden(rapist)+"\nCanGetRape:" + xxx.can_get_raped(target));
if (target != rapist && rapist.CanReserve(target, comfort_prisoners.max_rapists_per_prisoner, 0) && !target.Position.IsForbidden(rapist) && Can_rape_Easily(target))
{
if (xxx.is_human(target) || (xxx.is_zoophiliac(rapist) && xxx.is_animal(target) && xxx.config.animals_enabled))
{
var fuc = GetFuckability(rapist, target);
//var fuc = xxx.would_fuck(rapist, target); //Cant Use default would f**k because victims are always bleeding.
//--Log.Message("[ABF]"+this.GetType().ToString()+ "::FindVictim( " + rapist.NameStringShort + " -> " + target.NameStringShort + " ) - fuckability:" + fuc + " ");
if ((fuc > best_fuckability) && (Rand.Value < 0.9 * fuc))
{
best_rapee = target;
best_fuckability = fuc;
}
//else { //--Log.Message("[ABF] JobGiver_RapeEnemy::TryGiveJob( " + rapist.NameStringShort + " -> " + target.NameStringShort + " ) - is not good for me "+ "( " + fuc + " )"); }
}
//else { //--Log.Message("[ABF] JobGiver_RapeEnemy::TryGiveJob( " + rapist.NameStringShort + " -> " + target.NameStringShort + " ) - is not human or not zoophilia"); }
}
//else { //--Log.Message("[ABF] JobGiver_RapeEnemy::TryGiveJob( " + rapist.NameStringShort + " -> " + target.NameStringShort + " ) - is not good"); }
}
//--Log.Message("[RJW]"+this.GetType().ToString()+"::TryGiveJob( " + rapist.NameStringShort + " -> " + best_rapee.NameStringShort + " ) - fuckability:" + best_fuckability + " ");
return(best_rapee);
}
private static Job HopperFillJob(Pawn pawn, ISlotGroupParent hopperSgp, Thing resource)
{
Building building = hopperSgp as Building;
// Get a sorted list (by distance) of matching resources
List <Thing> resources = null;
if (resource != null)
{
resources = Find.Map.listerThings.ThingsOfDef(resource.def)
.Where(t => (
(HaulAIUtility.PawnCanAutomaticallyHaul(pawn, t)) &&
(hopperSgp.GetStoreSettings().AllowedToAccept(t)) &&
(HaulAIUtility.StoragePriorityAtFor(t.Position, t) < hopperSgp.GetSlotGroup().Settings.Priority)
)).ToList();
}
else
{
resources = Find.Map.listerThings.AllThings
.Where(t => (
(HaulAIUtility.PawnCanAutomaticallyHaul(pawn, t)) &&
(hopperSgp.GetStoreSettings().AllowedToAccept(t)) &&
(HaulAIUtility.StoragePriorityAtFor(t.Position, t) < hopperSgp.GetSlotGroup().Settings.Priority)
)).ToList();
}
if (resources.NullOrEmpty())
{
return((Job)null);
}
// Sort by distance (closest first)
resources.Sort((Thing x, Thing y) => (IntVec3Utility.ManhattanDistanceFlat(x.Position, building.Position) < IntVec3Utility.ManhattanDistanceFlat(y.Position, building.Position)) ? -1 : 1);
var grabResource = resources.First();
if (grabResource != null)
{
// Try to haul the first (closest) resource found
var job = HaulAIUtility.HaulMaxNumToCellJob(pawn, grabResource, building.Position, true);
if (job != null)
{
return(job);
}
}
return((Job)null);
}
public override void LordToilTick()
{
base.LordToilTick();
if (this.lord.ticksInToil > GenTicks.TickRareInterval)
{
Building_OrbitalRelay orbitalRelay = OG_Util.FindOrbitalRelay(OG_Util.FactionOfMiningCo);
if (orbitalRelay != null)
{
IntVec3 hostilePosition = orbitalRelay.FindHostileInPerimeter();
if ((hostilePosition == IntVec3.Invalid) ||
(IntVec3Utility.ManhattanDistanceFlat(hostilePosition, this.FlagLoc) > 60)) // If an hostile is still in the perimeter, a new lord will be generated.
{
this.lord.ReceiveMemo("ThreatIsFinished");
}
}
}
}
bool NearDownedEnemy(Thing target, Pawn me)
{
Pawn dead = JobGiver_InsectGatherFood.FindTarget(me);
if (dead == null || target == null)
{
return(false);
}
float dist = (float)IntVec3Utility.ManhattanDistanceFlat(target.Position, me.Position);
float dist2 = (float)IntVec3Utility.ManhattanDistanceFlat(dead.Position, me.Position);
if (dist2 * 1.6f < dist && dist > 20f)
{
return(true);
}
return(false);
}
public static Thing GetClosest(Pawn pawn, List <Thing> list)
{
Thing result = null;
int best = int.MaxValue;
if (list != null && list.Any())
{
Queen queen = HiveUtility.FindQueen(pawn);
if (queen == null)
{
return(null);
}
if (list.Contains(queen as Thing) && !pawn.CanReach(queen, PathEndMode.OnCell, Danger.Deadly, true, TraverseMode.PassDoors))
{
return(queen);
}
else
{
IntVec3 pos = pawn.Position;
Insect insect = pawn as Insect;
if (insect != null && insect.targetColonyFood)
{
pos = queen.colonyFoodLoc;
}
foreach (Thing thing in list)
{
int dist = IntVec3Utility.ManhattanDistanceFlat(pos, thing.Position);
if (dist < best && dist <= JobGiver_InsectHunt.MaxDistance(pawn))
{
if (!pawn.CanReach(thing, PathEndMode.OnCell, Danger.Deadly, true, TraverseMode.PassDoors))
{
best = dist;
result = thing;
}
}
}
}
}
return(result);
}
public static int HiveFoodCount(Queen queen, int maxDistance = 5)
{
if (queen != null)
{
List <Thing> things = queen.Map.listerThings.ThingsOfDef(ThingDefOf.InsectJelly);
if (things != null && things.Any())
{
int foodAmount = 0;
float dist = 0f;
foreach (Thing thing in things)
{
maxDistance = 12;
dist = IntVec3Utility.ManhattanDistanceFlat(thing.Position, queen.hiveLocation);
if (dist <= maxDistance)
{
foodAmount = foodAmount + thing.stackCount;
continue;
}
List <Egg> eggs = queen.spawnedEggs;
if (eggs != null && eggs.Any())
{
maxDistance = 5;
foreach (Egg egg in eggs)
{
if (egg != null)
{
dist = IntVec3Utility.ManhattanDistanceFlat(thing.Position, egg.Position);
if (dist <= maxDistance)
{
foodAmount = foodAmount + thing.stackCount;
continue;
}
}
}
}
}
return(foodAmount);
}
}
return(0);
}
bool AtHome(Pawn me)
{
List <Thing> hives = me.Map.listerThings.ThingsOfDef(ThingDefOf.Hive);
if (!hives.Any())
{
return(false);
}
foreach (Thing hive in hives)
{
int dist = IntVec3Utility.ManhattanDistanceFlat(hive.Position, me.Position);
if (dist < 10)
{
return(true);
}
}
return(false);
}
static Pawn GetClosest(List <Pawn> _pawns, Pawn _me)
{
int best = int.MaxValue;
Pawn result = null;
foreach (Pawn p in _pawns)
{
if (_me.CanReach(p, PathEndMode.Touch, Danger.Deadly, true, TraverseMode.PassDoors))
{
int dist = IntVec3Utility.ManhattanDistanceFlat(_me.PositionHeld, p.PositionHeld);
if (dist < best)
{
best = dist;
result = p;
}
}
}
return(result);
}
public static bool WithinHive(Pawn pawn, Thing thing, bool NearAllyEggs)
{
List <Thing> things = HiveUtility.ListQueens(pawn.Map);
if (things == null || !things.Any())
{
return(false);
}
foreach (Thing t in things)
{
Queen queen = t as Queen;
if (queen != null)
{
if (queen == HiveUtility.FindQueen(pawn) || (NearAllyEggs && queen.Faction == pawn.Faction))
{
int dist = IntVec3Utility.ManhattanDistanceFlat(queen.hiveLocation, thing.Position);
if (dist <= 12)
{
return(true);
}
List <Egg> eggs = queen.spawnedEggs;
if (eggs != null && eggs.Any())
{
foreach (Egg egg in eggs)
{
if (egg != null)
{
dist = IntVec3Utility.ManhattanDistanceFlat(egg.Position, thing.Position);
if (dist <= 5)
{
return(true);
}
}
}
}
}
}
}
return(false);
}
public static bool FindCloserTarget(Pawn pawn, Thing targetA, Thing targetB)
{
IntVec3 pos = pawn.Position;
Insect insect = pawn as Insect;
if (insect != null && insect.targetColonyFood)
{
Queen queen = HiveUtility.FindQueen(pawn);
if (queen != null)
{
pos = queen.colonyFoodLoc;
}
}
float dist = IntVec3Utility.ManhattanDistanceFlat(targetA.Position, pos);
float dist2 = IntVec3Utility.ManhattanDistanceFlat(targetB.Position, pos);
if (dist2 < dist)
{
return(true);
}
return(false);
}
private static int CalculateDistanceToHives(IntVec3 cell, Map map)
{
int best = int.MaxValue;
List <Thing> things = HiveUtility.ListQueens(map);
if (things != null && things.Any())
{
foreach (Thing thing in things)
{
Queen queen = thing as Queen;
if (queen != null && queen.hiveLocation != null && queen.hiveLocation.IsValid)
{
int dist = IntVec3Utility.ManhattanDistanceFlat(cell, queen.hiveLocation);
if (dist < best)
{
best = dist;
}
}
}
}
return(best);
}
public static Thing GetClosest(Pawn pawn, List <Thing> things)
{
if (things == null || !things.Any())
{
return(null);
}
Thing result = null;
int best = int.MaxValue;
IntVec3 pos = pawn.Position;
Insect insect = pawn as Insect;
if (insect != null && insect.targetColonyFood)
{
Queen queen = HiveUtility.FindQueen(pawn);
if (queen != null)
{
pos = queen.colonyFoodLoc;
}
}
foreach (Thing thing in things)
{
int dist = IntVec3Utility.ManhattanDistanceFlat(pos, thing.Position);
if (dist < best && dist <= JobGiver_InsectHunt.MaxDistance(pawn))
{
if (pawn.CanReserve(thing) && pawn.CanReach(thing, PathEndMode.Touch, Danger.Deadly, true, TraverseMode.PassDoors))
{
best = dist;
result = thing;
}
}
}
return(result);
}
//public override bool HasJobOnThing(Pawn pawn, Thing t, bool forced = false)
static bool Prefix(Pawn pawn, Thing t, bool forced, ref bool __result)
{
//Log.Message("Hello from Patch_WorkGiver_FightFires_HasJobOnThing Prefix!");
Fire fire = t as Fire;
if (fire == null)
{
__result = false;
return(false);
}
Pawn pawn2 = fire.parent as Pawn;
bool isFireInArea = isInFirefightingArea(fire.Map, fire.Position);
if (pawn2 != null)
{
if (pawn2 == pawn)
{
__result = false;
return(false);
}
if ((pawn2.Faction == pawn.Faction || pawn2.HostFaction == pawn.Faction || pawn2.HostFaction == pawn.HostFaction) && !isFireInArea && IntVec3Utility.ManhattanDistanceFlat(pawn.Position, pawn2.Position) > 15)
{
__result = false;
return(false);
}
if (!pawn.CanReach(pawn2, PathEndMode.Touch, Danger.Deadly))
{
__result = false;
return(false);
}
}
else
{
if (pawn.WorkTagIsDisabled(WorkTags.Firefighting))
{
__result = false;
return(false);
}
if (!isFireInArea)
{
JobFailReason.Is(WorkGiver_FixBrokenDownBuilding.NotInHomeAreaTrans);
__result = false;
return(false);
}
}
if ((pawn.Position - fire.Position).LengthHorizontalSquared > 225 && !pawn.CanReserve(fire, 1, -1, null, forced))
{
__result = false;
return(false);
}
if (FireIsBeingHandled(fire, pawn))
{
__result = false;
return(false);
}
//return true;
__result = true;
return(false);
}
protected Job ResourceDeliverJobFor(Pawn pawn, IConstructible c, bool canRemoveExistingFloorUnderNearbyNeeders = true)
{
Blueprint_Install blueprint_Install = c as Blueprint_Install;
if (blueprint_Install != null)
{
return(this.InstallJob(pawn, blueprint_Install));
}
bool flag = false;
ThingDefCountClass thingDefCountClass = null;
List <ThingDefCountClass> list = c.MaterialsNeeded();
int count = list.Count;
int i = 0;
while (i < count)
{
ThingDefCountClass need = list[i];
if (!pawn.Map.itemAvailability.ThingsAvailableAnywhere(need, pawn))
{
flag = true;
thingDefCountClass = need;
break;
}
Thing foundRes = GenClosest.ClosestThingReachable(pawn.Position, pawn.Map, ThingRequest.ForDef(need.thingDef), PathEndMode.ClosestTouch, TraverseParms.For(pawn, Danger.Deadly, TraverseMode.ByPawn, false), 9999f, (Thing r) => WorkGiver_ConstructDeliverResources.ResourceValidator(pawn, need, r), null, 0, -1, false, RegionType.Set_Passable, false);
if (foundRes != null)
{
int resTotalAvailable;
this.FindAvailableNearbyResources(foundRes, pawn, out resTotalAvailable);
int num;
Job job;
HashSet <Thing> hashSet = this.FindNearbyNeeders(pawn, need, c, resTotalAvailable, canRemoveExistingFloorUnderNearbyNeeders, out num, out job);
if (job != null)
{
return(job);
}
hashSet.Add((Thing)c);
Thing thing = hashSet.MinBy((Thing nee) => IntVec3Utility.ManhattanDistanceFlat(foundRes.Position, nee.Position));
hashSet.Remove(thing);
int num2 = 0;
int j = 0;
do
{
num2 += WorkGiver_ConstructDeliverResources.resourcesAvailable[j].stackCount;
j++;
}while (num2 < num && j < WorkGiver_ConstructDeliverResources.resourcesAvailable.Count);
WorkGiver_ConstructDeliverResources.resourcesAvailable.RemoveRange(j, WorkGiver_ConstructDeliverResources.resourcesAvailable.Count - j);
WorkGiver_ConstructDeliverResources.resourcesAvailable.Remove(foundRes);
Job job2 = new Job(JobDefOf.HaulToContainer);
job2.targetA = foundRes;
job2.targetQueueA = new List <LocalTargetInfo>();
for (j = 0; j < WorkGiver_ConstructDeliverResources.resourcesAvailable.Count; j++)
{
job2.targetQueueA.Add(WorkGiver_ConstructDeliverResources.resourcesAvailable[j]);
}
job2.targetB = thing;
if (hashSet.Count > 0)
{
job2.targetQueueB = new List <LocalTargetInfo>();
foreach (Thing current in hashSet)
{
job2.targetQueueB.Add(current);
}
}
job2.targetC = (Thing)c;
job2.count = num;
job2.haulMode = HaulMode.ToContainer;
return(job2);
}
else
{
flag = true;
thingDefCountClass = need;
i++;
}
}
if (flag)
{
JobFailReason.Is(string.Format("{0}: {1}", WorkGiver_ConstructDeliverResources.MissingMaterialsTranslated, thingDefCountClass.thingDef.label), null);
}
return(null);
}
public override void CompTick()
{
base.CompTick();
tickCounter++;
if (tickCounter > Props.tickInterval)
{
thisBuilding = this.parent as Building;
if (thisBuilding != null && thisBuilding.Map != null && thisBuilding.GetComp <CompPowerTrader>().PowerOn)
{
List <Pawn> allPawnsSpawned = thisBuilding.Map.mapPawns.AllPawnsSpawned;
for (int k = 0; k < allPawnsSpawned.Count; k++)
{
if (allPawnsSpawned[k] != null && !allPawnsSpawned[k].AnimalOrWildMan() && allPawnsSpawned[k].RaceProps.IsFlesh)
{
pawnList.Add(allPawnsSpawned[k]);
}
}
if (pawnList.Count > 0)
{
IntVec3 thisPawnLocation = thisBuilding.Position;
List <Pawn> tempList = new List <Pawn>();
for (int k = 0; k < pawnList.Count; k++)
{
if (IntVec3Utility.ManhattanDistanceFlat(thisPawnLocation, pawnList[k].Position) < Props.radius)
{
tempList.Add(pawnList[k]);
}
}
if (tempList.Count > 0)
{
Pawn chosenOne = tempList.RandomElement();
if (chosenOne != null)
{
if (!chosenOne.Dead && !chosenOne.Downed)
{
if (Props.showEffect)
{
Find.TickManager.slower.SignalForceNormalSpeedShort();
SoundDefOf.PsychicPulseGlobal.PlayOneShot(new TargetInfo(this.parent.Position, this.parent.Map, false));
MoteMaker.MakeAttachedOverlay(this.parent, ThingDef.Named("Mote_PsycastPsychicEffect"), Vector3.zero, 1f, -1f);
}
if (chosenOne.needs.mood.thoughts.memories.GetFirstMemoryOfDef(ThoughtDef.Named(Props.foundThoughtDef)) != null)
{
//Log.Message("Memoria encontrada");
chosenOne.needs.mood.thoughts.memories.TryGainMemory(ThoughtDef.Named(Props.thoughtDef), null);
}
else //Log.Message("Memoria no encontrada");
{
}
}
}
}
tempList.Clear();
}
}
pawnList.Clear();
tickCounter = 0;
}
}
public override bool HasJobOnThing(Pawn pawn, Thing t, bool forced = false)
{
GuardPost gpost = t as GuardPost;
if (gpost == null)
{
return(false);
}
Pawn pawn2 = gpost.CurrentGuard;
if (pawn2 != null)
{
if (pawn2 == pawn)
{
return(false);
}
if ((pawn2.Faction == pawn.Faction || pawn2.HostFaction == pawn.Faction || pawn2.HostFaction == pawn.HostFaction) && !pawn.Map.areaManager.Home[gpost.Position] && IntVec3Utility.ManhattanDistanceFlat(pawn.Position, pawn2.Position) > 15)
{
return(false);
}
if (!pawn.CanReach(pawn2, PathEndMode.Touch, Danger.Deadly))
{
return(false);
}
}
else
{
if (pawn.story.WorkTagIsDisabled(WorkTags.Violent))
{
return(false);
}
if (!pawn.Map.areaManager.Home[gpost.Position])
{
JobFailReason.Is(WorkGiver_FixBrokenDownBuilding.NotInHomeAreaTrans);
return(false);
}
}
if ((pawn.Position - gpost.Position).LengthHorizontalSquared > 225)
{
LocalTargetInfo target = gpost;
bool ignoreOtherReservations = forced;
if (!pawn.CanReserve(target, 1, -1, null, ignoreOtherReservations))
{
return(false);
}
}
return(true);
}
public static Thing FindTarget(Pawn pawn)
{
List <Thing> allThings = pawn.Map.listerThings.AllThings;
if (allThings == null || !allThings.Any())
{
return(null);
}
if (BetterInfestationsMod.settings == null)
{
return(null);
}
List <Thing> targets = new List <Thing>();
foreach (Thing target in allThings)
{
Pawn pawnTarget = target as Pawn;
Building_Turret turretTarget = target as Building_Turret;
Egg eggTarget = target as Egg;
if (!pawnTarget.DestroyedOrNull() && !pawnTarget.Downed)
{
if ((pawnTarget.Faction != null && pawnTarget.Faction != pawn.Faction) || pawnTarget.Faction == null)
{
if (!BetterInfestationsMod.settings.disabledDefList.Contains(pawnTarget.def.defName))
{
targets.Add(target);
}
}
}
else if (!turretTarget.DestroyedOrNull())
{
if ((turretTarget.Faction != null && turretTarget.Faction != pawn.Faction) || turretTarget.Faction == null)
{
targets.Add(target);
}
}
else if (!eggTarget.DestroyedOrNull())
{
if ((eggTarget.Faction != null && eggTarget.Faction != pawn.Faction) || eggTarget.Faction == null)
{
targets.Add(target);
}
}
}
Thing result = null;
if (pawn.mindState.enemyTarget == null)
{
if (targets.Any())
{
foreach (Thing target in targets)
{
Pawn pawnTarget = target as Pawn;
Building_Turret turretTarget = target as Building_Turret;
Egg eggTarget = target as Egg;
bool attackingHive;
if (pawnTarget != null)
{
attackingHive = pawnTarget.mindState.lastAttackedTarget == pawn;
result = GetAttacker(pawn, target, attackingHive);
}
else if (turretTarget != null)
{
attackingHive = turretTarget.LastAttackedTarget == pawn;
result = GetAttacker(pawn, target, attackingHive);
}
else if (eggTarget != null && GenSight.LineOfSight(pawn.Position, eggTarget.Position, pawn.Map, true, null, 0, 0) && IntVec3Utility.ManhattanDistanceFlat(pawn.PositionHeld, eggTarget.PositionHeld) < 30)
{
result = target;
}
if (result != null)
{
break;
}
}
}
}
else
{
Thing target = pawn.mindState.enemyTarget;
Pawn pawnTarget = target as Pawn;
Building_Turret turretTarget = target as Building_Turret;
Egg eggTarget = target as Egg;
Thing attackedTarget = null;
if (pawnTarget != null && pawnTarget.mindState != null)
{
attackedTarget = pawnTarget.mindState.lastAttackedTarget.Thing;
}
else if (turretTarget != null)
{
attackedTarget = turretTarget.LastAttackedTarget.Thing;
}
else if (eggTarget != null && GenSight.LineOfSight(pawn.Position, eggTarget.Position, pawn.Map, true, null, 0, 0) && IntVec3Utility.ManhattanDistanceFlat(pawn.PositionHeld, eggTarget.PositionHeld) < 30)
{
result = target;
}
if (attackedTarget != null)
{
bool attackingHive = attackedTarget.Faction != null && attackedTarget.Faction == pawn.Faction;
result = GetAttacker(pawn, target, attackingHive);
}
if (result == null)
{
pawn.mindState.enemyTarget = null;
}
}
if (result != null)
{
if (result.def != HiveUtility.ThingDefOfEgg)
{
pawn.mindState.enemyTarget = result;
}
List <Pawn> insectPawns = new List <Pawn>();
foreach (Thing thing in allThings)
{
Pawn insect = thing as Pawn;
if (!insect.DestroyedOrNull() && !insect.Downed && insect.Faction != null && insect.Faction == pawn.Faction && insect != pawn && insect.mindState.enemyTarget == null)
{
insectPawns.Add(insect);
}
}
foreach (Pawn insect in insectPawns)
{
int dist = IntVec3Utility.ManhattanDistanceFlat(insect.PositionHeld, result.PositionHeld);
if (insect.CanReach(result, PathEndMode.Touch, Danger.Deadly, true, TraverseMode.PassDoors) && dist < maxAttackDistance)
{
if (result.def != HiveUtility.ThingDefOfEgg)
{
insect.mindState.enemyTarget = result;
}
}
}
}
return(result);
}
public static bool ResourceDeliverJobFor(WorkGiver_ConstructDeliverResources __instance, ref Job __result, Pawn pawn, IConstructible c, bool canRemoveExistingFloorUnderNearbyNeeders = true)
{
Blueprint_Install blueprint_Install = c as Blueprint_Install;
if (blueprint_Install != null)
{
__result = InstallJob(pawn, blueprint_Install);
return(false);
}
List <Thing> resourcesAvailable = new List <Thing>();
bool flag = false;
ThingDefCountClass thingDefCountClass = null;
List <ThingDefCountClass> list = c.MaterialsNeeded();
int count = list.Count;
for (int i = 0; i < count; i++)
{
ThingDefCountClass need = list[i];
if (!pawn.Map.itemAvailability.ThingsAvailableAnywhere(need, pawn))
{
flag = true;
thingDefCountClass = need;
break;
}
Thing foundRes = GenClosest.ClosestThingReachable(pawn.Position, pawn.Map, ThingRequest.ForDef(need.thingDef), PathEndMode.ClosestTouch, TraverseParms.For(pawn), 9999f, (Thing r) => ResourceValidator(pawn, need, r));
if (foundRes != null)
{
resourcesAvailable.Clear();
//FindAvailableNearbyResources2(foundRes, pawn, out int resTotalAvailable, resourcesAvailable);
int resTotalAvailable;
int num0 = Mathf.Min(foundRes.def.stackLimit, pawn.carryTracker.MaxStackSpaceEver(foundRes.def));
resTotalAvailable = 0;
resourcesAvailable.Add(foundRes);
resTotalAvailable += foundRes.stackCount;
if (resTotalAvailable < num0)
{
foreach (Thing item in GenRadial.RadialDistinctThingsAround(foundRes.Position, foundRes.Map, 5f, useCenter: false))
{
if (resTotalAvailable >= num0)
{
break;
}
if (item.def == foundRes.def && GenAI.CanUseItemForWork(pawn, item))
{
resourcesAvailable.Add(item);
resTotalAvailable += item.stackCount;
}
}
}
int neededTotal;
Job jobToMakeNeederAvailable;
HashSet <Thing> hashSet = FindNearbyNeeders(pawn, need, c, resTotalAvailable, canRemoveExistingFloorUnderNearbyNeeders, out neededTotal, out jobToMakeNeederAvailable);
if (jobToMakeNeederAvailable != null)
{
__result = jobToMakeNeederAvailable;
return(false);
}
hashSet.Add((Thing)c);
Thing thing = hashSet.MinBy((Thing nee) => IntVec3Utility.ManhattanDistanceFlat(foundRes.Position, nee.Position));
hashSet.Remove(thing);
int num = 0;
int num2 = 0;
do
{
num += resourcesAvailable[num2].stackCount;
num2++;
}while (num < neededTotal && num2 < resourcesAvailable.Count);
resourcesAvailable.RemoveRange(num2, resourcesAvailable.Count - num2);
resourcesAvailable.Remove(foundRes);
Job job = JobMaker.MakeJob(JobDefOf.HaulToContainer);
job.targetA = foundRes;
job.targetQueueA = new List <LocalTargetInfo>();
for (num2 = 0; num2 < resourcesAvailable.Count; num2++)
{
job.targetQueueA.Add(resourcesAvailable[num2]);
}
job.targetB = thing;
if (hashSet.Count > 0)
{
job.targetQueueB = new List <LocalTargetInfo>();
foreach (Thing item in hashSet)
{
job.targetQueueB.Add(item);
}
}
job.targetC = (Thing)c;
job.count = neededTotal;
job.haulMode = HaulMode.ToContainer;
__result = job;
return(false);
}
flag = true;
thingDefCountClass = need;
}
if (flag)
{
JobFailReason.Is($"{MissingMaterialsTranslated}: {thingDefCountClass.thingDef.label}");
}
__result = null;
return(false);
}
private Thing SpawnAssembler(Map map, IncidentParms parms)
{
IntVec3 loc;
IntVec3 loc2;
if (!TryFindEntryCell(map, out loc))
{
return(null);
}
if (CellFinder.TryFindRandomCellNear(loc, map, 8, (IntVec3 c) => c.Standable(map) && IntVec3Utility.ManhattanDistanceFlat(c, loc) > 5, out loc2, -1))
{
Thing thing = GenSpawn.Spawn(ThingMaker.MakeThing(ThingDef.Named("AA_AncientAssembler"), null), loc2, map, WipeMode.FullRefund);
Building_AncientAssembler building = thing as Building_AncientAssembler;
return(thing);
}
else
{
return(null);
}
}
// Token: 0x06000021 RID: 33 RVA: 0x00002BA0 File Offset: 0x00000DA0
public override bool HasJobOnThing(Pawn pawn, Thing t, bool forced = false)
{
if (!(t is Fire fire))
{
return(false);
}
if (fire.parent is Pawn pawn2)
{
if (pawn2 == pawn)
{
return(false);
}
if ((pawn2.Faction == pawn.Faction || pawn2.HostFaction == pawn.Faction ||
pawn2.HostFaction == pawn.HostFaction) && !pawn.Map.areaManager.Home[fire.Position] &&
IntVec3Utility.ManhattanDistanceFlat(pawn.Position, pawn2.Position) > 15)
{
return(false);
}
if (!pawn.CanReach(pawn2, PathEndMode.Touch, Danger.Deadly))
{
return(false);
}
}
else
{
if (pawn.WorkTagIsDisabled(WorkTags.Firefighting))
{
return(false);
}
// Since pawns can use the extinguisher if they are incapable of violence now the following is not needed
//if (pawn.WorkTagIsDisabled(WorkTags.Violent))
//{
// return false;
//}
if (pawn.story.traits.HasTrait(TraitDefOf.Pyromaniac))
{
return(false);
}
if (!pawn.Map.areaManager.Home[fire.Position])
{
JobFailReason.Is(WorkGiver_FixBrokenDownBuilding.NotInHomeAreaTrans);
return(false);
}
}
if ((pawn.Position - fire.Position).LengthHorizontalSquared <= 225)
{
return(!FireIsBeingHandled(fire, pawn));
}
LocalTargetInfo target = fire;
if (!pawn.CanReserve(target, 1, -1, null, forced))
{
return(false);
}
return(!FireIsBeingHandled(fire, pawn));
}
protected Job ResourceDeliverJobFor(Pawn pawn, IConstructible c, bool canRemoveExistingFloorUnderNearbyNeeders = true)
{
Blueprint_Install blueprint_Install = c as Blueprint_Install;
if (blueprint_Install != null)
{
return(InstallJob(pawn, blueprint_Install));
}
bool flag = false;
ThingDefCountClass thingDefCountClass = null;
List <ThingDefCountClass> list = c.MaterialsNeeded();
int count = list.Count;
for (int i = 0; i < count; i++)
{
ThingDefCountClass need = list[i];
if (!pawn.Map.itemAvailability.ThingsAvailableAnywhere(need, pawn))
{
flag = true;
thingDefCountClass = need;
break;
}
Thing foundRes = GenClosest.ClosestThingReachable(pawn.Position, pawn.Map, ThingRequest.ForDef(need.thingDef), PathEndMode.ClosestTouch, TraverseParms.For(pawn), 9999f, (Thing r) => ResourceValidator(pawn, need, r));
if (foundRes != null)
{
FindAvailableNearbyResources(foundRes, pawn, out int resTotalAvailable);
int neededTotal;
Job jobToMakeNeederAvailable;
HashSet <Thing> hashSet = FindNearbyNeeders(pawn, need, c, resTotalAvailable, canRemoveExistingFloorUnderNearbyNeeders, out neededTotal, out jobToMakeNeederAvailable);
if (jobToMakeNeederAvailable != null)
{
return(jobToMakeNeederAvailable);
}
hashSet.Add((Thing)c);
Thing thing = hashSet.MinBy((Thing nee) => IntVec3Utility.ManhattanDistanceFlat(foundRes.Position, nee.Position));
hashSet.Remove(thing);
int num = 0;
int num2 = 0;
do
{
num += resourcesAvailable[num2].stackCount;
num2++;
}while (num < neededTotal && num2 < resourcesAvailable.Count);
resourcesAvailable.RemoveRange(num2, resourcesAvailable.Count - num2);
resourcesAvailable.Remove(foundRes);
Job job = new Job(JobDefOf.HaulToContainer);
job.targetA = foundRes;
job.targetQueueA = new List <LocalTargetInfo>();
for (num2 = 0; num2 < resourcesAvailable.Count; num2++)
{
job.targetQueueA.Add(resourcesAvailable[num2]);
}
job.targetB = thing;
if (hashSet.Count > 0)
{
job.targetQueueB = new List <LocalTargetInfo>();
foreach (Thing item in hashSet)
{
job.targetQueueB.Add(item);
}
}
job.targetC = (Thing)c;
job.count = neededTotal;
job.haulMode = HaulMode.ToContainer;
return(job);
}
flag = true;
thingDefCountClass = need;
}
if (flag)
{
JobFailReason.Is($"{MissingMaterialsTranslated}: {thingDefCountClass.thingDef.label}");
}
return(null);
}
