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)

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

Welcome to 2D Beginner: Adventure Game

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

Design and paint your game tilemap

Create decorative objects using sprites

Implement object collisions for your 2D game

Set up tilemap collision

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

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

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

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

6ea4a0f3-53dc-57be-82eb-4558e5ce6eac:6udFvAlfFjsjj7eis1blu4

Overview

Adjust the currentHealth value at game start

 Challenge: Create a functioning damage zone

Refine your damage zone functionality

Implement a cooldown after the character takes damage

Test your changes and adjust TimeInvincible

More things to try

Check your scripts

Next steps

In this tutorial you’ll create static damage zones to decrease the player character’s health.

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

Adapt your previous code to decrease player character health.

Implement a period of invincibility when player health is decreased.

In your game the player can increase their character’s health up to the maximum level, but there’s currently nothing that can negatively impact that health. In this tutorial, you’ll apply what you’ve previously learned to decrease player health when they enter a damage zone (collide with a particular GameObject). Later in the course you’ll build on this work to create moving enemies too.

This tutorial is part of Beginner 2D: Adventure Game and refers to the game project for that course, but this information will be helpful for any beginner creator who wants to set up a basic health system in their game.

Note: 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. 

When you set up the health collectibles, you set the player character's currentHealth value as 1 at game launch. To revise your script so the player starts at full health, follow these instructions:

1.  Open the PlayerController script in your IDE.

2.  At the top of the script, find the variable declaration for currentHealth. Revise the declaration so it no longer sets the variable to 1:

3.  In the Start function, remove the double slashes from the instruction to set currentHealth to the maxHealth value when the game launches:

The Start function will now execute this instruction when it runs.

You have already set up a GameObject to increase the player character’s health on collision — now you’ll do the opposite and decrease the character’s health. Apply what you’ve learned so far to set up a damage prefab, then you’ll have the opportunity to review the solution before we guide you through refining the damage object to give players an engaging experience. The damage zone should decrease the player character’s health value by one when the character collides with it. 

Review these high-level instructions to confirm that you have set up the damage zone correctly:

1.  Place some instances of the DamageZone prefab you created before around your scene.

2.  In prefab editing mode, add a Box Collider 2D component  and enable Is Trigger and Auto Tiling. 

This setting automatically resizes the collider to fit the area of the object.

3.  Create a new script called “DamageZone” and attach it to the GameObject.

4.  Copy the HealthCollectible script and adapt it to decrease player character health:

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


public class DamageZone : MonoBehaviour
{
   void OnTriggerEnter2D(Collider2D other)
   {
       PlayerController controller = other.GetComponent<PlayerController>();


       if (controller != null)
       {
           controller.ChangeHealth(-1);
       }
   }
}


Player health is irrelevant to the damage zone functionality, so the only condition for the health decrease is whether the colliding GameObject has a PlayerController script on it.

Damage zones that disappear immediately won’t be very powerful, so the instruction to destroy the GameObject has been removed. 

5.  Save your changes and return to the Unity Editor. Test the damage zone to confirm that it decreases player character health on collision.

At the moment, the player character’s health decreases by one when they enter the damage zone (hit its collider), but that’s the only damage the zone does. That approach isn’t very challenging for players — the zone should cause ongoing damage for as long as the player character is within its collider.

To adjust the damage zone functionality, follow these instructions:

1.  In your DamageZone script, adjust the function name to OnTriggerStay2D:

OnTriggerStay2D is called every frame that the GameObject with the Rigidbody component is inside the collider, not just when it enters. This change means that the damage zone won’t have a one-time impact — the function will continue to be called as long as the player character is in the damage zone.

2.  Save your changes, return to the Unity Editor, and test the updated functionality. You should notice the following:

The player character gets to zero health in less than a second (in five frames, to be precise, unless you have adjusted the maxHealth value in your own project).

There are no updates about the player character health in the Console window when you keep the player character still in the damage zone, only when you move the character.

Important: Remember to exit Play mode when you’ve finished testing.

3.  Open the PlayerCharacter prefab in prefab editing mode.

4.  In the Rigidbody 2D component, set the Sleeping Mode property to Never Sleep.

By default, the physics system stops computing collisions for a GameObject with a Rigidbody component when that GameObject stops moving: the Rigidbody component sleeps. This approach optimizes resources and avoids wasted calculations. However, for the damage zone to work properly, you need that computation to happen even when the PlayerCharacter GameObject is stationary.

5.  Save your changes and exit prefab editing mode.

Your adjustment to make the damage zone more dangerous also means that the player character loses all their health almost immediately. Even if you want to make your game challenging, the current configuration is impossible for a player to overcome.

There are different ways that you can address this issue. In this case, you’ll make the player character invincible after they receive damage for a brief cooldown period to avoid complete loss of health immediately.

To add a damage cooldown period after the player character takes damage, follow these instructions: 

2.  At the top of the PlayerController class, with the other variable declarations, add three new variables:

// Variables related to temporary invincibility
  public float timeInvincible = 2.0f;
  bool isInvincible;
  float damageCooldown;

The public float variable timeInvincible controls how long the player character remains invincible after taking damage, measured in seconds. This variable is public, so you can adjust it in the Inspector window for quick iteration.

The private bool variable isInvincible stores whether the player character is currently invincible. Bool type variables (short for Boolean) can only be true or false. This variable type can be very useful for constructing conditional statements.

The private float variable damageCooldown stores how much time is remaining until the player character is no longer invincible and can take more damage.

3.  At the top of the ChangeHealth function, add an if statement that will execute if the character health is currently being decreased:

