9 min read

In this article by, Abdelrahman Saher and Francesco Sapio, from the book, Unity 5.x 2D Game Development Blueprints, we will learn how to create and play animations for the player character to see as Unity controls the player and other elements in the game. The following is what we will go through:

(For more resources related to this topic, see here.)

  • Animating sprites
  • Integrating animations into animators
  • Continuing our platform game

Animating sprites

Creating and using animation for sprites is a bit easier than other parts of the development stage. By using animations and tools to animate our game, we have the ability to breathe some life into it. Let’s start by creating a running animation for our player. There are two ways of creating animations in Unity: automatic clip creation and manual clip creation.

Automatic clip creation

This is the recommended method for creating 2D animations. Here, Unity is able to create the entire animation for you with a single-click.

If you navigate in the Project Panel to Platformer Pack | Player | p1_walk, you can find an animation sheet as a single file p1_walk.png and a folder of a PNG image for each frame of the animation. We will use the latter. The reason for this is because the single sprite sheet will not work perfectly as it is not optimized for Unity.

In the Project Panel, create a new folder and rename it to Animations. Then, select all the PNG images in Platformer Pack | Player | p1_walk | PNG and drop them in the Hierarchy Panel:

A new window will appear that will give us the possibility to save them as a new animation in a folder that we chose. Let’s save the animation in our new folder titled Animations as WalkAnim:

After saving the animation, look in the Project Panel next to the animation file. Now, there is another asset with the name of one of the dropped sprites. This is an Animator Controller and, as the name suggests, it is used to control the animation. Let’s rename it to PlayerAnimator so that we can distinguish it later on.

In the Hierarchy panel, a game object has been automatically created with the original name of our controller. If we select it, the Inspector should look like the following:

You can always add an Animator component to a game object by clicking on Add Component | Miscellaneous | Animator.

As you can see, below the Sprite Renderer component there is an Animator component. This component will control the animation for the player and is usually accessed through a custom script to change the animations. For now, drag and drop the new controller PlayerAnimator on to our Player object.

Manual clip creation

Now, we also need a jump animation for our character. However, since we only have one sprite for the player jumping, we will manually create the animation clip for it.

To achieve this, select the Player object in the Hierarchy panel and open the Animation window from Window | Animation. The Animation window will appear, as shown in the screenshot below:

As you can see, our animation WalkAnim is already selected. To create a new animation clip, click on where the text WalkAnim is. As a result, a dropdown menu appears and here you can select Create New Clip. Save the new animation in the Animations folder as JumpAnim.

On the right, you can find the animation timeline. Select from the Project Panel the folder Platformer Pack/Player. Drag and drop the sprite p1_jump on the timeline. You can see that the timeline for the animation has changed. In fact, now it contains the jumping animation, even if it is made out of only one sprite. Finally, save what we have done so far.

The Animation window’s features are best used to make fine tunes for the animation or even merging two or more animations into one.

Now the Animations folder should look like this in the Project panel:

By selecting the WalkAnim file, you will be able to see the Preview panel, which is collocated at the bottom of the Inspector when an object that may contain animation is selected. To test the animation, drag the Player object and drop it in the Preview panel and hit play:

In the Preview panel, you can check out your animations without having to test them directly from code. In addition, you can easily select the desired animation and then drag the animation into a game object with the corresponding Animator Controller and dropping it in the Preview panel.

The Animator

In order to display an animation on a game object, you will be using both Animator Components and Animator Controllers. These two work hand in hand to control the animation of any animated object that you might have, and are described below:

  • Animator Controller uses a state-machine to manage the animation states and the transitions between one another, almost like a flow chart of animations.
  • Animator Component uses an Animator Controller to define which animation clips to use and applies them on the game object when needed. It also controls the blending and the transitions between them.

Let’s start modifying our controller to make it right for our character animations. Click on the Player and then open the Animator window from Window | Animator. We should see something like this:

This is a state-machine, although it is automatically generated. To move around the grid, hold the middle mouse button and drag around.

