public void Damaged(Actor self, AttackInfo e)
{
if (!self.IsIdle || !info.TargetWhenDamaged)
{
return;
}
var attacker = e.Attacker;
if (attacker.Destroyed || Stance < UnitStance.ReturnFire)
{
return;
}
if (!attacker.IsInWorld && !attacker.Destroyed)
{
// If the aggressor is in a transport, then attack the transport instead
var passenger = attacker.TraitOrDefault <Passenger>();
if (passenger != null && passenger.Transport != null)
{
attacker = passenger.Transport;
}
}
// not a lot we can do about things we can't hurt... although maybe we should automatically run away?
if (!attack.HasAnyValidWeapons(Target.FromActor(attacker)))
{
return;
}
// don't retaliate against own units force-firing on us. It's usually not what the player wanted.
if (attacker.AppearsFriendlyTo(self))
{
return;
}
// don't retaliate against healers
if (e.Damage < 0)
{
return;
}
Aggressor = attacker;
if (at == null || !at.IsReachableTarget(at.Target, info.AllowMovement && Stance != UnitStance.Defend))
{
Attack(self, Aggressor);
}
}
bool CanTargetActor(Actor self, Target target, TargetModifiers modifiers, ref string cursor)
{
IsQueued = modifiers.HasModifier(TargetModifiers.ForceQueue);
var a = ab.ChooseArmamentForTarget(target);
cursor = a != null && !target.IsInRange(self.CenterPosition, a.Weapon.Range)
? ab.info.OutsideRangeCursor
: ab.info.Cursor;
if (target.Type == TargetType.Actor && target.Actor == self)
{
return(false);
}
if (!ab.HasAnyValidWeapons(target))
{
return(false);
}
if (modifiers.HasModifier(TargetModifiers.ForceAttack))
{
return(true);
}
if (modifiers.HasModifier(TargetModifiers.ForceMove))
{
return(false);
}
if (target.RequiresForceFire)
{
return(false);
}
var targetableRelationship = negativeDamage ? Stance.Ally : Stance.Enemy;
var owner = target.Type == TargetType.FrozenActor ? target.FrozenActor.Owner : target.Actor.Owner;
return(self.Owner.Stances[owner] == targetableRelationship);
}
public void Damaged(Actor self, AttackInfo e)
{
if (!self.IsIdle)
{
return;
}
if (e.Attacker.Destroyed)
{
return;
}
if (stance < UnitStance.ReturnFire)
{
return;
}
// not a lot we can do about things we can't hurt... although maybe we should automatically run away?
if (!attack.HasAnyValidWeapons(Target.FromActor(e.Attacker)))
{
return;
}
// don't retaliate against own units force-firing on us. it's usually not what the player wanted.
if (e.Attacker.AppearsFriendlyTo(self))
{
return;
}
if (e.Damage < 0)
{
return; // don't retaliate against healers
}
Aggressor = e.Attacker;
if (at == null || !at.IsReachableTarget(at.Target, Info.AllowMovement && stance != UnitStance.Defend))
{
Attack(self, e.Attacker);
}
}
Actor ChooseTarget(Actor self, float range)
{
nextScanTime = self.World.SharedRandom.Next(Info.MinimumScanTimeInterval, Info.MaximumScanTimeInterval);
var inRange = self.World.FindUnitsInCircle(self.CenterLocation, (int)(Game.CellSize * range));
if (self.Owner.HasFogVisibility())
{
return(inRange
.Where(a => a.AppearsHostileTo(self))
.Where(a => !a.HasTrait <AutoTargetIgnore>())
.Where(a => attack.HasAnyValidWeapons(Target.FromActor(a)))
.ClosestTo(self.CenterLocation));
}
else
{
return(inRange
.Where(a => a.AppearsHostileTo(self))
.Where(a => !a.HasTrait <AutoTargetIgnore>())
.Where(a => attack.HasAnyValidWeapons(Target.FromActor(a)))
.Where(a => self.Owner.Shroud.IsTargetable(a))
.ClosestTo(self.CenterLocation));
}
}
Actor ChooseTarget(Actor self, float range)
{
var info = self.Info.Traits.Get <AttackBaseInfo>();
nextScanTime = (int)(25 * (info.ScanTimeAverage +
(self.World.SharedRandom.NextDouble() * 2 - 1) * info.ScanTimeSpread));
var inRange = self.World.FindUnitsInCircle(self.CenterLocation, (int)(Game.CellSize * range));
return(inRange
.Where(a => a.AppearsHostileTo(self))
.Where(a => !a.HasTrait <AutoTargetIgnore>())
.Where(a => attack.HasAnyValidWeapons(Target.FromActor(a)))
.ClosestTo(self.CenterLocation));
}
