Footsteps Not Working When Running

Welcome to the future :T

FootSteps.cs

 using UnityEngine;
 
 [RequireComponent( typeof(AudioSource) )]
 [RequireComponent( typeof(CharacterController) )]
 [AddComponentMenu( "CharacterPlayer/FootstepGrass" )]
 public class FootSteps : MonoBehaviour
 {
     public AudioClip[] ground;
     public float audioStepLengthWalk = 0.45f;
     public float audioStepLengthRun = 0.82f;
     float _nextStepTime = 0;
     bool _colliderTagCheck;
     AudioSource _audioSource;
     CharacterController _characterController;
 
     void Awake ()
     {
         _audioSource = GetComponent<AudioSource>();
         _characterController = GetComponent<CharacterController>();
     }
 
     void FixedUpdate ()
     {
         if( _colliderTagCheck && Time.time>_nextStepTime )
         {
             float speed = _characterController.velocity.magnitude;
             if( _characterController.isGrounded && speed>5 )
             {
                 _audioSource.clip = ground[ Random.Range(0,ground.Length) ];
                 _audioSource.volume = 0.1f;
                 _audioSource.Play();
                 
                 bool isRunning = Input.GetKey( KeyCode.LeftShift );
                 _nextStepTime = Time.time + ( isRunning ? audioStepLengthRun : audioStepLengthWalk );
             }
         }
     }
 
     void OnControllerColliderHit ( ControllerColliderHit hit )
     {
         _colliderTagCheck = hit.gameObject.CompareTag("Ground") || hit.gameObject.CompareTag("Grass");
     }
 
 }

