Animator Scripting - Unity Official Tutorials

In this lesson we will be addressing

some of the more common uses of the animator class.

For complete documentation on the animator class

see the documentation linked below.

In order to affect transitions between the states

of an animator controller we need to set the

animator parameters to appropriate values.

To do this we need to use some of the

functions of the animator class.

Here we have a scene with a model Ethan in it.

Ethan has an animator component

and a script called Ethan Script attached.

The animator component is using a

controller named EthanController.

If we open EthanController

we can see that there are 4 states.

Idle, Walk, Run and Jump.

Additionally there are 2 parameters.

A float named Speed and a

trigger named Jump.

the controller is setup in such a way

that Ethan will transition from Idle to Walk

to Run based on the Speed parameter.

Furthermore, if the Jump parameter is triggered

while Ethan is running Ethan will enter

a Jump state.

All of the animations of the Ethan model

are controlled by these 2 parameters,

which we will now learn to control

with our Ethan script.

Inside the Ethan Script we first need to create

an animator variable named anim

to contain our animator object.

We get a reference to this animator object

in the start method by typing

anim = GetComponent

For further details on the GetComponent function

see the lesson linked below.

Are animator controller is setup

so that the Speed parameter will dictate

which moving animation is being played.

We can use the player's input to

control that behaviour.

The first thing we will need to do is create

a float variable which we will call Move

in the update method.

Then we will set the Move variable

equal to the vertical input axis

by typing Input.GetAxis

and in parenthesis we will parse the string Vertical.

Next we will want to parse the

value of the Move variable to the

Speed attribute of the animator controller.

This is done with the SetFloat function

of the animator class.

We are using SetFloat because Speed

is a float parameter.

If it had been a Boolean parameter

we would use SetBool.

If had been a trigger parameter we would use

SetTrigger and so on.

For each of these functions there are

multiple ways that they can be called.

The most common way is to first parse

in the name of the parameter you are setting

as a string.

Then the next item is the value

you wish to set that parameter to.

In this instance we will call the SetFloat

method of our animator variable by typing

anim.SetFloat

and then in parenthesis the string Speed

and our variable Move.

Back in Unity we can run our scene.

We can see that if we press the W key

or the up arrow our model now moves.

The Speed parameter and the movement

animation played is now controlled by the player.

Parsing in a string name for the

parameter we wish to set can be inefficient

because it means that the animator needs to

evaluate the string every time it is called.

A faster way of setting parameter values

is by using hashIDs.

Each string that an animator can use is

given a hashID.

This is an integer value that is unique

for every different string.

We can store this value and then set

parameters using this ID instead.

To do this, first we will need

to store the value.

Let's create an integer variable named jumpHash

to store the hashID in.

We get the value for our hash variable by

calling the static method of the animator class

string to hash.

Since this method is static we access it

by typing Animator.StringToHash.

In the parenthesis we parse in the string

we wish to know the hashID value of.

In order to make our model jump

we will need to set the Jump trigger parameter

in the animator controller.

In our case we want to make the model jump

whenever we press the space bar.

So we will start by typing

if Input.GetKeyDown and then in the parenthesis

we will use KeyCode.Space.

Inside our if statement we will set

the Jump trigger parameter using the

anim.SetTrigger method.

Inside the parenthesis we will

parse our jumpHash variable.

Remember that this variable contains

the hasID of our Jump parameter.

Note that since Jump is a trigger

we do not need to also parse in a value.

Back in Unity we can run our scene.

Notice that while we are running we can also

press the spacebar to jump.

We have now utilised both our

float parameter Speed and our

trigger parameter Jump to make our model

more dynamic.

Occasionally, when writing the logic

behind animation we may want to

find out what state the controller is in.

Let's say for example we want to be able to

set the Jump trigger only when the model

is in the Run state.

The animator has some functions that we can call

to find out what state the controller

is currently in.

We can do this by creating an

animator state info variable

which we will call StateInfo.

The animator state info class

stores the name, name hash,

and various other pieces of information

about a state.

We will set our state info variable equal

to the anim.GetCurrentAnimatorStateInfo function.

Inside the parenthesis we will parse the index

of the layer we want to know more about.

Since we are dealing with the base layer

we will parse in a 0.

Again we could compare the current

animation states name with a string

but since it is more efficient to compare

hashIDs let's do that instead.

We will start by creating an integer named

runStateHash and setting it equal to our

Animator.StringToHash function.

We will parse in to the parenthesis

the string Base Layer.Run

We have to include the base layer. part

because we can have states of the same name

on different layers.

Now we can modify our if statement

to also only allow our model to jump

if stateInfo.nameHash

equals our runStateHash variable.