private void OnTriggerProjectile(BaseEventParameters baseParams)
{
float ownerLocalScaleX = m_Owner.transform.localScale.x;
GameObject projectile = GameObject.Instantiate(m_Config.m_ProjectilePrefab, m_ProjectileHook.position, Quaternion.AngleAxis(m_Config.m_ProjectileAngle, Vector3.forward * ownerLocalScaleX));
projectile.transform.localScale = new Vector3(ownerLocalScaleX, projectile.transform.localScale.y, projectile.transform.localScale.z);
ProjectileComponent projectileComponent = projectile.GetComponentInChildren <ProjectileComponent>();
if (projectileComponent)
{
projectileComponent.OnInit(this, m_Config);
m_MyProjectile = projectileComponent;
}
else
{
KakutoDebug.LogError("ProjectileComponent could not be found on " + projectile);
GameObject.Destroy(projectile);
}
if (m_IsGuardCrush)
{
SetNextNonSuperProjectileGuardCrush(m_InfoComponent.GetPlayerIndex(), false);
PlayerGuardCrushTriggerAttackLogic.SetTriggerPointStatus(m_InfoComponent, PlayerGuardCrushTriggerAttackLogic.ETriggerPointStatus.Inactive);
}
}
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));
}
}
}
private void OnRefillHP(BaseEventParameters baseParams)
{
StopAllCoroutines();
StartCoroutine(UpdateHealthFill(m_HealthBar, 1f, m_UIConfig.m_TimeToFillHealthBar, 0.0f));
StartCoroutine(UpdateHealthFill(m_HealthBarBackground, 1f, 0f, m_UIConfig.m_TimeToFillHealthBar));
}
public void TriggerEvent(EPlayerEvent eventType, BaseEventParameters eventParams = null)
{
if (m_EventDictionary.TryGetValue(eventType, out Action <BaseEventParameters> thisEvent))
{
thisEvent.Invoke(eventParams);
}
}
private void OnStunBegin(BaseEventParameters baseParams)
{
if (m_CurrentRefillHPCoroutine != null)
{
ChronicleManager.AddChronicle(gameObject, EChronicleCategory.Health, "Cancel Refill HP");
StopCoroutine(m_CurrentRefillHPCoroutine);
}
}
void OnEndOfAttack(BaseEventParameters baseParams)
{
EndOfAttackEventParameters endOfAttackEvent = (EndOfAttackEventParameters)baseParams;
if (m_AttackComponent.GetCurrentAttackLogic() == null || m_AttackComponent.CheckIsCurrentAttack(endOfAttackEvent.m_Attack))
{
m_CurrentAttack = null;
}
}
private void OnDamageTaken(BaseEventParameters baseParams)
{
DamageTakenEventParameters damageTakenInfo = (DamageTakenEventParameters)baseParams;
StopAllCoroutines();
StartCoroutine(UpdateHealthFill(m_HealthBar, damageTakenInfo.m_HealthRatio, m_UIConfig.m_TimeToFillHealthBar, 0.0f));
StartCoroutine(UpdateHealthFill(m_HealthBarBackground, damageTakenInfo.m_HealthRatio, m_UIConfig.m_TimeToFillHealthBar, m_UIConfig.m_TimeBetweenHealthBar));
}
private void OnDamageTaken(BaseEventParameters baseParams)
{
DamageTakenEventParameters damageTakenInfo = (DamageTakenEventParameters)baseParams;
if (damageTakenInfo.m_HitNotificationType != EHitNotificationType.None)
{
TriggerNotification_Internal(damageTakenInfo.m_HitNotificationType);
}
}
private void OnHitNotification(BaseEventParameters baseParams)
{
HitNotificationEventParameters hitNotifParams = (HitNotificationEventParameters)baseParams;
if (hitNotifParams.m_HitNotificationType != EHitNotificationType.None)
{
TriggerNotification_Internal(hitNotifParams.m_HitNotificationType);
}
}
void OnApplyGrabDamages(BaseEventParameters baseParams)
{
if (m_GrabPhase == EGrabPhase.Grabbed)
{
IncreaseSuperGauge(m_Config.m_SuperGaugeHitBonus);
//Launch hit event
Utils.GetEnemyEventManager(m_Owner).TriggerEvent(EPlayerEvent.Hit, new HitEventParameters(this));
}
}
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);
}
void OnAttackLaunched(BaseEventParameters baseParams)
{
AttackLaunchedEventParameters attackLaunchedParams = (AttackLaunchedEventParameters)baseParams;
m_CurrentAttack = null;
if(attackLaunchedParams.m_AttackLogic.NeedPushBoxCollisionCallback())
{
m_CurrentAttack = attackLaunchedParams.m_AttackLogic;
}
}
void OnGrabbed(BaseEventParameters baseParams)
{
GrabbedEventParameters grabbedParams = (GrabbedEventParameters)baseParams;
GameObject grabber = grabbedParams.m_AttackLogic.GetOwner();
GameObject grabbed = GetEnemyOf(grabber);
UpdateSortingOrder(grabber, ESortingOrder.Front);
UpdateSortingOrder(grabbed, ESortingOrder.Back);
}
void OnAttackLaunched(BaseEventParameters baseParams)
{
AttackLaunchedEventParameters attackLaunchedParams = (AttackLaunchedEventParameters)baseParams;
GameObject attacker = attackLaunchedParams.m_AttackLogic.GetOwner();
GameObject defender = GetEnemyOf(attacker);
UpdateSortingOrder(attacker, ESortingOrder.Front);
UpdateSortingOrder(defender, ESortingOrder.Back);
}
void OnDamageTaken(BaseEventParameters baseParams)
{
DamageTakenEventParameters damageTakenInfo = (DamageTakenEventParameters)baseParams;
GameObject instigator = damageTakenInfo.m_AttackLogic.GetOwner();
GameObject victim = damageTakenInfo.m_Victim;
UpdateSortingOrder(instigator, ESortingOrder.Front);
UpdateSortingOrder(victim, ESortingOrder.Back);
}
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);
}
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 OnAttackLaunched(BaseEventParameters baseParams)
{
AttackLaunchedEventParameters attackLaunchedParams = (AttackLaunchedEventParameters)baseParams;
// PlayerProjectileAttackLogic will be handled by ProjectileProximityBoxHandler
if (attackLaunchedParams.m_AttackLogic is PlayerProjectileAttackLogic)
{
return;
}
m_CurrentAttack = attackLaunchedParams.m_AttackLogic;
}
private void OnPlayerDeath(BaseEventParameters baseParams)
{
if (m_OnPlayerDeathCoroutine != null)
{
GameManager.Instance.StopCoroutine(m_OnPlayerDeathCoroutine);
m_OnPlayerDeathCoroutine = null;
}
m_OnPlayerDeathCoroutine = OnPlayerDeathCoroutine();
GameManager.Instance.StartCoroutine(m_OnPlayerDeathCoroutine);
}
void OnEnemyTakesDamages(BaseEventParameters baseParams)
{
if (m_HurtBoxesDetected.Count > 0)
{
DamageTakenEventParameters damageTakenEventParameters = (DamageTakenEventParameters)baseParams;
if (damageTakenEventParameters.m_AttackLogic == m_ProjectileComponent.GetLogic())
{
Utils.GetEnemyEventManager(m_ProjectileComponent.GetPlayerTag()).TriggerEvent(EPlayerEvent.ProximityBox, new ProximityBoxParameters(false, m_Collider));
m_EnemyTakesDamages = true;
}
}
}
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 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 OnEnemyTakesDamages(BaseEventParameters baseParams)
{
if (m_HurtBoxesDetected.Count > 0)
{
DamageTakenEventParameters damageTakenEventParameters = (DamageTakenEventParameters)baseParams;
if (damageTakenEventParameters.m_AttackLogic == m_CurrentAttack)
{
Utils.GetEnemyEventManager(gameObject).TriggerEvent(EPlayerEvent.ProximityBox, new ProximityBoxParameters(false, m_Collider));
m_CurrentAttack = null;
}
}
}
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);
}
}
protected virtual void OnEnemyTakesDamage(BaseEventParameters baseParams)
{
DamageTakenEventParameters damageTakenInfo = (DamageTakenEventParameters)baseParams;
if (this == damageTakenInfo.m_AttackLogic)
{
m_HasTouched = true;
}
else if (damageTakenInfo.m_AttackLogic.GetType() != typeof(PlayerProjectileAttackLogic))
{
KakutoDebug.LogError("DamageTaken event has been received in " + m_Attack.m_AnimationAttackName + " but damage taken doesn't come from this attack. This attack has not been stopped correctly");
}
}
private void EndOfPlayerRoundAnimation(BaseEventParameters baseParams)
{
EndOfRoundAnimationEventParameters endOfRoundAnimParams = (EndOfRoundAnimationEventParameters)baseParams;
EPlayer player = endOfRoundAnimParams.m_Player;
m_PlayerEndOfRoundAnimationFinished[(int)player] = true;
Utils.GetPlayerEventManager(GameManager.Instance.GetPlayer(player)).StopListening(EPlayerEvent.EndOfRoundAnimation, EndOfPlayerRoundAnimation);
if (m_PlayerEndOfRoundAnimationFinished[(int)EPlayer.Player1] && m_PlayerEndOfRoundAnimationFinished[(int)EPlayer.Player2])
{
m_RestartRoundCoroutine = RestartRound_Internal();
GameManager.Instance.StartCoroutine(m_RestartRoundCoroutine);
}
}
private void OnEnemyTakeDamage(BaseEventParameters baseParams)
{
DamageTakenEventParameters damageTakenInfo = (DamageTakenEventParameters)baseParams;
if (damageTakenInfo.m_AttackResult == EAttackResult.Hit)
{
if (damageTakenInfo.m_IsAlreadyHitStunned || m_ComboCounter == 0)
{
m_ComboCounter++;
m_CumulatedComboDamage += damageTakenInfo.m_DamageTaken;
OnHitCounterChanged?.Invoke();
}
}
}
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);
}
