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