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); }