public void OnEventAboutToTrigger(RuleCalculateBaseCMB evt)
{
var old_size = this.Owner.State.Size;
var new_size = old_size.Shift(bonus);
if (old_size == new_size)
{
return;
}
evt.AddBonus(new_size.GetModifiers().CMDAndCMD - old_size.GetModifiers().CMDAndCMD + new_size.GetModifiers().AttackAndAC - old_size.GetModifiers().AttackAndAC, this.Fact);
}
public void OnEventDidTrigger(RuleCalculateBaseCMB evt)
{
}
static bool Prefix(RuleCalculateBaseCMB __instance)
{
if (__instance.ReplaceBAB.HasValue)
{
// if bab is replaced it is not an attack (very likely a spell or some other ability)
return(true);
}
var attack = Rulebook.CurrentContext.AllEvents.LastOfType <RuleAttackWithWeapon>();
var maneuver = Rulebook.CurrentContext.AllEvents.LastOfType <RuleCombatManeuver>();
if (maneuver == null || !maneuverAsAttack(maneuver.Type, __instance.Initiator))
{
return(true);
}
var weapon = __instance.Initiator.Body?.PrimaryHand?.MaybeWeapon;
var penalty = 0;
if (attack != null)
{
weapon = attack.Weapon;
if (attack.AttackRoll != null && attack.AttackRoll.IsTriggererd)
{
//if maneuver is after attack - it is a free attempt that is using iterative attack bonus
penalty = attack.AttackBonusPenalty;
}
}
else if (__instance.Initiator.Ensure <UnitPartUseWeaponForCombatManeuver>().active())
{
var forced_weapon = __instance.Initiator.Ensure <UnitPartUseWeaponForCombatManeuver>().forcedWeapon();
if (forced_weapon != null)
{
weapon = forced_weapon;
}
penalty = __instance.Initiator.Ensure <UnitPartUseWeaponForCombatManeuver>().forcedPenalty();
}
else
{
return(true);
}
if (weapon == null || !weapon.Blueprint.IsMelee)
{
//no maneuvers without weapon or ranged weapon
return(true);
}
// in order to properly get attack bonus we normally need to trigger RuleCalculateAttackBonus
// the problem is that a lot of abilities add additional attack bonuses in OnEventAboutToTrigger( RuleAttackRoll),
// and thus might happen after we trigger this combat maneuver
// so instead we trigger a complete RuleAttackRoll to correctly get the bonus
// as an unfortunate side effect it might trigger something that should not be triggered (like limited use rerolls), so it is not ideal
// so we make a trick - we patch RuleAttackRoll to always trigger RuleCalculateAttackBonus and than call a fake RuleAttackRoll with auto hit
// which does not make a roll
var attack_roll = new RuleAttackRoll(maneuver.Initiator, maneuver.Target, weapon, penalty);
attack_roll.IgnoreConcealment = true;
attack_roll.AutoHit = true;
attack_roll.SuspendCombatLog = true;
var AttackBonus = Rulebook.Trigger <RuleAttackRoll>(attack_roll).AttackBonus;
var ResultSizeBonus = __instance.Initiator.Descriptor.State.Size.GetModifiers().CMDAndCMD + __instance.Initiator.Descriptor.State.Size.GetModifiers().AttackAndAC;
var ResultMiscBonus = (int)__instance.Initiator.Stats.AdditionalCMB;
/*Main.logger.Log("Attack Detected: " + AttackBonus.ToString());
* Main.logger.Log("Misc: " + ResultMiscBonus.ToString());
* Main.logger.Log("Size: " + ResultSizeBonus.ToString());
* Main.logger.Log("Additional Bonus: " + __instance.AdditionalBonus.ToString());*/
var tr = Harmony12.Traverse.Create(__instance);
tr.Property("Result").SetValue(AttackBonus + ResultSizeBonus + ResultMiscBonus + __instance.AdditionalBonus);
return(false);
}
