title: Player Movement using joystick based on camera facing
body: <p>I am developing an offline FPS multiplayer game.</p>
  
  <p>When the Player Rotation value is (0,0,0), then Player moves perfectly in direction. However, my problem is when I rotate the camera using touch input. The player can also rotate his face and press the joystick button for moving the player, but then the player should not move the direction the camera is facing.</p>
  
  <p><strong>My Joystick Script For Player</strong></p>
  
  <pre><code>public class VirtualJoystick : MonoBehaviour, IDragHandler, IPointerUpHandler,IPointerDownHandler {
  
      private Image bgImg;
      private Image JoyStickImage;
      private Vector3 InputVector;
  
      private void Start(){
          bgImg = GetComponent&lt;Image&gt; ();
          JoyStickImage = transform.GetChild (0).GetComponent&lt;Image&gt; ();
  
      }
  
      public virtual void OnDrag(PointerEventData ped){
          Vector2 pos;
          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);
  
              InputVector = new Vector3 (pos.x * 2 + 1, 0, pos.y * 2 - 1);
              InputVector = (InputVector.magnitude &gt; 1) ? InputVector.normalized : InputVector;
  
              JoyStickImage.rectTransform.anchoredPosition = new Vector3 (InputVector.x * (bgImg.rectTransform.sizeDelta.x / 2.5f),
                                                                          InputVector.z * (bgImg.rectTransform.sizeDelta.y / 2.5f));
  
  
          }
      }
  
      public virtual void OnPointerDown(PointerEventData ped){
  
          OnDrag (ped);
      }
  
      public virtual void OnPointerUp(PointerEventData ped){
  
          InputVector = Vector3.zero;
          JoyStickImage.rectTransform.anchoredPosition = Vector3.zero;
      }
  
      public float Horizontal(){
  
          if (InputVector.x != 0) {
              return InputVector.x;
          } else {
  
              return Input.GetAxis ("Horizontal");
          }
  
      }
      public float Vertical(){
  
          if (InputVector.z != 0)
              return InputVector.z;
          else
              return Input.GetAxis ("Vertical");
  
      }
  }
  </code></pre>
  
  <p><strong>My Camera Rotation Script Using Input Touch</strong></p>
  
  <pre><code>public class SwipeCam : MonoBehaviour {
  
      private Vector3 firstPoint;
      private Vector3 secondPoint;
      private float xAngle = 0.0f;
      private float yAngle = 0.0f;
      private float xAngleTemp = 0.0f;
      private float yAngleTemp = 0.0f;
  
      void Start(){
          xAngle = 0.0f;
          yAngle = 0.0f;
          this.transform.rotation = Quaternion.Euler (yAngle, xAngle, 0.0f);
  
      }
  
      void Update() {
  
          if (Input.touchCount &gt; 0) {
  
              for (int i = 0; i &lt; Input.touchCount; i++) {
  
                  Touch touch = Input.GetTouch (i);
  
                  if (touch.position.x &gt; Screen.width / 2) {
  
                      if (touch.phase == TouchPhase.Began) {
  
                          firstPoint = Input.GetTouch (0).position;
                          xAngleTemp = xAngle;
                          yAngleTemp = yAngle;
                      }
                      if (touch.phase == TouchPhase.Moved) { 
                          secondPoint = Input.GetTouch (0).position;
  
                          xAngle = xAngleTemp + (secondPoint.x - firstPoint.x) * 180.0f / Screen.width;
                          yAngle = yAngleTemp + (secondPoint.y - firstPoint.y) * 180.0f / -Screen.height;
  
                          yAngle = Mathf.Clamp (yAngle, -30f, 30f);
  
  
                          this.transform.rotation = Quaternion.Euler (yAngle, xAngle, 0.0f);
                          this.gameObject.GetComponentInParent&lt;FPScontroller&gt; ().transform.rotation = Quaternion.Euler (0.0f, xAngle, 0.0f);
                          //this.gameObject.GetComponentInParent&lt;FPScontroller&gt; ().transform.rotation = Quaternion.LookRotation(Vector3.forward,Vector3.up);
  
  
                      }
  
                  }
              }
          }
      }
  }
  </code></pre>
  
  <p>Where should I change my code to fix the facing the camera direction to player issue.</p>
  
  <p><strong>That is my Player Script (FPSController.cs)</strong></p>
  
  <pre><code>public class FPScontroller : MonoBehaviour {
  </code></pre>
  
  <p>.   // Should this script respond to input?
      public bool canControl = true;
      public GameObject lookObj; //This is root object that containc MainCamera, Weapons etc.
      public GameObject joystick;
      bool useFixedUpdate = false;</p>
  
  <pre><code>//Check when run, walk or when can run or not
  [HideInInspector]
  public bool Running ;
  [HideInInspector]
  public bool Walking;
  [HideInInspector]
  public bool canRun;
  [HideInInspector]
  public Vector3 rorationDir;
  
  //Ladder variables
  private GameObject mainCamera = null;
  [HideInInspector]
  public bool onLadder = false;
  //private float ladderHopSpeed = 6.0f;
  
  // For the next variables, @System.NonSerialized tells Unity to not serialize the variable or show it in the inspector view.
  // Very handy for organization!
  
  // The current global direction we want the character to move in.
  [System.NonSerialized]
  public Vector3 inputMoveDirection = Vector3.zero;
  
  // Is the jump button held down? We use this interface instead of checking
  // for the jump button directly so this script can also be used by AIs.
  [System.NonSerialized]
  public bool inputJump = false;
  
  [HideInInspector]
  public bool inputRun = false;
  
  [HideInInspector]
  public bool inputCrouch = false;
  
  [HideInInspector]
  public bool inputProne = false;
  
  [System.Serializable]
  public class  FPScontrollerMovement {
      // The maximum horizontal speed when moving
      [HideInInspector]
      public float maxForwardSpeed = 10.0f;
      [HideInInspector]
      public float maxSidewaysSpeed = 10.0f;
      [HideInInspector]
      public float maxBackwardsSpeed = 10.0f;
  
      //Run and walk variables
      public float WalkSpeed = 6.0f;
      public float RunSpeed = 9.0f;
      //Crouch
      public bool canCrouch = true;
      public float CrouchSpeed = 3.0f;
      public float crouchHeight = 1.5f;
      public float crouchSmooth = 8;
      //prone
      public bool canProne = true;
      public float ProneSpeed = 1.5f;
      public float proneHeight = 0.7f;
  
  
  
      // Curve for multiplying speed based on slope (negative = downwards)
      public AnimationCurve slopeSpeedMultiplier = new AnimationCurve(new Keyframe(-90, 1), new Keyframe(0, 1), new Keyframe(90, 0));
  
      // How fast does the character change speeds?  Higher is faster.
      public float maxGroundAcceleration = 30.0f;
      public float maxAirAcceleration = 20.0f;
  
      // The gravity for the character
      public float gravity = 10.0f;
      public float maxFallSpeed = 20.0f;
  
      [HideInInspector]
      public bool enableGravity = true;
  
      // For the next variables, @System.NonSerialized tells Unity to not serialize the variable or show it in the inspector view.
      // Very handy for organization!
  
      // The last collision flags returned from controller.Move
      [System.NonSerialized]
      public CollisionFlags collisionFlags;
  
      // We will keep track of the character's current velocity,
      [System.NonSerialized]
      public Vector3 velocity;
  
      // This keeps track of our current velocity while we're not grounded
      [System.NonSerialized]
      public Vector3 frameVelocity = Vector3.zero;
  
      [System.NonSerialized]
      public Vector3 hitPoint = Vector3.zero;
  
      [System.NonSerialized]
      public Vector3 lastHitPoint = new Vector3(Mathf.Infinity, 0, 0);
  }
  public FPScontrollerMovement movement = new FPScontrollerMovement();
  
      void Awake () {
      if (GetComponent&lt;NetworkView&gt; ().isMine) {
  
      joystick = GameObject.Find ("Joystick");
      controller = gameObject.GetComponent&lt;CharacterController&gt;();
      standartHeight = controller.height;
      /*if(GameObject.FindWithTag("LookObject") != null){
          lookObj = GameObject.FindWithTag("LookObject");
      }*/
      centerY = controller.center.y;
      tr = transform;
  
      canRun = true;
      canStand = true;
      StartCoroutine(setupBools());
  
      }
  }
  
      void Update () {
      if (GetComponent&lt;NetworkView&gt; ().isMine) {
          if (!useFixedUpdate) {
              UpdateFunction ();
          }
  
          movement.velocity.x = joystick.GetComponent&lt;VirtualJoystick&gt; ().Horizontal () * 5f;
          movement.velocity.z = joystick.GetComponent&lt;VirtualJoystick&gt; ().Vertical () * 5f;
  
  
  
          //Run input
          if (Input.GetAxis ("Vertical") &gt; 0.1f &amp;&amp; inputRun &amp;&amp; canRun &amp;&amp; !onLadder &amp;&amp; Walking) {
              if (canStand &amp;&amp; canStandCrouch) {
                  OnRunning ();
              }
          } else {
              OffRunning ();
          }   
  
          //Check when walk or not
          if ((movement.velocity.x &gt; 0.01f  || movement.velocity.z &gt; 0.01f) || (movement.velocity.x &lt; -0.01f || movement.velocity.z &lt; -0.01f)) {
              RunAnimation1 ();
              Debug.Log ("Forward");
              Walking = true;
          }else if (movement.velocity.x &gt; 0.01f) {
              Walking = true;
              Debug.Log ("Right");
          } else if (movement.velocity.x &lt; -0.01f) {
              Walking = true;
              Debug.Log ("Left");
          } else {
              RunAnimation ();
              Walking = false;
          }
  
  
          if (!canControl)
              return;
  
          if (movement.canCrouch) {
              if (!onLadder) {    
                  Crouch ();
              }
          }
  
          if (movement.canProne) {
              if (!onLadder) {    
                  Prone ();
              }
          }
  
          if (onLadder) {
              grounded = false;
              crouch = false;
              prone = false;
          }
  
          if (!crouch &amp;&amp; !prone &amp;&amp; controller.height &lt; standartHeight - 0.01f) {
              controller.height = Mathf.Lerp (controller.height, standartHeight, Time.deltaTime / movement.crouchSmooth);
              controller.center = new Vector3 (controller.center.x, Mathf.Lerp (controller.center.y, centerY, Time.deltaTime / movement.crouchSmooth), controller.center.z);
              lookObj.transform.localPosition = new Vector3 (lookObj.transform.localPosition.x, Mathf.Lerp (lookObj.transform.localPosition.y, standartHeight, Time.deltaTime / movement.crouchSmooth), lookObj.transform.localPosition.z);
          }
      }
  }
  
  void RunAnimation(){
      GetComponent&lt;NetworkView&gt; ().RPC ("SysnAnimation", RPCMode.All, 0);
  }
  void RunAnimation1(){
      GetComponent&lt;NetworkView&gt; ().RPC ("SysnAnimation", RPCMode.All, 1);
  }
  void RunAnimation2(){
      GetComponent&lt;NetworkView&gt; ().RPC ("SysnAnimation", RPCMode.All, 2);
  }
  
  [RPC]
  void SysnAnimation(int index){
      if (index == 0) {
          GetComponent&lt;Animator&gt; ().Play ("Idle Aim");
      } else if (index == 1) {
          GetComponent&lt;Animator&gt; ().Play ("Walk Aiming");
      } else if (index == 2) {
          GetComponent&lt;Animator&gt; ().Play ("Jump");
      }
  }
  
   void OnRunning (){
      Debug.Log ("Run");
      Running = true;
      movement.maxForwardSpeed = movement.RunSpeed;
      movement.maxSidewaysSpeed = movement.RunSpeed;
      //Make bigger extra height when player run to increase jump distance
      jumping.extraHeight = jumping.baseHeight + 0.15f;
  }
  
  void OffRunning (){
      Running = false;
      if(crouch || prone)
          return;
      movement.maxForwardSpeed = movement.WalkSpeed;
      movement.maxSidewaysSpeed = movement.WalkSpeed;
      movement.maxBackwardsSpeed = movement.WalkSpeed/2;
      //Change extraheight value to default when player walk
      jumping.extraHeight = jumping.baseHeight;
  }}
  </code></pre>