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

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

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

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

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

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

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

11c7a598-b42a-57a6-8ed3-4d2a09858974:zx7pohSEomVRos4yXEp9QD

Overview

Add functionality to attack enemies

Optimize the projectiles in your game

More things to try

Check your scripts

Next steps

In this tutorial, you’ll add functionality so your projectiles either neutralize or destroy the enemy. You’ll also adjust the projectile configuration to optimize game performance.

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

Change the enemy state on projectile impact, stopping all broken behavior.

You’ve set up projectiles that the player can throw, but they currently don’t actually do anything. In this tutorial, you’ll add functionality so your projectiles fix the enemy. You’re going to configure some of the visual and audio effects based on the enemy’s broken and fixed states later in this course. You’ll also adjust the projectile configuration to optimize game performance.

This tutorial is part of Beginner 2D: Adventure Game and refers to the game project for that course, but this information may be helpful for any beginner creator who wants to implement projectile attacks in their own 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. 

You’ve fixed the projectile errors, but there’s an important thing still missing: the projectile doesn’t do anything but disappear on collision. But the player character’s goal in the game is not just to evade the enemy characters, it’s to fix them — now it’s time to add that functionality.

Follow these instructions to update the projectile functionality:

1.   Open the EnemyController script in your IDE.

2.   At the top of the EnemyController class, declare a new bool variable:

The enemies start off broken and need to be fixed by the player — this variable stores that state and sets the enemy to initialize in the broken state.

3.   At the start of the FixedUpdate function, add the following test to check whether the enemy is broken or not:

   if(!broken)
      {
           return;
      }

You’ve used if statements to perform checks before — here the check is whether the broken bool is not (!) true.

If broken is not true (the enemy is fixed), Unity exits the function. If the enemy is still broken, the rest of the code in the function will execute.

4.   At the bottom of the script, add a new public function called Fix:

public void Fix()
   {
       broken = false;
       rigidbody2d.simulated = false;
   }

This function is public so you can call it from the Projectile script.

The first instruction sets the broken bool variable to false.

The second instruction sets the simulated property of the Enemy GameObject’s Rigidbody component to false, which removes the Enemy GameObject from the physics system’s simulations for collisions. This change means that projectiles will no longer collide with enemies or be able to damage the enemy character.

5.  Save your changes, then open the Projectile script.

6.  In the OnTriggerEnter2D function, remove the instruction printing to the Console window.

7.  Add a new instruction at the top of the function:

EnemyController enemy = other.GetComponent<EnemyController>();

This instruction stores a reference to the Enemy Controller (Script) component on the GameObject that collides with the projectile in a variable called enemy, if it has one.

8.  Before the first instruction (and above the final instruction destroying the Projectile GameObject), add the following conditional code to fix a broken enemy:


    if (enemy != null)
           {
               enemy.Fix();
           }

If enemy is not null (that is, if the OnTriggerEnter2D function has an EnemyController script reference), the Fix function in the Enemy Controller script is called.

9.  Add add a new OnCollisionEnter2D function with the following instruction:

void OnCollisionEnter2D(Collision2D other)
  {
     Destroy(gameObject)
  }

Since the previous function only handles collisions with triggers, you need to create a new one to handle collisions with standard colliders, like those used for objects, obstacles, and similar elements. This way, the projectile will be properly destroyed on impact.

10.  Save your changes and test the game in Unity. 

The player can now use the projectiles to fix enemies! Fixed enemies will stop moving and won’t deal damage to the player.

You’ve finished the projectile functionality, but there’s one more projectile issue for you to address. Right now, if the player character launches a projectile and it doesn’t hit anything, that projectile will continue moving offscreen for as long as the game runs. As you enhance this game (or create new, more complex games) this could cause performance issues — for example, 500 projectiles moving out of the player’s view could have a significant impact!

You can address this issue by checking the projectile’s distance from the center of the game world and destroying the GameObject when it is far enough away that the player character will never reach it.

To make this check, follow these instruction:

1.  Open the Projectile script in your IDE.

2.  Create a new Update function, below the Awake function:

3.  Add the following conditional statement and code to the Update function:

if(transform.position.magnitude > 100.0f)
       {
           Destroy(gameObject);
       }

You can consider position to be a vector from the center of the game world to the location of the Projectile GameObject. Magnitude is the length of that vector, so the magnitude of the position is the distance to the center of the game world.

If the distance is greater than 100, the Projectile GameObject is destroyed.

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!

We’ve guided you through fixing enemies because of the particular way that the example game for this course is designed, but you’ll more commonly find that the enemies are destroyed when you defeat them in a game. If you want, you can revert your game to this functionality instead.