First, let’s understand how all the different kinds of nodes work:

  • Entry node (marked green): It is used when transitioning into a state machine, provided the required conditions were met.
  • Exit node (marked red): It is used to exit a state machine when the conditions have been changed or completed. By default, it is not present, as there isn’t one in the previous image.
  • Default node (marked orange): It is the default state of the Animator and is automatically transitioned to from the entry node.
  • Sub-state nodes (marked grey): They are also called custom nodes. They are used typically to represent a state for an object where an event will occur (in our case, an animation will be played).
  • Transitions (arrows): They allow state machines to switch between one another by setting the conditions that will be used by Animator to decide which state will be activated.

To keep things organized, let’s reorder the nodes in the grid. Drag the three sub-states just right under the Entry node. Order them from left to right WalkAnim, New Animation, and JumpAnim. Then, right-click on New Animation and choose Set as Layer Default State. Now, our Animator window should look like the following:

To edit a node, we need to select it and modify it as needed in the Inspector. So, select New Animation and the Inspector should be like the screenshot below:

Here, we can have access to all the properties of the state or node New Animation. Let’s change its name to Idle. Next, we need to change the speed of the state machine, which controls how fast the animation will be played. Next, we have Motion which refers to the animation that will be used for this state. After we have changed the name, save the scene, and this is what everything should look like now:

We can test what we have done so far, by hitting play. As we can see in the Game view, the character is not animated. This is because the character is always in the Idle state and there are no transitions to let him change state. While the game is in runtime, we can see in the Animator window that the Idle state is running. Stop the game, and right-click on the WalkAnim node in the Animator window. Select from the menu Set as Layer Default State. As a result, the walking animation will be played automatically at the beginning of the game.

If we press the play button again, we can notice that the walk animation is played, as shown in the screenshot below:

You can experiment with the other states of the Animator. For example, you can try to set JumpAnim as the default animation or even tweak the speed of each state to see how they will be affected.

Now that we know the basics of how the Animator works, let’s stop the playback and revert the default state to the Idle state.

To be able to connect our states together, we need to create transitions. To achieve this, right-click on the Idle state and select Make Transition which turns the mouse cursor into an arrow. By clicking on other states, we can connect them with a transition. In our case, click on the WalkAnim state to make a transition from the Idle state to the WalkAnim state. The animator window should look like the following:

If we click on the arrow, we can have access to its properties in the Inspector, as shown in the following screenshot:

The main properties that we might want to change are:

  • Name (optional): We can assign a name to the transition. This is useful to keep everything organized and easy to access. In this case, let’s name this transition Start Walking.
  • Has Exit Time: Whether or not the animation should be played to the end before exiting its state when the conditions are not being met anymore.
  • Conditions: The conditions that should be met so that the transition takes place.

Let’s try adding a condition and see what happens:

When we try to create a condition for our transition, the following message appears next to Parameter does not exist in Controller which means that we need to add parameters that will be used for our condition.

To create a parameter, switch to Parameters in the top left of the Animator window and add a new float using the + button and name it PlayerSpeed, as shown in the following screenshot:

Any parameters that are created in the Animator are usually changed from code and those changes affect the state of animation. In the following screenshot, we can see the PlayerSpeed parameter on the left side:

Now that we have created a parameter, let’s head back to the transition.

Click the drop down button next to the condition we created earlier and choose the parameter PlayerSpeed. After choosing the parameter, another option appears next to it. You can either choose Greater or Less, which means that the transition will happen when this parameter is respectively less than X or greater than X. Don’t worry, as that X will be changed by our code later on.

For now, choose Greater and set the value to 1, which means that when the player speed is more than one, the walk animation starts playing.

You can test what we have done so far and change the PlayerSpeed parameter in runtime.


This wraps up everything that we will cover in this article. So far, we have added animations to our character to be played according to the player controls.

Resources for Article:

Further resources on this subject:

Subscribe to the weekly Packt Hub newsletter. We'll send you the results of our AI Now Survey, featuring data and insights from across the tech landscape.


Please enter your comment!
Please enter your name here