static bool Prefix(MadDogPackTactics __instance, RuleCalculateAttackBonus evt)
{
if (!evt.Target.isFlankedByAttacker(__instance.Owner.Unit))
{
return(false);
}
bool flag = false;
foreach (UnitEntityData unitEntityData in evt.Target.CombatState.EngagedBy)
{
flag = unitEntityData.Descriptor.IsPet && unitEntityData.Descriptor.Master == __instance.Owner.Unit ||
__instance.Owner.IsPet && (UnitReference)unitEntityData == (UnitEntityData)__instance.Owner.Master;
flag = flag && evt.Target.isFlankedByAttacker(unitEntityData);
if (flag)
{
break;
}
}
if (!flag)
{
return(false);
}
evt.AddBonus(2, __instance.Fact);
return(false);
}
static bool Prefix(RuleCalculateAttackBonus __instance, RulebookEventContext context)
{
FlankingParameters flankedParameters = new FlankingParameters(typeof(RuleCalculateAttackBonus_OnTrigger_Patch), __instance.Initiator);
UnitCombatState_get_IsFlanked_Patch.PushFlankingParameters(flankedParameters);
return(true);
}
static bool Prefix(OutflankAttackBonus __instance, RuleCalculateAttackBonus evt)
{
if (!evt.Target.isFlankedByAttacker(__instance.Owner.Unit))
{
return(false);
}
bool flag = (bool)__instance.Owner.State.Features.SoloTactics;
if (!flag)
{
foreach (UnitEntityData unitEntityData in evt.Target.CombatState.EngagedBy)
{
flag = unitEntityData.Descriptor.HasFact(__instance.OutflankFact) && unitEntityData != __instance.Owner.Unit && evt.Target.isFlankedByAttacker(unitEntityData);
if (flag)
{
break;
}
}
}
if (!flag)
{
return(false);
}
evt.AddBonus(__instance.AttackBonus * __instance.Fact.GetRank(), __instance.Fact);
return(false);
}
public static void IncreaseFlankingBonusTo(this RuleCalculateAttackBonus evt, int increaseTo)
{
int diff = 0;
if (evt.FlankingBonus <= increaseTo)
{
diff = increaseTo - evt.FlankingBonus;
evt.FlankingBonus = increaseTo;
}
if (diff > 0)
{
setResult(evt, evt.Result + diff);
}
}
static bool Prefix(FlankedAttackBonus __instance, RuleCalculateAttackBonus evt)
{
bool isFlatFooted = Rulebook.Trigger <RuleCheckTargetFlatFooted>(new RuleCheckTargetFlatFooted(evt.Initiator, evt.Target)).IsFlatFooted;
bool is_flanked = false;
foreach (var u in evt.Target.CombatState.EngagedBy)
{
is_flanked = evt.Target.isFlankedByAttacker(u);
if (is_flanked)
{
break;
}
}
if (is_flanked || isFlatFooted)
{
evt.AddBonus(__instance.AttackBonus * __instance.Fact.GetRank(), __instance.Fact);
}
return(false);
}
static void Postfix(MadDogPackTactics __instance, RuleCalculateAttackBonus evt)
{
MadDogPackTacticsPatch.OnEventDidTrigger(__instance, evt);
}
static bool Prefix(MadDogPackTactics __instance, RuleCalculateAttackBonus evt)
{
MadDogPackTacticsPatch.OnEventAboutToTrigger(__instance, evt);
return(false);
}
internal static void OnEventDidTrigger(MadDogPackTactics madDogPackTacticsInstance, RuleCalculateAttackBonus evt)
{
Func <UnitEntityData, UnitEntityData, UnitEntityData, bool> packTacticsFlankingConditions =
(target, owner, flankingPartner) => (owner.Descriptor.IsPet && owner.Descriptor.Master == flankingPartner) || (flankingPartner.Descriptor.IsPet && flankingPartner.Descriptor.Master == owner);
if (evt.Target.IsFlankedByUnit(madDogPackTacticsInstance.Owner.Unit, packTacticsFlankingConditions))
{
evt.IncreaseFlankingBonusTo(4);
}
}
internal static void OnEventAboutToTrigger(MadDogPackTactics madDogPackTacticsInstance, RuleCalculateAttackBonus evt)
{
// do nothing before the attack bonus is calculated
}
static bool Prefix(FlankedAttackBonus __instance, RuleCalculateAttackBonus evt)
{
Main.Logger?.Write("FlankedAttackBonus event triggered");
UnitCombatState_get_IsFlanked_Patch.PushFlankingParameters(new FlankingParameters(typeof(FlankedAttackBonus_OnEventAboutToTrigger_Patch), __instance.Owner.Unit));
return(true);
}
static bool Prefix(CallOfTheWild.TeamworkMechanics.CoordinatedShotAttackBonus __instance, RuleCalculateAttackBonus evt)
{
if (evt.Weapon == null)
{
return(false);
}
if (!evt.Weapon.Blueprint.IsRanged)
{
return(false);
}
int attack_bonus = __instance.AttackBonus;
int additional_flank_bonus = __instance.AdditionalFlankBonus;
BlueprintUnitFact coordinated_shot_fact = __instance.CoordinatedShotFact;
UnitDescriptor owner = __instance.Owner;
int bonus = 0;
bool solo_tactics = owner.State.Features.SoloTactics;
foreach (UnitEntityData unitEntityData in evt.Target.CombatState.EngagedBy)
{
AttackType attack_type = evt.Weapon == null ? AttackType.Melee : evt.Weapon.Blueprint.AttackType;
if ((unitEntityData.Descriptor.HasFact(coordinated_shot_fact) || solo_tactics) &&
unitEntityData != owner.Unit && unitEntityData.providesCoverToFrom(evt.Target, owner.Unit, attack_type) == Cover.CoverType.None)
{
bonus = Math.Max(bonus, (evt.Target.isFlankedByAttacker(unitEntityData) ? attack_bonus + additional_flank_bonus : attack_bonus));
}
}
if (bonus == 0)
{
return(false);
}
evt.AddBonus(bonus, __instance.Fact);
return(false);
}
static bool Prefix(OutflankAttackBonus __instance, RuleCalculateAttackBonus evt)
{
OutflankPatch.OnEventAboutToTrigger(__instance, evt);
return(false);
}
internal static void OnEventDidTrigger(OutflankAttackBonus outflankAttackBonusInstance, RuleCalculateAttackBonus evt)
{
BlueprintUnitFact outflankFact = outflankAttackBonusInstance.OutflankFact;
Func <UnitEntityData, UnitEntityData, UnitEntityData, bool> outflankPreconditions =
(target, owner, flankingPartner) => owner.Descriptor.State.Features.SoloTactics || flankingPartner.Descriptor.HasFact(outflankFact);
if (evt.Target.IsFlankedByUnit(outflankAttackBonusInstance.Owner.Unit, outflankPreconditions))
{
evt.IncreaseFlankingBonusTo(4);
}
}
// While the attack bonus portion of the Outflank feat is straightforward, the vanilla implementation makes the same mistake
// as the implementation for the Mad Dog's Pack Tactics feature. See the MadDogPackTactics patch for an explanation of this problem
// (and its solution).
internal static void OnEventAboutToTrigger(OutflankAttackBonus outflankAttackBonusInstance, RuleCalculateAttackBonus evt)
{
// do nothing before the attack bonus is calculated
}
static void Postfix(OutflankAttackBonus __instance, RuleCalculateAttackBonus evt)
{
OutflankPatch.OnEventDidTrigger(__instance, evt);
}