if (amount < 0)
{
   if (isInvincible)
   {
     return;
   }
   isInvincible = true;
   damageCooldown = timeInvincible;
}

The condition for this statement is the amount parameter having a value below zero. The value will be below zero if a health decrease has been made through the ChangeHealth function.

The nested if statement exits the ChangeHealth function if the player character is already invincible using the return statement. You can use the return statement to end a function early if a particular condition is met.

The second instruction sets isInvincible to true to avoid further damage during the cooldown period.

The third instruction sets damageCooldown (the cooldown timer) to the current value for the public timeInvincible variable.

4.  At the bottom of the Update function, add an if statement that will be executed if the player character is currently invincible:

if (isInvincible)
{
    damageCooldown -= Time.deltaTime;
    if (damageCooldown < 0)
    {
       isInvincible = false;
    }
}

Important: Make sure that the if statement and code block are enclosed within the closing brace of the Update function.

The condition for this if statement is isInvincible being true — that is, the player character has taken damage since the last time that Update was called (the previous frame).

The first instruction in the block subtracts (-=) Time.deltaTime from the damageCooldown timer. Time.deltaTime is the interval in seconds from the previous frame to the current one, so the instruction reduces the damageCooldown timer value every frame.

An if statement follows, with the condition that any instructions in the block after the statement will only be executed when damageCooldown is less than zero — that is, when the timer countdown has finished.

The final instruction in the block sets isInvincible to false, meaning that the player character is once again vulnerable to damage after the countdown finishes.

5.  Save your changes and return to Unity Editor.

Now that you’ve written the cooldown functionality, test it and adjust the cooldown duration:

1.  Enter Play mode and test that the damage cooldown functionality works. The damage will now reduce the player character health at two second intervals while the character is within the damage zone collider — you can find the notifications of this in the Console window.

2.  With your PlayerCharacter GameObject selected, in the Inspector window, go to the PlayerController (script) component and find the exposed Time Invincible property.

3.  Adjust the Time Invincible value and test the player experience until you are happy with the damage cooldown time.

4.  Exit Play mode and save your changes when you’ve finished testing.

Note: You can always adjust the cooldown again later as you continue to develop your game. You might also find it helpful to get specific user feedback on the damage cooldown period when you have created the full 2D Beginner game.

If you want to further develop your skills, explore new concepts, or improve your project, check out some of the optional activities below. Each one is tagged as either Easy, Medium, or Difficult, so you can choose the level of challenge.

These activities are entirely optional, so if you’re not interested, no problem — just skip this step. We do recommend attempting at least one of them in order to get the most out of this learning experience. Good luck!

Easy: Position damage zones to challenge the player

Take some time to experiment with your placement of damage zones and health collectibles within the environment, and consider the fact that you will soon add moving enemies too. It’s important to give your players sufficient challenge, but that needs to be balanced — an almost-impossible game probably isn’t your goal here!

You might have created variant health collectibles, and you can take a similar approach here: switch the value that the DamageZone script passes to the ChangeHealth function to a public float variable, then configure a prefab variant as you like.

If you want to practice applying what you’ve learned in this unit, you can configure slow healing zones that increase player health using the same principle as the damage zones. You know everything that you need to implement this functionality.

If you’re completing the 2D Beginner course, take a moment to check that your scripts are 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 PlayerController : MonoBehaviour
{
  // Variables related to player character movement
  public InputAction MoveAction;
  Rigidbody2D rigidbody2d;
  Vector2 move;
  public float speed = 3.0f;


  // Variables related to the health system
  public int maxHealth = 5;
  int currentHealth;
  public int health { get { return currentHealth; }}


  // Variables related to temporary invincibility
  public float timeInvincible = 2.0f;
  bool isInvincible;
  float damageCooldown;


  // Start is called before the first frame update
  void Start()
  {
     MoveAction.Enable();
     rigidbody2d = GetComponent<Rigidbody2D>();


     currentHealth = maxHealth;
  }
 
  // Update is called once per frame
  void Update()
  {
     move = MoveAction.ReadValue<Vector2>();


     if (isInvincible)
     {
         damageCooldown -= Time.deltaTime;
         if (damageCooldown < 0)
         {
            isInvincible = false;
         }
     }
   }


// FixedUpdate has the same call rate as the physics system
  void FixedUpdate()
  {
     Vector2 position = (Vector2)rigidbody2d.position + move * speed * Time.deltaTime;
     rigidbody2d.MovePosition(position);
  }


  public void ChangeHealth (int amount)
  {
     if (amount < 0)
     {
        if (isInvincible)
        {
           return;
        }
     isInvincible = true;
     damageCooldown = timeInvincible;
  }


     currentHealth = Mathf.Clamp(currentHealth + amount, 0, maxHealth);
     Debug.Log(currentHealth + "/" + maxHealth);
  }


}


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


public class DamageZone : MonoBehaviour
{
   void OnTriggerStay2D(Collider2D other)
   {
       PlayerController controller = other.GetComponent<PlayerController>();


       if (controller != null)
       {
           controller.ChangeHealth(-1);
       }
   }
}


The player character has a fully-functional health system, and can both take and heal damage. At the moment though, the player has no way of knowing what their health level is — you’ve been using the Console window as you test, but that won’t help your player. In the next unit, you’ll create a heads-up display (HUD) and configure it to show the player character’s health level.

Add damage zones to decrease health (static hazards)

1. Overview

2. Adjust the currentHealth value at game start

3. Challenge: Create a functioning damage zone

4. Refine your damage zone functionality

5. Implement a cooldown after the character takes damage

6. Test your changes and adjust TimeInvincible

7. More things to try

8. Check your scripts

9. Next steps

Complete this tutorial