private void OnPlayerInputChanged(InputListener inputListener)
{
PlayerControlInfo playerControlInfos = inputListener.m_Player == EPlayer.Player1 ? m_Player1ControlsMapping : m_Player2ControlsMapping;
List <EInputKey> unassignedInputs = new List <EInputKey>(PlayerGamePad.K_ASSIGNABLE_INPUTS);
for (int i = 0; i < playerControlInfos.m_InputListeners.Length; i++)
{
if (playerControlInfos.m_InputListeners[i] != inputListener && playerControlInfos.m_InputListeners[i].m_CurrentInputKey == inputListener.m_CurrentInputKey)
{
EGamePadType playerGamepadType = GamePadManager.GetPlayerGamepadType((int)inputListener.m_Player);
playerControlInfos.m_InputListeners[i].m_CurrentInputKey = inputListener.m_OldInputKey;
playerControlInfos.m_InputListeners[i].UpdateInputForGamepadType(playerGamepadType);
GamePadManager.SetPlayerGamepadInputMapping((int)inputListener.m_Player, inputListener.m_OldInputKey, playerControlInfos.m_InputListeners[i].m_DefaultInputKey);
}
unassignedInputs.Remove(playerControlInfos.m_InputListeners[i].m_CurrentInputKey);
}
#if UNITY_EDITOR || DEBUG_DISPLAY
if (unassignedInputs.Count > 1)
{
KakutoDebug.LogError("There should be only one unassigned remaining input after OnPlayerInputChanged");
}
#endif
for (int i = 0; i < unassignedInputs.Count; i++)
{
GamePadManager.SetPlayerGamepadInputMapping((int)inputListener.m_Player, unassignedInputs[i], PlayerGamePad.K_DEFAULT_UNASSIGNED_INPUT);
}
}
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);
}
}
protected override void Awake()
{
base.Awake();
#if UNITY_EDITOR
if (m_HealthComponent == null)
{
KakutoDebug.LogError("Missing HealthComponent in " + this);
}
if (m_Controller == null)
{
KakutoDebug.LogError("Missing CharacterController2D in " + this);
}
if (m_AttackComponent == null)
{
KakutoDebug.LogError("Missing AttackComponent in " + this);
}
if (m_Rigidbody == null)
{
KakutoDebug.LogError("Missing Rigidbody in " + this);
}
#endif
m_CurrentAttack = null;
RegisterListeners();
}
public static void LoadTrainingOptions()
{
m_Player1Settings = ScenesConfig.GetPlayerSettings(0, K_TRAININGMAP);
m_Player2Settings = ScenesConfig.GetPlayerSettings(1, K_TRAININGMAP);
m_DebugSettings = ScenesConfig.GetDebugSettings(K_TRAININGMAP);
#if UNITY_EDITOR
m_InitialPlayer1Settings = new PlayerSettings(Player.Player1);
CopyPlayerSettings(m_Player1Settings, m_InitialPlayer1Settings);
m_InitialPlayer2Settings = new PlayerSettings(Player.Player2);
CopyPlayerSettings(m_Player2Settings, m_InitialPlayer2Settings);
#endif
string trainingOptionsStr = PlayerPrefs.GetString(K_TRAININGOPTIONS);
if (string.IsNullOrEmpty(trainingOptionsStr))
{
K_DEFAULT_TRAINING_OPTIONS.CopyTo(m_TrainingOptions, 0);
return;
}
if (trainingOptionsStr.Length != m_TrainingOptions.Length)
{
KakutoDebug.LogError("LoadTrainingOptions failed");
return;
}
for (int i = 0; i < trainingOptionsStr.Length; i++)
{
int loadedValue = int.Parse(trainingOptionsStr[i].ToString());
UpdateTrainingOptions((ETrainingOption)i, loadedValue);
}
}
public List <GameInputList> GetInputList()
{
#if UNITY_EDITOR
if (m_ComputedGameInputList == null || m_ComputedGameInputList.Count == 0)
{
KakutoDebug.LogError("PlayerAttack " + m_Name + " has empty computed game input list.");
}
#endif
return(m_ComputedGameInputList);
}
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);
}
void HandleCollision(Collider2D collision)
{
if (isActiveAndEnabled && m_Collider.isActiveAndEnabled)
{
if (collision.CompareTag(Utils.GetEnemyTag(m_PlayerTag)) && collision.gameObject != gameObject) // Collision with an enemy player
{
#if UNITY_EDITOR || DEBUG_DISPLAY
if (!collision.gameObject.GetComponent <PlayerHurtBoxHandler>())
{
KakutoDebug.LogError("Projectile has collided with something else than HurtBox !");
}
#endif
if (m_Logic != null)
{
m_Logic.OnHandleCollision(true, true, m_Collider, collision);
PlaySFX(EProjectileSFXType.Impact);
if (m_Config.m_ApplyConstantSpeedOnPlayerHit)
{
m_KeepConstantSpeedUntilFrame = Time.frameCount + m_Config.FramesToKeepProjectileAtConstantSpeed;
}
if (m_Logic.GetCurrentHitCount() >= m_Logic.GetMaxHitCount())
{
RequestProjectileDestruction();
}
}
}
else if (collision.CompareTag(gameObject.tag) && collision.gameObject != gameObject) // Collision with another projectile
{
ProjectileComponent collisionProjectile = collision.gameObject.GetComponent <ProjectileComponent>();
if (collisionProjectile != null && collisionProjectile.GetLogic().GetOwner().CompareTag(Utils.GetEnemyTag(m_PlayerTag))) // Collision with an enemy projectile
{
m_Logic.OnHandleCollision(false, false, m_Collider, collision);
PlaySFX(EProjectileSFXType.Impact);
if (m_Config.m_ApplyConstantSpeedOnProjectileHit)
{
m_KeepConstantSpeedUntilFrame = Time.frameCount + m_Config.FramesToKeepProjectileAtConstantSpeed;
}
if (m_Logic.GetCurrentHitCount() >= m_Logic.GetMaxHitCount())
{
RequestProjectileDestruction();
}
}
}
else if (collision.CompareTag(K_GROUND_TAG)) // Collision with Ground
{
RequestProjectileDestruction();
}
}
}
static bool HasValidTag(string tag)
{
switch (tag)
{
case Player.Player1:
case Player.Player2:
return(true);
default:
KakutoDebug.LogError("AddChronicle on : " + tag + " is not allowed");
return(false);
}
}
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);
}
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
}
}
protected override void Awake()
{
base.Awake();
#if UNITY_EDITOR
if (m_AttackComponent == null)
{
KakutoDebug.LogError("Missing AttackComponent in " + this);
}
#endif
m_CurrentAttack = null;
RegisterListeners();
}
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");
}
}
// 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)
{
ProjectileComponent projectile = animator.GetComponentInChildren <ProjectileComponent>();
if (projectile != null)
{
projectile.OnEndOfDestructionAnim();
}
else
{
KakutoDebug.LogError("ProjectileComponent has not been found.");
}
}
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 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 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);
}
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);
}
}
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 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);
}
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 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 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)
{
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()));
}
}
}
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);
}
}
}
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();
}
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 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
}
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);
}