Adding the Humanoid Ethan to a Scene

Let's begin by adding a character asset to our scene.
To do this, above the center pane, click on the asset store, then type in Standard Assets and click Download.
Next click Import, which will pop uo the Import Unity Package window, and on which you should click Import again. Then get a coffee because it takes a while for this import to happen.
Now under your Project Pane click on Assets - Standard Assets - Characters - ThirdPersonCharacter - Prefabs, you should be able to see ThirdPersonController and drag it into your scene hierarchy.
We can then move Ethan around in our scene to get in the center pane a scene that looks like:
You'll notice in the Inspector that Ethan's scale is 1. But how tall is he? This is important to know because one cause of VR sickness is that things don't have their usual real work scale.
One way to estimate his scale is to move a unit cube next to him and see how many cubes high he is by scaled the cube's y dimension. It turns out he is around 1.6ish cubes high. If a cube were a meter high then this is roughly the height of an average human relative to the default cube.

Making Ethan Intelligent

If we go back to the asset folder, where we found Ethan, you'll notice there was also an AIThirdPersonController. Let's drag it into our scene hierarchy and mess around with it.
First, we can rename it Ethan.
One way to move this Ethan to where our old one was, is to select the ThirdPersonController (old Ethan) from our Hierarchy pane then click the Gear icon next to Transform and click Copy Component. Next select the new Ethan's Transform Gear and choose Paste Component Values.
We can then delete the old Ethan from the scene hierarchy and now just use the new one.
The new Ethan under Inspector has a Nav Mesh Agent component which controls how it moves around the scene.
Beneath this is a component AI Character Control Script which takes a target object where Ethan will walk to.
We can set this up as follows:
1. First, we click on Create in our Hierarchy pane, and choose Create Empty. This creates an empty game object. We rename it WalkTarget.
2. We set this object's Transform's position to `(0,0,0)`.
3. Then select Ethan then drag WalkTarget from the Hierarchy to the Target value of the AI Character Control Script component.
The idea is when we run the game, wherever WalkTarget is Ethan will walk there.

Using NavMesh

Before we can get Ethan to move around, we need to specify where he's allowed to go.
To do this we define a NavMesh -- a simplified geometrical plane that enables a character to plot path around obstacles.
To set this up, we first go to the main menu and select Window - AI - Navigation. This adds as a tab next to the Inspector tab, a new tab pane Navigation:
Select its Object sub tab, then click on the Plane in our Hierarchy Pane.
In the Navigation Pane one can then check the Navigation Static checkbox:
We can repeat this process for each of the objects that might get in Ethan's way.
Finally, we click on the Navigation Pane's Bake tab and click the Back button, to compile all this stuff.
You'll see that in the Game Window, it has now converted the region into a graph, which could be used for planning with an algorithm like `A^\star` how Nathan should go from where he is to his target:
We can test out the motion by clicking on the Game button above the Center pane and then clicking the Play button:

Scripting Motion

Okay, let's see how we can script the motion of Ethan.
One way to make Ethan appear to be walking around randomly, is to get Ethan to walk towards a target, but change that target every few seconds.
To create a script, we select WalkTarget in our Hierarchy Panel.
In its Inspector, we click on Add Component, select New Script, and name it RandomPosition.
Click Create and Add. This script will appear in your Assets pane at the top level. You can then make a new folder for Scripts and drag it there.

Double click on the C# file and let's edit it, so that it contains:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class RandomPosition : MonoBehaviour
{
    // Start is called before the first frame update
    void Start()
    {
        StartCoroutine(RepositionWithDelay()); 
    }
    IEnumerator RepositionWithDelay()
    {
        while (true)
        {
            SetRandomPosition();
            yield return new WaitForSeconds(5);
        }
    }
    void SetRandomPosition ()
    {
        float x = Random.Range(-5.0f, 5.0f);
        float z = Random.Range(-5.0f, 5.0f);
        Debug.Log("X,Z:" + x.ToString("F2") + ", " + z.ToString("F2"));
        transform.position = new Vector3(x, 0.0f, z);
    }
}

The script defines a subclass of MonoBehavior, the class used to control Navigation.
Such a class usually has two methods Start() (to set up the behavior) and Update() (called before each redraw). In our case, we only use Start.
We then set a coroutine RepositionWithDelay (a coroutine is method which runs till it hits yield, then goes back to its caller, when called again resumes from where left off).
Finally, this coroutine waits 5 seconds and then calls SetRandomPosition to move Ethan.
Debug.Log's are printed to the console as they happen when the scene is run.

Quiz

Which of the following statements is true?

Human VOR roll gain is small because we can tilt our heads left and right to make a roll movement, but can't do the same with our eyes.
Retinal image slip does not occur when wearing a VR headset.
Unity does not support texture maps.

Making Ethan Move to Where Looking

Let's try a different way of scripting Ethan's motion -- let's make Ethan move to where we are looking.
First, let's add a new script by repeating what we just did to add RandomPosition, but this time call the new script LookMoveTo. We should set the ground under the WalkTarget's Script to Plane:
We can move it into our Scripts folder under assets as before.

