add ckg

plantilla base para movimiento básico

Assets/Game Kit Controller/Scripts/Abilities System/magicSpellActionSystem.cs

@@ -0,0 +1,590 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Events;
+
+public class magicSpellActionSystem : MonoBehaviour
+{
+    [Header ("Main Settings")]
+    [Space]
+
+    public bool magicSystemEnabled = true;
+
+    public bool resetIndexIfNotAttackAfterDelay;
+
+    public float delayToResetIndexAfterAttack;
+
+    public float generalEnergyUseMultiplier = 1;
+
+    [Space]
+    [Header ("Attack Selection Settings")]
+    [Space]
+
+    public bool useAttackTypes;
+
+    public bool useRandomAttackIndex;
+
+    public bool useEnergyOnMagic;
+
+    public bool useNextMagicSpellOnListForNextAttackEnabled = true;
+
+    [Space]
+
+    public bool avoidActivateAbilityIfAnotherInProcessEnabled = true;
+
+    [Space]
+    [Header ("Movement Settings")]
+    [Space]
+
+    public bool useStrafeMode;
+    public int strafeIDUsed;
+    public bool setPreviousStrafeModeOnDisableMagicSystem;
+
+    public bool activateStrafeModeOnLockOnTargetActive;
+    public bool deactivateStrafeModeOnLockOnTargetDeactivate;
+
+    public bool toggleStrafeModeIfRunningActive;
+
+    public bool setNewCrouchID;
+    public int crouchIDUsed;
+
+
+    [Space]
+    [Header ("Magic Action List Settings")]
+    [Space]
+
+    public List<magicSpellActionInfo> magicSpellActionInfoList = new List<magicSpellActionInfo> ();
+
+    [Space]
+    [Header ("Debug")]
+    [Space]
+
+    public bool showDebugPrint;
+
+    [Space]
+
+    public bool previousStrafeMode;
+    public int previousStrafeID = -1;
+
+    public bool magicSystemActive;
+
+    [Space]
+
+    public int currentAttackIndex;
+
+    public bool attackInProcess;
+
+    [Space]
+    [Header ("Event Settings")]
+    [Space]
+
+    public bool useEventsOnAttack;
+    public UnityEvent eventOnAttackStart;
+    public UnityEvent eventOnAttackEnd;
+
+    public bool useEventsOnEnableDisableMagicSystem;
+    public UnityEvent eventOnEnableMagicSystem;
+    public UnityEvent eventOnDisableMagicSystem;
+
+    [Space]
+    [Header ("Components")]
+    [Space]
+
+    public otherPowers mainOtherPowers;
+
+    public playerController mainPlayerController;
+
+    public remoteEventSystem mainRemoteEventSystem;
+
+
+    magicSpellActionInfo currentMagicSpellActionInfo;
+
+    float lastTimeAttackActive;
+
+    float lastTimeAttackComplete;
+
+    Coroutine magicCoroutine;
+
+    Coroutine magicEventCoroutine;
+
+
+    public void enableOrDisableMagicSystem (bool state)
+    {
+        if (!magicSystemEnabled) {
+            return;
+        }
+
+        bool previouslyActive = magicSystemActive;
+
+        magicSystemActive = state;
+
+        checkEventsOnEnableDisableMagicSystem (magicSystemActive);
+
+        mainOtherPowers.enableOrDisablePowersInfoPanel (magicSystemActive);
+
+        if (magicSystemActive) {
+            checkMagicStateAtStart ();
+
+        } else {
+            if (previouslyActive) {
+                checkMagicStateAtEnd ();
+
+                resumeState ();
+            }
+        }
+    }
+
+    public void useMagicSpell (string magicTypeName)
+    {
+        if (showDebugPrint) {
+            print ("input activated");
+        }
+
+        if (!magicSystemActive) {
+            return;
+        }
+
+        if (!canUseInput ()) {
+            return;
+        }
+
+        if (currentAttackIndex > 0 && currentMagicSpellActionInfo != null) {
+            //				print (currentAttackInfo.minDelayBeforeNextAttack);
+
+            if (Time.time < lastTimeAttackActive + currentMagicSpellActionInfo.minDelayBeforeNextAttack) {
+                return;
+            }
+        }
+
+        if (attackInProcess && avoidActivateAbilityIfAnotherInProcessEnabled) {
+            if (showDebugPrint) {
+                print ("attack in process, cancelling");
+            }
+
+            return;
+        }
+
+        if (resetIndexIfNotAttackAfterDelay && !attackInProcess) {
+            if (Time.time > lastTimeAttackComplete + delayToResetIndexAfterAttack) {
+                //				print ("reset attack index");
+
+                currentAttackIndex = 0;
+            }
+        }
+
+        if (useAttackTypes) {
+            if (showDebugPrint) {
+                print ("attack all conditions checked");
+            }
+
+            int numberOfAttacksSameType = 0;
+
+            int numberOfAttacksAvailable = magicSpellActionInfoList.Count;
+
+            for (int i = 0; i < numberOfAttacksAvailable; i++) {
+                if (magicSpellActionInfoList [i].magicTypeName.Equals (magicTypeName) &&
+                    magicSpellActionInfoList [i].magicEnabled) {
+                    numberOfAttacksSameType++;
+                }
+            }
+
+            if (numberOfAttacksSameType == 1) {
+                bool cancelAttack = false;
+
+                if (attackInProcess &&
+                    currentMagicSpellActionInfo != null &&
+                    currentMagicSpellActionInfo.magicTypeName.Equals (magicTypeName)) {
+                    cancelAttack = true;
+
+                    if (showDebugPrint) {
+                        print ("same attack type already in process with just 1 type configured, so " +
+                            "the system is trying to activate the same magic attack which is already in process");
+                    }
+                }
+
+                if (Time.time < lastTimeAttackComplete + 0.4f) {
+                    cancelAttack = true;
+                }
+
+                if (cancelAttack) {
+                    if (showDebugPrint) {
+                        print ("just one attack type available and it is in process, avoiding to play it again");
+                    }
+
+                    return;
+                }
+            }
+
+            bool attackFound = false;
+
+            setNextAttackIndex ();
+
+            while (!attackFound) {
+                currentMagicSpellActionInfo = magicSpellActionInfoList [currentAttackIndex];
+
+                //				print (currentAttackInfo.magicTypeName + " " + magicTypeName);
+
+                if (currentMagicSpellActionInfo.magicTypeName.Equals (magicTypeName) &&
+                    currentMagicSpellActionInfo.magicEnabled) {
+
+                    attackFound = true;
+                } else {
+                    setNextAttackIndex ();
+
+                    numberOfAttacksAvailable--;
+
+                    if (numberOfAttacksAvailable < 0) {
+                        return;
+                    }
+                }
+            }
+        } else {
+            bool attackFound = false;
+
+            int numberOfAttacksAvailable = magicSpellActionInfoList.Count;
+
+            while (!attackFound) {
+                currentMagicSpellActionInfo = magicSpellActionInfoList [currentAttackIndex];
+
+                //				print (currentAttackInfo.magicTypeName + " " + magicTypeName);
+
+                if (currentMagicSpellActionInfo.magicEnabled) {
+                    attackFound = true;
+                } else {
+                    setNextAttackIndex ();
+
+                    numberOfAttacksAvailable--;
+
+                    if (numberOfAttacksAvailable < 0) {
+                        return;
+                    }
+                }
+            }
+
+            currentMagicSpellActionInfo = magicSpellActionInfoList [currentAttackIndex];
+        }
+
+        if (useEnergyOnMagic) {
+            float energyUsed = currentMagicSpellActionInfo.energyAmountUsed * generalEnergyUseMultiplier;
+
+            if (energyUsed > 0) {
+                mainOtherPowers.usePowerBar ((energyUsed));
+            }
+        }
+
+        //		print ("Magic used " + currentMagicSpellActionInfo.Name);
+
+        stopActivateMagicSpellAction ();
+
+        magicCoroutine = StartCoroutine (activateMagicSpellAction ());
+
+        stopActivateMagicSpellEvent ();
+
+        magicEventCoroutine = StartCoroutine (activateMagicSpellEvent ());
+
+        if (!useAttackTypes && useNextMagicSpellOnListForNextAttackEnabled) {
+            setNextAttackIndex ();
+        }
+    }
+
+    public void enableMagicByName (string magicName)
+    {
+        enableOrDisableMagicByName (magicName, true);
+    }
+
+    public void disableMagicByName (string magicName)
+    {
+        enableOrDisableMagicByName (magicName, false);
+    }
+
+    public void enableOrDisableMagicByName (string magicName, bool state)
+    {
+        int weaponIdex = magicSpellActionInfoList.FindIndex (s => s.Name.Equals (magicName));
+
+        if (weaponIdex > -1) {
+            magicSpellActionInfoList [weaponIdex].magicEnabled = state;
+        }
+    }
+
+    public void setNextAttackIndex ()
+    {
+        if (useRandomAttackIndex) {
+            currentAttackIndex = Random.Range (0, magicSpellActionInfoList.Count - 1);
+        } else {
+            currentAttackIndex++;
+
+            if (currentAttackIndex >= magicSpellActionInfoList.Count) {
+                currentAttackIndex = 0;
+            }
+        }
+    }
+
+    public void setPreviousAttackIndex ()
+    {
+        if (useRandomAttackIndex) {
+            currentAttackIndex = Random.Range (0, magicSpellActionInfoList.Count - 1);
+        } else {
+            currentAttackIndex--;
+
+            if (currentAttackIndex <= 0) {
+                currentAttackIndex = magicSpellActionInfoList.Count - 1;
+            }
+        }
+    }
+
+    public void stopActivateMagicSpellAction ()
+    {
+        if (magicCoroutine != null) {
+            StopCoroutine (magicCoroutine);
+        }
+    }
+
+    IEnumerator activateMagicSpellAction ()
+    {
+        checkEventsOnAttack (true);
+
+        lastTimeAttackActive = Time.time;
+
+        attackInProcess = true;
+
+        if (currentMagicSpellActionInfo.useRemoteEvent) {
+            for (int i = 0; i < currentMagicSpellActionInfo.remoteEventNameList.Count; i++) {
+                mainRemoteEventSystem.callRemoteEvent (currentMagicSpellActionInfo.remoteEventNameList [i]);
+            }
+        }
+
+        if (currentMagicSpellActionInfo.useCustomAction) {
+            mainPlayerController.activateCustomAction (currentMagicSpellActionInfo.customActionName);
+
+            if (showDebugPrint) {
+                print ("attack activated :" + mainPlayerController.getCurrentActionName ());
+            }
+        }
+
+        yield return new WaitForSeconds (currentMagicSpellActionInfo.attackDuration);
+
+        lastTimeAttackComplete = Time.time;
+
+        resumeState ();
+
+        if (showDebugPrint) {
+            print ("end of attack");
+        }
+
+        yield return null;
+    }
+
+    public void stopActivateMagicSpellEvent ()
+    {
+        if (magicEventCoroutine != null) {
+            StopCoroutine (magicEventCoroutine);
+        }
+    }
+
+    IEnumerator activateMagicSpellEvent ()
+    {
+        yield return new WaitForSeconds (currentMagicSpellActionInfo.delayToActiveEvent);
+
+        currentMagicSpellActionInfo.eventOnMagicUsed.Invoke ();
+    }
+
+    public void resumeState ()
+    {
+        attackInProcess = false;
+
+        checkEventsOnAttack (false);
+    }
+
+    public void checkEventsOnAttack (bool state)
+    {
+        if (useEventsOnAttack) {
+            if (state) {
+                eventOnAttackStart.Invoke ();
+            } else {
+                eventOnAttackEnd.Invoke ();
+            }
+        }
+    }
+
+    public void checkMagicStateAtStart ()
+    {
+        previousStrafeMode = mainPlayerController.isStrafeModeActive ();
+
+        if (previousStrafeID == -1) {
+            previousStrafeID = mainPlayerController.getCurrentStrafeIDValue ();
+        }
+
+        if (useStrafeMode) {
+            mainPlayerController.activateOrDeactivateStrafeMode (true);
+
+        } else {
+            if (showDebugPrint) {
+                print ("checking strafe mode when returning thrown weapon");
+            }
+
+            previousStrafeMode = false;
+
+            previousStrafeID = -1;
+
+            mainPlayerController.activateOrDeactivateStrafeMode (false);
+        }
+
+        if (toggleStrafeModeIfRunningActive) {
+            mainPlayerController.setDisableStrafeModeExternallyIfIncreaseWalkSpeedActiveState (true);
+        }
+
+        mainPlayerController.setCurrentStrafeIDValue (strafeIDUsed);
+
+        if (setNewCrouchID) {
+            mainPlayerController.setCurrentCrouchIDValue (crouchIDUsed);
+        }
+    }
+
+    public void checkMagicStateAtEnd ()
+    {
+        if (setPreviousStrafeModeOnDisableMagicSystem) {
+            mainPlayerController.activateOrDeactivateStrafeMode (previousStrafeMode);
+        } else {
+            mainPlayerController.setOriginalLookAlwaysInCameraDirectionState ();
+        }
+
+        if (previousStrafeID != -1) {
+            mainPlayerController.setCurrentStrafeIDValue (previousStrafeID);
+        }
+
+        if (toggleStrafeModeIfRunningActive) {
+            mainPlayerController.setDisableStrafeModeExternallyIfIncreaseWalkSpeedActiveState (false);
+        }
+
+        previousStrafeMode = false;
+
+        previousStrafeID = -1;
+
+        if (setNewCrouchID) {
+            mainPlayerController.setCurrentCrouchIDValue (0);
+        }
+    }
+
+    public void checkLookAtTargetActiveState ()
+    {
+        if (magicSystemActive) {
+            bool lookingAtTarget = mainPlayerController.isPlayerLookingAtTarget ();
+
+            if (lookingAtTarget) {
+                if (activateStrafeModeOnLockOnTargetActive) {
+                    mainPlayerController.activateOrDeactivateStrafeMode (true);
+
+                }
+            } else {
+                if (activateStrafeModeOnLockOnTargetActive) {
+                    mainPlayerController.activateOrDeactivateStrafeMode (false);
+
+                }
+            }
+        }
+    }
+
+    public void checkLookAtTargetDeactivateState ()
+    {
+        if (activateStrafeModeOnLockOnTargetActive) {
+            mainPlayerController.activateOrDeactivateStrafeMode (false);
+        }
+    }
+
+    public bool canUseInput ()
+    {
+        if (!playerIsBusy ()) {
+            return true;
+        }
+
+        return false;
+    }
+
+    public bool playerIsBusy ()
+    {
+        if (mainPlayerController.isUsingDevice ()) {
+            return true;
+        }
+
+        if (mainPlayerController.isTurnBasedCombatActionActive ()) {
+            return false;
+        }
+
+        if (mainPlayerController.isUsingSubMenu ()) {
+            return true;
+        }
+
+        if (mainPlayerController.isPlayerMenuActive ()) {
+            return true;
+        }
+
+        return false;
+    }
+
+    public void checkEventsOnEnableDisableMagicSystem (bool state)
+    {
+        if (useEventsOnEnableDisableMagicSystem) {
+            if (state) {
+                eventOnEnableMagicSystem.Invoke ();
+            } else {
+                eventOnDisableMagicSystem.Invoke ();
+            }
+        }
+    }
+
+    public void inputSetNextOrPreviousAttackIndex (bool useNextAttack)
+    {
+        if (!magicSystemActive) {
+            return;
+        }
+
+        if (!canUseInput ()) {
+            return;
+        }
+
+        if (useNextAttack) {
+            setNextAttackIndex ();
+        } else {
+            setPreviousAttackIndex ();
+        }
+    }
+
+    [System.Serializable]
+    public class magicSpellActionInfo
+    {
+        [Header ("Main Settings")]
+        [Space]
+
+        public string Name;
+
+        public bool magicEnabled = true;
+
+        public float energyAmountUsed;
+
+        public string magicTypeName;
+
+        [Space]
+        [Header ("Other Settings")]
+        [Space]
+
+        public float attackDuration;
+
+        public float minDelayBeforeNextAttack;
+
+        public bool useCustomAction;
+
+        public string customActionName;
+
+        [Space]
+        [Header ("Remote Events Settings")]
+        [Space]
+
+        public bool useRemoteEvent;
+
+        public List<string> remoteEventNameList = new List<string> ();
+
+        public float delayToActiveEvent;
+
+        public UnityEvent eventOnMagicUsed;
+    }
+}