Creating E-Learning Games with Unity

For every frame that our camera updates, if we have a valid trackObj GameObject reference, do the following:

Linearly interpolate from current facing to desired facing according to a dampening factor.

Linearly interpolate from current height to desired height according to another dampening factor.

Place the camera behind the track object, at the interpolated angle, facing the track object so that the object of interest can be seen in view, as shown in the following screenshot:

Right click on the Chapter1 assets folder and select Create New C# Script. Name it GameCam and add it to the Main Camera object.

Create a public GameObject reference called TrackObj with the following code. This will point to the GameObject that this camera is tracking at any given time, as shown in the following code:

public GameObject trackObj;

Create the following four public float variables that will allow adjustment of the camera behavior in the object inspector. We will leave these uninitialized and then find working default values with the inspector, as shown in the following code:

Public float height; 
Public float desiredDistance;
Public float heightDamp; 
Public float rotDamp; 

Recall that the Update() loop of any GameObject gets called repeatedly while the game simulation is running, which makes this method a great candidate in which we can put our main camera logic. Hence, inside the Update() loop of this script, we will call a UpdateRotAndTrans() custom method, which will contain the actual camera logic. We will place this logic inside the UpdateRotAndTrans() method. This method will update the rotation (facing angle) and translation (position) of the camera in the world; this is how GameCam will accomplish the stated goal of moving in the world and tracking the player:

void Update() { 
  UpdateRotAndTrans(); 
} 

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

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

Inside this method, step 1 of our algorithm is accomplished with a sanity check on trackObj. By checking for null and reporting an error to debugLog, we can make catching bugs much easier by looking at the console. This is shown in the following code:

if (trackObj) { 
} 
else { 
  Debug.Log("GameCamera:Error,trackObj invalid");
}

Step 2 of our algorithm is to store the desired rotation and height in two local float variables. In the case of the height, we offset the height of trackObj by an exposed global variable height so that we can adjust the specifics of the object as shown in the following code (sometimes an object may have its transform 0 at the ground plane, which would not look pleasing, we need numbers to tweak):

DesiredRotationAngle = trackObj.transform.eulerAngles.y; 
DesiredHeight = trackObj.transform.position.y + height; 

We also need to store the local variants of the preceding code for processing in our algorithm. Note the simplified but similar code compared to the code in the previous step. Remember that the this pointer is implied if we don't explicitly place it in front of a component (such as transform):

float RotAngle = transform.eulerAngles.y; 
float Height = transform.position.y; 

Step 3 of our algorithm is where we do the actual LERP (linear interpolation) of the current and destination values for y-axis rotation and height. Remember that making use of the LERP method between two values means having to calculate a series of new values between the start and end that differs between one another by a constant amount.

Remember that Euler angles are the rotation about the cardinal axes, and Euler y indicates the horizontal angle of the object. Since these values change, we smooth out the current rotation and height more with a smaller dampening value, and we tighten the interpolation with a larger value.

Also note that we multiply heightDamp by Time.deltaTime in order to make the height interpolation frame rate independent, and instead dependent on elapsed time, as follows:

RotAngle = Mathf.LerpAngle 
(RotAngle, DesiredRotationAngle, rotDamp); 
Height = Mathf.Lerp 
(Height, DesiredHeight, heightDamp * Time.deltaTime); 

The fourth and last step in our GameCam algorithm is to compute the position of the camera.

Now that we have an interpolated rotation and height, we will place the camera behind trackObject at the interpolated height and angle. To do this, we will take the facing vector of trackObject and scale it by the negative value of desiredDistance to find a vector pointing in the opposite direction to trackObject; doing this requires us to convert eulerAngles to Quaternion to simplify the math (we can do it with one API function!).

Adding this to the trackObject position and setting the height gives the desired offset behind the object, as shown in the following code:

Quaternion CurrentRotation = Quaternion.Euler 
(0.0f, RotAngle, 0.0f);
Vector3 pos = trackObj.transform.position; 
pos -= 
CurrentRotation * Vector3.forward * desiredDistance; 
pos.y = Height; 
transform.position = pos;

As a final step, we point the LookAt GameObject reference of the camera to the center of trackObject so that it is always precisely in the middle of the field of view. It is most important to never lose the object you are tracking in a 3D game. This is critical!

transform.LookAt (trackObj.transform.position);

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);