static bool Prefix(UnitAttack __instance, AttackHandInfo attack)
{
var combatManeuver = Rulebook.Trigger(new RuleCheckCombatManeuverReplaceAttack(__instance.Executor, __instance.Target, attack)).Result;
if (combatManeuver == CombatManeuver.None)
{
return(true);
}
var lastAttackRule = new RuleAttackWithWeapon(__instance.Executor, __instance.Target, attack.Weapon, attack.AttackBonusPenalty)
{
IsRend = __instance.IsRend(__instance.PlannedAttack),
IsFirstAttack = (attack.AttackNumber == 0),
IsFullAttack = __instance.IsFullAttack,
IsCharge = __instance.IsCharge,
AttackNumber = attack.AttackNumber,
AttacksCount = ((List <AttackHandInfo>)unitattack_get_m_AllAttacks(__instance)).Count
};
unitattack_set_LastAttackRule(__instance, lastAttackRule);
attack.Target = __instance.Target;
attack.IsHit = __instance.Executor.TriggerAttackReplacementCombatManeuver(__instance.Target, attack.Weapon, attack.AttackBonusPenalty, combatManeuver);
return(false);
}
static bool Prefix(UnitAttackOfOpportunity __instance)
{
if (Game.Instance.IsPaused && __instance.Target != null && __instance.Target != __instance.Executor)
{
__instance.Executor.ForceLookAt(__instance.Target.Position);
}
typeof(UnitCommand).GetProperty("DidRun", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(__instance, true);
if (__instance.NeedEquipWeapons)
{
__instance.Executor.View.HandleAttackCommandRun();
}
if (!(__instance.Executor.View.AnimationManager == null) && __instance.Executor.View.AnimationManager.CanRunIdleAction())
{
AttackHandInfo attackHandInfo = new AttackHandInfo(__instance.Hand, 0, 0);
attackHandInfo.CreateAnimationHandleForAttack();
if (attackHandInfo.AnimationHandle != null)
{
attackHandInfo.AnimationHandle.SpeedScale = 1.8f;
__instance.Executor.LookAt(__instance.Target.Position);
__instance.Executor.View.AnimationManager.ExecuteIfIdle(attackHandInfo.AnimationHandle);
}
}
return(false);
}
static void Postfix(UnitAttack __instance, AttackHandInfo attack)
{
TwoWeaponFightingDamagePenalty__OnEventAboutToTrigger__Patch.is_off_hand = false;
}
static bool Prefix(UnitAttack __instance, AttackHandInfo attack)
{
TwoWeaponFightingDamagePenalty__OnEventAboutToTrigger__Patch.is_off_hand = (attack?.Hand != null && attack?.Hand == __instance.Executor?.Body?.SecondaryHand);
return(true);
}
public override IEnumerator <AbilityDeliveryTarget> Deliver(AbilityExecutionContext context, TargetWrapper target)
{
if (target.Unit == null)
{
UberDebug.LogError("Target unit is missing", Array.Empty <object>());
yield break;
}
UnitAttack cmd = new UnitAttack(target.Unit)
{
IsSingleAttack = true
};
cmd.Init(context.Caster);
cmd.Start();
AttackHandInfo attackHandInfo = cmd.AllAttacks.FirstOrDefault <AttackHandInfo>();
ItemEntityWeapon weapon = (attackHandInfo != null) ? attackHandInfo.Weapon : null;
if (weapon == null)
{
UberDebug.LogError("Has no weapon for attack", Array.Empty <object>());
cmd.Interrupt();
yield break;
}
bool hitHandled = false;
bool isMelee = weapon.Blueprint.IsMelee;
for (; ;)
{
if (cmd.IsFinished)
{
RuleAttackWithWeapon lastAttackRule = cmd.LastAttackRule;
if (((lastAttackRule != null) ? lastAttackRule.Projectile : null) == null || cmd.LastAttackRule.Projectile.IsHit || cmd.LastAttackRule.Projectile.Cleared || cmd.LastAttackRule.Projectile.Destroyed)
{
break;
}
}
bool wasActed = cmd.IsActed;
if (!cmd.IsFinished)
{
cmd.Tick();
}
RuleAttackWithWeapon lastAttackRule2 = cmd.LastAttackRule;
if (!wasActed && cmd.IsActed && isMelee)
{
hitHandled = true;
if (lastAttackRule2.AttackRoll.IsHit)
{
yield return(new AbilityDeliveryTarget(target));
}
}
yield return(null);
}
if (!hitHandled && !isMelee)
{
RuleAttackWithWeapon lastAttackRule3 = cmd.LastAttackRule;
bool?flag3 = (lastAttackRule3 != null) ? new bool?(lastAttackRule3.AttackRoll.IsHit) : null;
if (flag3 != null && flag3.Value)
{
yield return(new AbilityDeliveryTarget(target));
}
}
yield break;
}
public RuleCheckCombatManeuverReplaceAttack(UnitEntityData initiator, UnitEntityData target, AttackHandInfo attack) : base(initiator, target)
{
Result = CombatManeuver.None;
Weapon = attack.Weapon.Blueprint;
}
