c# Mobile Joystick issues - implementing joystick controls into movement and camera script

I am trying to build a first person mobile game and i need some assistance.

I am having some issues with my mobile joysticks. I have 2 joysticks, one for movement and one for the camera. They both are not working

Here is the movement and camera script all in one (which may be one of the issues, not sure..)

 using System;
 using UnityEngine;
 using UnityStandardAssets.CrossPlatformInput;
 using UnityStandardAssets.Utility;
 using Random = UnityEngine.Random;
 
 namespace UnityStandardAssets.Characters.FirstPerson
 {
     [RequireComponent(typeof (CharacterController))]
     [RequireComponent(typeof (AudioSource))]
     public class FirstPersonController : MonoBehaviour
     {
         [SerializeField] private bool m_IsWalking;
         [SerializeField] private float m_WalkSpeed;
         [SerializeField] private float m_RunSpeed;
         [SerializeField] [Range(0f, 1f)] private float m_RunstepLenghten;
         [SerializeField] private float m_JumpSpeed;
         [SerializeField] private float m_StickToGroundForce;
         [SerializeField] private float m_GravityMultiplier;
         [SerializeField] private MouseLook m_MouseLook;
         [SerializeField] private bool m_UseFovKick;
         [SerializeField] private FOVKick m_FovKick = new FOVKick();
         [SerializeField] private bool m_UseHeadBob;
         [SerializeField] private CurveControlledBob m_HeadBob = new CurveControlledBob();
         [SerializeField] private LerpControlledBob m_JumpBob = new LerpControlledBob();
         [SerializeField] private float m_StepInterval;
         [SerializeField] private AudioClip[] m_FootstepSounds;    
         [SerializeField] private AudioClip m_JumpSound;           
         [SerializeField] private AudioClip m_LandSound;           
 
         private Camera m_Camera;
         private bool m_Jump;
         private float m_YRotation;
         private Vector2 m_Input;
         private Vector3 m_MoveDir = Vector3.zero;
         private CharacterController m_CharacterController;
         private CollisionFlags m_CollisionFlags;
         private bool m_PreviouslyGrounded;
         private Vector3 m_OriginalCameraPosition;
         private float m_StepCycle;
         private float m_NextStep;
         private bool m_Jumping;
         private AudioSource m_AudioSource;
 
         // Use this for initialization
         private void Start()
         {
             m_CharacterController = GetComponent<CharacterController>();
             m_Camera = Camera.main;
             m_OriginalCameraPosition = m_Camera.transform.localPosition;
             m_FovKick.Setup(m_Camera);
             m_HeadBob.Setup(m_Camera, m_StepInterval);
             m_StepCycle = 0f;
             m_NextStep = m_StepCycle/2f;
             m_Jumping = false;
             m_AudioSource = GetComponent<AudioSource>();
             m_MouseLook.Init(transform , m_Camera.transform);
         }
 
 
         
         private void Update()
         {
             RotateView();
             // the jump state needs to read here to make sure it is not missed
             if (!m_Jump)
             {
                 m_Jump = CrossPlatformInputManager.GetButtonDown("Jump");
             }
 
             if (!m_PreviouslyGrounded && m_CharacterController.isGrounded)
             {
                 StartCoroutine(m_JumpBob.DoBobCycle());
                 PlayLandingSound();
                 m_MoveDir.y = 0f;
                 m_Jumping = false;
             }
             if (!m_CharacterController.isGrounded && !m_Jumping && m_PreviouslyGrounded)
             {
                 m_MoveDir.y = 0f;
             }
 
             m_PreviouslyGrounded = m_CharacterController.isGrounded;
         }
 
 
         private void PlayLandingSound()
         {
             m_AudioSource.clip = m_LandSound;
             m_AudioSource.Play();
             m_NextStep = m_StepCycle + .5f;
         }
 
 
         private void FixedUpdate()
         {
             float speed;
             GetInput(out speed);
             Vector3 desiredMove = transform.forward*m_Input.y + transform.right*m_Input.x;
 
             RaycastHit hitInfo;
             Physics.SphereCast(transform.position, m_CharacterController.radius, Vector3.down, out hitInfo,
                                m_CharacterController.height/2f, Physics.AllLayers, QueryTriggerInteraction.Ignore);
             desiredMove = Vector3.ProjectOnPlane(desiredMove, hitInfo.normal).normalized;
 
             m_MoveDir.x = desiredMove.x*speed;
             m_MoveDir.z = desiredMove.z*speed;
 
 
             if (m_CharacterController.isGrounded)
             {
                 m_MoveDir.y = -m_StickToGroundForce;
 
                 if (m_Jump)
                 {
                     m_MoveDir.y = m_JumpSpeed;
                     PlayJumpSound();
                     m_Jump = false;
                     m_Jumping = true;
                 }
             }
             else
             {
                 m_MoveDir += Physics.gravity*m_GravityMultiplier*Time.fixedDeltaTime;
             }
             m_CollisionFlags = m_CharacterController.Move(m_MoveDir*Time.fixedDeltaTime);
 
             ProgressStepCycle(speed);
             UpdateCameraPosition(speed);
 
             m_MouseLook.UpdateCursorLock();
         }
 
 
         private void PlayJumpSound()
         {
             m_AudioSource.clip = m_JumpSound;
             m_AudioSource.Play();
         }
 
 
         private void ProgressStepCycle(float speed)
         {
             if (m_CharacterController.velocity.sqrMagnitude > 0 && (m_Input.x != 0 || m_Input.y != 0))
             {
                 m_StepCycle += (m_CharacterController.velocity.magnitude + (speed*(m_IsWalking ? 1f : m_RunstepLenghten)))*
                              Time.fixedDeltaTime;
             }
 
             if (!(m_StepCycle > m_NextStep))
             {
                 return;
             }
 
             m_NextStep = m_StepCycle + m_StepInterval;
 
             PlayFootStepAudio();
         }
 
 
         private void PlayFootStepAudio()
         {
             if (!m_CharacterController.isGrounded)
             {
                 return;
             }
             int n = Random.Range(1, m_FootstepSounds.Length);
             m_AudioSource.clip = m_FootstepSounds[n];
             m_AudioSource.PlayOneShot(m_AudioSource.clip);
             m_FootstepSounds[n] = m_FootstepSounds[0];
             m_FootstepSounds[0] = m_AudioSource.clip;
         }
 
 
         private void UpdateCameraPosition(float speed)
         {
             Vector3 newCameraPosition;
             if (!m_UseHeadBob)
             {
                 return;
             }
             if (m_CharacterController.velocity.magnitude > 0 && m_CharacterController.isGrounded)
             {
                 m_Camera.transform.localPosition =
                     m_HeadBob.DoHeadBob(m_CharacterController.velocity.magnitude +
                                       (speed*(m_IsWalking ? 1f : m_RunstepLenghten)));
                 newCameraPosition = m_Camera.transform.localPosition;
                 newCameraPosition.y = m_Camera.transform.localPosition.y - m_JumpBob.Offset();
             }
             else
             {
                 newCameraPosition = m_Camera.transform.localPosition;
                 newCameraPosition.y = m_OriginalCameraPosition.y - m_JumpBob.Offset();
             }
             m_Camera.transform.localPosition = newCameraPosition;
         }
 
 
         private void GetInput(out float speed)
         {
             
             float horizontal = CrossPlatformInputManager.GetAxis("Horizontal");
             float vertical = CrossPlatformInputManager.GetAxis("Vertical");
 
             bool waswalking = m_IsWalking;
 
 #if !MOBILE_INPUT
             m_IsWalking = !Input.GetKey(KeyCode.LeftShift);
 #endif
             
             speed = m_IsWalking ? m_WalkSpeed : m_RunSpeed;
             m_Input = new Vector2(horizontal, vertical);
 
            
             if (m_Input.sqrMagnitude > 1)
             {
                 m_Input.Normalize();
             }
 

             if (m_IsWalking != waswalking && m_UseFovKick && m_CharacterController.velocity.sqrMagnitude > 0)
             {
                 StopAllCoroutines();
                 StartCoroutine(!m_IsWalking ? m_FovKick.FOVKickUp() : m_FovKick.FOVKickDown());
             }
         }
 
 
         private void RotateView()
         {
             m_MouseLook.LookRotation (transform, m_Camera.transform);
         }
 
 
         private void OnControllerColliderHit(ControllerColliderHit hit)
         {
             Rigidbody body = hit.collider.attachedRigidbody;
           
             if (m_CollisionFlags == CollisionFlags.Below)
             {
                 return;
             }
 
             if (body == null || body.isKinematic)
             {
                 return;
             }
             body.AddForceAtPosition(m_CharacterController.velocity*0.1f, hit.point, ForceMode.Impulse);
         }
     }
 }
 