Medium: Create an animation for fixed enemies

If you want to add an additional animation for fixed enemies, follow these high-level instructions:

1.  Create a new animation clip for the enemy using the following sprites:

Name the new animation clip “EnemyFixed".

2.  Select the Enemy GameObject and view its Animator Controller in the Animator window. Your new animation clip will be visible in the graph layout area.

3.  Right-click the Blend Tree node, select Make Transition, and then select the EnemyFixed node. The connection between the nodes will have an arrow showing the direction of the transition.

4.  In the Layers & Parameters panel, select the Parameters tab, add a new Trigger parameter, and name it “Fixed”.

5.  Select the transition between the Blend Tree node and the EnemyFixed node, then go to the Conditions list in the Inspector window. Select Add (+) and set the new Fixed parameter as the condition.

6.  Select the transition between the Blend Tree node and the EnemyFixed node and disable HasExitTime. 

The enemy will now be in its fixed state until the end of the game.

7.  Save your changes and open the EnemyController script in your IDE.

8.  Go to the Fix function and add the following instruction:

9.  Save your script changes and return to the Unity Editor. 

10.  Test your changes — when you fix the enemy, the new animation will play until you exit Play mode.

Hard: Alternative optimization approaches

There are other ways that you can address the optimization issue for projectiles, depending on the specification and requirements of your game. For example, you can also take one of the following approaches:

Get the distance between the player character and the projectile by using the function Vector3.Distance(a,b) to compute the distance between position a and position b.

Add a timer to the Projectile script, decrement (reduce) that timer in the Update function, and then destroy the projectile when the timer reaches zero.

If you’re completing the 2D Beginner course, take a moment to check that your scripts are correct before continuing.

Note: This script includes the instruction to implement the optional fixed animation in the Fix function, but does not contain code for any additional extension work.

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

public class EnemyController : MonoBehaviour
{
   // Public variables
   public float speed;
   public bool vertical;
   public float changeTime = 3.0f;
  
   // Private variables
   Rigidbody2D rigidbody2d;
   Animator animator;
   float timer;
   int direction = 1;
   bool broken = true;


   // Start is called before the first frame update
   void Start()
   {
       rigidbody2d = GetComponent<Rigidbody2D>();
       animator = GetComponent<Animator>();
       timer = changeTime;
      
   }


 // Update is called every frame
  void Update()
  {
        timer -= Time.deltaTime;


        if (timer < 0)
        {
            direction = -direction;
            timer = changeTime;
        }
  }


  // FixedUpdate has the same call rate as the physics system
  void FixedUpdate()
  {
      if(!broken)
      {
           return;
      }
     
       Vector2 position = rigidbody2d.position;
     
       if (vertical)
       {
           position.y = position.y + speed * direction * Time.deltaTime;
           animator.SetFloat("Move X", 0);
           animator.SetFloat("Move Y", direction);
       }
       else
       {
           position.x = position.x + speed * direction * Time.deltaTime;
           animator.SetFloat("Move X", direction);
           animator.SetFloat("Move Y", 0);
       }


       rigidbody2d.MovePosition(position);
  }


   void OnTriggerEnter2D(Collider2D other)
   {
       PlayerController player = other.gameObject.GetComponent<PlayerController>();


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


 void OnCollisionEnter2D(Collision2D collision)
    {
        Destroy(gameObject);
    }



   public void Fix()
   {
       broken = false;
       GetComponent<Rigidbody2D>().simulated = false;
       animator.SetTrigger("Fixed");
   }


}

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

public class Projectile : MonoBehaviour
{
   Rigidbody2D rigidbody2d;


   // Awake is called when the Projectile GameObject is instantiated
   void Awake()
   {
       rigidbody2d = GetComponent<Rigidbody2D>();
   }

   void Update()
   {
       if(transform.position.magnitude > 100.0f)
       {
           Destroy(gameObject);
       }
   }


   public void Launch(Vector2 direction, float force)
  {
       rigidbody2d.AddForce(direction * force);
  }


   void OnTriggerEnter2D(Collider2D other)
  {
       EnemyController enemy = other.GetComponent<EnemyController>();
       if (enemy != null)
           {
               enemy.Fix();
           }


       Destroy(gameObject);
  }

}

You’ve now got a functioning projectile that will fix enemies. However, some players may need a little guidance to help them know what they need to do — next you’ll finish this unit by creating a friendly NPC to give them an instruction.

Configure projectiles to affect the enemy

1. Overview

2. Add functionality to attack enemies

3. Optimize the projectiles in your game

4. More things to try

5. Check your scripts

6. Next steps

Complete this tutorial