void OnGrabTry(BaseEventParameters baseParams)
{
if (IsDead())
{
return;
}
GrabTryEventParameters grabTryParams = (GrabTryEventParameters)baseParams;
PlayerBaseAttackLogic grabAttackLogic = grabTryParams.m_AttackLogic;
ChronicleManager.AddChronicle(gameObject, EChronicleCategory.Health, "On grab try");
if (CanBlockGrabAttack(grabAttackLogic))
{
// Here, both players are currently playing grab attack
// But one is the attacker, and the second the defender
// Only the defender can trigger GrabBlocked event and start a block animation
// If the player who's trying to grab is the first one to have triggered the grab attack, he's the attacker, so we can block it
if (IsGrabAttacker(grabAttackLogic))
{
ChronicleManager.AddChronicle(gameObject, EChronicleCategory.Health, "On grab blocked");
Utils.GetEnemyEventManager(gameObject).TriggerEvent(EPlayerEvent.GrabBlocked, new GrabBlockedEventParameters(grabAttackLogic));
m_StunInfoSC.StartStun(grabAttackLogic, EAttackResult.Blocked);
PlayBlockAnimation(grabAttackLogic);
}
}
else if (!m_StunInfoSC.IsHitStunned() && !m_StunInfoSC.IsBlockStunned() && !m_MovementComponent.IsJumping()) // A grab can't touch if player is stunned or is jumping
{
ChronicleManager.AddChronicle(gameObject, EChronicleCategory.Health, "On grab touched");
Utils.GetEnemyEventManager(gameObject).TriggerEvent(EPlayerEvent.GrabTouched, new GrabTouchedEventParameters(grabAttackLogic));
}
}
void OnEndOfGrab(BaseEventParameters baseParams)
{
ChronicleManager.AddChronicle(m_Owner, EChronicleCategory.Attack, "End of grab phase");
if (m_GrabPhase == EGrabPhase.Startup)
{
ChronicleManager.AddChronicle(m_Owner, EChronicleCategory.Attack, "Grab touched enemy : " + m_GrabTouchedEnemy + ", Last grab touched frame count : " + m_LastGrabTouchedFrameCount);
if (!m_GrabTouchedEnemy || (Time.frameCount - m_LastGrabTouchedFrameCount) > K_MAX_LAST_FRAME_TO_GRAB)
{
ChronicleManager.AddChronicle(m_Owner, EChronicleCategory.Attack, "On grab missed");
m_GrabPhase = EGrabPhase.Missed;
m_Animator.Play(K_GRAB_MISS_ANIM, 0, 0);
}
else
{
ChronicleManager.AddChronicle(m_Owner, EChronicleCategory.Attack, "On grab enemy");
m_GrabPhase = EGrabPhase.Grabbed;
Utils.IgnorePushBoxLayerCollision();
OnSyncGrabPosition();
//Launch grabbed event
Utils.GetEnemyEventManager(m_Owner).TriggerEvent(EPlayerEvent.Grabbed, new GrabbedEventParameters(this));
}
}
}
void OnRoundOver(RoundSubGameManager.ELastRoundWinner lastRoundWinner)
{
ChronicleManager.AddChronicle(gameObject, EChronicleCategory.Movement, "On Round Over");
SetMovementBlocked(true, EBlockedReason.TimeOver);
m_Animator.SetBool("IsCrouching", false);
RoundSubGameManager.OnRoundOver -= OnRoundOver;
}
public void TriggerBackgroundEffect(BackgroundEffectAnimEventConfig backgroundEffectConfig)
{
ChronicleManager.AddChronicle(gameObject, EChronicleCategory.Animation, "Trigger background effect");
m_UIBackground.enabled = true;
m_UIBackground.color = backgroundEffectConfig.m_BackgroundColor;
if (backgroundEffectConfig.m_UseMask)
{
m_UIBackgroundMask.enabled = true;
m_UIBackgroundMask.sprite = backgroundEffectConfig.m_Mask;
m_UIBackgroundMask.transform.position = m_FXHook.position;
if (backgroundEffectConfig.m_MaskDetail != null)
{
m_UIBackgroundMaskDetail.enabled = true;
m_UIBackgroundMaskDetail.sprite = backgroundEffectConfig.m_MaskDetail;
m_UIBackgroundMaskDetail.color = backgroundEffectConfig.m_MaskedBackgroundColor;
m_UIBackgroundMaskDetail.transform.position = m_UIBackgroundMask.transform.position;
}
else
{
m_UIMaskedBackground.enabled = true;
m_UIMaskedBackground.color = backgroundEffectConfig.m_MaskedBackgroundColor;
}
}
}
private void OnDamageTaken(PlayerBaseAttackLogic attackLogic, uint damage, EAttackResult attackResult, EHitNotificationType hitNotificationType)
{
Profiler.BeginSample("PlayerHealthComponent.OnDamageTaken");
#if DEBUG_DISPLAY || UNITY_EDITOR
KakutoDebug.Log("Player : " + gameObject.name + " HP : " + m_HP + " damage taken : " + damage + " attack " + attackResult.ToString());
#endif
ChronicleManager.AddChronicle(gameObject, EChronicleCategory.Health, "On damage taken : " + damage + ", current HP : " + m_HP);
DamageTakenEventParameters damageTakenInfo = new DamageTakenEventParameters(gameObject, attackLogic, attackResult, m_StunInfoSC.IsHitStunned(), damage, (float)m_HP / (float)m_HealthConfig.m_MaxHP, hitNotificationType);
Utils.GetPlayerEventManager(gameObject).TriggerEvent(EPlayerEvent.DamageTaken, damageTakenInfo);
if (!IsDead() && attackLogic.CanPlayDamageTakenAnim())
{
PlayDamageTakenAnim(attackLogic, attackResult);
}
TriggerEffects(attackLogic, damage, attackResult, hitNotificationType);
if (damage > 0 && m_InfoComponent.GetPlayerSettings().m_DisplayDamageTaken)
{
DisplayDamageTakenUI(damage);
}
if (IsDead())
{
OnDeath(attackLogic);
}
Profiler.EndSample();
}
private void OnStunBegin(BaseEventParameters baseParams)
{
if (m_CurrentRefillHPCoroutine != null)
{
ChronicleManager.AddChronicle(gameObject, EChronicleCategory.Health, "Cancel Refill HP");
StopCoroutine(m_CurrentRefillHPCoroutine);
}
}
IEnumerator RefillHPAfter(float _timeToWait)
{
yield return(new WaitForSeconds(_timeToWait));
m_HP = m_HealthConfig.m_MaxHP;
ChronicleManager.AddChronicle(gameObject, EChronicleCategory.Health, "On Refill HP");
Utils.GetPlayerEventManager(gameObject).TriggerEvent(EPlayerEvent.OnRefillHP, new RefillHPEventParameters());
}
protected override void OnShutdown()
{
base.OnShutdown();
ShutdownSubManagers();
DeleteSubManagers();
SceneManager.sceneUnloaded -= OnSceneUnloaded;
ChronicleManager.OnShutdown();
}
public void RestoreBackground()
{
ChronicleManager.AddChronicle(gameObject, EChronicleCategory.Animation, "Restore background");
m_UIBackground.enabled = false;
m_UIMaskedBackground.enabled = false;
m_UIBackgroundMask.enabled = false;
m_UIBackgroundMaskDetail.enabled = false;
}
void UnblockMovement(BaseEventParameters baseParams)
{
if (m_IsMovementBlocked == false)
{
KakutoDebug.LogError("Movement was not blocked");
return;
}
ChronicleManager.AddChronicle(gameObject, EChronicleCategory.Movement, "Unblock movement requested by : " + ((UnblockMovementEventParameters)baseParams).m_CurrentAttack);
SetMovementBlocked(false, EBlockedReason.RequestByAttack);
}
void BlockMovement(BaseEventParameters baseParams)
{
if (m_IsMovementBlocked)
{
KakutoDebug.LogError("Movement was already blocked");
return;
}
ChronicleManager.AddChronicle(gameObject, EChronicleCategory.Movement, "Block movement requested by : " + ((BlockMovementEventParameters)baseParams).m_CurrentAttack);
SetMovementBlocked(true, EBlockedReason.PlayAttack);
}
private void OnStunEnd(BaseEventParameters baseParams)
{
PlayerSettings settings = m_InfoComponent.GetPlayerSettings();
if (settings.m_RefillHPAfterStun)
{
ChronicleManager.AddChronicle(gameObject, EChronicleCategory.Health, "Start Refill HP after: " + settings.m_RefillHPDelay + "s");
m_CurrentRefillHPCoroutine = RefillHPAfter(settings.m_RefillHPDelay);
StartCoroutine(m_CurrentRefillHPCoroutine);
}
}
void OnGrabTouched(BaseEventParameters baseParams)
{
GrabTouchedEventParameters grabTouchedParams = (GrabTouchedEventParameters)baseParams;
if (this == grabTouchedParams.m_AttackLogic && m_GrabPhase == EGrabPhase.Startup)
{
ChronicleManager.AddChronicle(m_Owner, EChronicleCategory.Attack, "On grab touched");
m_GrabTouchedEnemy = true;
m_LastGrabTouchedFrameCount = Time.frameCount;
}
}
void OnSyncGrabbedPosition(BaseEventParameters baseParams)
{
if (IsDead())
{
return;
}
SyncGrabbedPositionEventParameters syncGrabbedParams = (SyncGrabbedPositionEventParameters)baseParams;
ChronicleManager.AddChronicle(gameObject, EChronicleCategory.Health, "On sync grab position");
transform.position = syncGrabbedParams.m_GrabHook.position;
}
void OnGrabBlocked(BaseEventParameters baseParams)
{
GrabBlockedEventParameters grabBlockedParams = (GrabBlockedEventParameters)baseParams;
if (this == grabBlockedParams.m_AttackLogic && m_GrabPhase == EGrabPhase.Startup)
{
ChronicleManager.AddChronicle(m_Owner, EChronicleCategory.Attack, "On grab blocked");
m_GrabPhase = EGrabPhase.Blocked;
IncreaseSuperGauge(m_Config.m_SuperGaugeBlockBonus);
m_Animator.Play(K_GRAB_CANCEL_ANIM, 0, 0);
}
}
public void UnblockMovement()
{
if (m_CurrentAttack)
{
ChronicleManager.AddChronicle(gameObject, EChronicleCategory.Animation, "Unblock movement");
Utils.GetPlayerEventManager(gameObject).TriggerEvent(EPlayerEvent.UnblockMovement, new UnblockMovementEventParameters(m_CurrentAttack.GetAnimationAttackName()));
}
else
{
ChronicleManager.AddChronicle(gameObject, EChronicleCategory.Animation, "Unblock movement: Unable to find BaseAttackStateMachineBehaviour from current animation state info.");
KakutoDebug.LogError("Unblock movement: Unable to find BaseAttackStateMachineBehaviour from current animation state info.");
}
}
public override void OnAttackStopped()
{
base.OnAttackStopped();
if (m_ParryState == EParryState.Counter)
{
ChronicleManager.AddChronicle(m_Owner, EChronicleCategory.Attack, "ParrySuccess: Unreeze time");
m_TimeScaleManager.UnfreezeTime(m_Animator);
}
m_ParryState = EParryState.None;
Utils.GetPlayerEventManager(m_Owner).StopListening(EPlayerEvent.ParrySuccess, OnParrySuccess);
Utils.GetPlayerEventManager(m_Owner).StopListening(EPlayerEvent.EndOfParry, OnEndOfParry);
}
void OnTriggerJumpImpulse(BaseEventParameters baseParams)
{
if (!m_IsMovementBlocked || m_MovementBlockedReason == EBlockedReason.TimeOver)
{
m_JumpTakeOffRequested = false;
m_TriggerJumpImpulse = true;
m_Animator.ResetTrigger(K_ANIM_TAKE_OFF_TRIGGER);
ChronicleManager.AddChronicle(gameObject, EChronicleCategory.Movement, "Jump impulse requested after take off");
}
else
{
ChronicleManager.AddChronicle(gameObject, EChronicleCategory.Movement, "Jump impulse can't be requested because movement has been blocked, reason : " + m_MovementBlockedReason);
}
}
void OnParrySuccess(BaseEventParameters baseParams)
{
IncreaseSuperGauge(m_Config.m_SuperGaugeParrySuccessBonus);
m_ParryState = EParryState.Counter;
m_HasTouched = true; // Set it to true in order to allow unblock attack and cancelling this one by another one if needed (parry success is considered as a regular attack hit)
if (PlayerGuardCrushTriggerAttackLogic.GetTriggerPointStatus(GetPlayerIndex()) == PlayerGuardCrushTriggerAttackLogic.ETriggerPointStatus.Inactive)
{
PlayerGuardCrushTriggerAttackLogic.SetTriggerPointStatus(m_InfoComponent, PlayerGuardCrushTriggerAttackLogic.ETriggerPointStatus.Active); // Successfully parrying a hit activate the trigger
}
m_Animator.Play(K_PARRY_COUNTER_ANIM, 0, 0);
ChronicleManager.AddChronicle(m_Owner, EChronicleCategory.Attack, "ParrySuccess: Freeze time");
m_TimeScaleManager.FreezeTime(m_Animator);
}
public void ChangePlayerStance(EPlayerStance newStance, EJumpPhase newJumpPhase)
{
if (m_PlayerStance != newStance)
{
ChronicleManager.AddChronicle(gameObject, EChronicleCategory.Movement, "On player stance changed | " + string.Format("{0,-20} {1,-20}", ("Old stance : " + m_PlayerStance), "New stance : " + newStance));
m_PlayerStance = newStance;
m_Animator.ResetTrigger(K_ANIM_TURN_AROUND_TRIGGER);
}
if (m_JumpPhase != newJumpPhase)
{
ChronicleManager.AddChronicle(gameObject, EChronicleCategory.Movement, "On player jump phase changed | " + string.Format("{0,-20} {1,-20}", ("Old phase : " + m_JumpPhase), "New phase : " + newJumpPhase));
m_JumpPhase = newJumpPhase;
}
}
// Update is called once per frame
void Update()
{
if (IsPlayerTimeFrozen())
{
return;
}
UpdatePlayerSide();
int playerIndex = m_InfoComponent.GetPlayerIndex();
m_HorizontalMoveInput = 0f;
m_JumpInput = false;
m_CrouchInput = false;
bool isStatic = m_InfoComponent.GetPlayerSettings().m_IsStatic;
EPlayerStance defaultStance = m_InfoComponent.GetPlayerSettings().m_DefaultStance;
if (m_MovementBlockedReason != EBlockedReason.TimeOver)
{
m_CrouchInput = (isStatic) ? defaultStance == EPlayerStance.Crouch : InputManager.GetCrouchInput(playerIndex);
}
if (!m_IsMovementBlocked)
{
if (!isStatic)
{
m_HorizontalMoveInput = InputManager.GetHorizontalMovement(playerIndex);
}
m_JumpInput = (isStatic) ? defaultStance == EPlayerStance.Jump : InputManager.GetJumpInput(playerIndex);
if (IsStanding())
{
if (m_JumpInput && !m_JumpTakeOffRequested && !m_TriggerJumpImpulse && m_Controller.CanJump())
{
ChronicleManager.AddChronicle(gameObject, EChronicleCategory.Movement, "Jump take off requested");
m_Animator.SetTrigger(K_ANIM_TAKE_OFF_TRIGGER);
m_AttackComponent.SetAttackBlockedByTakeOff(true);
m_JumpTakeOffRequested = true;
m_JumpTakeOffDirection = m_HorizontalMoveInput;
}
}
}
m_Animator.SetBool(K_ANIM_IS_CROUCHING_BOOL, m_CrouchInput);
m_Animator.SetFloat(K_ANIM_SPEED_FLOAT, Mathf.Abs(m_HorizontalMoveInput));
}
private void OnProximityBoxEvent(BaseEventParameters baseEventParameters)
{
ProximityBoxParameters proximityBoxParameters = (ProximityBoxParameters)baseEventParameters;
if (proximityBoxParameters.m_OnEnter)
{
m_ProximityBoxes.Add(proximityBoxParameters.m_Collider);
}
else
{
m_ProximityBoxes.Remove(proximityBoxParameters.m_Collider);
}
m_IsInsideProximityBox = proximityBoxParameters.m_OnEnter || m_ProximityBoxes.Count > 0;
ChronicleManager.AddChronicle(m_Owner, EChronicleCategory.Proximity, "Is inside proximity box: " + m_IsInsideProximityBox);
UpdateProximityGuard();
}
void SetMovementBlocked(bool isMovementBlocked, EBlockedReason reason)
{
if (CanUpdateMovementBlockedStatus(isMovementBlocked, reason))
{
m_IsMovementBlocked = isMovementBlocked;
m_MovementBlockedReason = reason;
ChronicleManager.AddChronicle(gameObject, EChronicleCategory.Movement, "Movement has been " + (isMovementBlocked ? "blocked" : "unblocked") + ", reason : " + reason);
if (m_IsMovementBlocked)
{
m_Animator.ResetTrigger(K_ANIM_TAKE_OFF_TRIGGER);
m_Animator.ResetTrigger(K_ANIM_TURN_AROUND_TRIGGER);
m_JumpTakeOffRequested = false;
// If movement is blocked by timeOver, let the jump be triggered before end of round anim
// Otherwise, player will be blocked in takeOff animation for ever
if (reason != EBlockedReason.TimeOver)
{
m_JumpTakeOffDirection = 0f;
m_TriggerJumpImpulse = false;
m_AttackComponent.SetAttackBlockedByTakeOff(false);
}
if (m_Controller.IsJumping() && reason == EBlockedReason.Stun)
{
OnStopMovement();
}
if (m_NeedFlip)
{
if (reason == EBlockedReason.Stun)
{
Flip();
}
else if ((reason == EBlockedReason.PlayAttack || reason == EBlockedReason.RequestByAttack) && !m_Controller.IsJumping())
{
Flip();
}
}
}
}
else
{
ChronicleManager.AddChronicle(gameObject, EChronicleCategory.Movement, "/!\\ Movement has NOT been " + (isMovementBlocked ? "blocked" : "unblocked") + " by reason : " + reason);
}
}
void EndOfAttack(BaseEventParameters baseParams)
{
EndOfAttackEventParameters endOfAttackParams = (EndOfAttackEventParameters)baseParams;
ChronicleManager.AddChronicle(gameObject, EChronicleCategory.Movement, "On end of attack : " + endOfAttackParams.m_Attack);
if (m_IsMovementBlocked)
{
// We need to check m_AttackComponent.GetCurrentAttack().m_AnimationAttackName AND m_AttackComponent.GetCurrentAttackLogic().GetAnimationAttackName() because for ProjectileAttack,
// it can happen that a different animation is triggered due to guard crush property, so the animation attack name is changed at runtime
if (m_AttackComponent.GetCurrentAttack() == null ||
m_AttackComponent.GetCurrentAttack().m_AnimationAttackName == endOfAttackParams.m_Attack ||
m_AttackComponent.GetCurrentAttackLogic().GetAnimationAttackName() == endOfAttackParams.m_Attack.ToString())
{
SetMovementBlocked(false, EBlockedReason.EndAttack);
}
}
}
private void UpdateProximityGuard()
{
bool wasInProximityGuard = m_IsInProximityGuard;
m_IsInProximityGuard = CheckProximityGuardConditions();
if (wasInProximityGuard != m_IsInProximityGuard)
{
ChronicleManager.AddChronicle(m_Owner, EChronicleCategory.Proximity, (m_IsInProximityGuard) ? "Trigger" : "End" + " proximity guard");
if (m_IsInProximityGuard)
{
TriggerProximityGuard();
}
else
{
EndProximityGuard();
}
}
}
public override void OnHandlePushBoxCollision(Collision2D collision)
{
base.OnHandlePushBoxCollision(collision);
if (m_AttackLaunched)
{
// If enemy is in a corner
if (GameManager.Instance.GetSubManager <OutOfBoundsSubGameManager>(ESubManager.OutOfBounds).IsInACorner(collision.gameObject))
{
ChronicleManager.AddChronicle(m_Owner, EChronicleCategory.Attack, "HandlePushBoxCollision : Stop movement while dashing to avoid passing through opponent");
// to avoid passing through, stop movement
Utils.GetPlayerEventManager(m_Owner).TriggerEvent(EPlayerEvent.StopMovement);
}
}
else
{
KakutoDebug.LogError("OnHandlePushBoxCollision has been triggered whereas the attack is not launched !");
}
}
bool CanUpdateMovementBlockedStatus(bool isMovementBlocked, EBlockedReason reason)
{
//Block reasons :
// PlayAttack, RequestByAttack, Stun, TimeOver
//Unblock reasons :
// EndAttack, RequestByAttack, StunEnd
if (m_IsMovementBlocked)
{
if (m_MovementBlockedReason == EBlockedReason.TimeOver)
{
// We can't update the block status if the current block reason is TimeOver
return(false);
}
// If we need to unblock movement
if (!isMovementBlocked)
{
switch (m_MovementBlockedReason)
{
// If movement blocked reason is Play/RequestBy Attack, you can unblock the movement with EndAttack or RequestByAttack
case EBlockedReason.PlayAttack:
case EBlockedReason.RequestByAttack:
return(reason == EBlockedReason.EndAttack || reason == EBlockedReason.RequestByAttack);
// If movement blocked reason is Stun, you can unblock the movement only with a StunEnd reason
case EBlockedReason.Stun:
return(reason == EBlockedReason.StunEnd);
default:
string errorMsg = "Movement has been blocked with an invalid reason : " + m_MovementBlockedReason + " and trying to unblock with reason : " + reason;
KakutoDebug.LogError(errorMsg);
ChronicleManager.AddChronicle(gameObject, EChronicleCategory.Movement, "ERROR : " + errorMsg);
return(true);
}
}
}
return(true);
}
void OnGrabbed(BaseEventParameters baseParams)
{
if (IsDead())
{
return;
}
#if UNITY_EDITOR || DEBUG_DISPLAY
if (m_DEBUG_BreakOnGrabbed)
{
Debug.Break();
}
#endif
GrabbedEventParameters grabbedParams = (GrabbedEventParameters)baseParams;
PlayerBaseAttackLogic grabAttackLogic = grabbedParams.m_AttackLogic;
ChronicleManager.AddChronicle(gameObject, EChronicleCategory.Health, "On grabbed by : " + grabAttackLogic.GetAttack().m_Name);
m_StunInfoSC.StartStun(grabAttackLogic, EAttackResult.Hit);
PlayHitAnimation(grabAttackLogic);
m_AudioManager.PlayHitSFX(m_InfoComponent.GetPlayerIndex(), EAttackSFXType.Hit_Throw, false);
}
private bool IsGrabAttacker(PlayerBaseAttackLogic grabLogic)
{
bool isGrabAttacker = false;
GameObject grabInstigator = grabLogic.GetOwner();
Animator grabInstigatorAnim = grabLogic.GetAnimator();
float currentGrabInstigatorFrame = Utils.GetCurrentAnimFrame(grabInstigatorAnim);
float currentGrabOwnerFrame = Utils.GetCurrentAnimFrame(m_Anim);
// If grab instigator has been triggered at exact same frame than owner
if (currentGrabInstigatorFrame == currentGrabOwnerFrame)
{
isGrabAttacker = grabInstigator.CompareTag(Player.Player1);
ChronicleManager.AddChronicle(gameObject, EChronicleCategory.Health, "Is " + grabInstigator.tag + " GrabAttacker | Grab attack has been triggered at same frame on both players. Player1 defined as attacker by default");
}
else
{
isGrabAttacker = currentGrabInstigatorFrame > currentGrabOwnerFrame;
ChronicleManager.AddChronicle(gameObject, EChronicleCategory.Health, "Is " + grabInstigator.tag + " GrabAttacker | " + ((isGrabAttacker) ? grabInstigator.tag : gameObject.tag) + " is grab attacker");
}
return(isGrabAttacker);
}
public override void OnHandleCollision(bool triggerHitEvent, bool checkHitDelay, Collider2D hitCollider, Collider2D hurtCollider)
{
base.OnHandleCollision(triggerHitEvent, checkHitDelay, hitCollider, hurtCollider);
if (!checkHitDelay || m_LastHitCountTimeStamp == 0f || Time.time > m_LastHitCountTimeStamp + GetDelayBetweenHits())
{
if (m_CurrentHitCount < GetMaxHitCount())
{
m_CurrentHitCount++;
m_LastHitCountTimeStamp = Time.time;
m_LastHitCollider = hitCollider;
m_LastHurtCollider = hurtCollider;
ChronicleManager.AddChronicle(m_Owner, EChronicleCategory.Attack, "On handle collision | Hit count : " + GetCurrentHitCount() + ", Max hit count : " + GetMaxHitCount());
if (triggerHitEvent)
{
Utils.GetEnemyEventManager(m_Owner).TriggerEvent(EPlayerEvent.Hit, new HitEventParameters(this));
}
}
}
}
