protected override Job TryGiveJob(Pawn pawn)
{
var bestDistSq = maxDistance * maxDistance;
var bestThing = (Thing)null;
var potentialTargetsFor = pawn.Map.attackTargetsCache.GetPotentialTargetsFor(pawn);
foreach (var target in potentialTargetsFor)
{
if (!target.ThreatDisabled(pawn) && AttackTargetFinder.IsAutoTargetable(target))
{
var thing = (Thing)target;
var distSq = thing.Position.DistanceToSquared(pawn.Position);
if (distSq < bestDistSq && pawn.CanReach((LocalTargetInfo)thing, PathEndMode.OnCell, Danger.Deadly, true, true))
{
bestDistSq = distSq;
bestThing = thing;
}
}
}
if (bestThing == null)
{
return(null);
}
var job = JobMaker.MakeJob(JobDefOf.Goto, (LocalTargetInfo)bestThing);
job.checkOverrideOnExpire = true;
job.expiryInterval = 500;
job.collideWithPawns = true;
return(job);
}
protected LocalTargetInfo TryFindNewTarget() // Core method
{
IAttackTargetSearcher attackTargetSearcher = this.TargSearcher();
Faction faction = attackTargetSearcher.Thing.Faction;
float range = this.AttackVerb.verbProps.range;
Building t;
if (Rand.Value < 0.5f && this.AttackVerb.ProjectileFliesOverhead() && faction.HostileTo(Faction.OfPlayer) && base.Map.listerBuildings.allBuildingsColonist.Where(delegate(Building x)
{
float num = this.AttackVerb.verbProps.EffectiveMinRange(x, this);
float num2 = (float)x.Position.DistanceToSquared(this.Position);
return(num2 > num * num && num2 < range * range);
}).TryRandomElement(out t))
{
return(t);
}
TargetScanFlags targetScanFlags = TargetScanFlags.NeedThreat;
if (!this.AttackVerb.ProjectileFliesOverhead())
{
targetScanFlags |= TargetScanFlags.NeedLOSToAll;
targetScanFlags |= TargetScanFlags.LOSBlockableByGas;
}
if (this.AttackVerb.IsIncendiary())
{
targetScanFlags |= TargetScanFlags.NeedNonBurning;
}
return((Thing)AttackTargetFinder.BestShootTargetFromCurrentPosition(attackTargetSearcher, targetScanFlags, new Predicate <Thing>(this.IsValidTarget), 0f, 9999f));
}
protected LocalTargetInfo TryFindNewTarget()
{
IAttackTargetSearcher attackTargetSearcher = TargSearcher();
Faction faction = attackTargetSearcher.Thing.Faction;
float range = AttackVerb.verbProps.range;
if (Rand.Value < 0.5f && AttackVerb.ProjectileFliesOverhead() && faction.HostileTo(Faction.OfPlayer) && base.Map.listerBuildings.allBuildingsColonist.Where(delegate(Building x)
{
float num = AttackVerb.verbProps.EffectiveMinRange(x, this);
float num2 = x.Position.DistanceToSquared(base.Position);
return(num2 > num * num && num2 < range * range);
}).TryRandomElement(out var result))
{
return(result);
}
TargetScanFlags targetScanFlags = TargetScanFlags.NeedThreat | TargetScanFlags.NeedAutoTargetable;
if (!AttackVerb.ProjectileFliesOverhead())
{
targetScanFlags |= TargetScanFlags.NeedLOSToAll;
targetScanFlags |= TargetScanFlags.LOSBlockableByGas;
}
if (AttackVerb.IsIncendiary())
{
targetScanFlags |= TargetScanFlags.NeedNonBurning;
}
if (IsMortar)
{
targetScanFlags |= TargetScanFlags.NeedNotUnderThickRoof;
}
return((Thing)AttackTargetFinder.BestShootTargetFromCurrentPosition(attackTargetSearcher, targetScanFlags, IsValidTarget));
}
// ReSharper disable once InconsistentNaming
public static void Postfix_JobDriver_Wait_CheckForAutoAttack(JobDriver_Wait __instance)
{
if (__instance.pawn.Downed ||
__instance.pawn.stances.FullBodyBusy ||
!__instance.pawn.RaceProps.Animal ||
!__instance.job.canUseRangedWeapon ||
__instance.job.def != JobDefOf.Wait_Combat)
{
return;
}
var currentEffectiveVerb = __instance.pawn.CurrentEffectiveVerb;
if (currentEffectiveVerb == null || currentEffectiveVerb.verbProps.IsMeleeAttack)
{
return;
}
var flags = TargetScanFlags.NeedLOSToAll | TargetScanFlags.NeedThreat | TargetScanFlags.NeedAutoTargetable;
if (currentEffectiveVerb.IsIncendiary())
{
flags |= TargetScanFlags.NeedNonBurning;
}
var thing = (Thing)AttackTargetFinder.BestShootTargetFromCurrentPosition(__instance.pawn, flags);
if (thing == null)
{
return;
}
__instance.pawn.TryStartAttack((LocalTargetInfo)thing);
__instance.collideWithPawns = true;
}
protected LocalTargetInfo TryFindNewTarget()
{
IAttackTargetSearcher attackTargetSearcher = this.TargSearcher();
Faction faction = attackTargetSearcher.Thing.Faction;
float range = this.GunCompEq.PrimaryVerb.verbProps.range;
float minRange = this.GunCompEq.PrimaryVerb.verbProps.minRange;
Building t;
if (Rand.Value < 0.5f && Projectile.projectile.flyOverhead && faction.HostileTo(Faction.OfPlayer) && base.Map.listerBuildings.allBuildingsColonist.Where(delegate(Building x)
{
float num = (float)x.Position.DistanceToSquared(this.Position);
return(num > minRange * minRange && num < range * range);
}).TryRandomElement(out t))
{
return(t);
}
TargetScanFlags targetScanFlags = TargetScanFlags.NeedThreat;
if (!Projectile.projectile.flyOverhead)
{
targetScanFlags |= TargetScanFlags.NeedLOSToAll;
targetScanFlags |= TargetScanFlags.LOSBlockableByGas;
}
return((Thing)AttackTargetFinder.BestShootTargetFromCurrentPosition(attackTargetSearcher, targetScanFlags, new Predicate <Thing>(this.IsValidTarget), minRange, range)); // WTF B19???
}
protected TargetInfo TryFindNewTarget()
{
IAttackTargetSearcher attackTargetSearcher = this.TargSearcher();
Faction faction = attackTargetSearcher.Thing.Faction;
float range = this.GunCompEq.PrimaryVerb.verbProps.range;
float minRange = this.GunCompEq.PrimaryVerb.verbProps.minRange;
Building t;
if (Rand.Value < 0.5f && this.GunCompEq.PrimaryVerb.verbProps.projectileDef.projectile.flyOverhead && faction.HostileTo(Faction.OfPlayer) && Find.VisibleMap.listerBuildings.allBuildingsColonist.Where(delegate(Building x)
{
float num = x.Position.DistanceToSquared(this.Position);
return(num > minRange * minRange && num < range * range);
}).TryRandomElement(out t))
{
return(t);
}
TargetScanFlags targetScanFlags = TargetScanFlags.NeedThreat;
if (!this.GunCompEq.PrimaryVerb.verbProps.projectileDef.projectile.flyOverhead)
{
targetScanFlags |= TargetScanFlags.NeedLOSToAll;
}
if (this.GunCompEq.PrimaryVerb.verbProps.ai_IsIncendiary)
{
targetScanFlags |= TargetScanFlags.NeedNonBurning;
}
return((Thing)AttackTargetFinder.BestShootTargetFromCurrentPosition(attackTargetSearcher, new Predicate <Thing>(this.IsValidTarget),
range, minRange, targetScanFlags));
}
private Job TryGetAttackNearbyEnemyJob(Pawn pawn)
{
if (pawn.story != null && pawn.story.WorkTagIsDisabled(WorkTags.Violent))
{
return(null);
}
bool flag = pawn.equipment.Primary == null || pawn.equipment.Primary.def.IsMeleeWeapon;
float num = 8f;
if (!flag)
{
num = Mathf.Clamp((float)(pawn.equipment.PrimaryEq.PrimaryVerb.verbProps.range * 0.6600000262260437), 2f, 20f);
}
TargetScanFlags flags = TargetScanFlags.NeedLOSToPawns | TargetScanFlags.NeedLOSToNonPawns | TargetScanFlags.NeedReachableIfCantHitFromMyPos | TargetScanFlags.NeedThreat;
float maxDist = num;
Thing thing = (Thing)AttackTargetFinder.BestAttackTarget(pawn, flags, null, 0f, maxDist, default(IntVec3), 3.40282347E+38f, false);
if (thing == null)
{
return(null);
}
if (!flag && !pawn.CanReachImmediate(thing, PathEndMode.Touch))
{
Job job = new Job(JobDefOf.AttackStatic, thing);
job.maxNumStaticAttacks = 2;
job.expiryInterval = 2000;
job.endIfCantShootTargetFromCurPos = true;
return(job);
}
return(new Job(JobDefOf.AttackMelee, thing));
}
private static void JobDriver_Wait_CheckForAutoAttackPostfix(JobDriver_Wait __instance)
{
if (__instance.pawn.Faction != null || __instance.pawn.Downed || __instance.pawn.stances.FullBodyBusy)
{
return;
}
if ((__instance.pawn.story == null || !__instance.pawn.story.WorkTagIsDisabled(WorkTags.Violent)) && __instance.job.def == JobDefOf.Wait_Combat && (__instance.pawn.drafter == null || __instance.pawn.drafter.FireAtWill))
{
Verb currentEffectiveVerb = __instance.pawn.CurrentEffectiveVerb;
if (currentEffectiveVerb != null && !currentEffectiveVerb.verbProps.IsMeleeAttack)
{
TargetScanFlags targetScanFlags = TargetScanFlags.NeedLOSToPawns | TargetScanFlags.NeedLOSToNonPawns | TargetScanFlags.NeedThreat;
if (currentEffectiveVerb.IsIncendiary())
{
targetScanFlags |= TargetScanFlags.NeedNonBurning;
}
Thing thing = (Thing)AttackTargetFinder.BestShootTargetFromCurrentPosition(__instance.pawn, targetScanFlags, null, 0f, 9999f);
if (thing != null)
{
__instance.pawn.TryStartAttack(thing);
__instance.collideWithPawns = true;
return;
}
}
}
return;
}
protected LocalTargetInfo TryFindNewTarget()
{
IAttackTargetSearcher attackTargetSearcher = this.TargSearcher();
Faction faction = attackTargetSearcher.Thing.Faction;
float range = this.GunCompEq.PrimaryVerb.verbProps.range;
float minRange = this.GunCompEq.PrimaryVerb.verbProps.minRange;
Building t = default(Building);
if (Rand.Value < 0.5 && this.GunCompEq.PrimaryVerb.ProjectileFliesOverhead() && faction.HostileTo(Faction.OfPlayer) && base.Map.listerBuildings.allBuildingsColonist.Where(delegate(Building x)
{
float num = (float)x.Position.DistanceToSquared(base.Position);
return(num > minRange * minRange && num < range * range);
}).TryRandomElement <Building>(out t))
{
return(t);
}
TargetScanFlags targetScanFlags = TargetScanFlags.NeedThreat;
if (!this.GunCompEq.PrimaryVerb.ProjectileFliesOverhead())
{
targetScanFlags |= TargetScanFlags.NeedLOSToAll;
targetScanFlags |= TargetScanFlags.LOSBlockableByGas;
}
if (this.GunCompEq.PrimaryVerb.IsIncendiary())
{
targetScanFlags |= TargetScanFlags.NeedNonBurning;
}
return((Thing)AttackTargetFinder.BestShootTargetFromCurrentPosition(attackTargetSearcher, this.IsValidTarget, range, minRange, targetScanFlags));
}
protected LocalTargetInfo TryFindNewTarget()
{
Thing searcher;
Faction faction;
if (this.mannableComp != null && this.mannableComp.MannedNow)
{
searcher = this.mannableComp.ManningPawn;
faction = this.mannableComp.ManningPawn.Faction;
}
else
{
searcher = this;
faction = base.Faction;
}
if (this.GunCompEq.PrimaryVerb.verbProps.projectileDef.projectile.flyOverhead && faction.HostileTo(Faction.OfPlayer) && Rand.Value < 0.5f && base.Map.listerBuildings.allBuildingsColonist.Count > 0)
{
return(base.Map.listerBuildings.allBuildingsColonist.RandomElement <Building>());
}
TargetScanFlags targetScanFlags = TargetScanFlags.NeedThreat;
if (!this.GunCompEq.PrimaryVerb.verbProps.projectileDef.projectile.flyOverhead)
{
targetScanFlags |= TargetScanFlags.NeedLOSToAll;
}
if (this.GunCompEq.PrimaryVerb.verbProps.ai_IsIncendiary)
{
targetScanFlags |= TargetScanFlags.NeedNonBurning;
}
return(AttackTargetFinder.BestShootTargetFromCurrentPosition(searcher, new Predicate <Thing>(this.IsValidTarget), this.GunCompEq.PrimaryVerb.verbProps.range, this.GunCompEq.PrimaryVerb.verbProps.minRange, targetScanFlags));
}
private Job TryGetAttackNearbyEnemyJob(Pawn pawn)
{
if (pawn.story != null && pawn.story.WorkTagIsDisabled(WorkTags.Violent))
{
return(null);
}
bool isMeleeAttack = pawn.CurrentEffectiveVerb.IsMeleeAttack;
float num = 8f;
if (!isMeleeAttack)
{
num = Mathf.Clamp(pawn.CurrentEffectiveVerb.verbProps.range * 0.66f, 2f, 20f);
}
TargetScanFlags flags = TargetScanFlags.NeedLOSToPawns | TargetScanFlags.NeedLOSToNonPawns | TargetScanFlags.NeedReachableIfCantHitFromMyPos | TargetScanFlags.NeedThreat;
float maxDist = num;
Thing thing = (Thing)AttackTargetFinder.BestAttackTarget(pawn, flags, null, 0f, maxDist, default(IntVec3), 3.40282347E+38f, false, true);
if (thing == null)
{
return(null);
}
if (isMeleeAttack || pawn.CanReachImmediate(thing, PathEndMode.Touch))
{
return(new Job(JobDefOf.AttackMelee, thing));
}
return(new Job(JobDefOf.AttackStatic, thing)
{
maxNumStaticAttacks = 2,
expiryInterval = 2000,
endIfCantShootTargetFromCurPos = true
});
}
private Job TryGetAttackNearbyEnemyJob(Pawn pawn)
{
if (pawn.story != null && pawn.WorkTagIsDisabled(WorkTags.Violent))
{
return(null);
}
bool flag = pawn.equipment.Primary == null || pawn.equipment.Primary.def.IsMeleeWeapon;
float num = 8f;
if (!flag)
{
num = Mathf.Clamp(pawn.equipment.PrimaryEq.PrimaryVerb.verbProps.range * 0.66f, 2f, 20f);
}
float maxDist = num;
Thing thing = (Thing)AttackTargetFinder.BestAttackTarget(pawn, TargetScanFlags.NeedLOSToPawns | TargetScanFlags.NeedLOSToNonPawns | TargetScanFlags.NeedReachableIfCantHitFromMyPos | TargetScanFlags.NeedThreat, null, 0f, maxDist, default(IntVec3), 3.40282347E+38f, false);
// TODO evaluate if this is necessary?
Pawn o = thing as Pawn;
if (o != null)
{
if
(o.Downed || o.health.InPainShock)
{
return(null);
}
}
if (thing == null)
{
return(null);
}
if (flag || thing.Position.AdjacentTo8Way(pawn.Position))
{
return(new Job(JobDefOf.AttackMelee, thing));
}
// Check for reload before attacking
bool allowManualCastWeapons = !pawn.IsColonist; //TODO: Is this correct?
Verb verb = pawn.TryGetAttackVerb(thing, allowManualCastWeapons);
if (pawn.equipment.Primary != null && pawn.equipment.PrimaryEq != null && verb != null && verb == pawn.equipment.PrimaryEq.PrimaryVerb)
{
CompAmmoUser compAmmo = pawn.equipment.Primary.TryGetComp <CompAmmoUser>();
if (compAmmo != null && !compAmmo.CanBeFiredNow)
{
if (compAmmo.HasAmmo)
{
Job job = new Job(CE_JobDefOf.ReloadWeapon, pawn, pawn.equipment.Primary);
if (job != null)
{
return(job);
}
}
return(new Job(JobDefOf.AttackMelee, thing));
}
}
return(new Job(JobDefOf.AttackStatic, thing));
}
protected override Job TryGiveJob(Pawn pawn)
{
if (!Base.Features.RangedAnimals)
{
return(null);
}
var enemyTarget = pawn.mindState.enemyTarget;
if (enemyTarget != null && (enemyTarget.Destroyed ||
Find.TickManager.TicksGame - pawn.mindState.lastEngageTargetTick > 400 ||
!pawn.CanReach(enemyTarget, PathEndMode.Touch, Danger.Deadly) ||
(pawn.Position - enemyTarget.Position).LengthHorizontalSquared >
TargetKeepRadius * TargetKeepRadius ||
((IAttackTarget)enemyTarget).ThreatDisabled(pawn)))
{
enemyTarget = null;
}
if (pawn.TryGetAttackVerb(null, !pawn.IsColonist) == null)
{
enemyTarget = null;
}
else if (enemyTarget == null)
{
enemyTarget = (Thing)AttackTargetFinder.BestAttackTarget(pawn, TargetScanFlags.NeedThreat,
x => x is Pawn && x.def.race.intelligence >= Intelligence.ToolUser, 0f, 9999f,
static void checkForAutoAttack(JobDriver_Goto __instance)
{
if ((__instance.pawn.story == null || !__instance.pawn.story.DisabledWorkTagsBackstoryAndTraits.HasFlag(WorkTags.Violent)) &&
__instance.pawn.Faction != null &&
!(__instance.pawn.stances.curStance is Stance_RunAndGun) &&
__instance.pawn.jobs.curJob.def == JobDefOf.Goto &&
(__instance.pawn.drafter == null || __instance.pawn.drafter.FireAtWill))
{
CompRunAndGun comp = __instance.pawn.TryGetComp <CompRunAndGun>();
if (comp == null || comp.isEnabled == false)
{
return;
}
Verb verb = __instance.pawn.TryGetAttackVerb(null);
if (verb != null)
{
TargetScanFlags targetScanFlags = TargetScanFlags.NeedLOSToPawns | TargetScanFlags.NeedLOSToNonPawns | TargetScanFlags.NeedThreat;
if (verb.IsIncendiary())
{
targetScanFlags |= TargetScanFlags.NeedNonBurning;
}
Thing thing = (Thing)AttackTargetFinder.BestShootTargetFromCurrentPosition(__instance.pawn, targetScanFlags, null, 0f, 9999f);
if (thing != null && !(verb.IsMeleeAttack && __instance.pawn.CanReachImmediate(thing, PathEndMode.Touch))) //Don't allow melee attacks, but take into account ranged animals or dual wield users
{
__instance.pawn.TryStartAttack(thing);
return;
}
}
}
}
static void checkForAutoAttack(JobDriver_Goto __instance)
{
if ((__instance.pawn.story == null || !__instance.pawn.story.WorkTagIsDisabled(WorkTags.Violent)) &&
__instance.pawn.Faction != null &&
!(__instance.pawn.stances.curStance is Stance_RunAndGun) &&
__instance.pawn.jobs.curJob.def == JobDefOf.Goto &&
(__instance.pawn.drafter == null || __instance.pawn.drafter.FireAtWill))
{
CompRunAndGun comp = __instance.pawn.TryGetComp <CompRunAndGun>();
if (comp == null || comp.isEnabled == false)
{
return;
}
Verb verb = __instance.pawn.TryGetAttackVerb(true);
if (verb != null && !verb.verbProps.MeleeRange)
{
TargetScanFlags targetScanFlags = TargetScanFlags.NeedLOSToPawns | TargetScanFlags.NeedLOSToNonPawns | TargetScanFlags.NeedThreat;
if (verb.IsIncendiary())
{
targetScanFlags |= TargetScanFlags.NeedNonBurning;
}
Thing thing = (Thing)AttackTargetFinder.BestShootTargetFromCurrentPosition(__instance.pawn, null, verb.verbProps.range, verb.verbProps.minRange, targetScanFlags);
if (thing != null)
{
__instance.pawn.TryStartAttack(thing);
return;
}
}
}
}
public static bool Prefix(ref IAttackTarget __result, IAttackTargetSearcher searcher,
TargetScanFlags flags, Predicate <Thing> validator = null, float minDist = 0f,
float maxDist = 9999f, IntVec3 locus = default(IntVec3),
float maxTravelRadiusFromLocus = 3.40282347E+38f, bool canBash = false,
bool canTakeTargetsCloserThanEffectiveMinRange = true)
{
bool result = true;
if (!recursiveTrap)
{
recursiveTrap = true;
Map oldMap = searcher.Thing.Map;
IntVec3 oldPosition = searcher.Thing.Position;
foreach (var map in ZUtils.GetAllMapsInClosestOrder(searcher.Thing, oldMap, oldPosition))
{
var target = AttackTargetFinder.BestAttackTarget(searcher, flags, validator, minDist,
maxDist, locus, maxTravelRadiusFromLocus, canBash, canTakeTargetsCloserThanEffectiveMinRange);
Log.Message(ZUtils.ZTracker.GetMapInfo(searcher.Thing.Map) + " - result: " + target);
if (target != null)
{
__result = target;
result = false;
break;
}
}
ZUtils.TeleportThing(searcher.Thing, oldMap, oldPosition);
recursiveTrap = false;
}
return(result);
}
protected override Job TryGiveJob(Pawn pawn)
{
float num = float.MaxValue;
Thing thing = null;
List <IAttackTarget> potentialTargetsFor = pawn.Map.attackTargetsCache.GetPotentialTargetsFor(pawn);
for (int i = 0; i < potentialTargetsFor.Count; i++)
{
IAttackTarget attackTarget = potentialTargetsFor[i];
if (!attackTarget.ThreatDisabled(pawn) && AttackTargetFinder.IsAutoTargetable(attackTarget))
{
Thing thing2 = (Thing)attackTarget;
int num2 = thing2.Position.DistanceToSquared(pawn.Position);
if ((float)num2 < num && pawn.CanReach(thing2, PathEndMode.OnCell, Danger.Deadly))
{
num = num2;
thing = thing2;
}
}
}
if (thing != null)
{
Job job = JobMaker.MakeJob(JobDefOf.Goto, thing);
job.checkOverrideOnExpire = true;
job.expiryInterval = 500;
job.collideWithPawns = true;
return(job);
}
return(null);
}
private Job TryGetAttackNearbyEnemyJob(Pawn pawn)
{
if (pawn.story != null && pawn.story.WorkTagIsDisabled(WorkTags.Violent))
{
return(null);
}
bool isMeleeAttack = pawn.CurrentEffectiveVerb.IsMeleeAttack;
float num = 8f;
if (!isMeleeAttack)
{
num = Mathf.Clamp(pawn.CurrentEffectiveVerb.verbProps.range * 0.66f, 2f, 20f);
}
float maxDist = num;
Thing thing = (Thing)AttackTargetFinder.BestAttackTarget(pawn, TargetScanFlags.NeedLOSToPawns | TargetScanFlags.NeedLOSToNonPawns | TargetScanFlags.NeedReachableIfCantHitFromMyPos | TargetScanFlags.NeedThreat, null, 0f, maxDist, default(IntVec3), 3.40282347E+38f, false);
// TODO evaluate if this is necessary?
Pawn o = thing as Pawn;
if (o != null)
{
if
(o.Downed || o.health.InPainShock)
{
return(null);
}
}
if (thing == null)
{
return(null);
}
if (isMeleeAttack || pawn.CanReachImmediate(thing, PathEndMode.Touch))
{
return(new Job(JobDefOf.AttackMelee, thing));
}
// Check for reload before attacking
Verb verb = pawn.TryGetAttackVerb(thing);
if (pawn.equipment.Primary != null && pawn.equipment.PrimaryEq != null && verb != null && verb == pawn.CurrentEffectiveVerb)
{
CompAmmoUser compAmmo = pawn.equipment.Primary.TryGetComp <CompAmmoUser>();
if (compAmmo != null && !compAmmo.CanBeFiredNow)
{
if (compAmmo.HasAmmo)
{
Job job = new Job(CE_JobDefOf.ReloadWeapon, pawn, pawn.equipment.Primary);
if (job != null)
{
return(job);
}
}
return(new Job(JobDefOf.AttackMelee, thing));
}
}
return(new Job(JobDefOf.AttackStatic, thing));
}
private static Building FindTurretTarget(Pawn pawn)
{
Pawn pawn1 = pawn;
Predicate <Thing> predicate = (Thing t) => t is Building;
IntVec3 intVec3 = new IntVec3();
return((Building)AttackTargetFinder.BestAttackTarget(pawn1, TargetScanFlags.NeedLOSToPawns | TargetScanFlags.NeedLOSToNonPawns | TargetScanFlags.NeedLOSToAll | TargetScanFlags.NeedReachable | TargetScanFlags.NeedThreat, predicate, 0f, 70f, intVec3, float.MaxValue, false));
}
private Building FindTurretTarget(Pawn pawn)
{
return((Building)AttackTargetFinder.BestAttackTarget(pawn,
TargetScanFlags.NeedLOSToPawns | TargetScanFlags.NeedLOSToNonPawns |
TargetScanFlags.NeedReachable | TargetScanFlags.NeedThreat |
TargetScanFlags.NeedAutoTargetable, (Thing t) => t is Building, 0f, 70f,
default(IntVec3), float.MaxValue, false, true));
}
// Token: 0x06003091 RID: 12433 RVA: 0x00111BB8 File Offset: 0x0010FDB8
private Pawn FindPawnTarget(Pawn pawn)
{
return((Pawn)AttackTargetFinder.BestAttackTarget(pawn, TargetScanFlags.NeedReachable, delegate(Thing x)
{
Pawn pawn2;
return (pawn2 = (x as Pawn)) != null && pawn2.Spawned && !pawn2.Downed && !pawn2.IsInvisible();
}, 0f, 40f, default(IntVec3), float.MaxValue, true, true));
}
public void MapInterfaceUpdate()
{
if (Find.CurrentMap != null)
{
if (!WorldRendererUtility.WorldRenderedNow)
{
Profiler.BeginSample("TargeterUpdate()");
this.targeter.TargeterUpdate();
Profiler.EndSample();
Profiler.BeginSample("DrawSelectionOverlays()");
SelectionDrawer.DrawSelectionOverlays();
Profiler.EndSample();
Profiler.BeginSample("EnvironmentStatsDrawer.DrawRoomOverlays()");
EnvironmentStatsDrawer.DrawRoomOverlays();
Profiler.EndSample();
Profiler.BeginSample("DesignatorManagerUpdate()");
this.designatorManager.DesignatorManagerUpdate();
Profiler.EndSample();
Profiler.BeginSample("RoofGridUpdate()");
Find.CurrentMap.roofGrid.RoofGridUpdate();
Profiler.EndSample();
Profiler.BeginSample("ExitMapGridUpdate()");
Find.CurrentMap.exitMapGrid.ExitMapGridUpdate();
Profiler.EndSample();
Profiler.BeginSample("DeepResourceGridUpdate()");
Find.CurrentMap.deepResourceGrid.DeepResourceGridUpdate();
Profiler.EndSample();
Profiler.BeginSample("Debug drawing");
if (DebugViewSettings.drawPawnDebug)
{
Find.CurrentMap.pawnDestinationReservationManager.DebugDrawDestinations();
Find.CurrentMap.reservationManager.DebugDrawReservations();
}
if (DebugViewSettings.drawFoodSearchFromMouse)
{
FoodUtility.DebugFoodSearchFromMouse_Update();
}
if (DebugViewSettings.drawPreyInfo)
{
FoodUtility.DebugDrawPredatorFoodSource();
}
if (DebugViewSettings.drawAttackTargetScores)
{
AttackTargetFinder.DebugDrawAttackTargetScores_Update();
}
MiscDebugDrawer.DebugDrawInteractionCells();
Find.CurrentMap.debugDrawer.DebugDrawerUpdate();
Find.CurrentMap.regionGrid.DebugDraw();
InfestationCellFinder.DebugDraw();
StealAIDebugDrawer.DebugDraw();
if (DebugViewSettings.drawRiverDebug)
{
Find.CurrentMap.waterInfo.DebugDrawRiver();
}
Profiler.EndSample();
}
}
}
protected override Thing FindTarget(Pawn pawn)
{
return((Thing)AttackTargetFinder.BestAttackTarget(
pawn,
TargetScanFlags.NeedReachable | TargetScanFlags.NeedThreat,
(Thing x) => x is Pawn && ((Pawn)x).RaceProps.Animal,
0f,
MaxAttackDistance,
default(IntVec3),
3.40282347E+38f,
true));
}
protected override Thing FindAttackTarget(Pawn pawn)
{
TargetScanFlags targetScanFlags = TargetScanFlags.NeedLOSToPawns | TargetScanFlags.NeedReachableIfCantHitFromMyPos | TargetScanFlags.NeedThreat;
/*if (PrimaryVerbIsIncendiary(pawn))
* {
* targetScanFlags |= TargetScanFlags.NeedNonBurning;
* }*/
return((Thing)AttackTargetFinder.BestAttackTarget(pawn, targetScanFlags,
x => ExtraTargetValidator(pawn, x), 0f, TargetAcquireRadius,
default(IntVec3), float.MaxValue, false));
}
protected override Thing FindTarget(Pawn pawn)
{
return((Thing)AttackTargetFinder.BestAttackTarget(
pawn,
TargetScanFlags.NeedReachable | TargetScanFlags.NeedThreat,
(Thing x) => x is Pawn && pawn.relations.OpinionOf((Pawn)x) < 0,
0f,
MaxAttackDistance,
default(IntVec3),
3.40282347E+38f,
true));
}
protected virtual Thing FindAttackTarget(Pawn pawn)
{
TargetScanFlags targetScanFlags = TargetScanFlags.NeedLOSToPawns | TargetScanFlags.NeedReachableIfCantHitFromMyPos | TargetScanFlags.NeedThreat | TargetScanFlags.NeedAutoTargetable;
if (needLOSToAcquireNonPawnTargets)
{
targetScanFlags |= TargetScanFlags.NeedLOSToNonPawns;
}
if (PrimaryVerbIsIncendiary(pawn))
{
targetScanFlags |= TargetScanFlags.NeedNonBurning;
}
return((Thing)AttackTargetFinder.BestAttackTarget(pawn, targetScanFlags, (Thing x) => ExtraTargetValidator(pawn, x), 0f, targetAcquireRadius, GetFlagPosition(pawn), GetFlagRadius(pawn)));
}
public static bool Prefix(ref IAttackTarget __result, List <IAttackTarget> ___tmpTargets, List <Pair <IAttackTarget, float> > ___availableShootingTargets,
List <float> ___tmpTargetScores, List <bool> ___tmpCanShootAtTarget, List <IntVec3> ___tempDestList, List <IntVec3> ___tempSourceList,
IAttackTargetSearcher searcher, TargetScanFlags flags, Predicate <Thing> validator = null, float minDist = 0f,
float maxDist = 9999f, IntVec3 locus = default(IntVec3), float maxTravelRadiusFromLocus = 3.40282347E+38f, bool canBash = false,
bool canTakeTargetsCloserThanEffectiveMinRange = true)
{
bool result = true;
if (!recursiveTrap && multiMapSearch)
{
recursiveTrap = true;
Map oldMap = searcher.Thing.Map;
IntVec3 oldPosition = searcher.Thing.Position;
bool dontCheckForStairs = searcher.Thing is Building;
foreach (var map in ZUtils.GetAllMapsInClosestOrder(searcher.Thing, oldMap, oldPosition, dontCheckForStairs: dontCheckForStairs))
{
if (ZUtils.ZTracker.GetZIndexFor(map) < ZUtils.ZTracker.GetZIndexFor(oldMap))
{
CanBeSeenOverFast_Patch.checkLevels = true;
CanBeSeenOverFast_Patch.upperMap = oldMap;
CanBeSeenOverFast_Patch.lowerMap = map;
CanBeSeenOverFast_Patch.caster = searcher.Thing;
}
var target = AttackTargetFinder.BestAttackTarget(searcher, flags, validator, minDist,
maxDist, locus, maxTravelRadiusFromLocus, canBash, canTakeTargetsCloserThanEffectiveMinRange);
//ZLogger.Message(searcher.Thing + " - 1: " + ZUtils.ZTracker.GetMapInfo(searcher.Thing.Map) + " - result: " + target);
if (target != null)
{
__result = target;
result = false;
break;
}
}
//ZLogger.Message("1 Trying to get " + searcher.Thing + " back to " + oldMap + " - " + oldPosition, true);
ZUtils.TeleportThing(searcher.Thing, oldMap, oldPosition);
recursiveTrap = false;
CanBeSeenOverFast_Patch.checkLevels = false;
CanBeSeenOverFast_Patch.upperMap = null;
CanBeSeenOverFast_Patch.lowerMap = null;
CanBeSeenOverFast_Patch.caster = null;
}
//else if (!multiMapSearch)
//{
// ZLogger.Message("BestAttackTarget: multiMapSearch: " + multiMapSearch, true);
//}
return(result);
}
public void MapInterfaceUpdate()
{
if (Find.CurrentMap != null && !WorldRendererUtility.WorldRenderedNow)
{
targeter.TargeterUpdate();
SelectionDrawer.DrawSelectionOverlays();
EnvironmentStatsDrawer.DrawRoomOverlays();
designatorManager.DesignatorManagerUpdate();
Find.CurrentMap.roofGrid.RoofGridUpdate();
Find.CurrentMap.fertilityGrid.FertilityGridUpdate();
Find.CurrentMap.terrainGrid.TerrainGridUpdate();
Find.CurrentMap.exitMapGrid.ExitMapGridUpdate();
Find.CurrentMap.deepResourceGrid.DeepResourceGridUpdate();
if (DebugViewSettings.drawPawnDebug)
{
Find.CurrentMap.pawnDestinationReservationManager.DebugDrawDestinations();
Find.CurrentMap.reservationManager.DebugDrawReservations();
}
if (DebugViewSettings.drawDestReservations)
{
Find.CurrentMap.pawnDestinationReservationManager.DebugDrawReservations();
}
if (DebugViewSettings.drawFoodSearchFromMouse)
{
FoodUtility.DebugFoodSearchFromMouse_Update();
}
if (DebugViewSettings.drawPreyInfo)
{
FoodUtility.DebugDrawPredatorFoodSource();
}
if (DebugViewSettings.drawAttackTargetScores)
{
AttackTargetFinder.DebugDrawAttackTargetScores_Update();
}
MiscDebugDrawer.DebugDrawInteractionCells();
Find.CurrentMap.debugDrawer.DebugDrawerUpdate();
Find.CurrentMap.regionGrid.DebugDraw();
InfestationCellFinder.DebugDraw();
StealAIDebugDrawer.DebugDraw();
if (DebugViewSettings.drawRiverDebug)
{
Find.CurrentMap.waterInfo.DebugDrawRiver();
}
BuildingsDamageSectionLayerUtility.DebugDraw();
}
}
// Verse.AI.GenAI
private bool EnemyIsNear([NotNull] Pawn p, float radius)
{
bool enemy = false;
this._target = null;
if (!p.Spawned)
{
return(false);
}
List <IAttackTarget> potentialTargetsFor = p.Map?.attackTargetsCache?.GetPotentialTargetsFor(p);
if (!potentialTargetsFor.NullOrEmpty())
{
// ReSharper disable once PossibleNullReferenceException
foreach (IAttackTarget attackTarget in potentialTargetsFor)
{
if (attackTarget == null || attackTarget.ThreatDisabled())
{
continue;
}
if (!p.Position.InHorDistOf(((Thing)attackTarget).Position, radius))
{
continue;
}
enemy = true;
break;
}
}
if (!enemy)
{
return(false);
}
Thing thing = (Thing)AttackTargetFinder.BestAttackTarget(
p,
TargetScanFlags.NeedReachable |
TargetScanFlags.NeedThreat,
x => x is Pawn,
0f,
radius,
protected override Thing FindAttackTarget(Pawn pawn)
{
TargetScanFlags targetScanFlags = TargetScanFlags.NeedLOSToPawns
| TargetScanFlags.NeedReachableIfCantHitFromMyPos | TargetScanFlags.NeedThreat | TargetScanFlags.NeedAutoTargetable;
if (PrimaryVerbIsIncendiary(pawn))
{
targetScanFlags |= TargetScanFlags.NeedNonBurning;
}
var target = enemies.RandomElement();
if (target is null)
{
return((Thing)AttackTargetFinder.BestAttackTarget
(pawn, targetScanFlags, (Thing x) => ExtraTargetValidator(pawn, x), 0f, pawn.Map.Size.x, GetFlagPosition(pawn), GetFlagRadius(pawn)));
}
return(target);
}
