title: PlayerMovement And CameraFollow
body: <p>I am making a thirdperson Unity game. I think that I'm almost done but I just can't figure out how to make so the WASD control is relative to the camera?
  Right now when I'm moving with WASD it works, but if i start to rotate the camera by using mouse, suddenly my (W) button makes the player walk backwards and left button (A) goes right. All controls are just bugging.
  This is my PlayerMovement.cs and CameraFollow.cs:</p>
  
  <p>PlayerMovement:</p>
  
  <pre><code>    public float speed = 6f;            // The speed that the player will move at.
  
      Vector3 movement;                   // The vector to store the direction of the player's movement.
      Animator anim;                      // Reference to the animator component.
      Rigidbody playerRigidbody;          // Reference to the player's rigidbody.
      int floorMask;                      // A layer mask so that a ray can be cast just at gameobjects on the floor layer.
      float camRayLength = 100f;          // The length of the ray from the camera into the scene.
  
      void Awake ()
      {
          // Create a layer mask for the floor layer.
          floorMask = LayerMask.GetMask ("Floor");
  
          // Set up references.
          anim = GetComponent &lt;Animator&gt; ();
          playerRigidbody = GetComponent &lt;Rigidbody&gt; ();
      }
  
  
      void FixedUpdate ()
      {
          // Store the input axes.
          float h = CrossPlatformInputManager.GetAxisRaw("Horizontal");
          float v = CrossPlatformInputManager.GetAxisRaw("Vertical");
  
          // Move the player around the scene.
          Move (h, v);
  
          // Turn the player to face the mouse cursor.
          Turning ();
  
          // Animate the player.
          Animating (h, v);
  
          Shooting ();
      }
  
  
      void Move (float h, float v)
      {
          // Set the movement vector based on the axis input.
          movement.Set (h, 0f, v);
  
          // Normalise the movement vector and make it proportional to the speed per second.
          movement = movement.normalized * speed * Time.deltaTime;
  
          // Move the player to it's current position plus the movement.
          playerRigidbody.MovePosition (transform.position + movement);
      }
  
  
      void Turning ()
      {
          // Create a ray from the mouse cursor on screen in the direction of the camera.
          Ray camRay = Camera.main.ScreenPointToRay (Input.mousePosition);
  
          // Create a RaycastHit variable to store information about what was hit by the ray.
          RaycastHit floorHit;
  
          // Perform the raycast and if it hits something on the floor layer...
          if(Physics.Raycast (camRay, out floorHit, camRayLength, floorMask))
          {
              // Create a vector from the player to the point on the floor the raycast from the mouse hit.
              Vector3 playerToMouse = floorHit.point - transform.position;
  
              // Ensure the vector is entirely along the floor plane.
              playerToMouse.y = 0f;
  
              // Create a quaternion (rotation) based on looking down the vector from the player to the mouse.
              Quaternion newRotatation = Quaternion.LookRotation (playerToMouse);
  
              // Set the player's rotation to this new rotation.
              playerRigidbody.MoveRotation (newRotatation);
          }
      }
  
  
      void Animating (float h, float v)
      {
          // Create a boolean that is true if either of the input axes is non-zero.
          bool walking = h != 0f || v != 0f;
  
          // Tell the animator whether or not the player is walking.
          anim.SetBool ("IsWalking", walking);
      }
  
  
      void Shooting ()
      {
          // Create a boolean that is true if either of the input axes is non-zero.
          bool shooting = (Input.GetMouseButtonDown(0));
  
          // Tell the animator whether or not the player is walking.
          anim.SetBool ("IsShooting", shooting);
      }
  </code></pre>
  
  <p>CameraFollow:</p>
  
  <pre><code>// Camera target to look at.
  public Transform target;
  
  // Exposed vars for the camera position from the target.
  public float height = 20f;
  public float distance = 20f;
  
  // Camera limits.
  public float min = 10f;
  public float max = 60;
  
  // Rotation.
  public float rotateSpeed = 1f;
  
  // Options.
  public bool doRotate;
  public bool doZoom;
  
  // The movement amount when zooming.
  public float zoomStep = 30f;
  public float zoomSpeed = 5f;
  private float heightWanted;
  private float distanceWanted;
  
  // Result vectors.
  private Vector3 zoomResult;
  private Quaternion rotationResult;
  private Vector3 targetAdjustedPosition;
  
  void Start(){
      // Initialise default zoom vals.
      heightWanted = height;
      distanceWanted = distance;
  
      // Setup our default camera.  We set the zoom result to be our default position.
      zoomResult = new Vector3(0f, height, -distance);
  }
  
  void LateUpdate(){
      // Check target.
      if( !target ){
          Debug.LogError("This camera has no target, you need to assign a target in the inspector.");
          return;
      }
  
      if( doZoom ){
          // Record our mouse input.  If we zoom add this to our height and distance.
          float mouseInput = Input.GetAxis("Mouse ScrollWheel");
          heightWanted -= zoomStep * mouseInput;
          distanceWanted -= zoomStep * mouseInput;
  
          // Make sure they meet our min/max values.
          heightWanted = Mathf.Clamp(heightWanted, min, max);
          distanceWanted = Mathf.Clamp(distanceWanted, min, max);
  
          height = Mathf.Lerp(height, heightWanted, Time.deltaTime * zoomSpeed);
          distance = Mathf.Lerp(distance, distanceWanted, Time.deltaTime * zoomSpeed);
  
          // Post our result.
          zoomResult = new Vector3(0f, height, -distance);
      }
  
      if( doRotate ){
          // Work out the current and wanted rots.
          float currentRotationAngle = transform.eulerAngles.y;
          float wantedRotationAngle = target.eulerAngles.y;
  
          // Smooth the rotation.
          currentRotationAngle = Mathf.LerpAngle(currentRotationAngle, wantedRotationAngle, rotateSpeed * Time.deltaTime);
  
          // Convert the angle into a rotation.
          rotationResult = Quaternion.Euler(0f, currentRotationAngle, 0f);
      }
  
      // Set the camera position reference.
      targetAdjustedPosition = rotationResult * zoomResult;
      transform.position = target.position + targetAdjustedPosition;
  
      // Face the desired position.
      transform.LookAt(target);
  }
  </code></pre>