public OrderInvalidReason CanAttack(
AttackMethod AttackMethod, bool EnemyArmored, LineOfSight LineOfSight, bool UseSecondaryWeapon)
{
var r = CanAttack(AttackMethod);
if (r != OrderInvalidReason.NONE)
{
return(r);
}
if (Configuration.GetWeapon(UseSecondaryWeapon).Ammunition > 0 && GetAmmunition(UseSecondaryWeapon) == 0)
{
return(OrderInvalidReason.UNIT_NO_AMMUNITION);
}
if (AttackMethod == AttackMethod.DIRECT_FIRE)
{
return(Configuration.CanDirectFireAt(EnemyArmored, LineOfSight, UseSecondaryWeapon));
}
if (AttackMethod == AttackMethod.INDIRECT_FIRE)
{
r = Configuration.CanIndirectFireAt(LineOfSight, UseSecondaryWeapon);
if (r != OrderInvalidReason.NONE)
{
return(r);
}
if (Configuration.CanDirectFireAt(
EnemyArmored, LineOfSight, UseSecondaryWeapon) != OrderInvalidReason.NONE)
{
if (Army.SightFinder.HasTileSightLevel(LineOfSight.Final, TileSightLevel.SOFT_SPOTTED))
{
return(OrderInvalidReason.NONE);
}
return(OrderInvalidReason.ATTACK_NO_SPOTTER);
}
return(OrderInvalidReason.NONE);
}
if (AttackMethod == AttackMethod.OVERRUN)
{
return(Configuration.CanOverrunAt(EnemyArmored));
}
if (AttackMethod == AttackMethod.CLOSE_ASSAULT)
{
if (!Configuration.CanCloseAssault)
{
return(OrderInvalidReason.UNIT_NO_ATTACK);
}
}
if (AttackMethod == AttackMethod.AIR)
{
return(Configuration.CanAirAttackAt(EnemyArmored, UseSecondaryWeapon));
}
if (AttackMethod == AttackMethod.ANTI_AIRCRAFT)
{
return(Configuration.CanAntiAircraftAt(EnemyArmored, LineOfSight, UseSecondaryWeapon));
}
return(OrderInvalidReason.NONE);
}
public int PosterizeLineOfSight(
LineOfSight LineOfSight, Unit Unit, AttackMethod AttackMethod)
{
return(Math.Min(
LineOfSight.Range * HIGHLIGHT_COLORS.Length / (Unit.Configuration.GetRange(AttackMethod, false) + 1),
HIGHLIGHT_COLORS.Length - 1));
}
void GetAntiAirAttack(Unit Unit, LineOfSight LineOfSight, bool UseSecondaryWeapon)
{
var weapon = Unit.Configuration.GetWeapon(UseSecondaryWeapon);
Factors = new List <AttackFactorCalculationFactor>();
Attack = weapon.Attack;
if (LineOfSight.Range < weapon.Range / 2)
{
Attack *= 2;
Factors.Add(AttackFactorCalculationFactor.ANTI_AIR_RANGE);
}
}
public AttackFactorCalculation(
Unit Unit,
AttackMethod AttackMethod,
bool EnemyArmored,
LineOfSight LineOfSight,
bool UseSecondaryWeapon)
{
if (Unit.CanAttack(AttackMethod, EnemyArmored, LineOfSight, UseSecondaryWeapon) != OrderInvalidReason.NONE)
{
Attack = 0;
Factors = new List <AttackFactorCalculationFactor> {
AttackFactorCalculationFactor.CANNOT_ATTACK
};
return;
}
switch (AttackMethod)
{
case AttackMethod.DIRECT_FIRE:
GetNormalAttack(Unit, EnemyArmored, LineOfSight, UseSecondaryWeapon, true);
break;
case AttackMethod.INDIRECT_FIRE:
GetNormalAttack(Unit, EnemyArmored, LineOfSight, UseSecondaryWeapon, false);
Attack /= 4;
Factors.Add(AttackFactorCalculationFactor.INDIRECT_FIRE);
break;
case AttackMethod.AIR:
GetAirAttack(Unit, EnemyArmored, UseSecondaryWeapon);
break;
case AttackMethod.ANTI_AIRCRAFT:
GetAntiAirAttack(Unit, LineOfSight, UseSecondaryWeapon);
break;
default:
if (Unit.CanAttack(
AttackMethod, EnemyArmored, LineOfSight, UseSecondaryWeapon) != OrderInvalidReason.NONE)
{
Attack = 0;
Factors = new List <AttackFactorCalculationFactor>
{
AttackFactorCalculationFactor.CANNOT_ATTACK
};
}
Attack = Unit.Configuration.GetWeapon(UseSecondaryWeapon).Attack;
Factors = new List <AttackFactorCalculationFactor>();
break;
}
}
void GetNormalAttack(
Unit Unit, bool EnemyArmored, LineOfSight LineOfSight, bool UseSecondaryWeapon, bool FactorElevation)
{
var weapon = Unit.Configuration.GetWeapon(UseSecondaryWeapon);
Factors = new List <AttackFactorCalculationFactor>();
Attack = weapon.Attack;
if (EnemyArmored)
{
int HalfRange = weapon.Range / 2;
if (weapon.WeaponClass == WeaponClass.HIGH_EXPLOSIVE ||
weapon.WeaponClass == WeaponClass.MORTAR)
{
if (LineOfSight.Range > HalfRange)
{
Attack /= 2;
Factors.Add(AttackFactorCalculationFactor.ARMOR_RANGE);
}
}
else if (weapon.WeaponClass == WeaponClass.ANTI_ARMOR)
{
if (LineOfSight.Range <= HalfRange)
{
Attack *= 2;
Factors.Add(AttackFactorCalculationFactor.ANTI_ARMOR_RANGE);
}
}
}
else if (weapon.WeaponClass == WeaponClass.ANTI_ARMOR && !EnemyArmored)
{
Attack /= 2;
Factors.Add(AttackFactorCalculationFactor.NOT_ARMORED);
}
if (FactorElevation)
{
if (LineOfSight.Initial.Rules.SubTieredElevation
< LineOfSight.Final.Rules.SubTieredElevation)
{
Attack /= 2;
Factors.Add(AttackFactorCalculationFactor.ELEVATION);
}
}
if (weapon.Range < LineOfSight.Range && weapon.CanDoubleRange)
{
Attack /= 2;
Factors.Add(AttackFactorCalculationFactor.DOUBLE_RANGE);
}
}
public OrderInvalidReason CanAntiAircraftAt(bool EnemyArmored, LineOfSight LineOfSight, bool UseSecondaryWeapon)
{
if (!CanAntiAircraft)
{
return(OrderInvalidReason.UNIT_NO_ATTACK);
}
if (LineOfSight.Range > GetAdjustedRange(UseSecondaryWeapon))
{
return(OrderInvalidReason.TARGET_OUT_OF_RANGE);
}
if (GetWeapon(UseSecondaryWeapon).WeaponClass == WeaponClass.INFANTRY && EnemyArmored)
{
return(OrderInvalidReason.TARGET_ARMORED);
}
return(OrderInvalidReason.NONE);
}
public OrderInvalidReason CanIndirectFireAt(LineOfSight LineOfSight, bool UseSecondaryWeapon)
{
var range = GetAdjustedRange(UseSecondaryWeapon);
if (LineOfSight.Range > range)
{
return(OrderInvalidReason.TARGET_OUT_OF_RANGE);
}
if (LineOfSight.Range < MinimumIndirectFireRange)
{
return(OrderInvalidReason.TARGET_TOO_CLOSE);
}
if (!CanIndirectFire)
{
return(OrderInvalidReason.UNIT_NO_ATTACK);
}
return(OrderInvalidReason.NONE);
}
public OrderInvalidReason CanDirectFireAt(bool EnemyArmored, LineOfSight LineOfSight, bool UseSecondaryWeapon)
{
if (!CanDirectFire)
{
return(OrderInvalidReason.UNIT_NO_ATTACK);
}
if (LineOfSight.Validate() != NoLineOfSightReason.NONE)
{
return(OrderInvalidReason.ATTACK_NO_LOS);
}
if (LineOfSight.Range > GetAdjustedRange(UseSecondaryWeapon))
{
return(OrderInvalidReason.TARGET_OUT_OF_RANGE);
}
if (GetWeapon(UseSecondaryWeapon).WeaponClass == WeaponClass.INFANTRY && EnemyArmored)
{
return(OrderInvalidReason.TARGET_ARMORED);
}
return(OrderInvalidReason.NONE);
}
double GetPotential(Unit Unit, LineOfSight LineOfSight)
{
var defenders =
LineOfSight.Final.Units.Where(
i => i.CanBeAttackedBy(Root.Army, AttackMethod.DIRECT_FIRE, true) == OrderInvalidReason.NONE);
var armoredCount = defenders.Count(i => i.Configuration.IsArmored);
var unArmoredCount = defenders.Count(i => !i.Configuration.IsArmored);
if (armoredCount > unArmoredCount ||
defenders.Any(i => i.Configuration.UnitClass == UnitClass.FORT) ||
LineOfSight.Final.Rules.TreatUnitsAsArmored)
{
return(GetThreat(Unit, LineOfSight, true));
}
if (armoredCount < unArmoredCount)
{
return(GetThreat(Unit, LineOfSight, false));
}
return(Math.Min(GetThreat(Unit, LineOfSight, true), GetThreat(Unit, LineOfSight, false)));
}
public DirectFireSingleAttackOrder(SerializationInputStream Stream, List <GameObject> Objects)
: base((Unit)Objects[Stream.ReadInt32()], (Unit)Objects[Stream.ReadInt32()], Stream.ReadBoolean())
{
LineOfSight = new LineOfSight((Tile)Objects[Stream.ReadInt32()], (Tile)Objects[Stream.ReadInt32()]);
}
public DirectFireSingleAttackOrder(Unit Attacker, Unit Defender, bool UseSecondaryWeapon)
: base(Attacker, Defender, UseSecondaryWeapon)
{
LineOfSight = Attacker.GetLineOfSight(Defender.Position);
}
public IndirectFireSingleAttackOrder(Unit Attacker, Tile AttackTile, bool UseSecondaryWeapon)
: base(Attacker, null, UseSecondaryWeapon)
{
this.AttackTile = AttackTile;
LineOfSight = Attacker.GetLineOfSight(AttackTile);
}
public Color GetRangeColor(
LineOfSight LineOfSight, Unit Unit, AttackMethod AttackMethod)
{
return(HIGHLIGHT_COLORS[PosterizeLineOfSight(LineOfSight, Unit, AttackMethod)]);
}
double GetThreat(Unit Unit, LineOfSight LineOfSight, bool EnemyArmored)
{
return(Math.Max(
new AttackFactorCalculation(Unit, AttackMethod.DIRECT_FIRE, EnemyArmored, LineOfSight, true).Attack,
new AttackFactorCalculation(Unit, AttackMethod.DIRECT_FIRE, EnemyArmored, LineOfSight, false).Attack));
}
