private void InitIfNeeded(GameObject owner)
{
if (m_PlayerAnimationEventHandler == null)
{
m_PlayerAnimationEventHandler = owner.GetComponent <PlayerAnimationEventHandler>();
#if UNITY_EDITOR
if (m_PlayerAnimationEventHandler == null)
{
KakutoDebug.LogError("Can't find PlayerAnimationEventHandler on " + owner);
}
#endif
}
}
GameObject GetEnemyOf(GameObject player)
{
foreach (GameObject currentPlayer in GameManager.Instance.GetPlayers())
{
if (currentPlayer != player)
{
return(currentPlayer);
}
}
KakutoDebug.LogError("Enemy of " + player + " has not been found.");
return(null);
}
public void SetInputStringComputed()
{
m_IsInputStringComputed = true;
m_IsInputStringProcessing = false;
m_ComputedGameInputList = new List <GameInputList>();
// Parse all the computed input list
foreach (string inputs in m_ComputedInputStringList)
{
GameInputList gameInputList = new GameInputList();
string inputToCheck = string.Empty;
// Parse all single character
foreach (char c in inputs)
{
inputToCheck += c;
// For each inputToCheck, try to find the matching EInputKey
foreach (EInputKey inputKey in Enum.GetValues(typeof(EInputKey)))
{
string inputKeyToString = GameInput.ConvertInputKeyToString(inputKey);
if (inputToCheck.Equals(inputKeyToString))
{
gameInputList.Add(new GameInput(inputKey));
inputToCheck = string.Empty;
break;
}
}
}
m_ComputedGameInputList.Add(gameInputList);
}
if (m_NeededStanceList.Count == 0)
{
KakutoDebug.LogError("Needed stance list is empty for attack " + m_Name);
}
else
{
for (int i = 0; i < m_NeededStanceList.Count; i++)
{
for (int j = i + 1; j < m_NeededStanceList.Count; j++)
{
if (m_NeededStanceList[i] == m_NeededStanceList[j])
{
KakutoDebug.LogError("Needed stance list contains the stance " + m_NeededStanceList[i] + " twice for attack " + m_Name);
}
}
}
}
}
public void UnregisterPlayer(GameObject player)
{
if (!player.CompareTag(Player.Player1) && !player.CompareTag(Player.Player2))
{
KakutoDebug.LogError("GameManager::UnregisterPlayer - Trying to unregister an invalid player " + player);
return;
}
m_Players.Remove(player);
foreach (SubGameManagerBase subManager in m_SubManagers.Values)
{
subManager.OnPlayerUnregistered(player);
}
}
public override void OnInit(PlayerAttackComponent playerAttackComponent, PlayerAttack attack)
{
base.OnInit(playerAttackComponent, attack);
m_ProjectileHook = m_Owner.transform.Find("Model/" + K_PROJECTILE_HOOK);
m_CurrentProjectiles = new List <ProjectileComponent>();
#if UNITY_EDITOR
if (m_ProjectileHook == null)
{
KakutoDebug.LogError(K_PROJECTILE_HOOK + " can't be found on " + m_Owner);
}
#endif
Utils.GetPlayerEventManager(m_Owner).StartListening(EPlayerEvent.ProjectileSpawned, OnProjectileSpawned);
Utils.GetPlayerEventManager(m_Owner).StartListening(EPlayerEvent.ProjectileDestroyed, OnProjectileDestroyed);
}
static TextWriter GetWriter(string playerTag)
{
switch (playerTag)
{
case Player.Player1:
return(m_WriterP1);
case Player.Player2:
return(m_WriterP2);
default:
KakutoDebug.LogError("GetWriter on : " + playerTag + " is not allowed");
return(null);
}
}
public static PlayerEventManager GetPlayerEventManager(string tag)
{
switch (tag)
{
case Player.Player1:
return(Player1EventManager.Instance);
case Player.Player2:
return(Player2EventManager.Instance);
default:
KakutoDebug.LogError("Can't find PlayerEventManager from tag : " + tag);
return(null);
}
}
public static string GetEnemyTag(string tag)
{
switch (tag)
{
case "Player1":
return("Player2");
case "Player2":
return("Player1");
default:
KakutoDebug.LogError("Can't find enemy from tag : " + tag);
return(null);
}
}
public override string GetBlockAnimName(EPlayerStance playerStance, EStunAnimState state)
{
string blockAnimName = "Block";
blockAnimName += playerStance.ToString();
if (playerStance == EPlayerStance.Jump)
{
KakutoDebug.LogError("A player can't block an attack while jumping.");
}
blockAnimName += "_" + state.ToString();
return(blockAnimName);
}
private void HandleCollision(Collider2D collision, bool onEnter)
{
if ((m_CurrentAttack != null && m_Collider.isActiveAndEnabled) || !onEnter)
{
if (collision.CompareTag(Utils.GetEnemyTag(gameObject)) && collision.gameObject != gameObject)
{
#if UNITY_EDITOR || DEBUG_DISPLAY
if (!collision.gameObject.GetComponent <PlayerHurtBoxHandler>())
{
KakutoDebug.LogError("ProximityBox has collided with something else than HurtBox !");
}
#endif
Utils.GetEnemyEventManager(gameObject).TriggerEvent(EPlayerEvent.ProximityBox, new ProximityBoxParameters(onEnter, m_Collider));
}
}
}
private void HandleCollision(Collider2D collision)
{
if (m_Collider.isActiveAndEnabled && m_CurrentAttack != null)
{
if (collision.CompareTag(Utils.GetEnemyTag(gameObject)) && collision.gameObject != gameObject)
{
#if UNITY_EDITOR || DEBUG_DISPLAY
if (!collision.gameObject.GetComponent <PlayerHurtBoxHandler>())
{
KakutoDebug.LogError("HitBox has collided with something else than HurtBox !");
}
#endif
m_CurrentAttack.OnHandleCollision(true, true, m_Collider, collision);
}
}
}
private void HandleCollision(Collider2D collision)
{
if (m_Collider.isActiveAndEnabled)
{
if (collision.CompareTag(Utils.GetEnemyTag(gameObject)) && collision.gameObject != gameObject)
{
#if UNITY_EDITOR || DEBUG_DISPLAY
if (!collision.gameObject.GetComponent <PlayerGrabHurtBoxHandler>())
{
KakutoDebug.LogError("GrabBox has collided with something else than GrabHurtBox !");
}
#endif
Utils.GetEnemyEventManager(gameObject).TriggerEvent(EPlayerEvent.GrabTry, new GrabTryEventParameters(m_PlayerAttackComponent.GetCurrentAttackLogic()));
}
}
}
public void DecreaseGaugeValue(float value)
{
if (m_InfoComponent.GetPlayerSettings().SuperGaugeAlwaysFilled)
{
return;
}
if (value > m_CurrentGaugeValue)
{
KakutoDebug.LogError("The amount to decrease to the super gauge is superior to the current amount: Current Amount(" + m_CurrentGaugeValue + ") - Amount to Decrease(" + value + ")");
}
m_CurrentGaugeValue -= value;
ClampGaugeValue();
OnGaugeValueChanged?.Invoke();
}
public override void OnInit(PlayerAttackComponent playerAttackComponent, PlayerAttack attack)
{
base.OnInit(playerAttackComponent, attack);
m_GrabHook = m_Owner.transform.Find("Model/" + K_GRAB_HOOK);
m_FXHook = m_Owner.transform.Find("Model/" + K_FX_HOOK);
#if UNITY_EDITOR
if (m_GrabHook == null)
{
KakutoDebug.LogError(K_GRAB_HOOK + " can't be found on " + m_Owner);
}
if (m_FXHook == null)
{
KakutoDebug.LogError(K_FX_HOOK + " can't be found on " + m_Owner);
}
#endif
}
private void UpdateRootPosition()
{
if (RootMotionEnabled)
{
if (!m_OriginalRootPositionSetted)
{
m_OriginalRootPosition = transform.root.position;
m_OriginalRootPositionSetted = true;
if (Application.isPlaying)
{
m_CharacterController2D.enabled = false;
m_GravityScale = m_Rigidbody.gravityScale;
m_Rigidbody.gravityScale = 0f;
}
}
Vector3 newPosToReach = m_OriginalRootPosition + RootMotion;
transform.root.position = newPosToReach;
}
else
{
if (m_OriginalRootPositionSetted)
{
if (Application.isPlaying)
{
m_CharacterController2D.enabled = true;
if (m_GravityScale == 0f)
{
KakutoDebug.LogError("Stored gravity scale of " + transform.root.gameObject.name + " is zero !!");
m_GravityScale = 2.25f;
}
m_Rigidbody.gravityScale = m_GravityScale;
}
else
{
transform.root.position = m_OriginalRootPosition;
}
m_OriginalRootPosition = Vector3.zero;
m_OriginalRootPositionSetted = false;
}
}
}
private void OnProjectileDestroyed(BaseEventParameters baseParams)
{
ProjectileDestroyedEventParameters projectileDestroyedParams = (ProjectileDestroyedEventParameters)baseParams;
ProjectileComponent destroyedProjectile = projectileDestroyedParams.m_Projectile;
if (m_MyProjectile == destroyedProjectile)
{
Utils.GetEnemyEventManager(m_Owner).StopListening(EPlayerEvent.DamageTaken, OnEnemyTakesDamage);
m_MyProjectile = null;
}
if (!m_CurrentProjectiles.Contains(destroyedProjectile))
{
KakutoDebug.LogError("Trying to destroy a projectile which is not in the list");
}
m_CurrentProjectiles.Remove(destroyedProjectile);
}
static int SortByInput(PlayerAttack attack1, PlayerAttack attack2)
{
if (attack1.GetInputStringList().Count > 0 && attack2.GetInputStringList().Count > 0)
{
int compareOrder = attack2.GetInputStringList()[0].Length.CompareTo(attack1.GetInputStringList()[0].Length);
if (compareOrder == 0)
{
compareOrder = attack2.m_Name.CompareTo(attack1.m_Name);
if (compareOrder == 0)
{
KakutoDebug.LogError("2 attacks have the same name, this is not allowed. Attack sorting failed.");
}
}
return(compareOrder);
}
KakutoDebug.LogError("Attack list contains attack without input");
return(0);
}
private void Awake()
{
m_Animator = GetComponent <Animator>();
m_TimeScaleManager = GameManager.Instance.GetSubManager <TimeScaleSubGameManager>(ESubManager.TimeScale);
m_FXManager = GameManager.Instance.GetSubManager <FXSubGameManager>(ESubManager.FX);
m_AudioManager = GameManager.Instance.GetSubManager <AudioSubGameManager>(ESubManager.Audio);
m_UIBackground = GameObject.FindGameObjectWithTag("UIBackground")?.GetComponent <SpriteRenderer>();
m_UIMaskedBackground = GameObject.FindGameObjectWithTag("UIMaskedBackground")?.GetComponent <SpriteRenderer>();
m_UIBackgroundMask = GameObject.FindGameObjectWithTag("UIBackgroundMask")?.GetComponent <SpriteMask>();
m_UIBackgroundMaskDetail = GameObject.FindGameObjectWithTag("UIBackgroundMaskDetail")?.GetComponent <SpriteRenderer>();
#if UNITY_EDITOR
if (m_UIBackground == null || m_UIMaskedBackground == null || m_UIBackgroundMask == null)
{
KakutoDebug.LogError("UIBackground elements can't be found");
}
#endif
}
// OnStateEnter is called when a transition starts and the state machine starts to evaluate this state
//override public void OnStateEnter(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
//{
//
//}
// OnStateUpdate is called on each Update frame between OnStateEnter and OnStateExit callbacks
//override public void OnStateUpdate(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
//{
//
//}
// OnStateExit is called when a transition ends and the state machine finishes evaluating this state
override public void OnStateExit(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
{
base.OnStateExit(animator, stateInfo, layerIndex);
AnimatorClipInfo[] clipInfoList = animator.GetNextAnimatorClipInfo(0);
if (clipInfoList.Length != 1)
{
KakutoDebug.LogError("clipInfoList should have one element");
return;
}
//If the next clip to play is not a throw animation, then this is the end of the grab
string lowerClipName = clipInfoList[0].clip.name.ToLower();
if (!lowerClipName.Contains(PlayerAnimationHelper.K_GRAB_MISS_ANIM_STANDARD_NAME) && !lowerClipName.Contains(PlayerAnimationHelper.K_GRAB_CANCEL_ANIM_STANDARD_NAME))
{
Utils.GetPlayerEventManager(animator.gameObject).TriggerEvent(EPlayerEvent.EndOfAttack, new EndOfAttackEventParameters(EAnimationAttackName.Grab));
}
}
// OnStateEnter is called when a transition starts and the state machine starts to evaluate this state
//override public void OnStateEnter(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
//{
//
//}
// OnStateUpdate is called on each Update frame between OnStateEnter and OnStateExit callbacks
//override public void OnStateUpdate(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
//{
//
//}
// OnStateExit is called when a transition ends and the state machine finishes evaluating this state
override public void OnStateExit(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
{
base.OnStateExit(animator, stateInfo, layerIndex);
AnimatorClipInfo[] clipInfoList = animator.GetNextAnimatorClipInfo(0);
if (clipInfoList.Length != 1)
{
KakutoDebug.LogError("clipInfoList should have one element");
return;
}
//If the next clip to play is not a parry animation, then this is the end of the parry
//Update: added parry anim because parry success can be now cancelled by parry
string lowerClipName = clipInfoList[0].clip.name.ToLower();
if (!lowerClipName.Contains(PlayerAnimationHelper.K_PARRY_SUCCESS_ANIM_STANDARD_NAME) && !lowerClipName.Contains(PlayerAnimationHelper.K_PARRY_ANIM_STANDARD_NAME))
{
Utils.GetPlayerEventManager(animator.gameObject).TriggerEvent(EPlayerEvent.EndOfAttack, new EndOfAttackEventParameters(EAnimationAttackName.Parry));
}
}
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);
}
public List <PlayerBaseAttackLogic> CreateLogics(PlayerAttackComponent playerAttackComponent)
{
List <PlayerBaseAttackLogic> attackLogics = new List <PlayerBaseAttackLogic>();
for (int i = 0; i < m_AttackList.Count; i++)
{
PlayerAttack attack = m_AttackList[i];
if (attack.m_AttackConfig)
{
PlayerBaseAttackLogic attackLogic = attack.m_AttackConfig.CreateLogic();
attackLogic.OnInit(playerAttackComponent, attack);
attackLogics.Add(attackLogic);
}
else
{
KakutoDebug.LogError("No attack config found for " + attack.m_Name);
}
}
return(attackLogics);
}
private void PlayHitSFX(PlayerBaseAttackLogic attackLogic, EAttackResult attackResult, EHitNotificationType hitNotificationType)
{
EAttackSFXType attackSFXType = EAttackSFXType.Hit_Light;
bool validHitSFXFound = IsDead() || attackLogic.GetHitSFX(attackResult, hitNotificationType, ref attackSFXType);
if (IsDead())
{
attackSFXType = EAttackSFXType.Final_Hit;
}
if (validHitSFXFound)
{
// Play attack SFX on the instigator of the hit in order to cancel whiff sfx
m_AudioManager.PlayHitSFX(m_InfoComponent.GetPlayerIndex(), attackSFXType, attackLogic is PlayerProjectileAttackLogic);
}
else
{
KakutoDebug.LogError("No SFX found for attack " + attackLogic.GetAnimationAttackName() + " taken in " + attackResult);
ChronicleManager.AddChronicle(gameObject, EChronicleCategory.Health, "No SFX found for attack " + attackLogic.GetAnimationAttackName() + " taken in " + attackResult);
}
}
void ComputeOffset()
{
//Need to detect ground
GameObject ground = GameObject.FindGameObjectWithTag("Ground");
if (ground != null)
{
float groundYPos = ground.transform.position.y;
BoxCollider2D groundCollider = ground.GetComponent <BoxCollider2D>();
if (groundCollider != null)
{
groundYPos += groundCollider.offset.y;
groundYPos += groundCollider.size.y / 2f;
}
m_Offset = Vector3.up * -groundYPos;
}
else
{
KakutoDebug.LogError("Ground doesn't found.");
}
}
public void RegisterPlayer(GameObject player)
{
if (!player.CompareTag(Player.Player1) && !player.CompareTag(Player.Player2))
{
KakutoDebug.LogError("GameManager::RegisterPlayer - Trying to register an invalid player " + player);
return;
}
m_Players.Add(player);
foreach (SubGameManagerBase subManager in m_SubManagers.Values)
{
subManager.OnPlayerRegistered(player);
}
GetOnPlayerRegisteredCallback(player.tag)?.Invoke(player);
if (ArePlayersRegistered())
{
foreach (SubGameManagerBase subManager in m_SubManagers.Values)
{
subManager.OnPlayersRegistered();
}
}
}
public static void LogPlayer2InputMapping()
{
KakutoDebug.Log(m_PlayerGamePads[1].GetInputMappingStr());
}
private void ComputeInputStringList_Internal(PlayerAttack attack)
{
attack.SetInputStringProcessing();
var attackNameToInputs = new Dictionary <string, List <string> >();
List <string> inputsAssociatedToAttack = new List <string>();
// Find inputs associated to attack ///////////////////////////////////////////////////////
foreach (string rawInputString in attack.GetRawInputStringList())
{
string rawInputStringWithoutEmptySpace = rawInputString.Replace(" ", string.Empty);
string[] inputList = rawInputStringWithoutEmptySpace.Split('+');
attack.m_ComputedInputStringList.Add(string.Concat <string>(inputList));
foreach (string input in inputList)
{
// If input is more than 1 character, it's not a normal input
if (input.Length > 1)
{
string attackName = input;
if (attackNameToInputs.ContainsKey(attackName) == false)
{
foreach (PlayerAttack attack2 in m_AttackList)
{
if (attackName == attack2.m_Name)
{
// Catch error cases ///////////////
if (attack == attack2)
{
KakutoDebug.LogError("An input of attack " + attack.m_Name + " is refering itself.");
attack.SetInputStringComputed();
return;
}
if (attack2.IsInputStringProcessing())
{
KakutoDebug.LogError("Attacks " + attack.m_Name + " and " + attack2.m_Name + " inputs are refering each other");
attack.SetInputStringComputed();
return;
}
///////////////////////////////////
if (attack2.IsInputStringComputed() == false)
{
ComputeInputStringList_Internal(attack2);
}
inputsAssociatedToAttack = new List <string>(attack2.GetInputStringList());
break;
}
}
if (inputsAssociatedToAttack.Count > 0)
{
attackNameToInputs.Add(attackName, new List <string>(inputsAssociatedToAttack));
inputsAssociatedToAttack.Clear();
}
}
}
}
}
///////////////////////////////////////////////////////////////////////////////////////////
// Create X ComputedInputStringList according to the x variations of inputs for each attack
int nbComputedInputInputStringNeeded = 1;
foreach (var pair in attackNameToInputs)
{
nbComputedInputInputStringNeeded *= pair.Value.Count;
}
if (nbComputedInputInputStringNeeded > 1)
{
List <string> originalComputedStringList = new List <string>(attack.m_ComputedInputStringList);
attack.m_ComputedInputStringList.Clear();
foreach (string originalComputedString in originalComputedStringList)
{
for (int i = 0; i < nbComputedInputInputStringNeeded; i++)
{
attack.m_ComputedInputStringList.Add(originalComputedString);
}
}
}
////////////////////////////////////////////////////////////////////////////////////////////
// Replace recursively attackName by the right inputs //////////////////////////////////////
if (attackNameToInputs.Count > 0 && attack.m_ComputedInputStringList.Count > 0)
{
List <KeyValuePair <string, string> > listKeyValue = new List <KeyValuePair <string, string> >();
int computedInputStringIndex = 0;
for (int attackNameToInputsIndex = 0; attackNameToInputsIndex < attackNameToInputs.Count; attackNameToInputsIndex++)
{
if (computedInputStringIndex >= attack.m_ComputedInputStringList.Count)
{
break;
}
ReplaceAttackNameByInputs(attack, attackNameToInputs, ref attackNameToInputsIndex, ref computedInputStringIndex, listKeyValue);
}
}
////////////////////////////////////////////////////////////////////////////////////////////
attack.SetInputStringComputed();
}
private void SortAttackList()
{
m_AttackList.Sort(SortByInput);
KakutoDebug.Log("Attack list sorted !");
}
public static void ClearSavedInputMapping()
{
PlayerPrefs.SetString("Player1InputMapping", "");
PlayerPrefs.SetString("Player2InputMapping", "");
KakutoDebug.Log("Input mapping cleared!");
}
