Set up a 2D player character

Create a basic 2D gameplay environment

Read keyboard input to control 2D character movement

Create Input Actions for player character movement

Make your game frame rate independent

By the end of this unit, you will be able to do the following:

Move the player character using Unity’s Input System.

Configure your game to be frame rate independent.

Player character and movement

Welcome to 2D Beginner: Adventure Game

Design and paint your game tilemap

Create decorative objects using sprites

Implement object collisions for your 2D game

Set up tilemap collision

Set up a basic health system

Create a health collectible using triggers

Check character health before destroying collectibles

Add damage zones to decrease health (static hazards)

Create a health display with UI Toolkit

Display character health on the UI

Add an enemy character

Create 2D sprite animations

Play animations based on game data

Implement projectiles for the player 

Configure projectiles to affect the enemy

Display character dialogue using raycasting

Implement a dynamic camera

Add game audio

Create 2D particle effects

Get started with hand-drawn animation

Build and share your game

An engaging world to explore is a critical aspect of your 2D adventure game. In this unit, you’ll take your tilemap from placeholder to fully-realized game environment and implement basic physics so the player character can begin to interact with it.

Game environment and physics

Health is the key stat that players need to keep track of in your game. In this unit, you’ll set up a functional health system and configure objects to increase and decrease the player character’s health.

Health system

You’ve set up a health system, but at the moment the player has no way to know what their character’s health actually is. In this unit unit, you’ll create a heads-up display (HUD) interface and configure it to show the player character’s health level.

Heads-up UI display

In this unit you’ll work on adding enemies and interaction mechanics to bring your game to life. 

By the end of the unit, you’ll do the following:

Implement projectiles to attack the enemies.

Add a friendly NPC to share a message with the player character.

Characters and interaction mechanics

You’ve created a functional 2D adventure game, but it’s not finished yet. In this unit, you’ll enhance the overall player experience with a dynamic camera, game audio, and visual effects. You’ll then build your game.

Enhance and polish

Immerse yourself in the world of game development with this comprehensive 2D Beginner Adventure Game project, designed to guide you through the fundamentals of creating an interactive experience. Follow along  step by step to create your own 2D adventure game, with a choice of assets and options for customization along the way. 

Explore more 2D assets including 2D characters, textures, GUIs, and more on the Unity Asset Store.

2D Beginner: Adventure Game

50e5d2c4-b8d2-51c6-8d12-e2a84a1cc4f7:d4iGoW1sBVoVWhMgZMEMIf

Overview

The Input System package and your game

Read input from a keyboard

Apply horizontal movement to the player character

Challenge: Set up vertical movement using keyboard input

Check your script

Next steps

silentvideo7.mp4

The player character can move, but at the moment it does so whenever you test the game. Now you need to configure it to move only when the player provides specific input.

By the end of this tutorial, you’ll be able to do the following:

Read the current state of a player input device (keyboard).

Apply horizontal and vertical movement to a GameObject in response to keyboard input.

Player input is a critical part of most games, whatever the players actually control. In 2D Beginner: Adventure Game, the player will control character movement around the full environment that you create using an input device. Unity has a package that can help you do this: the Input System.

This tutorial is part of Beginner 2D: Adventure Game, but you might find it useful if you want to create a 2D character controller that works using Unity’s Input System package. For further guidance on using the package, refer to the Input System package documentation.

Important: If you are working in your own 2D Unity project, make sure that you have installed the Input System package before you continue with this tutorial.

For the purposes of this tutorial, we chose to use the Ruby’s Adventure asset set, and the file paths used in instructions will reflect this. If you chose another asset set, the file names will  be the same, but in your corresponding theme folder. 

You’re going to use Unity’s Input System package to allow your player to control the movement of their character in your game. The Input System is a flexible and relatively new system that you can use to allow players to control content in Unity with any kind of input device. 

For this game, you’re going to focus on a keyboard as the input device, but as you become more experienced you will be able to create more flexible input configurations and allow players to remap the controls that they use to play your game.

The Input System enables you to define particular Input Actions and bind them to controls on an input device. An Input Action is something that the player can do in the game; running, jumping, or interacting with an object, for example. When the player interacts with a control that is bound to a particular Input Action in the correct way, that action will occur in the game. 

For example, you might decide that the player character should jump whenever the player interacts with a particular control (a key on a keyboard, for example). To do this, you would need to create an Input Action for jumping, and then bind it to your chosen control.

In these tutorials, we’re going to guide you through setting up your 2D adventure game for keyboard input by default. However, you can also bind alternative inputs to the Input Actions that you define — you don’t need to write additional code to make this work for your game.


We’ve decided to guide you through a very basic approach to working with player input for 2D Beginner: Adventure Game. There are additional tools in the Input System that you can use to work with inputs in more efficient ways, including Input Action Assets and the Player Input component. However, the workflows for these tools require more scripting than the beginner approach that we have chosen for this course.

If you are a more experienced developer, you can find more information about these tools and workflows in the Input System package documentation. 

At the moment, the PlayerController script that you’ve written adds 0.1 to the PlayerCharacter GameObject’s horizontal position every frame of the game. However, you need to change this script so that PlayerCharacter responds to inputs from the arrow keys on the keyboard instead.

Let’s start by reading input directly from the player’s keyboard. To update the PlayerController script, follow these instructions:

1.  Open the PlayerController script in your IDE. 