PlayerScript.cs

 using UnityEngine;
 
 [RequireComponent( typeof(CharacterController) )]
 [AddComponentMenu("CharacterPlayer/PlayerScript")]
 public class PlayerScript : MonoBehaviour
 {
 
     public float walkSpeed = 6.0f;
     public float runSpeed = 11.0f;
     float crouchSpeed = 3.0f;
 
     // If true, diagonal speed (when strafing + moving forward or back) can't exceed normal move speed; otherwise it's about 1.4 times faster
     public bool limitDiagonalSpeed = true;
 
     // If checked, the run key toggles between running and walking. Otherwise player runs if the key is held down and walks otherwise
     // There must be a button set up in the Input Manager called "Run"
     public bool enableRun = true;
     public bool enableCrouch = true;
 
     public float jumpSpeed = 8.0f;
     public float gravity = 20.0f;
 
     public bool enableFallingDammage = true;
     // Units that player can fall before a falling damage function is run. To disable, type "infinity" in the inspector
     public float fallingDamageThreshold = 10.0f;
     public float fallingDammageMultiplier = 2f;
 
     // If the player ends up on a slope which is at least the Slope Limit as set on the character controller, then he will slide down
     public bool slideWhenOverSlopeLimit = false;
 
     // If checked and the player is on an object tagged "Slide", he will slide down it regardless of the slope limit
     public bool slideOnTaggedObjects = false;
 
     public float slideSpeed = 12.0f;
 
     // If checked, then the player can change direction while in the air
     public bool airControl = false;
 
     // Small amounts of this results in bumping when walking down slopes, but large amounts results in falling too fast
     public float antiBumpFactor = .75f;
 
     // Player must be grounded for at least this many physics frames before being able to jump again; set to 0 to allow bunny hopping 
     public int antiBunnyHopFactor = 1;
 
     Vector3 moveDirection = Vector3.zero;
     bool grounded = false;
     CharacterController _controller;
     Transform myTransform;
     float speed;
     float fallStartLevel;
     bool falling = false;
     float slideLimit;
     float rayDistance;
     Vector3 contactPoint;
     bool playerControl = false;
     int jumpTimer;
 
     void Start ()
     {
         _controller = GetComponent<CharacterController>();
         myTransform = transform;
         speed = walkSpeed;
         rayDistance = _controller.height * .5f + _controller.radius;
         slideLimit = _controller.slopeLimit - .1f;
         jumpTimer = antiBunnyHopFactor;
     }
 
     void FixedUpdate ()
     {
         float inputX = Input.GetAxis("Horizontal");
         float inputY = Input.GetAxis("Vertical");
         // If both horizontal and vertical are used simultaneously, limit speed (if allowed), so the total doesn't exceed normal move speed
         float inputModifyFactor = (inputX!=0f && inputY!=0f && limitDiagonalSpeed)? .7071f : 1.0f;
 
         if( grounded )
         {
             var sliding = false;
             // See if surface immediately below should be slid down. We use this normally rather than a ControllerColliderHit point,
             // because that interferes with step climbing amongst other annoyances
             RaycastHit hit;
             if( Physics.Raycast( myTransform.position , Vector3.down , out hit , rayDistance ) )
             {
                 if( Vector3.Angle(hit.normal, Vector3.up) > slideLimit)
                     sliding = true;
             }
             // However, just raycasting straight down from the center can fail when on steep slopes
             // So if the above raycast didn't catch anything, raycast down from the stored ControllerColliderHit point instead
             else
             {
                 if( Physics.Raycast( contactPoint + Vector3.up, -Vector3.up, out hit ) )
                     if( Vector3.Angle(hit.normal, Vector3.up)>slideLimit )
                         sliding = true;
             }
             
             // If we were falling, and we fell a vertical distance greater than the threshold, run a falling damage routine
             if( falling )
             {
                 falling = false;
                 if( myTransform.position.y < fallStartLevel - fallingDamageThreshold && enableFallingDammage==true)
                     ApplyFallingDamage (fallStartLevel - myTransform.position.y);
             }
             
             if( Input.GetKey(KeyCode.LeftShift) && enableRun==true)
             {
                 speed = runSpeed;
             } 
             
             else if( Input.GetKey(KeyCode.C) && enableCrouch==true)
             {
                 speed = crouchSpeed;
             }
             
             else
             { 
                 speed = walkSpeed;
             }
 
             // If sliding (and it's allowed), or if we're on an object tagged "Slide", get a vector pointing down the slope we're on
             if( ( sliding && slideWhenOverSlopeLimit ) || ( slideOnTaggedObjects && hit.collider.CompareTag("Slide") ) )
             {
                 var hitNormal = hit.normal;
                 moveDirection = new Vector3( hitNormal.x , -hitNormal.y , hitNormal.z );
                 Vector3.OrthoNormalize( ref hitNormal , ref moveDirection );
                 moveDirection *= slideSpeed;
                 playerControl = false;
             }
             // Otherwise recalculate moveDirection directly from axes, adding a bit of -y to avoid bumping down inclines
             else
             {
                 moveDirection = new Vector3( inputX * inputModifyFactor , -antiBumpFactor , inputY * inputModifyFactor );
                 moveDirection = myTransform.TransformDirection(moveDirection) * speed;
                 playerControl = true;
             }
 
             // Jump! But only if the jump button has been released and player has been grounded for a given number of frames
             if( !Input.GetButton("Jump") )
             {
                 jumpTimer++;
             }
             else if( jumpTimer>=antiBunnyHopFactor )
             {
                 moveDirection.y = jumpSpeed;
                 jumpTimer = 0;
             }
         }
         else
         {
             // If we stepped over a cliff or something, set the height at which we started falling
             if( !falling )
             {
                 falling = true;
                 fallStartLevel = myTransform.position.y;
             }
 
             // If air control is allowed, check movement but don't touch the y component
             if( airControl && playerControl )
             {
                 moveDirection.x = inputX * speed * inputModifyFactor;
                 moveDirection.z = inputY * speed * inputModifyFactor;
                 moveDirection = myTransform.TransformDirection(moveDirection);
             }
         }
 
         // Apply gravity
         moveDirection.y -= gravity * Time.deltaTime;
 
         // Move the controller, and set grounded true or false depending on whether we're standing on something
         grounded = (_controller.Move(moveDirection * Time.deltaTime) & CollisionFlags.Below)!=0;
     }
 
     // Store point that we're in contact with for use in FixedUpdate if needed
     void OnControllerColliderHit ( ControllerColliderHit hit )
     {
         contactPoint = hit.point;
     }
 
     // If falling damage occured, this is the place to do something about it. You can make the player
     // have hitpoints and remove some of them based on the distance fallen, add sound effects, etc.
     void ApplyFallingDamage ( float fallDistance )
     {
         gameObject.SendMessage( "ApplyDamage", fallDistance * fallingDammageMultiplier );
         //    ^    replcace this with a direct call, something like:
         //        HealtScript.ApplyDamage( fallDistance * fallingDammageMultiplier );
 
         Debug.Log($"Ouch! Fell {fallDistance} units!");
     }
 
 }