add ckg

plantilla base para movimiento básico

Assets/Game Kit Controller/Scripts/AI/Custom AI Behavior/AIAimRotationManager.cs

@@ -0,0 +1,297 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class AIAimRotationManager : MonoBehaviour
+{
+    [Header ("Main Settings")]
+    [Space]
+
+    public bool AIAimRotationEnabled = true;
+
+    public bool setAIAimRotationStateOnAwake;
+
+    public string AIAimRotationStateOnAwakeName;
+
+    [Space]
+    [Header ("AI Aim Rotation States List Settings")]
+    [Space]
+
+    public List<AIAimRotationInfo> AIAimRotationInfoList = new List<AIAimRotationInfo> ();
+
+    [Space]
+    [Header ("Debug")]
+    [Space]
+
+    public bool showDebugPrint;
+    public bool randomAimPositionOffsetActive;
+    public string currentAIAimRotationInfoName;
+
+    [Space]
+    [Header ("Components")]
+    [Space]
+
+    public playerCamera mainPlayerCamera;
+    public playerController mainPlayerController;
+    public findObjectivesSystem mainFindObjectivesSystem;
+
+
+    float lastTimeRandomAimPositionOffsetActive = 0;
+
+    float currentWaitTimeRandomAimPositionOffset;
+    float currentRandomAimPositionOffset;
+    float currentRandomAimPositionOffsetDuration;
+
+    float currentMinRandomAimPositionOffset;
+
+    bool currentUseMinRandomAimPositionOffset;
+
+    Coroutine updateCoroutine;
+
+    Vector2 randomAimPositionOffsetRange;
+    Vector2 randomAimPositionOffsetDurationRange;
+    Vector2 randomAimPositionOffsetWaitRange;
+
+    void Awake ()
+    {
+        if (setAIAimRotationStateOnAwake) {
+            setAIAImRotationState (AIAimRotationStateOnAwakeName);
+        }
+    }
+
+    public void stopUpdateCoroutine ()
+    {
+        if (updateCoroutine != null) {
+            StopCoroutine (updateCoroutine);
+        }
+
+        randomAimPositionOffsetActive = false;
+    }
+
+    IEnumerator updateSystemCoroutine ()
+    {
+        var waitTime = new WaitForFixedUpdate ();
+
+        while (true) {
+            updateSystem ();
+
+            yield return waitTime;
+        }
+    }
+
+    void updateSystem ()
+    {
+        if (!randomAimPositionOffsetActive) {
+            return;
+        }
+
+        if (!mainFindObjectivesSystem.isOnSpotted ()) {
+            if (currentWaitTimeRandomAimPositionOffset != 0) {
+                if (showDebugPrint) {
+                    print ("character is not attacking a target, reseting random aim position offset state");
+                }
+
+                disableAndResetRandomAimPositionValues ();
+            }
+
+            return;
+        }
+
+        if (currentWaitTimeRandomAimPositionOffset == 0) {
+            currentWaitTimeRandomAimPositionOffset = Random.Range (randomAimPositionOffsetWaitRange.x, randomAimPositionOffsetWaitRange.y);
+
+            currentRandomAimPositionOffset = Random.Range (randomAimPositionOffsetRange.x, randomAimPositionOffsetRange.y);
+
+            if (currentUseMinRandomAimPositionOffset) {
+                if (currentMinRandomAimPositionOffset != 0) {
+                    if (currentRandomAimPositionOffset > 0) {
+                        if (currentRandomAimPositionOffset < currentMinRandomAimPositionOffset) {
+                            currentRandomAimPositionOffset = currentMinRandomAimPositionOffset;
+                        }
+                    } else {
+                        if (Mathf.Abs (currentRandomAimPositionOffset) < currentMinRandomAimPositionOffset) {
+                            currentRandomAimPositionOffset = -currentMinRandomAimPositionOffset;
+                        }
+                    }
+                }
+            }
+
+            lastTimeRandomAimPositionOffsetActive = Time.time;
+
+            if (showDebugPrint) {
+                print ("select wait time " + currentWaitTimeRandomAimPositionOffset);
+            }
+        } else {
+            if (Time.time > lastTimeRandomAimPositionOffsetActive + currentWaitTimeRandomAimPositionOffset) {
+                if (currentRandomAimPositionOffsetDuration == 0) {
+                    currentRandomAimPositionOffsetDuration = Random.Range (randomAimPositionOffsetDurationRange.x, randomAimPositionOffsetDurationRange.y);
+
+                    mainFindObjectivesSystem.addLookDirectionToTargetOffset (currentRandomAimPositionOffset);
+
+                    lastTimeRandomAimPositionOffsetActive = Time.time;
+
+                    if (showDebugPrint) {
+                        print ("select offset duration " + currentRandomAimPositionOffsetDuration);
+
+                        print ("current random position offset " + currentRandomAimPositionOffset);
+                    }
+                }
+            }
+
+            if (currentRandomAimPositionOffsetDuration != 0) {
+                if (Time.time > lastTimeRandomAimPositionOffsetActive + currentRandomAimPositionOffsetDuration) {
+                    disableAndResetRandomAimPositionValues ();
+                }
+            }
+        }
+    }
+
+    void disableAndResetRandomAimPositionValues ()
+    {
+        mainFindObjectivesSystem.addLookDirectionToTargetOffset (0);
+
+        lastTimeRandomAimPositionOffsetActive = Time.time;
+
+        currentWaitTimeRandomAimPositionOffset = 0;
+
+        currentRandomAimPositionOffsetDuration = 0;
+
+        if (showDebugPrint) {
+            print ("reset values");
+        }
+    }
+
+    public void setAIAImRotationState (string stateName)
+    {
+        if (!AIAimRotationEnabled) {
+            return;
+        }
+
+        int newIndex = AIAimRotationInfoList.FindIndex (s => s.Name.Equals (stateName));
+
+        if (newIndex > -1) {
+            AIAimRotationInfo currentInfo = AIAimRotationInfoList [newIndex];
+
+            if (currentInfo.stateEnabled) {
+                currentAIAimRotationInfoName = currentInfo.Name;
+
+                mainPlayerCamera.changeRotationSpeedValue (currentInfo.verticalAimRotationSpeed, currentInfo.horizontalAimRotationSpeed);
+
+                mainPlayerCamera.updateOriginalRotationSpeedValues ();
+
+                if (currentInfo.setRotateDirectlyTowardCameraOnStrafe) {
+                    mainPlayerController.setRotateDirectlyTowardCameraOnStrafeState (currentInfo.rotateDirectlyTowardCameraOnStrafe);
+                }
+
+                if (currentInfo.setLookAtTargetSpeed) {
+                    mainFindObjectivesSystem.setLookAtTargetSpeedValue (currentInfo.lookAtTargetSpeed);
+                }
+
+                if (currentInfo.setAutoTurnSpeed) {
+                    mainPlayerController.setAutoTurnSpeed (currentInfo.autoTurnSpeed);
+                }
+
+                if (currentInfo.setAimTurnSpeed) {
+                    mainPlayerController.setAimTurnSpeed (currentInfo.aimTurnSpeed);
+                }
+
+                if (randomAimPositionOffsetActive) {
+                    stopUpdateCoroutine ();
+                }
+
+                if (currentInfo.addRandomAimPositionOffset) {
+                    randomAimPositionOffsetActive = true;
+
+                    updateCoroutine = StartCoroutine (updateSystemCoroutine ());
+
+                    randomAimPositionOffsetRange = currentInfo.randomAimPositionOffsetRange;
+                    randomAimPositionOffsetDurationRange = currentInfo.randomAimPositionOffsetDurationRange;
+                    randomAimPositionOffsetWaitRange = currentInfo.randomAimPositionOffsetWaitRange;
+
+                    currentMinRandomAimPositionOffset = currentInfo.minRandomAimPositionOffset;
+
+                    currentUseMinRandomAimPositionOffset = currentInfo.useMinRandomAimPositionOffset;
+
+                    lastTimeRandomAimPositionOffsetActive = 0;
+
+                    currentWaitTimeRandomAimPositionOffset = 0;
+                } else {
+                    mainFindObjectivesSystem.addLookDirectionToTargetOffset (0);
+                }
+
+                if (showDebugPrint) {
+                    print ("setting aim state " + currentAIAimRotationInfoName);
+                }
+            }
+        }
+    }
+
+    public void setAIAimRotationEnabledState (bool state)
+    {
+        AIAimRotationEnabled = state;
+    }
+
+    public void setAIAimRotationEnabledStateFromEditor (bool state)
+    {
+        setAIAimRotationEnabledState (state);
+
+        updateComponent ();
+    }
+
+    public void updateComponent ()
+    {
+        GKC_Utils.updateComponent (this);
+
+        GKC_Utils.updateDirtyScene ("Update AI Aim Rotation Manager " + gameObject.name, gameObject);
+    }
+
+
+    [System.Serializable]
+    public class AIAimRotationInfo
+    {
+        [Header ("Aiming Rotation Speed Settings")]
+        [Space]
+
+        public string Name;
+        public bool stateEnabled = true;
+
+        [Space]
+
+        public bool setAimRotationSpeed;
+        public float verticalAimRotationSpeed;
+        public float horizontalAimRotationSpeed;
+
+        [Space]
+
+        public bool setRotateDirectlyTowardCameraOnStrafe;
+        public bool rotateDirectlyTowardCameraOnStrafe;
+
+        [Space]
+
+        public bool setLookAtTargetSpeed;
+        public float lookAtTargetSpeed;
+
+        [Space]
+
+        public bool setAutoTurnSpeed;
+        public float autoTurnSpeed;
+
+        [Space]
+
+        public bool setAimTurnSpeed;
+        public float aimTurnSpeed;
+
+        [Space]
+
+        public bool addRandomAimPositionOffset;
+        public Vector2 randomAimPositionOffsetDurationRange;
+        public Vector2 randomAimPositionOffsetWaitRange;
+
+        [Space]
+
+        public Vector2 randomAimPositionOffsetRange;
+
+        public bool useMinRandomAimPositionOffset;
+        public float minRandomAimPositionOffset;
+    }
+}