add ckg

plantilla base para movimiento básico

Assets/Game Kit Controller/Scripts/Weapons/New Weapon Behaviors/simpleChainSaw.cs

@@ -0,0 +1,294 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Events;
+
+public class simpleChainSaw : MonoBehaviour
+{
+    [Header ("Main Settings")]
+    [Space]
+
+    public Transform mainRotationPivot;
+
+    public float initialPivotRotation;
+
+    public bool useFixedVerticalHorizontalRotations;
+
+    public float angleRotationAmount;
+
+    public float rotationSpeed;
+
+    public float manualRotationAmount;
+
+    public float maxRotationAngle = 80;
+
+    public float minRotationAngle = -10;
+
+    [Space]
+    [Header ("Weapon Settings")]
+    [Space]
+
+    public bool useFuelEnabled = true;
+    public float useFuelRate;
+    public int amountFuelUsed;
+
+    [Space]
+    [Header ("Debug")]
+    [Space]
+
+    public bool chainsawActive;
+
+    [Space]
+    [Header ("Events Settings")]
+    [Space]
+
+    public UnityEvent eventOnActivateChainsaw;
+
+    public UnityEvent eventOnDeactivateChainsaw;
+
+    public UnityEvent eventOnRotateWeapon;
+
+    [Space]
+    [Header ("Components")]
+    [Space]
+
+    public playerWeaponSystem weaponManager;
+
+
+    bool rotating;
+
+    bool rotationToggleState;
+
+    Coroutine rotationCoroutine;
+
+    Coroutine updateCoroutine;
+
+    bool isWeaponReloading;
+
+    bool remainAmmoInClip;
+
+    bool reloading;
+
+    float lastTimeUsed;
+
+    bool ignoreDisableCoroutine;
+
+
+    void Start ()
+    {
+        mainRotationPivot.localEulerAngles = new Vector3 (0, 0, initialPivotRotation);
+    }
+
+    public void stopUpdateCoroutine ()
+    {
+        if (updateCoroutine != null) {
+            StopCoroutine (updateCoroutine);
+        }
+    }
+
+    IEnumerator updateSystemCoroutine ()
+    {
+        var waitTime = new WaitForFixedUpdate ();
+
+        while (true) {
+            updateSystem ();
+
+            yield return waitTime;
+        }
+    }
+
+    void updateSystem ()
+    {
+        isWeaponReloading = weaponManager.isWeaponReloading ();
+
+        remainAmmoInClip = weaponManager.remainAmmoInClip ();
+
+        if (reloading) {
+            if (remainAmmoInClip && weaponManager.carryingWeapon () && !isWeaponReloading) {
+                reloading = false;
+            } else {
+                return;
+            }
+        }
+
+        if (reloading) {
+            return;
+        }
+
+        if (!chainsawActive) {
+            return;
+        }
+
+        if (useFuelEnabled) {
+            if (Time.time > lastTimeUsed + useFuelRate) {
+                if (remainAmmoInClip && !isWeaponReloading) {
+                    lastTimeUsed = Time.time;
+
+                    weaponManager.useAmmo (amountFuelUsed);
+
+                    weaponManager.checkToUpdateInventoryWeaponAmmoTextFromWeaponSystem ();
+                }
+
+                if (!remainAmmoInClip || isWeaponReloading) {
+                    ignoreDisableCoroutine = true;
+
+                    activateOrDeactivateChainsaw (false);
+
+                    ignoreDisableCoroutine = false;
+
+                    reloading = true;
+
+                    return;
+                }
+            }
+        }
+    }
+
+    public void activateChainSaw ()
+    {
+        activateOrDeactivateChainsaw (true);
+    }
+
+    public void deactivateChainSaw ()
+    {
+        activateOrDeactivateChainsaw (false);
+    }
+
+    void activateOrDeactivateChainsaw (bool state)
+    {
+        if (chainsawActive == state) {
+            return;
+        }
+
+        chainsawActive = state;
+
+        if (chainsawActive) {
+            eventOnActivateChainsaw.Invoke ();
+        } else {
+            eventOnDeactivateChainsaw.Invoke ();
+        }
+
+        if (ignoreDisableCoroutine) {
+            return;
+        }
+
+        if (chainsawActive) {
+            updateCoroutine = StartCoroutine (updateSystemCoroutine ());
+        } else {
+            stopUpdateCoroutine ();
+        }
+    }
+
+    public void rotatePivotToRight ()
+    {
+        mainRotationPivot.Rotate (manualRotationAmount * Vector3.forward);
+
+        checkMainRotationPivotMaxRotationAngle ();
+    }
+
+    public void rotatePivotToLeft ()
+    {
+        mainRotationPivot.Rotate (manualRotationAmount * (-Vector3.forward));
+
+        checkMainRotationPivotMaxRotationAngle ();
+    }
+
+    void checkMainRotationPivotMaxRotationAngle ()
+    {
+        if (maxRotationAngle == 0) {
+            return;
+        }
+
+        Vector3 mainRotationPivotEulerAngles = mainRotationPivot.localEulerAngles;
+
+        float newZAngle = mainRotationPivotEulerAngles.z;
+
+        if (newZAngle > 0 && newZAngle < 180) {
+            newZAngle = Mathf.Clamp (newZAngle, 0, maxRotationAngle);
+
+        } else {
+            if (newZAngle > 180) {
+                newZAngle -= 360;
+            }
+
+            newZAngle = Mathf.Clamp (newZAngle, minRotationAngle, 0);
+        }
+
+        mainRotationPivot.localEulerAngles = new Vector3 (mainRotationPivotEulerAngles.x, mainRotationPivotEulerAngles.y, newZAngle);
+    }
+
+    public void changePivotRotation ()
+    {
+        if (rotating) {
+            return;
+        }
+
+        float rotationAmount = 0;
+
+        if (useFixedVerticalHorizontalRotations) {
+            rotationToggleState = !rotationToggleState;
+
+            if (rotationToggleState) {
+                rotationAmount = 90;
+            } else {
+                rotationAmount = 0;
+            }
+        } else {
+            rotationAmount += angleRotationAmount;
+
+            if (rotationAmount > 360) {
+                rotationAmount = 360 - rotationAmount;
+            }
+        }
+
+        eventOnRotateWeapon.Invoke ();
+
+        stopChangePivotRotation ();
+
+        rotationCoroutine = StartCoroutine (stopChangePivotRotationCoroutine (rotationAmount));
+    }
+
+    public void stopChangePivotRotation ()
+    {
+        if (rotationCoroutine != null) {
+            StopCoroutine (rotationCoroutine);
+        }
+    }
+
+    IEnumerator stopChangePivotRotationCoroutine (float rotationAmount)
+    {
+        rotating = true;
+
+        Vector3 eulerTarget = Vector3.zero;
+
+        eulerTarget.z = rotationAmount;
+
+        Quaternion rotationTarget = Quaternion.Euler (eulerTarget);
+
+        float t = 0;
+
+        float movementTimer = 0;
+
+        bool targetReached = false;
+
+        float angleDifference = 0;
+
+        while (!targetReached) {
+            t += Time.deltaTime * rotationSpeed;
+            mainRotationPivot.localRotation = Quaternion.Lerp (mainRotationPivot.localRotation, rotationTarget, t);
+
+            movementTimer += Time.deltaTime;
+
+            angleDifference = Quaternion.Angle (mainRotationPivot.localRotation, rotationTarget);
+
+            movementTimer += Time.deltaTime;
+
+            if (angleDifference < 0.2f || movementTimer > 2) {
+                targetReached = true;
+            }
+            yield return null;
+        }
+
+        rotating = false;
+    }
+}