Hey guys! These tutorials have been very helpful! I ran into an issue I can seem to fix. My character that has animations doesn't move forward but can strafe left and right. But my model w/o animations (I used it to test) can go forward without an issue. Not sure what is happening since they are using the same script. Any suggestions?

My Third Person Controller so far:
Code:
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class ThirdPersonController : MonoBehaviour {

    //static so we can access from multiple scripts
    public static CharacterController CharacterController;

    //hold reference to a current instance of itself
    public static ThirdPersonController Instance;

    public bool ClimbEnabled { get; set; }

    void Awake()
    {
        //assign references to start with
        CharacterController = GetComponent("CharacterController") as CharacterController;
        Instance = this;

        ThirdPersonCamera.ExistingOrCreateNewCamera();
    }

    // Use this for initialization
    void Start () {
		
	}
	
	// Update is called once per frame
	void Update () {

        //checking to see if there is a camera in the scene
        if (Camera.main == null)
        {
            return;
        }

        //calling method
        GetLocomotionInput();
        HandleActionInput();

        ThirdPersonMotor.Instance.UpdateMotor();
	}

    void GetLocomotionInput()
    {
        var deadZone = 0.1f;
        ThirdPersonMotor.Instance.VerticalVel = ThirdPersonMotor.Instance.MoveVector.y;

        ThirdPersonMotor.Instance.MoveVector = Vector3.zero;

        if(Input.GetAxis("Vertical") > deadZone || Input.GetAxis("Vertical") <-deadZone)
        {
            ThirdPersonMotor.Instance.MoveVector += new Vector3(0, 0, Input.GetAxis("Vertical"));
                
        }

        if (Input.GetAxis("Horizontal") > deadZone || Input.GetAxis("Horizontal") < -deadZone)
        {
            ThirdPersonMotor.Instance.MoveVector += new Vector3(Input.GetAxis("Horizontal"), 0, 0);

        }

        //determine which direction state we should be in based off moveVector
        Animator_TP.Instance.DetermineCurrentMoveDir();
    }

    void HandleActionInput()
    {
        if (Input.GetButton("Jump"))
        {
            if (ClimbEnabled)
            {
                Climb();
            }
            else
            {
                Jump();
            }
        }

        if (Input.GetKeyDown(KeyCode.A))
        {
            Use();
        }
    }

   public void Jump()
    {
        ThirdPersonMotor.Instance.Jump();
        Animator_TP.Instance.Jump();
    }

    void Use()
    {
        Animator_TP.Instance.Use();
    }

    void Climb()
    {
        Animator_TP.Instance.Climb();
    }


   }
Third person motor:
Code:
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class ThirdPersonMotor : MonoBehaviour {
    //the brain of all the player scripts

    public static ThirdPersonMotor Instance;

    public float ForwardSpeed = 10f; // 10 meters per second
    public float BackwardSpeed = 2f; 
    public float StrafingSpeed = 5f;
    public float SlideSpeed = 10f;

    public float JumpSpeed = 6f;
    public float Gravity = 21f;
    public float TerminalVel = 20f;
    public float SlideThreshold = 0.6f;
    public float MaxCtrlSlideMag = 0.4f;

    private Vector3 slideDirection;

    //take in inputs and convert over to motion
    public Vector3 MoveVector { get; set; }

    public float VerticalVel { get; set; }
    public bool IsSliding { get; set; }

    // Use this for initialization
    void Awake()
    {
        Instance = this; //assign to instance of this class when created, when game runs
    }


    // Use this for initialization
    void Start () {
  
	}
	
	// Not the same as "Update"
	public void UpdateMotor () {

        SnapAlignCharacterCamera();
        ProcessMotion();
    }

    private void Update()
    {
     
    }

    void ProcessMotion()
    {
       
            //transform MoveVector into world space relative to characters rotation
            MoveVector = transform.TransformDirection(MoveVector);

            //normalize MoveVector if Magnitude > 1
            if (MoveVector.magnitude > 1)
            {
                MoveVector = Vector3.Normalize(MoveVector);
            }

            //Apply sliding if applicable
            ApplySlide();

            //Multiply MoveVector by MoveSpeed
            MoveVector *= MoveSpeed();

            //Reapply verticalVel to MoveVector.y
            MoveVector = new Vector3(MoveVector.x, VerticalVel, MoveVector.z);

            //Apply gravity
            ApplyGravity();

            //move the character in world space
            ThirdPersonController.CharacterController.Move(MoveVector * Time.deltaTime);
        }
    

    void ApplyGravity()
    {
       

            if (MoveVector.y > -TerminalVel)
            {
                //apply gravity
                MoveVector = new Vector3(MoveVector.x, MoveVector.y - Gravity * Time.deltaTime, MoveVector.z);
            }

            if (ThirdPersonController.CharacterController.isGrounded && MoveVector.y < -1)
            {
                MoveVector = new Vector3(MoveVector.x, -1, MoveVector.z);
            }
        
    }

    void ApplySlide()
    {
        if (!ThirdPersonController.CharacterController.isGrounded)
        {
            return;
        }

        slideDirection = Vector3.zero;

        RaycastHit hitInfo;

        if (Physics.Raycast(transform.position + Vector3.up, Vector3.down, out hitInfo))
        {
            if(hitInfo.normal.y < SlideThreshold)
            {
                slideDirection = new Vector3(hitInfo.normal.x, -hitInfo.normal.y, hitInfo.normal.z);

                if (!IsSliding)
                {
                    Animator_TP.Instance.Slide();
                }

                IsSliding = true;
            }
            else
            {
                //if y is greater than slide threshold, not sliding
                IsSliding = false;
            }
        }

        if (slideDirection.magnitude < MaxCtrlSlideMag)
        {
            MoveVector += slideDirection;
        }else
        {
            MoveVector = slideDirection;
        }
    }

    public void Jump()
    {
        if (ThirdPersonController.CharacterController.isGrounded)
        {
            VerticalVel = JumpSpeed;
        }
    }

    void SnapAlignCharacterCamera()
    {
        //going to look if player is moving
        //if player is moving its going to align character with direction of camera

        if(MoveVector.x !=0 || MoveVector.z != 0)
        {
            transform.rotation = Quaternion.Euler(transform.eulerAngles.x,
                Camera.main.transform.eulerAngles.y,
                transform.eulerAngles.z);
        }
    }

   float MoveSpeed()
    {
        var moveSpeed = 0f;

        switch (Animator_TP.Instance.MoveDirection)
        {
            case Animator_TP.Direction.Stationary:
                moveSpeed = 0;
                break;
            case Animator_TP.Direction.Forward:
                moveSpeed = ForwardSpeed;
                break;
            case Animator_TP.Direction.Backward:
                moveSpeed = BackwardSpeed;
                break;
            case Animator_TP.Direction.Left:
                moveSpeed = StrafingSpeed;
                break;
            case Animator_TP.Direction.Right:
                moveSpeed = StrafingSpeed;
                break;
            case Animator_TP.Direction.LeftForward:
                moveSpeed = ForwardSpeed;
                break;
            case Animator_TP.Direction.RightForward:
                moveSpeed = ForwardSpeed;
                break;
            case Animator_TP.Direction.LeftBackward:
                moveSpeed = BackwardSpeed;
                break;
            case Animator_TP.Direction.RightBackward:
                moveSpeed = BackwardSpeed;
                break;

        }
        
        if(IsSliding)
        {
            moveSpeed = SlideSpeed;
        }

        return moveSpeed;
    }
}