add ckg

plantilla base para movimiento básico

Assets/Game Kit Controller/Scripts/Health/damageHitReactionSystem.cs

@@ -0,0 +1,786 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Events;
+
+public class damageHitReactionSystem : MonoBehaviour
+{
+    [Header ("Main Settings")]
+    [Space]
+
+    public bool hitReactionsEnabled = true;
+
+    public string defaultCategoryReaction = "Melee";
+
+    [Space]
+    [Header ("Reaction Probability Settings")]
+    [Space]
+
+    [Range (0, 1)] public float probabilityToActivateReactionMultiplier = 1;
+
+    public bool canChangeProbabilityMultiplierExternally = true;
+
+    [Space]
+
+    public bool ignoreMinWaitTimeToPlayHitReactionAgain;
+
+    public bool ignoreMinAmountToReceiveDamage;
+
+    [Space]
+    [Header ("Hit Reaction Settings")]
+    [Space]
+
+    public List<hitReactionInfo> hitReactionInfoList = new List<hitReactionInfo> ();
+
+    [Space]
+
+    public List<damageStateInfo> damageStateInfoList = new List<damageStateInfo> ();
+
+    [Space]
+    [Header ("Debug")]
+    [Space]
+
+    public bool showDebugPrint;
+    public bool hitReactionActive;
+
+    public int currentBlockID;
+
+    public string currentReactionCategory;
+
+    public bool damageReactionPaused;
+
+    public bool ignoreParryActive;
+
+    [Space]
+    [Header ("Events Settings")]
+    [Space]
+
+    public bool useMainEventOnHitReactionFound;
+    public UnityEvent mainEventOnHitReactionFound;
+
+    [Space]
+    [Header ("Components")]
+    [Space]
+
+    public Transform playerControllerTransform;
+    public playerActionSystem mainPlayerActionSystem;
+
+    hitReactionInfo currentHitReactionInfo;
+
+    Coroutine perfectBlockCoroutine;
+
+    float lastTimeBlockActive;
+
+    int currentBlockIDToCheck;
+
+    hitDamageDirection currenthitDamageDirection;
+
+    public void checkDamageReceived (float damageReceived, Vector3 damagePosition, GameObject objectBlocked)
+    {
+        if (!hitReactionsEnabled || !hitReactionActive) {
+            return;
+        }
+
+        if (damageReactionPaused) {
+            return;
+        }
+
+        checkHitReaction (damageReceived, 0, damagePosition, false, false, false, objectBlocked, -1);
+    }
+
+    public void checkDamageReceivedTemporally (float damageReceived, Vector3 damagePosition, GameObject objectBlocked)
+    {
+        if (!hitReactionsEnabled) {
+            return;
+        }
+
+        if (damageReactionPaused) {
+            return;
+        }
+
+        checkHitReaction (damageReceived, 0, damagePosition, false, false, false, objectBlocked, -1);
+    }
+
+    public void checkDamageBlocked (float damageReceived, float originalDamageAmountReceived, Vector3 damagePosition, bool damageBlocked, GameObject objectBlocked)
+    {
+        if (!hitReactionsEnabled || !hitReactionActive) {
+            return;
+        }
+
+        if (damageReactionPaused) {
+            return;
+        }
+
+        checkHitReaction (damageReceived, originalDamageAmountReceived, damagePosition, damageBlocked, true, false, objectBlocked, -1);
+    }
+
+    public void checkDamageReceivedUnblockable (float damageReceived, Vector3 damagePosition, GameObject objectBlocked)
+    {
+        if (!hitReactionsEnabled || !hitReactionActive) {
+            return;
+        }
+
+        if (damageReactionPaused) {
+            return;
+        }
+
+        checkHitReaction (damageReceived, 0, damagePosition, false, false, true, objectBlocked, -1);
+    }
+
+    public void checkReactionToTriggerExternally (float damageReceived, Vector3 damagePosition, GameObject objectBlocked)
+    {
+        if (!hitReactionsEnabled || !hitReactionActive) {
+            return;
+        }
+
+        if (damageReactionPaused) {
+            return;
+        }
+
+        checkHitReaction (damageReceived, 0, damagePosition, false, false, false, objectBlocked, -1);
+    }
+
+    public void activateDamageReactionByID (float damageReceived, Vector3 damagePosition, GameObject objectBlocked, int damageReactionID)
+    {
+        if (!hitReactionsEnabled) {
+            return;
+        }
+
+        if (damageReactionPaused) {
+            return;
+        }
+
+        checkHitReaction (damageReceived, 0, damagePosition, false, false, false, objectBlocked, damageReactionID);
+    }
+
+    void checkHitReaction (float damageReceived, float originalDamageAmountReceived, Vector3 damagePosition, bool damageBlocked,
+                           bool blockDamageActive, bool unblockableDamage, GameObject objectBlocked, int damageReactionID)
+    {
+        if (damageReactionID == -1) {
+            Vector3 damageDirection = damagePosition - playerControllerTransform.position;
+
+            damageDirection = damageDirection / damageDirection.magnitude;
+
+            float damageAngle = Vector3.SignedAngle (playerControllerTransform.forward, damageDirection, playerControllerTransform.up);
+
+            float damageAngleAbs = Mathf.Abs (damageAngle);
+
+            currenthitDamageDirection = hitDamageDirection.front;
+
+            bool isPlayerMovingOn3dWorld = mainPlayerActionSystem.isPlayerMovingOn3dWorld ();
+
+            if (isPlayerMovingOn3dWorld) {
+                if (damageAngleAbs > 45 && damageAngleAbs < 135) {
+                    if (damageAngle < 0) {
+                        currenthitDamageDirection = hitDamageDirection.left;
+                    } else {
+                        currenthitDamageDirection = hitDamageDirection.right;
+                    }
+                } else if (damageAngleAbs > 135) {
+                    currenthitDamageDirection = hitDamageDirection.backward;
+                }
+            } else {
+                if (!isFacingToAttacker (objectBlocked.transform.position)) {
+                    currenthitDamageDirection = hitDamageDirection.backward;
+                }
+            }
+
+            if (showDebugPrint) {
+                print (currenthitDamageDirection);
+            }
+        }
+
+        int hitReactionIndex = -1;
+        float maxDamageFound = -1;
+
+        bool damageStateFound = false;
+
+        if (damageReceived > 0) {
+            for (int i = 0; i < damageStateInfoList.Count; i++) {
+                damageStateInfo currentDamageStateInfo = damageStateInfoList [i];
+
+                if (!damageStateFound && currentDamageStateInfo.damageStateEnabled) {
+                    if (currentDamageStateInfo.damageStateRange.x <= damageReceived &&
+                        currentDamageStateInfo.damageStateRange.y >= damageReceived) {
+
+                        if (showDebugPrint) {
+                            print (currentDamageStateInfo.Name);
+                        }
+
+                        currentDamageStateInfo.eventOnDamageState.Invoke ();
+
+                        damageStateFound = true;
+                    }
+                }
+            }
+        }
+
+        if (!damageStateFound) {
+            for (int i = 0; i < damageStateInfoList.Count; i++) {
+                damageStateInfo currentDamageStateInfo = damageStateInfoList [i];
+
+                if (!damageStateFound && currentDamageStateInfo.damageStateEnabled) {
+                    if (currentDamageStateInfo.useAsDefaultState) {
+                        currentDamageStateInfo.eventOnDamageState.Invoke ();
+
+                        if (showDebugPrint) {
+                            print (currentDamageStateInfo.Name);
+                        }
+
+                        damageStateFound = true;
+                    }
+                }
+            }
+        }
+
+        bool canCheckReaction = false;
+
+        if (currentReactionCategory == "") {
+            currentReactionCategory = defaultCategoryReaction;
+        }
+
+        bool searchingReactionByID = damageReactionID > -1;
+
+        bool canCheckRegularReaction = false;
+
+
+        for (int i = 0; i < hitReactionInfoList.Count; i++) {
+
+            currentHitReactionInfo = hitReactionInfoList [i];
+
+            if (currentHitReactionInfo.reactionEnabled) {
+
+                if (searchingReactionByID) {
+                    if (hitReactionIndex == -1) {
+                        if (damageReactionID == currentHitReactionInfo.damageReactionID) {
+                            canCheckRegularReaction = true;
+
+                            if (showDebugPrint) {
+                                print ("Damage reaction activated by ID, checking reaction" + currentHitReactionInfo.Name);
+                            }
+                        }
+                    }
+                } else {
+                    canCheckRegularReaction = false;
+
+                    if (currentHitReactionInfo.reactionCategory == currentReactionCategory) {
+
+                        if (currentHitReactionInfo.reactionOnBlock == blockDamageActive) {
+
+                            if (!blockDamageActive || currentHitReactionInfo.blockID == currentBlockID) {
+                                canCheckRegularReaction = true;
+                            }
+                        }
+                    }
+                }
+
+                if (canCheckRegularReaction) {
+                    canCheckReaction = false;
+
+                    if (damageReceived >= currentHitReactionInfo.minAmountToReceiveDamage) {
+                        canCheckReaction = true;
+                    }
+
+                    if (ignoreMinAmountToReceiveDamage) {
+                          canCheckReaction = true;
+                    }
+
+                    if (blockDamageActive && (damageBlocked || damageReceived == 0)) {
+                        canCheckReaction = true;
+                    }
+
+                    if (showDebugPrint) {
+                        print (currentHitReactionInfo.Name + " " + damageReceived + " " + blockDamageActive + " " + damageBlocked + " " + canCheckReaction);
+                    }
+
+                    if (canCheckReaction) {
+                        if (currentHitReactionInfo.minAmountToReceiveDamage > maxDamageFound) {
+                            if (damageReactionID > -1 ||
+                                (currentHitReactionInfo.damageDirection == hitDamageDirection.anyDirection ||
+                                currentHitReactionInfo.damageDirection == currenthitDamageDirection)) {
+
+                                maxDamageFound = currentHitReactionInfo.minAmountToReceiveDamage;
+
+                                hitReactionIndex = i;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        if (hitReactionIndex > -1) {
+            activateHitReactionByIndex (hitReactionIndex, damageReceived, originalDamageAmountReceived, unblockableDamage, objectBlocked);
+        }
+    }
+
+    bool isFacingToAttacker (Vector3 attackerPosition)
+    {
+        Vector3 directionDamage = (attackerPosition - playerControllerTransform.position).normalized;
+
+        Vector3 playerForward = playerControllerTransform.forward;
+
+        bool isFacingDamage = Vector2.Dot (directionDamage, playerForward) > 0;
+
+        if (isFacingDamage) {
+            return true;
+        }
+
+        return false;
+    }
+
+    float lastTimeHitReaction;
+
+    float currentReactionDelayUntilNextReaction = 0;
+
+    void activateHitReactionByIndex (int hitReactionIndex, float damageReceived, float originalDamageAmountReceived, bool unblockableDamage, GameObject objectBlocked)
+    {
+        if (hitReactionIndex > -1) {
+            currentHitReactionInfo = hitReactionInfoList [hitReactionIndex];
+
+            if (currentHitReactionInfo.useProbabilityToActivateReaction) {
+                float probabilityToActivateReaction = Random.Range (0, 100);
+
+                float currentProbability = currentHitReactionInfo.probabilityToActivateReaction * probabilityToActivateReactionMultiplier;
+
+                if (currentProbability < probabilityToActivateReaction) {
+                    return;
+                }
+            }
+
+            if (!currentHitReactionInfo.ignoreReactionDelayFromPreviousReaction) {
+                if (currentReactionDelayUntilNextReaction > 0 && Time.time < currentReactionDelayUntilNextReaction + lastTimeHitReaction) {
+                    if (showDebugPrint) {
+                        print ("\n reaction delay from previous reaction is active, disabling reaction activation \n");
+                    }
+
+                    return;
+                }
+
+                currentReactionDelayUntilNextReaction = 0;
+
+                if (currentHitReactionInfo.setReactionDelayUntilNextReaction) {
+                    currentReactionDelayUntilNextReaction = currentHitReactionInfo.reactionDelayUntilNextReaction;
+                }
+            }
+
+            lastTimeHitReaction = Time.time;
+
+            bool checkMinWaitTimeResult = false;
+
+            if (Time.time > currentHitReactionInfo.minWaitTimeToPlayHitReactionAgain +
+                currentHitReactionInfo.lastTimeHitReaction) {
+                checkMinWaitTimeResult = true;
+            }
+
+            if (ignoreMinWaitTimeToPlayHitReactionAgain) {
+                checkMinWaitTimeResult = true;
+            }
+
+            if (checkMinWaitTimeResult) {
+                currentHitReactionInfo.lastTimeHitReaction = Time.time;
+
+                bool canActivateHitReaction = true;
+
+                bool perfectBlockActivated = false;
+
+                if (!currentHitReactionInfo.activateHitReactionOnPerfectBlock && !unblockableDamage) {
+                    if (currentHitReactionInfo.reactionOnBlock && currentHitReactionInfo.canUsePerfectBlock) {
+                        if (lastTimeBlockActive != 0) {
+                            if (Time.time < lastTimeBlockActive + currentHitReactionInfo.maxTimeToPerfectBlock) {
+                                canActivateHitReaction = false;
+
+                                perfectBlockActivated = true;
+                            }
+                        }
+                    }
+                }
+
+                if (showDebugPrint) {
+                    print ("\n\n");
+                    print (currentHitReactionInfo.Name + " " + damageReceived + " " + playerControllerTransform.name + " " + perfectBlockActivated + " " + canActivateHitReaction);
+                }
+
+                if (canActivateHitReaction) {
+                    if (useMainEventOnHitReactionFound) {
+                        mainEventOnHitReactionFound.Invoke ();
+                    }
+
+                    if (currentHitReactionInfo.stopPreviousActionIfActive) {
+                        mainPlayerActionSystem.stopAllActions ();
+                    }
+
+                    if (currentHitReactionInfo.playHitAction) {
+                        mainPlayerActionSystem.activateCustomAction (currentHitReactionInfo.hitActionName);
+                    }
+                } else {
+                    if (perfectBlockActivated) {
+                        if (currentHitReactionInfo.stopPreviousActionIfActive) {
+                            mainPlayerActionSystem.stopAllActions ();
+                        }
+
+                        if (currentHitReactionInfo.playHitAction) {
+                            mainPlayerActionSystem.activateCustomAction (currentHitReactionInfo.hitActionNameOnPerfectBlock);
+                        }
+                    }
+                }
+
+                if (currentHitReactionInfo.useStaminaOnBlock) {
+                    float currentDamageReceived = damageReceived;
+
+                    if (currentDamageReceived == 0) {
+                        currentDamageReceived = originalDamageAmountReceived;
+                    }
+
+                    float staminaAmountToUse = currentHitReactionInfo.staminaToUseMultiplier * currentDamageReceived;
+
+                    currentHitReactionInfo.eventToUseStamina.Invoke (staminaAmountToUse);
+                }
+
+                if (canActivateHitReaction) {
+                    currentHitReactionInfo.eventOnHit.Invoke ();
+                } else {
+                    if (perfectBlockActivated) {
+                        currentHitReactionInfo.eventOnHitReactionOnPerfectBlock.Invoke ();
+
+                        if (currentHitReactionInfo.useRemoteEvent) {
+                            bool useRemoteEvents = false;
+
+                            if (objectBlocked != null) {
+                                if (currentHitReactionInfo.checkObjectsToUseRemoteEventsOnDamage) {
+                                    if ((1 << objectBlocked.layer & currentHitReactionInfo.layerToUseRemoteEventsOnDamage.value) == 1 << objectBlocked.layer) {
+                                        useRemoteEvents = true;
+                                    }
+                                } else {
+                                    useRemoteEvents = true;
+                                }
+
+                                if (useRemoteEvents) {
+                                    remoteEventSystem currentRemoteEventSystem = objectBlocked.GetComponent<remoteEventSystem> ();
+
+                                    if (currentRemoteEventSystem != null) {
+                                        int remoteEventNameListCount = currentHitReactionInfo.remoteEventNameList.Count;
+
+                                        for (int j = 0; j < remoteEventNameListCount; j++) {
+                                            currentRemoteEventSystem.callRemoteEvent (currentHitReactionInfo.remoteEventNameList [j]);
+                                        }
+
+                                        if (!ignoreParryActive) {
+                                            if (currentHitReactionInfo.useRemoteEventToEnableParryInteraction) {
+                                                for (int j = 0; j < currentHitReactionInfo.remoteEventToEnableParryInteractionNameList.Count; j++) {
+                                                    currentRemoteEventSystem.callRemoteEvent (currentHitReactionInfo.remoteEventToEnableParryInteractionNameList [j]);
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    public void checkDamageStateTemporally (float damageReceived, bool damageBlockedByShieldSystem)
+    {
+        //		print (damageReceived);
+
+        bool damageStateFound = false;
+
+        if (damageReceived > 0) {
+
+            if (damageBlockedByShieldSystem) {
+                damageReceived /= 2;
+            }
+
+            for (int i = 0; i < damageStateInfoList.Count; i++) {
+                damageStateInfo currentDamageStateInfo = damageStateInfoList [i];
+
+                if (!damageStateFound && currentDamageStateInfo.damageStateEnabled) {
+                    if (currentDamageStateInfo.damageStateRange.x <= damageReceived &&
+                        currentDamageStateInfo.damageStateRange.y >= damageReceived) {
+                        //						print (currentDamageStateInfoName);
+
+                        currentDamageStateInfo.eventOnDamageState.Invoke ();
+
+                        damageStateFound = true;
+                    }
+                }
+            }
+        }
+
+        if (!damageStateFound) {
+            for (int i = 0; i < damageStateInfoList.Count; i++) {
+                damageStateInfo currentDamageStateInfo = damageStateInfoList [i];
+
+                if (!damageStateFound && currentDamageStateInfo.damageStateEnabled) {
+                    if (currentDamageStateInfo.useAsDefaultState) {
+                        currentDamageStateInfo.eventOnDamageState.Invoke ();
+
+                        //						print (currentDamageStateInfo.Name);
+
+                        damageStateFound = true;
+                    }
+                }
+            }
+        }
+    }
+
+    public void setHitReactionActiveState (bool state)
+    {
+        hitReactionActive = state;
+    }
+
+    public bool getHitReactionActiveState ()
+    {
+        return hitReactionActive;
+    }
+
+    public void setHitReactionBlockIDValue (int newBlockID)
+    {
+        currentBlockID = newBlockID;
+
+        if (currentBlockID != -1) {
+
+            currentBlockIDToCheck = -1;
+
+            for (int i = 0; i < hitReactionInfoList.Count; i++) {
+                hitReactionInfo temporalReationInfo = hitReactionInfoList [i];
+
+                if (currentBlockIDToCheck == -1 &&
+                    temporalReationInfo.reactionOnBlock &&
+                    temporalReationInfo.reactionCategory.Equals (currentReactionCategory) &&
+                    temporalReationInfo.canUsePerfectBlock &&
+                    temporalReationInfo.blockID == currentBlockID) {
+
+                    float probabilityForPerfectBlock = Random.Range (0, 100);
+
+                    if (temporalReationInfo.probabilityForPerfectBlock >= probabilityForPerfectBlock) {
+                        currentBlockIDToCheck = i;
+                    }
+                }
+            }
+
+            if (currentBlockIDToCheck > -1) {
+
+                lastTimeBlockActive = Time.time;
+
+                setPerfectBlockDuration ();
+            } else {
+                lastTimeBlockActive = 0;
+            }
+        } else {
+            lastTimeBlockActive = 0;
+
+            stopSetPerfectBlockDurationCoroutine ();
+
+            if (currentBlockIDToCheck > -1) {
+                hitReactionInfoList [currentBlockIDToCheck].eventOnDisablePerfectBlock.Invoke ();
+
+                currentBlockIDToCheck = -1;
+            }
+        }
+    }
+
+    public void setPerfectBlockDuration ()
+    {
+        stopSetPerfectBlockDurationCoroutine ();
+
+        perfectBlockCoroutine = StartCoroutine (setPerfectBlockDurationCoroutine ());
+    }
+
+    void stopSetPerfectBlockDurationCoroutine ()
+    {
+        if (perfectBlockCoroutine != null) {
+            StopCoroutine (perfectBlockCoroutine);
+        }
+    }
+
+    IEnumerator setPerfectBlockDurationCoroutine ()
+    {
+        hitReactionInfo temporalReationInfo = hitReactionInfoList [currentBlockIDToCheck];
+
+        temporalReationInfo.eventOnEnablePerfectBlock.Invoke ();
+
+        float maxTimeToPerfectBlock = temporalReationInfo.maxTimeToPerfectBlock;
+
+        var currentWaitTime = new WaitForSeconds (maxTimeToPerfectBlock);
+
+        yield return currentWaitTime;
+
+        temporalReationInfo.eventOnDisablePerfectBlock.Invoke ();
+    }
+
+    public void setCurrentReactionCategory (string newCategory)
+    {
+        currentReactionCategory = newCategory;
+    }
+
+    public void setNewProbabilityToActivateReactionMultiplierValue (float newValue)
+    {
+        if (!canChangeProbabilityMultiplierExternally) {
+            return;
+        }
+
+        probabilityToActivateReactionMultiplier = newValue;
+    }
+
+    public void setHitReactionsEnabledState (bool state)
+    {
+        hitReactionsEnabled = state;
+    }
+
+    public void setDamageReactionPausedState (bool state)
+    {
+        damageReactionPaused = state;
+    }
+
+    public bool isDamageReactionPaused ()
+    {
+        return damageReactionPaused;
+    }
+
+    public void setIgnoreParryActiveState (bool state)
+    {
+        ignoreParryActive = state;
+    }
+
+    public void setHitReactionsEnabledStateFromEditor (bool state)
+    {
+        setHitReactionsEnabledState (state);
+
+        updateComponent ();
+    }
+
+    void updateComponent ()
+    {
+        GKC_Utils.updateComponent (this);
+
+        GKC_Utils.updateDirtyScene ("Updating Damage Reaction System " + gameObject.name, gameObject);
+    }
+
+    [System.Serializable]
+    public class hitReactionInfo
+    {
+        [Header ("Main Settings")]
+        [Space]
+
+        public string Name;
+        public bool reactionEnabled = true;
+
+        public int damageReactionID = -1;
+
+        public string reactionCategory;
+
+        public float minAmountToReceiveDamage;
+
+        public hitDamageDirection damageDirection;
+
+        public bool useProbabilityToActivateReaction = true;
+
+        public float probabilityToActivateReaction = 100;
+
+        public float minWaitTimeToPlayHitReactionAgain;
+
+        [Space]
+        [Header ("Pause Reaction Activation Settings")]
+        [Space]
+
+        public bool setReactionDelayUntilNextReaction;
+        public float reactionDelayUntilNextReaction;
+
+        public bool ignoreReactionDelayFromPreviousReaction;
+
+        [Space]
+        [Header ("Action Settings")]
+        [Space]
+
+        public bool playHitAction;
+        public string hitActionName;
+
+        public string hitActionNameOnPerfectBlock;
+
+        public bool stopPreviousActionIfActive;
+
+        [Space]
+        [Header ("Hit Reaction On Block Settings")]
+        [Space]
+
+        public bool reactionOnBlock;
+        public int blockID;
+
+        public bool useStaminaOnBlock;
+        public float staminaToUseMultiplier = 1;
+
+        [Space]
+
+        public eventParameters.eventToCallWithAmount eventToUseStamina;
+
+        [Space]
+        [Header ("Perfect Block Settings")]
+        [Space]
+
+        public bool canUsePerfectBlock;
+
+        public bool activateHitReactionOnPerfectBlock;
+
+        public float probabilityForPerfectBlock = 100;
+
+        public float maxTimeToPerfectBlock = 0.5f;
+
+        [Space]
+
+        public UnityEvent eventOnEnablePerfectBlock;
+        public UnityEvent eventOnDisablePerfectBlock;
+
+        [Space]
+        [Header ("Events Settings")]
+        [Space]
+
+        public UnityEvent eventOnHit;
+
+        [HideInInspector] public float lastTimeHitReaction;
+
+        public UnityEvent eventOnHitReactionOnPerfectBlock;
+
+        [Space]
+        [Header ("Remote Events Settings")]
+        [Space]
+
+        public bool checkObjectsToUseRemoteEventsOnDamage;
+        public LayerMask layerToUseRemoteEventsOnDamage;
+
+        public bool useRemoteEvent;
+        public List<string> remoteEventNameList;
+
+        [Space]
+        [Space]
+
+        public bool useRemoteEventToEnableParryInteraction;
+        public List<string> remoteEventToEnableParryInteractionNameList;
+    }
+
+    public enum hitDamageDirection
+    {
+        front,
+        backward,
+        right,
+        left,
+        anyDirection
+    }
+
+    [System.Serializable]
+    public class damageStateInfo
+    {
+        public string Name;
+
+        public bool damageStateEnabled;
+
+        public Vector2 damageStateRange;
+
+        public bool useAsDefaultState;
+
+        public UnityEvent eventOnDamageState;
+    }
+}