Humanoid animator manager

Fixed humanoid so max speed has a hardset limit of 1.6x greater than the set max speed in the event of running down very steep inclines. This is to keep the Animator smooth.

The new HumanoidAnim also assumes that the user has FinalIK installed. This can easily be removed though via the deletion of the component reference.

Author: TCPHijinks

Humanoid.cs

@@ -6,16 +6,16 @@ public class Humanoid : MonoBehaviour
 {
     protected GroundCheck gndCheck; // If grounded, incline checks, etc.
     protected CharacterController controller; // Movement handling.
-    protected float Gravity { get; set; } = .04f;
+    protected float Gravity { get; set; } = .032f;
 
-    private bool startedJmpCd = false; // Only allow one active jump cooldown.
-    private bool canJump = true; // Jump cooldown lock.
-
-    private float curSpd, maxSpd;
-
-    public float jogSpd = 2, runSpd = 4;
-    public float jumpAmount = 2, jumpCooldown = .4f;
+    [HideInInspector] public bool StartedJmpCd { get; private set; } = false; // Only allow one active jump cooldown.
+    [HideInInspector] public bool CanJump { get; private set; } = true; // Jump cooldown lock.
+    [HideInInspector] public float CurSpd { get; private set; }
+    [HideInInspector] public float MaxSpd { get; private set; }
 
+    public float jogSpd = 1.45f, runSpd = 2f;
+    public float jumpAmount = 0.35f, jumpCooldown = 0.8f;
+    public float accelMod = 10; // Used to calculate cur speed.
 
     void Awake()
     {
@@ -27,23 +27,23 @@ void Awake()
     // Update is called once per frame
     protected void Update()
     {      
-        if (gndCheck.Grounded && !canJump) // Start jump cooldown once grounded.
+        SetCurSpeed(MaxSpd > 0, CurSpd, MaxSpd);
+        GravityCalc(Gravity);
+
+        if (gndCheck.Grounded && !CanJump) // Start jump cooldown once grounded.
             StartCoroutine(JumpCooldown(jumpCooldown));
 
-        SetCurSpeed(maxSpd > 0, curSpd, maxSpd);
-        GravityCalc(Gravity);
         ApplyMoveVelocity();
 
         if (gndCheck.Grounded) // If grounded, limit move speed.
         {
             moveVel.x = 0;
             moveVel.z = 0;
         }    
-        else canJump = false; // Can't jump if not grounded. 
-        Debug.Log(controller.velocity.magnitude);
+        else CanJump = false; // Can't jump if not grounded. 
     }
 
-
+    [SerializeField] private float rotSpdPenalty = .4f;
     /// <summary>
     /// Rotates humanoid to look at target position.
     /// </summary>
@@ -52,10 +52,13 @@ protected void Update()
     /// <param name="rotSpeed"></param>
     protected void Rotate(Vector3 newDir, int dampening, int rotSpeed)
     {
-        Vector3 curMoveDir = Vector3.Lerp(transform.position, newDir, dampening);
+        // Greater speed decreases turn speed.
+        float spdRotPenalty = CurSpd * rotSpdPenalty; // Used on dampening & rotation speed.     
+        
+        Vector3 curMoveDir = Vector3.Lerp(transform.position, newDir, (dampening + spdRotPenalty));
         // Lerp from cur rot to new one.
         transform.rotation = (Quaternion.Slerp(transform.rotation,
-               Quaternion.LookRotation(new Vector3(curMoveDir.x, 0, curMoveDir.z)), rotSpeed * Time.deltaTime));
+               Quaternion.LookRotation(new Vector3(curMoveDir.x, 0, curMoveDir.z)), (rotSpeed - spdRotPenalty) * Time.deltaTime));
     }
 
 
@@ -73,19 +76,23 @@ protected void Move(float speed)
     {    
         // Max speed more/less depending on terrain incline.
         if (controller.velocity.y >= 0)
-            maxSpd =  (speed + CurVel) - GndSpdMod; // Less top speed if go up incline.
-        else maxSpd = (speed + CurVel) + GndSpdMod; // More top speed if down incline.
+            MaxSpd =  (speed + CurVel) - GndSpdMod; // Less top speed if go up incline.
+        else MaxSpd = (speed + CurVel) + GndSpdMod; // More top speed if down incline.
 
-        // Limit min/top max speed.
-        if (maxSpd < 0) maxSpd = 0;
-        else if (maxSpd > speed * 2) maxSpd = speed * 2;
+        // Limit min/top max speed.     
+        if(speed != 0)
+        {
+            if (MaxSpd < 0) MaxSpd = 0;
+            else if (MaxSpd > speed * 1.6f) 
+                MaxSpd = speed * 1.6f;
+        }
+       
 
         if (gndCheck.Grounded)
-            moveVel += (transform.forward * curSpd) * Time.deltaTime;        
+            moveVel += (transform.forward * CurSpd) * Time.deltaTime;        
     }
 
 
