C# Interfaces In Unity – Create Games The Easy Way

When creating a game in Unity the most important thing is to structure your project in a way that you can expand it later by adding new updates to the game.

This is done from the beginning when you start creating parts of your game, not like what you see on all YouTube tutorials and low-quality courses where they just open a project and start creating things at random.

If you don’t have a proper structure and you decide after 6 months to add a new feature in your game, it can break other features, and then you’ll have to deal with bugs that are hard to solve.

And what’s worse, if you use a project with a bad structure in your portfolio and the game studio you applied for sees that, it’s an immediate rejection.

To solve this problem we use Object Oriented programming and design patterns principles. And one concept that helps us implement that is called Interface.

Before we start, this tutorial is not for complete beginners. If you don’t know how to create basic games with Unity and you’re not familiar what are classes, variables, and functions, you should first go through our C# beginner series and then come back to this lecture.

You can check out our C# beginner series by clicking here.

What Is A C# Interface And How Do We Create One?

An Interface is a container that holds functions that can have parameters but are empty e.g. not implemented inside the Interface itself.

The functions are implemented by the class which implements that particular interface.

To create an interface, simply create a new C# script in Unity and add the following lines of code:

Besides adding the “interface” keyword in the declaration the coding standard is to put “I” in front of the name of the Interface so that when we implement it in a class we’ll immediately know this class is implementing an Interface.

To implement the Interface in a class, we just add a comma (,) after the MonoBehavior keyword:

When you declare that you implement an Interface, you’ll immediately receive a red warning because you need to implement all functions that are declare inside the interface:

You can either hover over the Interface name and on the drop-down list implement the Interface using auto-complete:

Or you can implement it yourself by adding the functions one by one:

As you can see, the signature of the functions declared in an Interface must be the same when you implement them in a class.

If the function has parameters, you need to declare that function with the same parameters.

Implementing Doctor Player’s Movement Using The Interface Function

Let’s use the interface we created to implement the movement behavior of our Doctor game character.

I’ve already prepared the animations of the character and created a script that will play those animations:

Also, inside the Doctor script we got a reference to the AnimationController script inside the Awake function:

Since we’re are going to move the Doctor character via transform, we are going to declare two variables that are going to help us with that:

Now, inside the Walk function we implemented from ICharacterBehavior Interface we are going to add the following lines of code:

And lastly we are going to call that function inside the Update function so that we can execute it:

Now we can run the game and test the Doctor character’s movement:

Implementing Doctor Player’s Attack Using The Interface Function

Now that the Doctor character is moving, we can add attack functionality.

Since I’m using a separate game object which has the electricity animation for the Doctor’s gun, I’ve created a variable as a reference to that game object:

This game object is a child of the Doctor character in the Hierarchy and I’ve dragged and dropped it’s reference inside the script:

Inside the Attack function we’re going to add the following code:

One reminder, if you’re using this code for your own project, with the current setup the character will be able to move while he’s attacking.

To prevent that you can add a boolean variable:

And inside the Attack function disable the player from moving while he’s attacking:

Also, inside the Walk function at the beginning we need add the following condition:

The condition we added on line 38 is preventing the player from moving, but it allows him to change direction so that he can attack enemies on the left and right sides.

This is what it looks like in the preview:

Implementing Hazard Player’s Movement Using The Interface Function

Now we’re going to use the same interface to model the behavior of our Hazard character.

Inside the Hazard script, we’ve implemented the interface:

To make the two players different, we’re going to use Rigidbody2D to move the Hazard character so we’re going to declare the following code:

And of course, inside the Awake function get a reference to the Rigidbody2D component:

We also have a reference to the AnimatorController class that we used to animate the Doctor character.

Inside the Walk function, we are going to add the following code:

And inside the Update we’ll run the Walk function:

When we play the game this is how it looks like:

Implementing Hazard Player’s Attack Using The Interface Function

Since the Hazard character attack animation is different from the Doctor character animation, and we’re using a trigger as a parameter to play that animation, we added one more function inside the AnimationController:

Now inside the Attack function we’re going to add the following lines:

This is how it looks like in the preview:

Why Is This Approach Better Than What All Other Tutorials And Courses Are Teaching You?

As you saw, we created the same functionality for both characters using the Interface structure.

We even implemented the Walk functions differently by using transform to move the Doctor character and Rigidbody2D to move the Hazard character.

But why is this approach better than if we just implemented characters movement inside their appropriate scripts?

This way is more simple because we model the behavior of all characters inside the Interface.

When you create a game where you have a common behavior for characters, enemies, or any other game object, you can model the behavior inside the Interface and implement that behavior differently for each game object.

And if somewhere down the line you decide to add new features in your characters, you first model that feature inside the Interface, and then you implement it in every character.

You can also invoke Interface functions on game objects that have implemented that interface without getting a reference to that game object.

For example, we can implement the damage function inside the Interface:

Inside the game object that has implemented the Interface we implement the function:

And when we want to deal damage to that game object we can do that by calling the Interface:

In the example above, instead of checking if we have the right game object, we’ll invoke the function from the Interface and in turn, it will call this code:

Or whichever code we implemented in the particular class where we inherited the Interface.

This allows us to have more control over the structure of our game, and we can easily add new features, improve the current ones, or remove old features and all that without breaking our game or introducing hundreds of bugs.

Modeling Single Behaviors With Interfaces

We can even model single behaviors using an Interface. Using our damage example we can create an IDamageable Interface like this:

Now we can deal damage to every game object which implements this Interface and we can do that by calling the Interface itself like we did in the example above:

And there’s no limit to how many behaviors we can model using the Interface approach and we will not have to get references to different game objects every time we need them, instead we can just use the Interface to invoke their functionality.

Where To Go From Here

You can check out some posts we made, like how to use a Coroutine in Unity or how to implement Delegates and Events in your game.

Unity Coroutines – What Are They And How To Use Them

Delegates And Events In Unity – What Are They And How To Use Them

Or you can check out some of the other blog posts by clicking on the link below:

Awesome Tuts Blog