Here is the Joystick script I have been using for the movement of the player

     using System.Collections;
     using System.Collections.Generic;
     using UnityEngine;
     using UnityEngine.UI;
     using UnityEngine.EventSystems;
     
     public class VirtualJoystick : MonoBehaviour, IDragHandler, IPointerUpHandler, IPointerDownHandler
     {
     
         private Image bgImg;
         private Image joystickImg;
     
         public Vector3 InputDirection { set; get; }
     
         private void Start()
         {
             bgImg = GetComponent<Image>();
             joystickImg = transform.GetChild(0).GetComponent<Image>();
             InputDirection = Vector3.zero;
         }
     
         public virtual void OnDrag(PointerEventData ped)
         {
             Vector2 pos = Vector2.zero;
             if(RectTransformUtility.ScreenPointToLocalPointInRectangle
                 (bgImg.rectTransform,
                     ped.position,
                     ped.pressEventCamera,
                     out pos))
             {
                 pos.x = (pos.x / bgImg.rectTransform.sizeDelta.x);
                 pos.y = (pos.y / bgImg.rectTransform.sizeDelta.y);
     
                 float x = (bgImg.rectTransform.pivot.x == 1) ? pos.x * 2 + 1 : pos.x * 2 - 1;
                 float y = (bgImg.rectTransform.pivot.y == 1) ? pos.y * 2 + 1 : pos.y * 2 - 1;
     
                 InputDirection = new Vector3(x, 0, y);
     
                 InputDirection = (InputDirection.magnitude > 1) ? InputDirection.normalized : InputDirection;
     
                 joystickImg.rectTransform.anchoredPosition =
                     new Vector3(InputDirection.x * (bgImg.rectTransform.sizeDelta.x / 3)
                         , InputDirection.z * (bgImg.rectTransform.sizeDelta.y / 3));
             }
         }
         
         public virtual void OnPointerDown(PointerEventData ped)
         {
             OnDrag(ped);
         }
     
         public virtual void OnPointerUp(PointerEventData ped)
         {
             InputDirection = Vector3.zero;
             joystickImg.rectTransform.anchoredPosition = Vector3.zero;
         }
     }
 

so, what i want is the player to be able to use the joysticks to move the player and move the camera with joysticks that i have already setup. I cannot figure out what i have done wrong, i need some code assistance.

thank you

also I have tired to do this... and it did not work.

  using UnityEngine
  using System.Collections;
  using System.Collections.Generic;
  using UnityStandardAssets.CrossPlatformInput;
  public class PlayerMovement : MonoBehaviour 
  {
  public float moveSpeed = 2.0f;
  public float moveHorizontal = 2.0f;
  public float moveVertical = 2.0f;
  
  private void Update () 
    {      
        float moveHorizontal = Input.GetAxisRaw ("Horizontal");
        float moveVertical = Input.GetAxisRaw ("Vertical");

           if( moveHorizontal != 0.0f )
         {
        Vector3 movement = new Vector3(moveHorizontal, 0.0f, 0); 
        transform.rotation = Quaternion.Slerp(transform.rotation, Quaternion.LookRotation(-movement), 0.15F);
         }
           if( moveVertical != 0.0f )
         {
        Vector3 movement = new Vector3(moveVertical, 0.0f, 0); 
        transform.rotation = Quaternion.Slerp(transform.rotation, Quaternion.LookRotation(-movement), 0.15F);
         }
    }
  }