private IEnumerator StopBlockingCoroutine(Character character)
{
yield return(new WaitForSeconds(0.05f)); // 50ms wait (1 or 2 frames)
At.Call(character, "StopBlocking", null);
At.SetValue(false, typeof(Character), character, "m_blockDesired");
}
private void SendDodge(Character self, float staminaCost, Vector3 _direction)
{
float f = (float)At.GetValue(typeof(CharacterStats), self.Stats, "m_stamina");
if (f >= staminaCost)
{
At.SetValue(f - staminaCost, typeof(CharacterStats), self.Stats, "m_stamina");
At.SetValue(0, typeof(Character), self, "m_dodgeAllowedInAction");
if (self.CharacterCamera && self.CharacterCamera.InZoomMode)
{
self.SetZoomMode(false);
}
self.ForceCancel(false, true);
self.ResetCastType();
(self as Photon.MonoBehaviour).photonView.RPC("SendDodgeTriggerTrivial", PhotonTargets.All, new object[] { _direction });
At.Call(self, "ActionPerformed", new object[] { false });
(self as MonoBehaviour).Invoke("ResetDodgeTrigger", 0.5f);
}
}
public static bool Prefix(Character __instance, int _type, int _id = 0)
{
var self = __instance;
if (self.IsLocalPlayer && (bool)CombatOverhaul.config.GetValue(Settings.Attack_Cancels_Blocking) && !self.IsAI && self.Blocking)
{
Instance.StartCoroutine(Instance.StopBlockingCoroutine(self));
At.Call(self, "StopBlocking", null);
At.SetValue(false, typeof(Character), self, "m_blockDesired");
}
return(true);
}
public static bool Prefix(Character __instance, Vector3 _direction)
{
var self = __instance;
if (!(bool)CombatOverhaul.config.GetValue(Settings.Custom_Bag_Burden))
{
return(true);
}
if (self.CurrentWeapon)
{
if (self.HasDodgeDirection)
{
self.Animator.SetFloat("DodgeBlend", !self.DodgeRestricted ? 0.0f : Instance.GetDodgeRestriction(self));
}
}
self.Animator.SetTrigger("Dodge");
if (self.CurrentlyChargingAttack)
{
//self.SendCancelCharging();
At.Call(self, "SendCancelCharging", new object[0]);
}
// get sound player with null coalescing operator
(At.GetValue(typeof(Character), self, "m_dodgeSoundPlayer") as SoundPlayer)?.Play(false);
//self.m_dodging = true;
At.SetValue(true, typeof(Character), self, "m_dodging");
//self.StopBlocking();
At.Call(self, "StopBlocking", new object[0]);
// null coalescing OnDodgeEvent invoke
self.OnDodgeEvent?.Invoke();
if (At.GetValue(typeof(Character), self, "m_characterSoundManager") is CharacterSoundManager charSounds)
{
Global.AudioManager.PlaySoundAtPosition(charSounds.GetDodgeSound(), self.transform, 0f, 1f, 1f, 1f, 1f);
}
self.SendMessage("DodgeTrigger", _direction, SendMessageOptions.DontRequireReceiver);
return(false);
}
public static bool Prefix(Character __instance, bool _down, Vector3 _dir)
{
var self = __instance;
var _base = self as Photon.MonoBehaviour;
if (At.GetValue(typeof(Character), self, "m_stability") is float m_stability)
{
//OLogger.Error("Autoknock, m_stability: " + m_stability);
At.Call(self, "StabilityHit", new object[] {
(!_down) ? Mathf.Clamp(m_stability - (float)CombatOverhaul.config.GetValue(Settings.Stagger_Threshold), 1f, 100 - (float)CombatOverhaul.config.GetValue(Settings.Stagger_Threshold)) : m_stability,
Vector3.Angle(_base.transform.forward, -_dir),
_down,
null
});
}
return(false);
}
public static bool Prefix(Character __instance, float _knockValue, float _angle, bool _block, Character _dealerChar)
{
var self = __instance;
var _base = self as Photon.MonoBehaviour;
if (At.GetValue(typeof(Character), self, "m_impactImmune") is bool m_impactImmune &&
At.GetValue(typeof(Character), self, "m_shieldStability") is float m_shieldStability &&
At.GetValue(typeof(Character), self, "m_stability") is float m_stability &&
At.GetValue(typeof(Character), self, "m_knockbackCount") is float m_knockbackCount &&
At.GetValue(typeof(Character), self, "m_knockHurtAllowed") is bool m_knockHurtAllowed &&
At.GetValue(typeof(Character), self, "m_currentlyChargingAttack") is bool m_currentlyChargingAttack &&
At.GetValue(typeof(Character), self, "m_animator") is Animator m_animator)
{
// Begin actual stability hit function
var hit = _knockValue;
if (hit < 0)
{
hit = 0;
}
if (!m_impactImmune && hit > 0f)
{
//Debug.Log("--------- " + self.Name + " ---------");
// check stagger immunity dictionary (custom)
float lastStagger = -1;
if (Instance.LastStaggerTimes.ContainsKey(self.UID))
{
lastStagger = Instance.LastStaggerTimes[self.UID];
}
// if you run out of stamina and get hit, you will always get staggered. (unchanged, except to reflect custom stagger threshold)
if (self.Stats.CurrentStamina < 1f)
{
float hitToStagger = m_shieldStability + m_stability - (100 - (float)CombatOverhaul.config.GetValue(Settings.Stagger_Threshold));
if (hit < hitToStagger)
{
hit = hitToStagger;
}
//Debug.LogError("Stamina autostagger called! hitToStagger: " + hitToStagger + ", hit: " + hit);
}
At.SetValue(Time.time, typeof(Character), self, "m_timeOfLastStabilityHit");
// Debug.Log("Set " + Time.time + " as character's last stability hit");
if (self.CharacterCamera != null && hit > 0f)
{
self.CharacterCamera.Hit(hit * 6f);
}
// check shield stability if blocking (unchanged)
if (_block && m_shieldStability > 0f)
{
if (hit > m_shieldStability)
{
var num2 = m_stability - (hit - m_shieldStability);
At.SetValue(num2, typeof(Character), self, "m_stability");
m_stability = num2;
}
var num3 = Mathf.Clamp(m_shieldStability - hit, 0f, 50f);
At.SetValue(num3, typeof(Character), self, "m_shieldStability");
m_shieldStability = num3;
}
// check non-blocking stability (unchanged)
else
{
var num2 = Mathf.Clamp(m_stability - hit, 0f, 100f);
At.SetValue(num2, typeof(Character), self, "m_stability");
m_stability = num2;
}
// if hit takes us below knockdown threshold, or if AI auto-knockdown stagger count was reached...
if (m_stability <= (float)CombatOverhaul.config.GetValue(Settings.Knockdown_Threshold) ||
(self.IsAI && m_knockbackCount >= (float)CombatOverhaul.config.GetValue(Settings.Enemy_AutoKD_Count)))
{
//Debug.LogError("Knockdown! Hit Value: " + _knockValue + ", current stability: " + m_stability);
if ((!self.IsAI && _base.photonView.isMine) || (self.IsAI && (_dealerChar == null || _dealerChar.photonView.isMine)))
{
_base.photonView.RPC("SendKnock", PhotonTargets.All, new object[]
{
true,
m_stability
});
}
else
{
At.Call(self, "Knock", new object[]
{
true
});
}
At.SetValue(0f, typeof(Character), self, "m_stability");
m_stability = 0f;
if (self.IsPhotonPlayerLocal)
{
self.BlockInput(false);
}
}
// else if hit is a stagger...
else if (m_stability <= (float)CombatOverhaul.config.GetValue(Settings.Stagger_Threshold) && (Time.time - lastStagger > (float)CombatOverhaul.config.GetValue(Settings.Stagger_Immunity_Period)))
{
// Debug.LogWarning("Stagger! Hit Value: " + _knockValue + ", current stability: " + m_stability);
// update Stagger Immunity dictionary
if (!Instance.LastStaggerTimes.ContainsKey(self.UID))
{
Instance.LastStaggerTimes.Add(self.UID, Time.time);
}
else
{
Instance.LastStaggerTimes[self.UID] = Time.time;
}
if ((!self.IsAI && _base.photonView.isMine) || (self.IsAI && (_dealerChar == null || _dealerChar.photonView.isMine)))
{
_base.photonView.RPC("SendKnock", PhotonTargets.All, new object[]
{
false,
m_stability
});
}
else
{
At.Call(self, "Knock", new object[]
{
false
});
}
if (self.IsPhotonPlayerLocal && _block)
{
self.BlockInput(false);
}
}
// else if we are not blocking...
else if (!_block)
{
// Debug.Log("Value: " + _knockValue + ", new stability: " + m_stability);
if (m_knockHurtAllowed)
{
At.SetValue(Character.HurtType.Hurt, typeof(Character), self, "m_hurtType");
if (m_currentlyChargingAttack)
{
self.CancelCharging();
}
m_animator.SetTrigger("Knockhurt");
_base.StopCoroutine("KnockhurtRoutine");
MethodInfo _knockhurtRoutine = self.GetType().GetMethod("KnockhurtRoutine", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
IEnumerator _knockEnum = (IEnumerator)_knockhurtRoutine.Invoke(self, new object[] { hit });
_base.StartCoroutine(_knockEnum);
}
if (m_stability <= (float)CombatOverhaul.config.GetValue(Settings.Stagger_Immunity_Period))
{
// Debug.LogError(self.Name + " would have staggered. Current delta: " + (Time.time - lastStagger));
}
}
else // hit was blocked and no stagger
{
Instance.StaggerAttacker(self, m_animator, _dealerChar);
}
m_animator.SetInteger("KnockAngle", (int)_angle);
self.StabilityHitCall?.Invoke();
}
else if (!m_impactImmune && _block) // hit dealt 0 impact and was blocked
{
Instance.StaggerAttacker(self, m_animator, _dealerChar);
}
}
return(false);
}