-    public float accelMod = 1;
     /// <summary>
     /// Accel/Decel for current speed.
     /// </summary>
@@ -96,7 +103,7 @@ protected void Move(float speed)
     private void SetCurSpeed(bool moving, float curSpeed, float maxBaseSpd)
     {
         float acclBonus = 0;
-        if (maxBaseSpd <= maxSpd) // Down slope - accel faster.
+        if (maxBaseSpd <= MaxSpd) // Down slope - accel faster.
             acclBonus += (CurVel + GndSpdMod) / 3;
         else acclBonus -= (CurVel +  GndSpdMod) / 3;
 
@@ -105,11 +112,11 @@ private void SetCurSpeed(bool moving, float curSpeed, float maxBaseSpd)
         else curSpeed -= (accelMod + acclBonus) * Time.deltaTime;
 
         // Limit min/max speed.
-        if (curSpeed > maxSpd)
-            curSpeed = maxSpd;
-        else if (curSpd < 0)
+        if (curSpeed > MaxSpd)
+            curSpeed = MaxSpd;
+        else if (curSpeed < 0)
             curSpeed = 0;
-        curSpd = curSpeed;
+        CurSpd = curSpeed;
     }
 
 
@@ -130,15 +137,15 @@ private void GravityCalc(float gravity)
       //  Debug.Log(gndCheck.Grounded);
     }
 
-  
+
     /// <summary>
-    /// If not on cooldown, add jump force to vertical move velocity.
+    /// If not on cooldown, add jump force to vertical move velocity & give small dist boost.
     /// </summary>
     /// <param name="amount"></param>
     /// <param name="cooldown"></param>
     protected void Jump()
     {       
-        if (!canJump || !gndCheck.Grounded) return;
+        if (!CanJump || !gndCheck.Grounded) return;
         moveVel.y += jumpAmount;
     }
 
@@ -150,12 +157,12 @@ protected void Jump()
     /// <returns></returns>
     private IEnumerator JumpCooldown(float cooldown)
     {
-        if (!startedJmpCd) // Cooldown once.
+        if (!StartedJmpCd) // Cooldown once.
         {
-            startedJmpCd = true;
+            StartedJmpCd = true;
             yield return new WaitForSeconds(cooldown);
-            canJump = true;
-            startedJmpCd = false;
+            CanJump = true;
+            StartedJmpCd = false;
         }       
     }
 
@@ -165,7 +172,7 @@ private IEnumerator JumpCooldown(float cooldown)
     /// </summary>
     private void ApplyMoveVelocity()
     {
-        if(maxSpd == 0)
+        if(MaxSpd == 0)
         {
             moveVel.x = 0;
             moveVel.z = 0;

HumanoidAnim.cs

@@ -0,0 +1,37 @@
+using RootMotion.FinalIK;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class HumanoidAnim : MonoBehaviour
+{
+    private GrounderFBBIK grounderIK;
+    private GroundCheck gndCheck;
+    private Humanoid humanoid;
+    private Animator anim;
+
+    // Start is called before the first frame update
+    void Start()
+    {
+        grounderIK = GetComponent<GrounderFBBIK>();
+        humanoid = GetComponent<Humanoid>();
+        gndCheck = GetComponent<GroundCheck>();
+        anim = GetComponent<Animator>();
+    }
+    
+    // Update is called once per frame
+    void Update()
+    {
+        // Jumping if can't jump and not on cooldown after landing.
+        bool jumping = !humanoid.CanJump && !humanoid.StartedJmpCd;
+
+        if (jumping) // Allow feet to leave ground when jump.
+            grounderIK.weight -= (float)(2.5 * Time.deltaTime);        
+        else        
+            grounderIK.weight += (float) (2.5 * Time.deltaTime);
+        
+        anim.SetBool("Jump", jumping); 
+        anim.SetFloat("Speed", humanoid.CurSpd);
+        anim.SetBool("OnGround", gndCheck.Grounded);
+    }
+}