Note: Remember you can find the PlayerController script in the Project window, in the Scripts folder.

2.  At the top of the script, beneath the existing namespaces declarations and before the class declaration, add the following instruction:

This instruction tells the computer that the script needs to use the Input System package features and functionality.

3.  Go to the Update function and add the following instruction on a new line at the top of the code block:

This instruction declares a new float variable called horizontal and sets its value to 0.0. Remember, the semicolon at the end of the instruction is vital; it tells the computer when one instruction ends and the next one begins

Important: Make sure that you add the instruction inside the Update function’s braces.

5.  Add the following code directly below the declaration of the horizontal variable:

if (Keyboard.current.leftArrowKey.isPressed)
{

horizontal = -1.0f;

}


Take a moment to consider what you learned when you first set up this script before you read on. What do you think this instruction is telling the computer to do?

This instruction begins with if. If statements are logical conditions that tell the computer what to do if a particular condition has been fulfilled.

The instruction uses the dot operator to check if the Left arrow key on the keyboard is currently pressed.

If the Left arrow key is being pressed when the instruction is executed, the variable that you just created is set to -1.0 (movement left along the x-axis).

else if (Keyboard.current.rightArrowKey.isPressed)
{

horizontal = 1.0f;

}


Based on the previous conditional statement you added, what do you think this one does?

This code begins with else if, a conditional statement that is run if the condition for the first if statement has not been met. 

If the Right arrow key is being pressed when this instruction is executed, the variable that you just created is set to 1.0 (movement right along the x-axis).

If neither of the conditions are met (that is, if neither the left nor the Right arrow key is being pressed) then the variable will remain set to 0.0 and the player character will remain stationary.

7.  Leave one line clear and add the following instruction directly below the conditional statement:

This instruction prints the value of your float variable to the Console window in the Unity Editor.

Now that you have set up your script to read keyboard inputs for horizontal movement, follow these instructions to apply that movement to the player character:

1.  Underneath the code you have just added, find the position.x = position.x + 0.1f line and update the instruction as follows:

position.x = position.x + 0.1f * horizontal;

This instruction now sets the Position X-value to the current position plus 0.1 multiplied by the value of the variable horizontal. This will set the variable’s value to the following:

Left arrow key pressed: current position + (0.1 * -1)

Right arrow key pressed: current position + (0.1 * 1)

No key pressed: current position + (0.1 * 0)

Note: Using the WASD keys will not move the player character, as the added code only applies to the arrow keys.

3.  Return to Unity Editor and enter Play Mode to test your updated script. Remember to exit Play mode when you’re done.

Before you continue, check that your updated Update function matches the reference code below:

void Update()
{
    float horizontal = 0.0f;
    if (Keyboard.current.leftArrowKey.isPressed)
    {
        horizontal = -1.0f;
    }
    else if (Keyboard.current.rightArrowKey.isPressed)
    {
        horizontal = 1.0f;
    }
    
    Debug.Log(horizontal);



    Vector2 position = transform.position;
    position.x = position.x + 0.1f * horizontal;
    transform.position = position;
}


Note: If you added vertical movement as an extension when you first set up this script, you may have additional lines of code in your script.

Now that you’ve set up horizontal movement, repeat the process that you just followed to add vertical movement using the Up arrow and Down arrow keys for input.

Use the following tips to help you if you need a little more guidance:

Check that every instruction you write ends with a semicolon.

Check that your instructions are inside the braces of the Update function.

Check that you declared a new variable for the vertical input.

Check for any typos in property names, including the use of uppercase and lowercase letters. The Console window will display an error if Unity can’t find a required property — when this happens, the cause is often a typo.

When you’ve finished, test your updated script in Unity Editor before continuing. You should now be able to move the player character diagonally by pressing a vertical arrow key and a horizontal arrow key at the same time!

The reference script at the end of this tutorial includes both vertical and horizontal movement.

Take a moment to check that your script is correct before continuing.

Important: If you completed any extension work in your script, this will not be reflected in the reference script below.

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


public class PlayerControllerTutorialUpdates : MonoBehaviour
{
// Start is called before the first frame update
void Start()
{


}


// Update is called once per frame
void Update()
{
    float horizontal = 0.0f;
    if (Keyboard.current.leftArrowKey.isPressed)
    {
        horizontal = -1.0f;
 	    }
    else if (Keyboard.current.rightArrowKey.isPressed)
    {
        horizontal = 1.0f;
    }
    Debug.Log(horizontal);


    float vertical = 0.0f;
    if (Keyboard.current.upArrowKey.isPressed)
    {
        vertical = 1.0f;
    }
    else if (Keyboard.current.downArrowKey.isPressed)
    {
        vertical = -1.0f;
    }
    Debug.Log(vertical);


    Vector2 position = transform.position;
    position.x = position.x + 0.1f * horizontal;
    position.y = position.y + 0.1f * vertical;
    transform.position = position;
}

}


You’ve now implemented basic movement by reading keyboard input from the player — a great start and very useful for prototyping! Next you’ll build on that by using specific Input System functionality to control movement in a way that can be scaled for multiple different input devices.

Read keyboard input to control 2D character movement

1. Overview

2. The Input System package and your game

3. Read input from a keyboard

4. Apply horizontal movement to the player character

5. Challenge: Set up vertical movement using keyboard input

6. Check your script

7. Next steps

Complete this tutorial