Into it, let's add the code:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class LookMoveTo : MonoBehaviour
{
    public GameObject ground;

    // Update is called once per frame
    void Update()
    {
        Transform camera = Camera.main.transform;
        Ray ray;
        RaycastHit hit;
        GameObject hitObject;
        Debug.DrawRay(camera.position, 
            camera.rotation * Vector3.forward * 100.0f);
        ray = new Ray(camera.position, camera.rotation * Vector3.forward);
        if (Physics.Raycast (ray, out hit))
        {
            hitObject = hit.collider.gameObject;
            if (hitObject == ground)
            {
                Debug.Log("Hit (x,y,z) :" + hit.point.ToString("F2"));
                transform.position = hit.point;
            }
        }
    }
}

Clicking save on our scene and then going to File Build and Run, we can test it out.
To understand what its doing, we not the code above first declares a public GameObject ground field, since it is public, we can assign GameObjects to it in the Inspector for aur WalkTarget that makes use of the Look Move To Script.
Unlike before, we are now overriding only the Update method.
Camera.main always refers to the current active camera object in our scene. Its transform component gets us its matrix.
We then create a Ray from the camera position and orientation in the forward direction.
Physics.Raycast then take this ray and determines if it hits and objects.
If the hit object is the ground, we set the WalkTarget (transform) object's position, to the place of intersection.
We now have two Debug statements. The Debug.DrawRay will draw a ray in the given direction of the given length in Scene View.

Adding a Where Looking Cursor

We can add a cursor to the scene to indicate where we are looking, by going to the hierarchy panel and selecting Walking Target.
Right click and choose to add a 3D Object - Cylinder.
Select this cylinder and change its scale to be `(0.4, 0.05, 0.4)`
Then disable its Capsule Collider.
If we save, build and run, this will make a horizontal disk that tracks where we are looking.
By applying a X rotation of 90 degrees we could make it look more like a cursor if we wanted.

Making Raycasting More Robust

The Physics.Raycast method we have been using returns the first object the ray hits.
What if it hits a different object first before the ground? This can cause our cylinder to get stuck.

To fix this we can modify our previous Update method as follows:

    void Update()
    {
        Transform camera = Camera.main.transform;
        Ray ray;
        RaycastHit[] hits;
        GameObject hitObject;
        Debug.DrawRay(camera.position, 
            camera.rotation * Vector3.forward * 100.0f);
        ray = new Ray(camera.position, camera.rotation * Vector3.forward);
        hits = Physics.RaycastAll(ray);
        for( int i = 0; i < hits.Length; i++) {
            RaycastHit hit = hits[i];
            hitObject = hit.collider.gameObject;
            if (hitObject == ground) {
                Debug.Log("Hit (x,y,z) :" + hit.point.ToString("F2"));
                transform.position = hit.point;
            }
        }
    }

Annihilating Objects

Let's make a script that shows a particle effect when we look at Ethan, and if we look for more than three seconds causes him to explode.
We'll then have Ethan respawn at a random new location.
First, we attach a new script KillTarget to a GameController object, by adding an empty game object to our hierarchy, then using Add Component to this object in Inspector, renaming things as we go.

Next we add to our script the following code:


public class KillTarget : MonoBehaviour
{
    public GameObject target;
    public ParticleSystem hitEffect;
    public GameObject killEffect;
    public float timeToSelect = 3.0f;
    public int score;

    private float countDown;
    // Start is called before the first frame update
    void Start()
    {
        score = 0;
        countDown = timeToSelect;
    }
    // Update is called once per frame
    void Update()
    {
        Transform camera = Camera.main.transform;
        Ray ray = new Ray(camera.position, camera.rotation * Vector3.forward);
        RaycastHit hit;
        if (Physics.Raycast(ray, out hit) &&
            (hit.collider.gameObject == target))
        {
            if (countDown > 0.0f) {
                countDown -= Time.deltaTime;
                hitEffect.transform.position = hit.point;
                hitEffect.Play();
            } else {
                Instantiate(killEffect, target.transform.position,
                    target.transform.rotation);
                score += 1;
                countDown = timeToSelect;
                SetRandomPosition();
            }
        } else {
            countDown = timeToSelect;
            hitEffect.Stop();
        }
    }
    void SetRandomPosition()
    {
        float x = Random.Range(-5.0f, 5.0f);
        float z = Random.Range(-5.0f, 5.0f);
        /* Notice not quite the code as before, now we change target's (Ethan )
          position */
        target.transform.position = new Vector3(x, 0.0f, z);
    }
}

Next back in Unity, we want to populate the public variables of our script.
We drag from the Hierarchy, Ethan over for the Target.
From the Main Menu bar, select GameObject - Effects - Particle System to add it to our Hierarchy Pane. Rename it Spark Emitter.
Select GameController and drag Spark Emitter over for the Hit Effect.
Under the Project Pane - Assets - Standard Assets - Particle Systems
In the Project Pane find Explosion, under Assets - Standard Assets - ParticleSystems - Prefabs and drag it onto Kill Effect.
Kill Target should now look like:
The SparkEmitter by default emits sparks as if from the point of a cone upwards (like maybe a fire would emit particles). To change this we can select the SparkEmitter in the Hierarchy Panel, under Particle System we might tweak the size and other properties of the particle, under Emission we can tweak the rate that particles are created, and under Shape we can switch the shape to Sphere and set its radius.
We can now Save the Scene and Build and Run.

Unity Avatars, Gaze-based Control, Scripting Unity

Outline

Introduction