Store the forward and right vectors of the current camera.

Store the raw axis input from the controller (keyboard or joystick). These values will range from -1.0 to 1.0, corresponding to full left or right, or full forward or backwards. Note that if you use a joystick, the rate of change of these values will generally be much slower than if a keyboard is used, so the code that processes it must be adjusted accordingly.

Apply the raw input to transform the current camera basis vectors and compute a camera relative target direction vector.

Interpolate the current movement vector towards the target vector and damp the rate of change of the movement vector, storing the result away.

Compute the displacement of the camera with movement * movespeed and apply this to the camera.

Rotate the camera to the current move direction vector.

Right click on the Chapter1 assets folder and select Create New C# Script. Name it PlayerControls.cs. Add this script to GameObject of Player1 by dragging-and-dropping it onto the object.

Add a CharacterController component to the player's GameObject component as well. If Unity asks you whether you want to replace the box collider, agree to the change.

Create public Vector3 moveDirection that will be used to store the current actual direction vector of the player. We initialize it to the zero vector by default as follows:

public Vector3 moveDirection = Vector3.zero;

Create three public float variables: rotateSpeed, moveSpeed, and speedSmoothing. The first two are coefficients of motion for rotation and translation, and the third is a factor that influences the smoothing of moveSpeed. Note that moveSpeed is private because this will only be computed as the result of the smoothing calculation between moveDirection and targetDirection as shown in the following code:

public Float rotateSpeed;
private float moveSpeed = 0.0f;
public float speedSmoothing = 10.0f;

Inside the update loop of this script, we will call a custom method called UpdateMovement(). This method will contain the code that actually reads input from the user and moves the player in the game as shown in the following code:

void Update() {
  UpdateMovement()
}

Above the update loop, let's implement the UpdateMovement() method as follows:

void UpdateMovement () { 
  // to be filled in
}

Inside this method, step 1 is accomplished by storing the horizontal projection of the forward and right vectors of the current camera as follows:

Vector3 cameraForward = Camera.mainCamera.transform.TransformDirection
(Vector3.forward); 

We project onto the horizontal plane because we want the character's motion to be parallel to the horizontal plane rather than vary with the camera's angle. We also use Normalize to ensure that the vector is well formed, as shown in the following code:

cameraForward.y = 0.0f; 
cameraForward.Normalize(); 

Also, note the trick whereby we find the right vector by flipping the x and z components and negating the last component. This is faster than extracting and transforming the right vector, but returns the same result shown in the following code:

Vector3 cameraRight = new Vector3
(cameraForward.z, 0.0f, -cameraForward.x); 

We store the raw axis values from Unity's Input class. Recall that this is the class that handles input for us, from which we can poll button and axes values. For h (which has a range from -1 to 1), the value between this range corresponds to an amount of horizontal displacement on the analog stick, joystick, or a keypress, as shown in the following code:

float v = Input.GetAxisRaw("Vertical"); 

For v (which ranges from -1 to 1), the value between this range corresponds to an amount of vertical displacement of the analog stick, joystick, or a different keypress.

float h = Input.GetAxisRaw("Horizontal"); 

We compute the target direction vector for the character as proportional to the user input (v, h). By transforming (v, h) into camera space, the result is a world space vector that holds a camera relative motion vector that we store in targetDirection as shown in the following code:

Vector3 targetDirection =
 h * cameraRight + v * cameraForward; 

If this target vector is non-zero (when the user is moving, and hence v, h are non-zero), we update moveDirection by rotating it smoothly (and by a small magnitude), towards moveTarget. By doing this in every frame, the actual direction eventually approximates the target direction, even as targetDirection itself changes.

We keep moveDirection normalized because our move speed calculation assumes a unit direction vector as shown in the following code:

moveDirection = Vector3.RotateTowards 
(moveDirection, targetDirection, rotateSpeed * Mathf.Deg2Rad * Time.deltaTime, 1000);
moveDirection = moveDirection.normalized; 

We smoothly LERP the speed of our character up and down, trailing the actual magnitude of the targetDirection vector. This is to create an appealing effect that reduces jitter in the player and is crucial when we are using keyboard controls, where the variance in v and h raw data is at its highest, as shown in the following code:

float curSmooth = 
speedSmoothing * Time.deltaTime;
float targetSpeed = Mathf.Min
(targetDirection.magnitude, 1.0f);
moveSpeed = Mathf.Lerp 
(moveSpeed, targetSpeed, curSmooth);

We compute the displacement vector for the player in this frame with movementDirection * movespeed (remember that movespeed is smoothly interpolated and moveDirection is smoothly rotated toward targetDirecton).

We scale displacement by Time.delta time (the amount of real time that has elapsed since the last frame). We do this so that our calculation is time dependent rather than frame rate dependent as shown in the following code:

Vector3 displacement = 
moveDirection * moveSpeed * Time.deltaTime;

Then, we move the character by invoking the move method on the CharacterController component of the player, passing the displacement vector as a parameter as follows:

this.GetComponent<CharacterController>()
.Move(displacement);

Finally, we assign the rotation of MoveDirection to the rotation of the transform as follows:

transform.rotation = Quaternion.LookRotation (moveDirection);