You can access the full course here: CREATE YOUR FIRST 2D GAME IN UNITY

Game Over – Part 1

In this lesson, we’ll set up the Game Over state for our game. In our game, the Game Over state will happen either when the Player hits an Enemy, or when the Player falls from the level.

The Game Over Function

To implement the Game Over state, we’ll go to the PlayerController script and do the following changes:

• Add the SceneManagement library at the top of the script
• Add the GameOver function to the PlayerController script
• In the GameOver function, use the LoadScene function to reload the current scene

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.SceneManagement; // Add me!!

public class PlayerController : MonoBehaviour
{
    // Older code omitted for brevity
    // Called when we get hit by an enemy or if we fall below the level.
    public void GameOver ()
    {
        SceneManager.LoadScene(SceneManager.GetActiveScene().buildIndex);
    }
}

And here’s what the PlayerController script looks like at the moment:

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

public class PlayerController : MonoBehaviour
{
    public float moveSpeed;
    public Rigidbody2D rig;
    public float jumpForce;
    public SpriteRenderer sr;

    private bool isGrounded;

    void FixedUpdate ()
    {
        float moveInput = Input.GetAxisRaw("Horizontal");
        rig.velocity = new Vector2(moveInput * moveSpeed, rig.velocity.y);

        if(rig.velocity.x > 0)
        {
            sr.flipX = true;
        }
        else if(rig.velocity.x < 0)
        {
            sr.flipX = false;
        }
    }

    void Update ()
    {
    // If we press the jump button and we are grounded, then jump.
        if(Input.GetKeyDown(KeyCode.UpArrow) && isGrounded)
        {
            isGrounded = false;
            rig.AddForce(Vector2.up * jumpForce, ForceMode2D.Impulse);
        }
    }

    private void OnCollisionEnter2D (Collision2D collision)
    {
        if(collision.GetContact(0).normal == Vector2.up)
        {
            isGrounded = true;
        }
    }

    // Called when we get hit by an enemy or if we fall below the level.
    public void GameOver ()
    {
        SceneManager.LoadScene(SceneManager.GetActiveScene().buildIndex);
    }
}

The Fall Game Over Challenge

As a bit of a challenge, we want you to implement one of the game-over cases yourself. In this challenge, you should make the fall-from-the-level scenario work as a game-over.

One of the ways to do so is to check whether the Player’s vertical position is below some level. Checking could be done in the Update function.

In this lesson, we implemented the Game Over function. In the next lesson, we’ll implement the game-over scenarios.

Game Over – Part 2

In this lesson, we’ll implement the Game Over scenarios.

The Fall Game Over

To make the Game Over happen when the Player falls from the level, we should make the following changes to the Player Controller > Update function:

• In the Update function, check whether the vertical position of the Player is less than -4
• If so, call the GameOver function

// Using directives omitted for brevity

public class PlayerController : MonoBehaviour
{
    // Older code omitted for brevity


    void Update ()
    {
    // Older code omitted for brevity


    // If we fall below -4 on the Y, then game over.
    if(transform.position.y < -4)
    {
    GameOver();
    }
}

    // Older code omitted for brevity
}

If you start the game now and jump from the level, in a couple of seconds, the level will reload from the beginning.

Here’s what the PlayerController script looks like now:

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

public class PlayerController : MonoBehaviour
{
    public float moveSpeed;
    public Rigidbody2D rig;
    public float jumpForce;
    public SpriteRenderer sr;

    private bool isGrounded;

    void FixedUpdate ()
    {
        // Get the horizontal move input.
        float moveInput = Input.GetAxisRaw("Horizontal");

        // Set our velocity.
        rig.velocity = new Vector2(moveInput * moveSpeed, rig.velocity.y);

        // Flip the sprite to face our moving direction.
        if(rig.velocity.x > 0)
        {
            sr.flipX = true;
        }
        else if(rig.velocity.x < 0)
        {
            sr.flipX = false;
        }
    }

    void Update ()
    {
        // If we press the jump button and we are grounded, then jump.
        if(Input.GetKeyDown(KeyCode.UpArrow) && isGrounded)
        {
            isGrounded = false;
            rig.AddForce(Vector2.up * jumpForce, ForceMode2D.Impulse);
        }

        // If we fall below -4 on the Y, then game over.
        if(transform.position.y < -4)
        {
            GameOver();
        }
    }

    private void OnCollisionEnter2D (Collision2D collision)
    {
        if(collision.GetContact(0).normal == Vector2.up)
        {
            isGrounded = true;
        }
    }

    // Called when we get hit by an enemy or if we fall below the level.
    public void GameOver ()
    {
        SceneManager.LoadScene(SceneManager.GetActiveScene().buildIndex);
    }
}

The Enemy Hit Game Over

We should also go to the Game Over state once the Player hits an Enemy. We’ll do this from the Enemy script.

But first, we need to add a way for an Enemy to know that it hits the Player, and not something else. Here’s what we’ll do:

• Select the Player game object
• Go to the Inspector window
• Set the Tag property at the top of the Inspector window to the Player value

Now our Player is tagged as a Player. Well done!

And here’s what we’ll do in the Enemy script:

• Add the OnTriggerEnter2D function. This function is called when something enters the trigger collider
• In this function, check whether we have a collision with an object tagged as a Player
• If so, get the PlayerController component from that object and call the GameOver function on it

// Using directives omitted for brevity
public class Enemy : MonoBehaviour
{
    // Older code omitted for brevity
    private void OnTriggerEnter2D (Collider2D collision)
    {
        // Did the player hit us?
        if(collision.CompareTag("Player"))
        {
            // Trigger the game over state on the player.
            collision.GetComponent<PlayerController>().GameOver();
        }
    }
}

Now, if you jump into an Enemy, the game will reload as well. Here’s what the full Enemy script looks like:

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

public class Enemy : MonoBehaviour
{
    public float moveSpeed;
    public Vector3 moveOffset;
    private Vector3 startPos;
    private Vector3 targetPos;
    // Start is called before the first frame update
    void Start()
    {
        startPos = transform.position;
        targetPos = startPos;
    }
    // Update is called once per frame
    void Update()
    {
        // Move towards the target position.
        transform.position = Vector3.MoveTowards(transform.position, targetPos, moveSpeed * Time.deltaTime);
        // Are we at the target position?
        if(transform.position == targetPos)
        {
            // Is our target pos our start pos? If so, set it to be the other one.
            if(targetPos == startPos)
            {
                targetPos = startPos + moveOffset;
            }
            // Otherwise, do the opposite.
            else
            {
                targetPos = startPos;
            }
        }
    }
    private void OnDrawGizmos()
    {
        Vector3 from;
        Vector3 to;
        if (Application.isPlaying)
        {
            from = startPos;
        }
        else
        {
            from = transform.position;
        }
        
        to = from + moveOffset;
        
        Gizmos.color = Color.red;
        Gizmos.DrawLine(from, to);
        Gizmos.DrawWireSphere(to, 0.2f);
        Gizmos.DrawWireSphere(from, 0.2f);
    }
    private void OnTriggerEnter2D (Collider2D collision)
    {
        // Did the player hit us?
        if(collision.CompareTag("Player"))
        {
            // Trigger the game over state on the player.
            collision.GetComponent<PlayerController>().GameOver();
        }
    }
}

In this lesson, we implemented the Game Over scenarios. In the next lesson, we’ll work on the collectible Coins.

BUILD GAMES

FINAL DAYS: Unlock 250+ coding courses, guided learning paths, help from expert mentors, and more.

ACCESS NOW

Transcript – Game Over – Part 1

Welcome back everyone. In this lesson we are going to be working on setting up our game overstate for our 2D platform here.

So the way the game over state is gonna work is pretty much whenever our player gets hit by an enemy or if they fall off the edge and down below our level, they are going to basically reset, okay?

The level is gonna restart and the player will spawn back up here. Okay, so how do we do this? Well, let’s go over and open up our player controller script right here.

Now inside of the player controller script, we are gonna go down and create a brand new function. And this function is gonna be a public void called GameOver. Okay? Like so.

Now the reason we are making this function a public function is because we need to be able to call this from outside of the script. For example, our enemy script here is going to be able to call that function.

So in order to do that, we need to make it public. Now, inside of this function, what we are going to do is basically reload our current scene.

So in order to do that, we first of all need to tell the script that we want to be able to access Unity’s scene manager. And to do that we need to go to the top and you’ll see here we have these three lines of code, okay?

They’re basically using, and then we have a library here. Now, the way code and C Sharp especially works is that you don’t have everything at your disposal right at the start, okay?

So for certain things you may need to access a library. In our case, we are accessing the Unity engine library which allows us to access things such as mono behavior, rigid body, sprite renderer, the fixed update function, the update function, okay?

These are all things that are built into the Unity engine itself. Now, the Unity engine doesn’t always give us everything we need since there are a lot of different code libraries that we can access.

So if we wanna get specific, we do need to actually add them here. So for example, in order to access our scene manager, we need to be using the scene management library.

Now to do that, we can go to a new line here and just go using Unity engine dot scene management like so, and now we have access to our scene manager. So let’s go back down to our GameOver function.

And inside of here what we are going to do is go scene manager dot load scene, okay? And this function right here, basically we need to give it either a scene name, so we can just go level one like so, which is the name of our scene, or we can give it a build index.

And our build index for level one is zero. Basically, the levels go 0, 1, 2, 3, 4, 5, et cetera. But what if we’re on level five, for example? We don’t wanna have to hardcode every single level we have.

So, instead what we can do is we can just get whatever our current scene is and reload that. So to do this, I’m gonna go SceneManager dot GetActiveScene.

Now this is a function call, so make sure to add the two empty brackets like so, and then dot buildIndex. So this here is basically getting the index for the current scene and loading that.

So this line of code essentially reloads our current scene. So we have our game over function, but at the moment it’s not hooked up to anything just yet. So if we were to play our game, nothing would happen.

So in order to make something happen, we are first of all gonna make it so that if our player is jumping along the level here and they fall off the platform we don’t want them to keep on falling down forever.

Let’s say once they reach below, we’ll say below negative four, okay? Once they go below negative four on the Y axis that is when we will basically call the game over function.

So to do this, we are gonna go up to our update function right here. And as a bit of a challenge, I want you to have a go at implementing this.

Here’s a hint. Basically, we are gonna have an if statement that checks to see if our Y position is below negative three or negative four, I’m pretty sure we said, and if that’s the case call the game over function. So have a go at that and I’ll be right back to see how you’re done.

Transcript – Game Over – Part 2

Pretty much what we want to do is inside of our PlayerController’s update function we want to check every single frame if our player’s y position is below a certain number.

So what we’re gonna do is we’re gonna create an IF statement here. We’re gonna go, if transform.position.y is less than, let’s just say negative four then what we are going to do is we are going to call the GameOver function like so, okay?

So that is what we need to do here and make sure it is inside of the update function since we do want to check this every single frame. So we can save that, we can then go back inside of Unity now.

And if we press play, we should be able to test this out. So let us go over to the side right here and jump off the edge. And as you can see, once we go below negative four our scene basically gets to reset.

So we are back at the start and there we go. Now one more thing and that is our enemy. As you can see right now our enemy is just passing directly through us.

So we need a way of making it so that when the enemy hits us the GameOver function gets called. So how do we do that? Well, let us go over to our enemy script right here, and inside of the enemy script we need to create ourselves a brand new function.

Now this is going to be the OnTriggerEenter2D function. So we’re gonna go void OnTriggerEenter2D. Now OnTriggerEenter works very similar to OnCollisionEnter yet they both differ in a certain way.

Collision is basically a solid hit, so you can think of when our player lands on the ground their feet are being planted on the ground’s collider, whereas a trigger is passing through something, okay?

So maybe you might want to have some sort of trigger when a player walks through a door that would be a trigger, okay? The player isn’t blocked, they can pass through it, yet we can detect when that pass through happens.

And that is what a trigger is. So what we need to do is we basically need to make it so that when the player is hit by the enemy we call the GameOver function. But how do we do that?

Well, we’ve got the function here that detects when a trigger has happened, but how do we know if it was a player or not? How do we know that what the enemy hit is a player and not a wall, or a coin, or another enemy?

Well, the way we can do this is by checking to see what the player’s tag is. And before we continue writing code, let’s go back inside a Unity and we need to give our player a tag.

So I’m gonna select our player here and if we go over to the inspector, you’ll see underneath their name they have this little tag dropdown. Now tag is basically a label that we can attach to a game object.

So I’m gonna click on where it says untagged and you’ll see there are a few preset ones here. We can click add tag to add a new one. But we’ve got player, sorry, I’m just gonna select that.

And now our player game object is tagged as player. And you can of course, create tags for other things as well if that’s needed.

But we’re just gonna tag our player for now. So back inside of our script, what we’re gonna do is we are going to check to see if the collision.CompareTag is Player. So the parameter here is collision.

This is basically going to be our player’s collider when the enemy hits us and we are checking to see if that game object’s tag is player, and if so then the condition is true and we can call the GameOver function.

Now, in order to call the players GameOver function, we need to access their player controller component. So to access another game objects component or get any component in general, we need to do a certain function call.

So I’m gonna go collision.GetComponent, and then inside of these two angled brackets we need to define the type of component we are searching for which is gonna be PlayerController, and then two empty brackets like so.

And then we can go .GameOver. Whoops, not GameObject, GameOver, like so. So basically what we have done here is we have accessed the collision component that we have hit.

In this case it will be the player after we do this IF statement. Then we are getting another component on that GameObject we are searching for the PlayerController and then we are calling the GameOver function on the PlayerController.

So we can save that, go back inside of Unity and let’s test it out to see if it works. So I’m going to press play right here and if we jump up into our enemy, we should see that when it hits us the scene gets reset and we can even jump into the enemy here to make sure it works.

There we go. So we’re able to reset the scene by having our enemy run into us. So we need to avoid them on this jump here. And if we jump off our level and fall down below that will also reset the level as well.

So yeah, that is a look at our GameOver state inside of Unity. Now, in the next lesson, we are gonna be looking at setting up our coins, okay? These are basically going to be the collectibles that our player will collect and that will increase their score over time. So thanks for watching, and I’ll see you then in the next lesson.

Interested in continuing?  Check out our all-access plan which includes 250+ courses, guided curriculums, new courses monthly, access to expert course mentors, and more!

Start your journey into becoming an expert game developer by learning one of the world’s most popular Unity game engine – all for free in the complete Unity engine tutorial above! You can also download the project files used for the course below.

Download the project files

About

In this Unity tutorial created by Daniel Buckley, you’ll dive into the basics of the Unity game engine which allows you to develop 2D, 3D, VR, and AR games, mobile content, training apps, and more. You’ll first discover the Unity Engine platform, how to create a Unity project, navigate Unity’s Editor, edit game objects, apply materials to objects, and adjust lights and physics in various ways. After, you’ll dive into the C# Scripting system and learn a few core scripting techniques to build your first interactive project!

Whether you want to build games, training apps, or something similar, these foundations will form the core knowledge you’ll need to build any sort of Unity Engine game or project in the future!

New to Unity Engine? Enroll in UNITY 101 – GAME DEVELOPMENT FOUNDATIONS on our website and find quick access to additional resources!

BUILD GAMES

FINAL DAYS: Unlock 250+ coding courses, guided learning paths, help from expert mentors, and more.

ACCESS NOW

Whether you’re a newcomer to Unity or an experienced developer, advancing your career with game development can be a fantastic path to take. However, there is a lot of competition – so what can you do to highlight your own self? The answer is Unity Certification, which can prove your credentials and is industry-recognized!

In this article, we’re going to focus specifically on the Unity Associate Game Developer Certification, get you excited about it, and then get you learning the materials you’ll need to obtain it!

Let’s get started!

What is the Unity Associate Game Developer Certification?

Unity’s Associate Game Developer Certification is designed for aspiring developers with intermediate skills who can take a game from an initial idea to completion. The certification will showcase a receiver’s mastery of Unity, proving their worthiness for a professional game development role.

Those that take the Associate Game Developer Certification will have a background in computer programming or be self-taught hobbyists with detailed knowledge of Unity and C#, including audio, animation, and game physics. Rather than focusing on more minor details, this exam focuses on the broader picture of game development and design.

To qualify for the Unity Associate Game Developer Certification, you’ll need to:

• Build complex games using C# in Unity
• Understand end-to-end game production
• Have previously built a game for publication
• Be confident using prototypes, debugging, and solving programming issues

When taking the exam, you’ll cover a range of topics, including:

• Animation
• Audio
• Asset management
• Employment preparedness
• Game art and design principles
• Industry awareness
• Lighting
• Materials and effects
• Physics & Programming
• Project management & services

BUILD YOUR OWN GAMES

Get 250+ coding courses for

$1

LEARN MORE

AVAILABLE FOR A LIMITED TIME ONLY

The Benefits of the Associate Game Developer Certification

Unity is an influential game engine, powering half the world’s games. Unity-made applications are used by 2 billion people every month, with 1.5 million creators using Unity to create new and innovative games and applications.

Learning how to use Unity will improve your chances of breaking into the gaming industry, and receiving an Associate Game Developer Certification proves to employers that you’re skilled in game design and development.

Here are the main benefits of taking the Unity Associate Game Developer Certification.

Become a Unity game developer

Receiving a Unity Certification allows you to stand out against your competitors as it’s a recognized qualification in the game development world. Even better, many Unity-based jobs will list a Unity Certification as a preferred requirement, helping you better your chances of becoming a game developer.

Showcase your skills

To take the Unity Associate Game Developer course, you’ll need advanced skills in both Unity and C#. You should be able to make intricate games from conception to reality. Having a Certification will prove your skillset to potential employers, allowing you to stand out in a busy crowd.

What courses are best to prepare for the Associate Game Developer Certification?

Taking the Unity Associate Game Developer Certification requires significant skill, and you’ll need advanced knowledge of Unity and C# to qualify.

It’s essential to build your knowledge practically by making fully-fledged games suitable for your professional portfolio. Luckily, there are plenty of advanced online courses you can take to improve your knowledge of Unity and C# practically by building games.

Here are the best advanced online courses you can take that are suitable to prepare for Unity’s Associate Game Developer Certification.

Unity Game Development Mini-Degree

As mentioned above, preparing for this exam isn’t just about learning Unity, it’s also about having proven game development projects under your belt. What if you could do both at the same time though?

In Zenva’s Unity Game Development Mini-Degree, you’ll go through a comprehensive set of courses that cover just about everything you might want to know about Unity. It covers everything from various tools offered by the engine, and up to covering specific genre mechanics. All the courses are project-based, so you’ll also get plenty of items to add to your portfolio. This includes things such as RPGs, FPS games, racing games, idle clickers, and much more!

Plus, Zenva’s courses also offer a ton of supplemental learning material. Like to read other people’s code? There are downloadable course files of the complete projects! Aren’t a video person? There are text-based summaries that can be used to learn independently of the video!

With Zenva’s Unity Game Development Mini-Degree, you’ll learn:

• C# coding basics
• UI systems
• Audio effects
• Cinematic cutscenes
• Special effects
• Procedural terrain
• Animation

Skill level: Beginner. You don’t need prior experience in Unity or C#.

Duration: 36h 23m

How to access: Access the curriculum here.

Unity Advanced Tutorials

When it comes to game development, there are a surprising lot of details in terms of how mechanics are rendered. Likewise, there are a ton of Unity tools that aren’t so clear or have nuances that can make or break how your game feels.

The Unity Advanced Tutorials series by Brackeys seeks to demystify this. From specific nuances of game mechanics to just taking better advantage of Unity as a tool, this series has a little bit of everything. Nevertheless, it will vastly improve your skillset that you can use for game development.

As part of this course, you’ll cover key topics, including:

• Gravity simulation
• Dialogue systems
• Altering the Unity windows
• Making a level editor
• Reversing game time
• Making a loading bar
• Procedural generation
• Putting Unity projects on GitHub
• Using Unity Analytics
• Volumetric lighting
• Scriptable objects
• Object pooling
• Different combat styles

Skill level: Intermediate. You’ll need to know how to use Unity and program in C#.

Duration: 4h 31m

How to access: Access the series here.

Survival Game Development Academy

To reinforce a point above, the game developer certification is about showing you can take a game from idea to completion. So, understandably, having experience in making a larger, more complex game can be a big boost.

This is where we come to Zenva’s Survival Game Development Academy. Unlike many entries on this list where you’re learning bits and pieces of Unity and doing a different project every course, this curriculum is about making one singular project: a survival game. You’ll learn core mechanics such as player needs, crafting, base building, and combat – and with the breakdown into several courses, wind up with a fairly complex game project!

Plus, this curriculum is perfect for any skill level. If you haven’t ever used Unity before, the curriculum will guide you through the fundamental courses first before throwing you into the project.

All in all, though, the skills here feed directly into learning what being a game developer is all about and teaches you a ton of material that will be helpful for taking the exam.

As part of this course, you’ll cover key topics, including:

• Hunger, thirst, health, and sleep needs
• Day-night cycles
• Item and inventory systems
• Crafting mechanics
• Base building
• Combat and Enemy AI
• Game Saving

Skill level: Beginner. No prior knowledge of Unity or C# is needed.

Duration: 18h 45m

How to access: Access the curriculum here.

Learn to Program with C# – Unity Advanced Tutorials

While programming isn’t the focus of this specific certification, you can’t really ignore it. After all, you’re going to need to know C# pretty well in order to show the advanced level at which you can create games.

Thus, we include Learn to Program with C# – Unity Advanced Tutorials by GameDevHQ. This series of tutorials focuses on a few very specific aspects of C# that are not typically covered in a beginner’s level journey. However, as you advance in game development, you will find they are integral and well-used – so learning them will boost your skills immensely (even if you decide not to get certified).

As part of this course, you’ll cover key topics, including:

• Lists
• Enumus
• Structs vs Classes
• Nullable types
• Interfaces
• Delegate and events

Skill level: Intermediate.

Duration: 1h 46m

How to access: Access the series here.

EdTech Mini-Degree

Unity is for more than just making entertainment industry games. EdTech is revolutionizing how Unity is used with educational games and job training applications. The industry is already worth $6 trillion and is set to grow further.

For the purposes of certification, though, EdTech is also a fantastic way to explore unique Unity features and other advanced skills that otherwise never get covered.

The EdTech Mini-Degree by Zenva is designed to teach you everything you need to develop educational and training-based apps. You’ll cover topics including developing in 2D and 3D, using virtual reality, data analytics, and much more.

Each subsequent project featured in the curriculum gives you a chance to explore new applications for Unity – while also teaching you important facets involved in the software development cycle. Plus, as these skills are a bit more unique, it adds some extra material to your portfolio to stand out from the competition.

As part of this course, you’ll cover key topics, including:

• Coding basics with C# and Unity
• Quizzes featuring text, images, audio, and video
• Virtual reality applications
• Data-driven development with Unity Analytics
• Retrieving data with external APIs
• Voice and language recognition
• Text-recognition and text-to-audio

Skill level: Beginner. No prior coding experience is needed.

Duration: 21h 40m

How to access: Access the curriculum here.

Learn Unity Engine and C# by creating a real top-down RPG

Similar to an earlier entry, a good portion of this exam is about showcasing you can make games as a whole. So, making games as a whole is sure to help you actually prove that.

Learn Unity Engine and C# by creating a real top-down RPG by Epitome, as the title suggests, is all about teaching you various skills while building a fully scoped top-down RPG. Where this tutorial is slightly unique is that it focuses specifically on 2D – which is just as important to learn as 3D. Nevertheless, this course will put you through the gambit and make sure you have tons of key systems down pat!

As part of this course, you’ll cover key topics, including:

• Setting up
• Moving and Manual Collision Detection
• Tilemap and Designing Dungeon
• Interactive Objects and Inheritance
• Saving Game’s State
• Floating Text System
• Top Down Combat System
• Animator and Weapon Swing Animation
• Character Menu and the new UI System
• Polishing and Adding Content

Skill level: Novice. Some basic knowledge of Unity and C# is needed.

Duration: 7h 45m

How to access: Access the course here.

Game Design Academy

Game design is integral to developing a game. Game designers will conceptualize levels and characters, create engaging stories, and make the game feel cohesive through stylistic and narrative choices. While not “technical” in the same way coding is, it still requires purposeful choices and skills that show you can plan a game. So, though often overlooked, it is a huge step in the entire game development process.

Game Design Academy by Zenva is the perfect way to jump into this aspect of the game development process. You’ll explore the main principles of design using real-world examples, and discover how these fundamental concepts affect the overall feel of the game

More importantly, though, you’ll learn skills that will let you enhance your game projects, which in turn improves your overall Unity skills with new reasons to learn specific skills and tools.

As part of this course, you’ll cover key topics, including:

• Core game loop setup
• How to guide players
• Game feel
• Level design foundations
• Storytelling techniques

Skill level: Beginner. You don’t need any prior knowledge of Unity or C#.

Duration: 3h 5m

How to access: Access the curriculum here.

Unity’s Associate Game Developer Certification

Well, that’s all, folks – the best courses for the Associate Game Developer Certification. This certification will be a lot tougher than the previous User level. However, preparing for it with enrich your ability to make games as a whole.

This said, be assured there are a lot more courses out there, even on platforms like Zenva. The more you can learn about Unity and game development, the better off you’ll be. Plus, everyone’s learning style is different, so your “best” course may be different from what’s on the list.

Regardless, we hope these resources help, and best of luck on your certification exam!

BUILD GAMES

FINAL DAYS: Unlock 250+ coding courses, guided learning paths, help from expert mentors, and more.

ACCESS NOW

This said, standing out from the competition can be difficult, as the industry is also highly competitive. With the popular Unity engine, though, the Unity Certification program – which is industry recognized – allows you to gain credentials to boost your resume and portfolio.

In this article, we’re going to help you prepare to take the exam for the Unity Associate Programmer Certification with the best courses available. We’ve also designed this list to work for both beginners and experienced developers – so all skill levels are welcome!

Let’s jump in and start learning Unity!

What is the Unity Associate Programmer Certification?

Unity’s Associate Programmer Certification is a credential offered by Unity Technologies, the company behind the Unity game engine. The program showcases a coder’s skills and knowledge in Unity, including C# programming and game development.

Unlike the User Programmer Certification, the Associate level exam focuses primarily on C# coding, and you’ll need a detailed understanding of Unity’s API to script behaviors and objects, including UI elements, to receive this qualification. This Certification proves that you understand best practices for data structures and that you’re competent at debugging.

After passing the exam, individuals will receive the Unity Associate Programmer Certification, which they can use to demonstrate their skills and knowledge in Unity programming and game development to employers. The certification is valid for two years. After this time, individuals must renew their certificates by taking the exam again.

BUILD YOUR OWN GAMES

Get 250+ coding courses for

$1

LEARN MORE

AVAILABLE FOR A LIMITED TIME ONLY

The Benefits of the Associate Programmer Certification

The Unity Associate Programmer Certification is an advanced exam designed to showcase your skills as a game developer. Some of the benefits of this certification include the following:

Stand out in the job market

Having a certification from Unity helps individuals stand out in the job market since it proves significant skill and dedication to programming. In fact, many employers, including Unity, will list certification as a preferred requirement.

Build your programming skills

Unity’s Associate Programmer Certification is an advanced exam and involves rigorous training on many concepts within game development. As you train for the exam, you’ll develop your skills and knowledge in core aspects, including programming, scripting, game physics, and optimization.

Networking

By getting Unity Certification, you’ll have access to a growing community of professional game developers, including holders of the certification. Having a network can provide individuals with valuable opportunities for their future careers, including learning and collaboration.

What courses are best to prepare for the Associate Programmer Certification?

To prepare for Unity’s Associate Programmer Certification, you’ll need a strong understanding of the Unity game engine and C#, as well as core programming concepts. Luckily, there are many online courses suitable for learning game development that will prepare you for taking the certification. Along the way, you’ll be able to develop complete games that will form the basis of your professional portfolio.

Here are the best advanced online courses you can take that will help you qualify for Unity’s Associate Programmer Certification.

Unity Game Development Mini-Degree

While the Associate Certifications are the second level of certifications available, that doesn’t mean that aren’t achievable by beginners looking to establish goals for themselves.

Our first stop is therefore Zenva’s Unity Game Development Mini-Degree. This comprehensive curriculum offers a little bit of everything in regards to Unity. You’ll learn the fundamentals of the engine and C#, genre game mechanics, asset handling, animations, procedural generation, and much more.

This curriculum also takes a very practical project-based approach, so you’ll get the opportunity to build things such as FPS games and action RPGs for your portfolio. There are also supplemental materials such as downloadable course files and text-based lesson summaries. This means that it doesn’t matter how you learn – this curriculum can match what you need!

Plus, as mentioned, this curriculum was designed for people with zero knowledge. So, any skill level can practice with these courses!

You’ll learn:

• C# coding basics
• UI systems
• Audio effects
• Cinematic cutscenes
• Special effects
• Procedural terrain
• Animation

Skill level: Beginner. You don’t need prior experience in Unity or C#.

Duration: 36h 23m

How to access: Access the curriculum here.

C# Programming (Advanced)

As the title of the certification suggests, knowing how to program with C# is a super important aspect of this exam. However, remember that C# is a general-purpose language and was actually primarily created to make software. Thus, it doesn’t hurt to learn the language divorced from Unity.

The C# Programming (Advanced) series by Code Master does just that and focuses on C# from a software development perspective. However, the principles covered are near universal to all C# applications – so they can easily be applied back to Unity. This said, do be prepared – this series is intended for those with C# experience, and is heavily comprehensive in just about everything you can do with the C# language and programming in general!

With this course, you’ll learn the following and more:

• Delegates, lambdas, and events
• Generics
• IEnumerables
• LINQ
• Functional programming
• Dictionaries
• Lookups
• Joining data
• Programming patterns
• Anonymous types
• Conversions
• Structs and classes
• Indexers
• States
• Different architectures
• Component systems
• Zone systems
• Game mechanics such as inventories and dialogue trees

And much more!

Skill level: Intermediate. You’ll need some coding experience.

Duration: 17h 45m

How to access: Access the series here.

Survival Game Development Academy

In the complete opposite from the above, it’s also just as important to understand programming in the practical Unity setting. The best way to achieve this is simply by building games – and unsurprisingly, the more complex the systems the more you’ll learn about coding.

Zenva’s Survival Game Development Academy is a curriculum focused specifically on building one single survival game. However, in so doing, you can focus on a lot of game mechanics, such as crafting systems, inventory management, and enemy AI.

Due to the complexity of the project featured, you’ll get the opportunity to explore a ton of aspects of Unity’s API and C# in general, however, which is integral for taking the exam. Plus, you’ll get a nifty project for your professional portfolio as well.

As part of this course, you’ll cover survival game topics, including:

• Hunger, thirst, health, and sleep needs
• Day-night cycles
• Item and inventory systems
• Crafting mechanics
• Base building
• Combat and Enemy AI
• Game Saving

Skill level: Beginner. No prior knowledge of Unity or C# is needed.

Duration: 18h 45m

How to access: Access the curriculum here.

Learn to Program: C# Advanced Unity Tutorials

We’ve included a lot of comprehensive courses on this list, but what if you’re more interested in something a bit more simple and focused on just a few C# programming skills.

GameDevHQ’s Learn to Program: C# Advanced Unity Tutorials series is just for you then! Instead of learning everything you could ever imagine about C#, this series focuses on just a few advanced concepts that are both important and regularly used for game development. Thus, you can be assured there is no fluff here – just the exact material you’ll want to learn to code your game projects more efficiently.

As part of this course, you’ll cover key topics, including:

• Lists
• Enumus
• Structs vs Classes
• Nullable types
• Interfaces
• Delegate and events

Skill level: Intermediate.

Duration: 1h 46m

How to access: Access the series here.

2D RPG Academy

As part of preparing for the exam, we highly encourage exploring lots of different game mechanics. This forces you to learn and re-learn C# structures and systems, as well as focus on improving your coding efficiency.

The 2D RPG Academy by Zenva is a perfect choice when it comes to this. In this collection of courses, you’ll focus on creating a variety of 2D RPGs, including turn-based RPGs, farming sims, action RPGs, and rogue-like games.

As each project featured involves different systems, you’ll quickly expand what you can do with C# and 2D in general. Likewise, you’ll also reinforce programming certain features like character movement that are integral to any kind of game that needs to be created.

With this course, you’ll learn the following:

• Tile-based maps
• Melee & ranged attacks
• Items & inventories
• Randomized dungeons
• Mini-maps
• Enemy AIs

Skill level: Beginner. No prior coding experience is needed.

Duration: 19h 2m

How to access: Access the curriculum here.

Learn Unity Multiplayer

If you really want to advance your skills with C#, one of the best game types to practice with is multiplayer. Multiplayer involves a ton of more advanced concepts to consider when it comes to programming since networks are a subject unto themselves. Plus, with Unity’s new multiplayer system, it’s become fairly integrated with understanding the API.

Learn Unity Multiplayer by Code Monkey is the ultimate solution here. You’ll master a ton of things like synchronizing data, deciding the authoritative structure, using RPCs and network variables, balancing server-side and client-side data, and more.

There is little chance this won’t improve your C# skills in some way!

With this course, you’ll learn the following:

• Singleplayer Overview
• Install Netcode and Basic Setup
• Sync Player Movement, Client Vs Server Auth
• Sync Player Animations
• Sync Delivery Manager
• Fix Selected Counter Visual
• Sync Pick up Objects
• Sync Kitchen Object Parent
• Sync Trash Counter, Cutting Counter, Stove Counter
• Sync Plate Add Ingredients
• Player collisions
• Sync Game State & Sync Pause
• Handle Disconnects & Late Joins
• Connection Scene Flow
• Character Select Scene
• Lobby & Relay
• Game Server Hosting (Multiplay), Matchmaker, Vivox
• Multiplayer Debug Tools
• Singleplayer Option
• Gamepad Test

Skill level: Intermediate. You’ll need some coding knowledge to understand this course.

Duration: 6h 20m

How to access: Access the course here.

Strategy Game Development Academy

Strategy games aren’t just popular – they feature a ton of complicated systems. Thus, learning just how strategy games work and are programmed can be a big boost to your skills.

The Strategy Game Development Academy by Zenva allows you to explore a variety of different strategy game mechanics. You’ll learn everything from making city-builders with an emphasis on resource management to turn-based strategy games featuring multiplayer mechanics. You’ll even get to explore universal systems such as unlockable, tech research trees!

The breadth of variety here is astounding – but allows you to practice a ton of C# programming and cement it into your skill set. You can also practice expanding these games as well to further your skills and make certain you’re prepared for the exam to come.

With this course, you’ll learn the following:

• Strategy game mechanics
• Resource management
• Turn-based and real-time formats
• Enemy AI and state machines
• Multiplayer games with Photon networking

Skill level: Beginner. No prior knowledge of Unity or C# is needed.

Duration: 28h 33m

How to access: Access the curriculum here.

Unity Associate Programmer Certification Wrap Up

That brings us to the end of this list, and you should hopefully soon be ready to tackle the Associate Programmer Certification. Regardless of whether you pursue certification or not, though, these courses are sure to help you upskill.

All this said, we hope you continue to explore other courses available on platforms like Zenva and elsewhere. There is a lot to learn about Unity, and there are even higher-level certifications after this. More education on working with Unity can never hurt!

Good luck with your preparations, and we look forward to seeing new Unity experts out there in the future!

BUILD GAMES

FINAL DAYS: Unlock 250+ coding courses, guided learning paths, help from expert mentors, and more.

ACCESS NOW

The game industry is currently booming, projected to reach $372.00bn by 2023 and grow to $545.98 bn by 2028. For those interested in game art, now is a fantastic time to break into the industry with jobs galore available. However, even with a portfolio, game art is a super competitive field without some extra edge to bring you above the competition.

This is why having Unity’s User Artist Certification can give you a boost. It proves your skills, and proves your knowledge of the game engine itself (both highly valued skills for jobs). That said, how can you prepare for the exam?

In this article, we’re going to explore some fantastic courses available to help you master the art of game art and learn Unity – even if you have zero experience with the engine.

Let’s get started!

What is the Unity User Artist Certification?

Unity’s User Artist Certification showcases your core Unity skills to help you achieve a professional role as a Unity 2D and 3D artist. It will demonstrate that you can manage aspects of art assets, scene design, and use complex tools in Unity to make character creations.

To be eligible for this exam, you’ll need at least 150 hours of Unity experience and some basic knowledge of character creation, lighting, materials, and cameras. You’ll also need to undertake two to three semesters of Unity classwork or independent study and have a portfolio containing a range of completed Unity projects before applying.

Many holders of the Unity User Artist Certification will go on to become junior developers, junior artists, lighting and technical artists, content designers, or quality assurance testers.

BUILD YOUR OWN GAMES

Get 250+ coding courses for

$1

LEARN MORE

AVAILABLE FOR A LIMITED TIME ONLY

The Benefits of Unity’s User Artist Certification

Unity is the most popular game engine to date, powering half of all games worldwide. Making games using Unity will improve your chances of starting a game artist career.

Unity’s User Artist Certification is designed to showcase the professional knowledge of aspiring game artists to help them stand out against their competitors. Here are the benefits of receiving Unity’s User Artist Certification.

Boost your career chances

Having a Unity Certification will allow you to stand out in an incredibly competitive industry against hundreds of other applicants. It’s a rare credential in the game artistry industry and is used as proof that an individual has the skills needed to start a professional career. Alongside this, a Unity Certification proves dedication to being a game artist since it costs significant money and time to finish the exam.

Many Unity-based jobs list certification as a requirement, putting you in a great position to start your career in the gaming industry.

Improve your talents as an artist

You’ll need plenty of experience using Unity and C# to create game art before taking the Unity User Artist Certification, allowing you to improve your talents as a game artist. By spending at least 150 hours using Unity to create complicated characters and worlds, you’ll be more than ready to enter a professional career.

Showcase your technical skills

To obtain the Unity User Artist Certification, you need to have strong technical skills for games, apps, models, and simulations. You’ll be able to showcase your technical skills and proficiency in using Unity, one of the most popular game development programs.

What courses are best to prepare for Unity’s User Artist Certification?

To take Unity’s User Artist Certification, you need foundational knowledge of using Unity and C# for the purposes of game design. It is essential to study game artistry before applying to take the exam. Luckily, there are many online courses designed to help you improve your skills as a game designer so that you can take the Unity User Artist Certification.

Here are the best online courses you can take to prepare for Unity’s User Artist Certification.

Unity Game Development Mini-Degree

Passing the artist certification is as much about knowing Unity as it is about art. Zenva’s Unity Game Development Mini-Degree is a comprehensive curriculum designed around teaching you Unity from the ground up. You’ll work on everything from the foundations of Unity to building real-world projects that are perfectly suitable for bulking up any portfolio you might want to create.

Along the way, you’ll learn a ton of aspects relevant to the User Artist Certification – such as how the cameras work, how audio assets work, and even how to manage animations for your game projects (whether 2D or 3D).

Plus, all of Zenva’s courses offer tons of extra material to help with your learning process. This includes downloadable project files and text-based summaries so you can learn in whatever way suits you best!

With the Unity Game Development Mini-Degree, you’ll learn the following topics:

• C# coding basics
• UI systems
• Audio effects
• Cinematic cutscenes
• Special effects
• Procedural terrain
• Animation

Skill level: Beginner. You don’t need prior experience in Unity or C#.

Duration: 36h 23m

How to access: Access the curriculum here.

Intro to Game Development with Unity

If you want to start off a bit smaller with your Unity journey, Intro to Game Development with Unity by Zenva is the perfect starter.

This short course is focused specifically on people who have never used Unity in their life. As such, rather than throwing to you the deep end of the pool, it takes a light, hand-holding approach. You’ll discover how to set up Unity, what windows in the engine mean, how to work in 3D space with objects, and more. Of course, you’ll also discover some fundamentals around C# as well – so when you’re ready to start building games, you’ll have the key skills you’ll need.

By the end, the course will also get you building your first interactive project!

If you’re unsure, Zenva does offer a free sample of this course via Unity 101 – Game Development Foundations.

As part of this course, you’ll cover key topics, including:

• Installing and setting up Unity projects
• manipulating object size, position, and rotation
• How to change aesthetics with materials
• Coding variables and operators with C#
• Using various skills to create interactive games
• Building and deploying your games

Skill level: Beginner. No prior knowledge is needed.

Duration: 2h 7m

How to access: Access the course here.

Unity Pixel Art Game Tutorial – Complete Starting Setup

2D games are still thriving, so learning how those sorts of assets work in Unity is a good skill to have as well – especially for certification.

Through Unity Pixel Art Game Tutorial – Complete Starting Setup by Restful Coder, you’ll explore how to take 2D pixel art assets and bring them into Unity for game projects. This includes how to paint tilemaps in the engine, how to import your assets properly, and even some idiosyncrasies when it comes to setting up cameras and collisions.  You’ll also learn a bit about the different ways in which creating pixel art levels through parts works.

You’ll cover key topics, including:

• Unity overview
• Player character and sprite
• Player movement
• Tilemaps and background
• Obstacles and collisions
• Prevent character spinning
• Add a camera (Cinemachine) and follow player
• Make the camera pixel perfect
• Confine the camera to the background
• Fix background collision bug
• Tweak camera settings

Skill level: Novice. Some basic knowledge of Unity and C# is needed.

Duration: 51m

How to access: Access the course here.

Create your First 3D Game in Unity

One of the best ways to learn to work with game assets is to just build a game. Of course, you don’t want to start off too complicated, which is why Zenva’s Create Your First 3D Game in Unity is a great course.

Focusing specifically on 3D games, you’ll master a variety of platformer mechanics including how to work with character controllers, set up “enemies”, create coin collectibles, add UI systems, and more. Each element has its own asset requirements, of course, so you’ll learn a lot about how to manipulate art aesthetics using the tools Unity offers. Plus, by the end of the course, you’ll have a nifty entry for your portfolio and good skills to begin expanding into other relevant areas (such as lighting).

With this course, you’ll learn how to:

• Create player and enemy objects
• Construct a level with 3D models
• Script the camera to follow the player
• Set up the game-winning conditions
• Add collectible coins
• Build UI elements and menus

Skill level: Novice. You’ll need minimal knowledge of Unity and C#.

Duration: 2h 16m

How to access: Access the course here.

How to Make a Game – Unity Beginner Tutorial

In How to Make a Game – Unity Beginner Tutorial by Jason Weimann, viewers are taught the entire process of building a physics-based game using Unity. As mentioned many times before this is key to learning Unity in general, as it forces you to work with game assets in various ways.

What makes this course stand out is the fact it begins with a focus specifically on bringing and preparing your assets to actually be used in your game. So right up front, you know you’re learning about this aspect and how the basics work!

You’ll cover the following key topics:

• Sprites
• Importing Art
• Animation
• Background art
• Physics
• Coding
• Dragging
• Launching
• Obstacles
• Indicator
• Camera Controller
• Enemy
• Particles
• Prefabs
• Levels

Skill level: Beginner. No prior knowledge is needed.

Duration: 3h 4m

How to access: Access the course here.

Create your First 2D Game in Unity

The Create Your First 2D Game in Unity course by Zenva is similar to another entry on this list. Rather than 3D assets, however, this one focuses on 2D.

Throughout the course, you’ll work through building a 2D platformer featuring collectibles, enemies, character movement, UI systems, and more. You’ll even learn how you can manage your levels so you can easily make a multiple-level game.

Along the way, of course, you’ll master a ton of tips and tricks specifically for working with basic 2D assets, which come with their own sets of rules in comparison. Nevertheless, these are essential for preparing for certification, since these differences will be important professionally as well.

This course will teach you key coding techniques, including:

• Implementing player and enemy objects
• Scripting platformer-style movements
• Building levels with 2D tiles
• Setting up collectibles and scoring
• Controlling gameplay flow with goals
• Creating UIs for scores and menus

Skill level: Intermediate. Some basic knowledge of Unity and C# is required.

Duration: 1h 55m

How to access: Access the course here.

How to do Character Customization!

If you’re interested in something a little more advanced at this point, look no further than How to do Character Customization! by Code Monkey! This free course shows you how to build the ever-popular feature of allowing users to have a custom character for their gameplay experience.

As you can imagine, this will cover a lot about how assets are managed, changed, and rendered – all core skills you’re going to want to master in your practice to pass the User Artist Certification!

Key topics:

• Character Customization Unity Tutorial
• Sponsor
• 4 Methods to do Character Customization
• Characters with 3 different setups
• Change Material, Texture
• Change Mesh, Avatar, Keep Animations
• Add parts with SkinnedMeshRenderer
• Issues with SkinnedMeshRenderer
• Character Customization Unity Tutorial

Skill level: Novice. Some basic knowledge of Unity and C# is required.

Duration: 17m

How to access: Access the course here.

Unity User Artist Certification Wrap Up

This brings us to the end of our list of best courses for the User Artist Certification. We’ve covered a lot of ground here, and we just know these skills will open up new doors for you professionally and personally.

But… we’ve only been able to scratch the surface. There are thousands of courses out there, and what’s “best” may mean something different for you than it does for us. So, don’t be afraid to explore more Unity courses through platforms like Zenva – the more you learn, the better positioned you’ll be to pass the exam!

We wish you all the best of luck with the exam, and we hope we’ve made prepping for it just a little bit easier!

BUILD GAMES

FINAL DAYS: Unlock 250+ coding courses, guided learning paths, help from expert mentors, and more.

ACCESS NOW

Long story short – now is a fantastic time to learn game development – even if you intend to stay a solo indie creator. This said, for those looking to bolster their resume more professionally, you’ll need some extra “oomph” to stand out from the crowd, as plenty of other people have the same skills. Enter Unity’s User Programmer Certification, which is a quick and easy way to show you know the popular Unity engine and the programming skills needed for game creation.

As passing the exam is no walk in the park, though, in this article, we’re going to showcase our favorite Unity courses. These courses will be geared towards helping you pass that exam, and ensure you get the skills you need to be at for your career!

Let’s get started!

What is the Unity User Programmer Certification?

Unity’s User Programmer Certification is designed for aspiring game or app developers to teach them Unity’s primary capabilities and functions as a development platform. With this certification, learners are evaluated on how much they know about the fundamentals of Unity, including making projects and Prefabs and navigating the editor. Students will also be tested on C# knowledge.

The overall aim is to prove students can read, write, and understand basic code used all the time in Unity. Many receivers of the Unity User Programmer Certification go on to start postsecondary programs in game development, animation, or STEM – or alternatively, create their own successful games.

To take the exam, students must build their knowledge base of Unity and C#. Test subjects could include:

• Building projects in Unity, using C#
• Navigating the Unity interface and interpreting API basics
• Creating prototypes, debugging, and solving programming difficulties
• Programming a function state machine

BUILD YOUR OWN GAMES

Get 250+ coding courses for

$1

LEARN MORE

AVAILABLE FOR A LIMITED TIME ONLY

The Benefits of a Unity User Programmer Certification

The Unity game engine is used to power half of all games globally. Learning how to use and code with Unity is, therefore, not only beneficial for creating high-powered games, but breaking into the competitive game development and design industry.

The Unity User Programmer Certification is designed to help aspiring developers stand out in a busy crowd, as to receive this certification, you’ll need professional knowledge of not only Unity but programming with C#.

Here are the main benefits of receiving Unity’s User Programmer Certification.

Stand out in the job market

The game development job sector is incredibly difficult to break into. You’ll be up against hundreds (if not thousands) of applicants, all gunning for the same position. To have any chance of winning a developer position, you’ll need to stand out from the crowd and position yourself as a proven professional.

The Unity User Programmer Certification is a rare credential in the developer world and is recognized as proof that you have skills and dedication to game development – since there is significant cost and time involved in taking the exam.

In fact, many Unity-based job postings will list Unity Certifications as a (preferred) requirement, putting you in a much better hiring position.

Showcase your skill level

To qualify for the Unity User Programmer Certification, you must build a solid knowledge base of both the game engine and C#. It will allow you to not only improve your skill levels as you study to take the exam, but once you’ve obtained the certification, you can prove just how knowledgeable you are to potential employers.

Go from hobbyist to professional

Many Unity developers are self-taught gaming lovers, having fun creating their own animations and worlds. For some, the main goal is to be entertained and learn the ins and outs of Unity simultaneously.

However, teaching yourself a complicated tool can be difficult, especially without a guided learning path. While there are plenty of courses available online, it can be hard to know what to do after you’ve finished.

Unity’s User Programmer Certification allows hobbyists to follow a structured path, with certifications ranging from beginner to professional. Taking the exams in order will allow them to progress naturally, picking up the skills needed to move on to the next certification.

What courses are best to prepare for Unity’s User Programmer Certification?

Unity’s User Programmer Certification is designed to showcase an individual’s skills in Unity and C#, and it’s essential to build knowledge before taking the exam. There are many professional courses online that will teach you everything you need to know about making games with Unity.

Here are the best courses for preparing to take the User Programmer Certification.

Unity Game Development Mini-Degree

The Unity Game Development Mini-Degree, created by Zenva, is a comprehensive curriculum focused around Unity. With no experience necessary to jump in, users get the opportunity to learn a wide variety of tools. This includes basic engine functionality like object manipulation, to rarer tools such as ProBuilder and Cinemachine.

While mastering the fundamentals of Unity, students will also get the chance to build real-world projects for a professional portfolio. This includes games in popular genres like RPGs, idle clicks, and FPS games (to name a few). Plus, everything is made with expandable systems that you can practice with further to improve your skills.

Of course, for the sake of the certification exam, this curriculum has just about all the basics you’ll need in both Unity and C# to upskill yourself in preparation!

With the Unity Game Development Mini-Degree, you’ll learn topics including:

• C# coding basics
• UI systems
• Audio effects
• Cinematic cutscenes
• Special effects
• Procedural terrain
• Animation
• Genre mechanics

Skill level: Beginner and comprehensive. No prior experience is necessary.

Duration: 36h 23m

How to access: Access the curriculum here.

Intro to Game Development with Unity

If you’re looking just for a single course to start, then Zenva’s Intro to Game Development with Unity course is a great choice. This course is intended for ultra-beginners – i.e. people who have literally never touched Unity before in any capacity.

The course focuses on three major areas: the basic tools of the engine and interacting with objects, C# fundamentals for Unity, and combining everything to make a balloon popper game. Together, these cores will set you up for success in beginning your Unity education journey, as the skills will serve you as you move into more complicated projects.

Likewise, it is worth noting this course is suitable for younger users – as young as Grade 8. Thus, you don’t have to wait at all to start learning.

Lastly, if you’re a bit hesitant, you can try a free course sample by taking Unity 101 – Game Development Foundations, which covers the basics of setting up and using key tools of Unity.

Intro to Game Development by Zenva Academy covers key topics, including:

• How to install and set up Unity projects
• How to manipulate object size, position, and rotation
• Ways to change aesthetics with materials
• Code variables and operators with C#
• Combining various skills in order to create interactive games
• How to build and deploy your games

Skill level: Beginner

Duration: 2h 7m

How to access: Access the course here.

How to Program in C#

With the name being User Programmer Certification, you might imagine there’s going to be quite a lot of C# knowledge expected. So, learning to program with C# is kind of a bit point.

In the How to Program in C# series by Brackeys, you’ll focus more specifically on C# itself and learn all the principles you’ll need to apply in Unity. These videos are also designed to keep games in mind – so you don’t have to worry about it not being too divorced from Unity either.

The series includes the following topics:

• Input and output
• Variables
• Conditions
• Loops
• Array
• Functions
• Classes

Skill level: Beginner

Duration: 2h 4m

How to access: Access the series here.

Unity Mini-Projects – C# Fundamentals

Unity Mini-Projects – C# Fundamentals by Zenva is a beginner-oriented course aimed at helping users expand their Unity and C# knowledge by applying them to real-world projects. These mini-projects are designed both to build out learners’ portfolios while also teaching them a number of C# techniques.

The projects featured for the course are a balloon popper with a scoring system, an efficient object spawner, and bowling and skiing mini-games. Through these, users get the chance to play with physics and more as well, rounding out their Unity education.

This is also a great stop if you don’t feel ready to jump into full games yet, since this lets you experiment with basic interactivity first.

Broader skills will also be covered, including:

• Implementing multiple scripts in one project
• Building user interfaces
• Dealing with user inputs
• Detecting collisions between game objects
• Accessing object data through C# scripting
• Applying physics to objects.

Skill level: Novice, but some basic Unity and C# skills are required.

Duration: 1h 40m

How to access: Access the course here.

How to Make a 2D Game

Sometimes, the best way to learn Unity is just to build games and experiment with various features. As Unity is able to do both 2D and 3D games, though, it can be beneficial to learn both.

In the case of this entry, the How to Make a 2D Game series by Brackeys will cover 2D specifically. From the fundamentals of just making a game in the first place to working with Unity tools like lighting, this series has a little bit of everything. All are in line with what you’ll need for the certification exam, however, so it’s a good jack-of-all-trades series to start preparing.

With this course, you’ll learn the following key topics:

• 2D Movement
• Animation
• 2D Camera
• 2D Shooting
• Organic Levels
• Lights
• Top Down Shooting
• Melee Combat
• Making a Boss

Skill level: Beginner

Duration: 2h 9m

How to access: Access the series here.

Create Your First 3D Game in Unity

As a companion to the entry above, you don’t want to neglect 3D game development either. That’s why the Create Your First 3D Game in Unity by Zenva is an excellent next step in your journey

This course covers creating a 3D platformer project that is designed to teach you some of the most common game mechanics you’ll want to know. This includes how to craft levels through the scene editor, how to add collectibles, how to add enemies that can trigger game-overs, and how to set up a simple UI. Of course, you’ll also learn 3D player movement – which is essential knowledge to have no matter what direction you go!

With this course, you’ll learn techniques such as:

• Creating player and enemy objects
• Constructing a level with 3D models
• Scripting the camera to follow the player
• Setting up the game-winning conditions
• Adding collectible coins
• Building UI elements and menus

Skill level: Novice. You’ll need basic knowledge of Unity and C#.

Duration: 2h 16m

How to access: Access the course here.

Learn Unity Beginner/Intermediate 2023

Designed to teach users how to write high-quality code by making a complex project, the Learn Unity Beginner/Intermediate 2023 course by Code Monkey is an all around master course for covering every Unity basic. With this course, you’ll make a fun arcade game while learning the complexities of both Unity and C#. This includes everything from more intermediate C# coding to working with things like sounds.

This said, it is still relatively beginner-friendly – so perfectly suited to passing the User Programmer Certification.

With this course, you’ll learn topics such as:

• Unity Layout
• Visual Studio
• Code Style, Naming Rules
• Importing Assets
• Post Processing
• Character Controller, Visual, Rotation
• Animations & Cinemachine
• Collision Detection
• Interact Action, C# Events
• Selected Counter Visual, Singleton Pattern
• Player Pick up, Drop Objects
• Cutting, World Canvas
• Music & Sound Effects
• Main Menu, Loading

Skill level: Novice. You’ll need some basic knowledge of Unity and C#.

Duration: 10h 49m

How to access: Access the course here.

Unity User Programmer Certification Wrap Up

With these Unity courses, you should be more than prepared to take on the User Programmer Certification. While the exam sounds intimidating, do keep in mind the exam was also made to be suitable for high school students to be able to take and pass as well. Thus, as the entry-level certification, you don’t yet have to be a Unity expert!

This said, we do encourage you to explore more courses. Zenva, for instance, offers far more Unity courses than we could mention here. And the more you know about Unity, the better your opportunities will be. Plus, there are even higher-level certifications to look for after this, so more preparation won’t hurt for that either.

No matter where your path takes you, we wish you the best of luck with your game development adventures!

BUILD GAMES

FINAL DAYS: Unlock 250+ coding courses, guided learning paths, help from expert mentors, and more.

ACCESS NOW

If you’re looking to break into the gaming industry, having VR coding skills is a surefire way to get a foothold in the door. Of course, plenty of people already had this idea – so how do you stand out from the crowd? The answer here is Unity’s User VR Developer Certification, one of the few certifications available to showcase that you have the skills you’re boasting. However, preparing and passing the exam is a challenge in and of itself – but thankfully there are resources available to save the day.

In this article, we’re going to discuss some of our favorite resources that will help you learn the VR skills you need to not only to succeed in making VR projects in general, but in passing your User VR Developer Certification exam.

Let’s dive in!

What is the Unity User VR Developer Certification?

Unity’s User VR Developer Certification is an exam-based certification designed to show employers and postsecondary programs that you have a solid understanding of VR experiences in Unity. The focus here is on showing that you understand how to consider adaptations to games for VR.

To take this certification exam, you’ll need some foundational skills in both Unity and C# programming since this is an advanced qualification. Additionally, you’ll also need to pass Unity’s Certified User Programmer Certification first.

All Unity’s certification exams were developed through careful research and collaboration with testing specialists and game development experts. Currently, the tests are administered by Pearson VUE, a renowned educational company, meaning the certifications are regarded highly by industry professionals.

BUILD YOUR OWN GAMES

Get 250+ coding courses for

$1

LEARN MORE

AVAILABLE FOR A LIMITED TIME ONLY

The Benefits of a Unity User VR Developer Certification

The Unity User VR Developer Certification is designed to help professionals break into the growing VR industry. Here are the main benefits of taking this exam.

Stand out in the job market

Unity’s User VR Certification shows employers that you have the knowledge and skill levels needed to succeed in a VR developer position, giving you a competitive edge over other professionals. Since certifications are rare in the gaming industry, having a Unity Certification will help you stand out against other professionals. You’ll also have a better chance of getting a Unity-based job, which will often list a Unity Certification as a requirement.

The certification is industry-recognized and can be included on your resume and professional portfolio.

Improve your skill level

This certification showcases your abilities to create VR experiences and programs using Unity. You’ll need to put in 200 hours of Unity training before obtaining the certification, improving your skill levels over time. Naturally, preparing for the exam also improves your skills by association.

What courses are best to prepare for Unity’s User VR Developer Certification?

To be eligible for Unity’s User VR Developer Certification, you must have some base knowledge of virtual reality. Luckily, there are many courses online that will teach you the basics of VR coding, development, and design.

Here are the best online courses you can take to boost your skills, all from the comfort of your home.

Virtual Reality Mini-Degree

Zenva’s Virtual Reality Mini-Degree is a comprehensive collection of courses designed to teach you everything that you need to know about VR. You’ll start from the ground up in this curriculum – first learning the Unity engine itself and then mastering a variety of VR principles and mechanics. These include working with controllers, different styles of movement, and so on.

Throughout the courses, you’ll also get hands-on experience with projects – such as a kitchen simulator – which can also be used to build out courses.

Many courses in this set also come with supplemental material to cement your knowledge, including live coding exercises, quizzes, course files, and downloadable text summaries to help you refresh your knowledge!

Overall, this is a truly comprehensive choice whether you’re new to Unity entirely or are just ready to learn the features of VR.

You’ll also learn the following key topics:

• Coding basics with C# and Unity
• Movement options
• VR-optimized UI design
• Hand-tracked controllers
• Industry best-practices
• Simulations and games

Skill level: Comprehensive

Duration: 17h 46m

How to access: Access the curriculum here.

How to make a VR game in Unity in 2022

Valem Tutorials’ How to make a VR game in Unity in 2022 series is designed to give you the basic knowledge needed to get into VR development. With the focus specifically on VR (so assuming you know some Unity already), these videos cover a wide array of topics. This includes movements and controllers – even covering how to grab with two hands!

The series also includes some other important considerations as well, such as dealing with motion sickness – which is a very common issue for VR projects.

Various topics include:

• Introduction: how to make a VR game in Unity
• Input and Hand Presence
• Continuous Movement
• Teleportation
• Hover, grab, and user interactable
• Offset and distance grab
• User interface
• Two hand grab

Skill level: Beginner

Duration: 3h 10m

How to access: Access the playlist here.

Intro to Game Development with Unity

If you’ve literally never touched Unity before, Zenva’s Intro to Game Development with Unity course is perfect. While there’s nothing pertaining to VR in it, as it is an ultra-level beginner’s course, you will learn all about Unity as a tool itself.

This includes how to do basic things like navigate the various windows, manipulate game objects, and so forth. You’ll also dive into C# programming and learn some basic coding principles.

So, while this course isn’t about VR itself, it’s an important step on the path. You have to learn Unity itself first before you can learn VR!

If you’re on a budget – or just aren’t sure about the course – there is a free course sample available via Unity 101 – Game Development Foundations. This will give you an idea of what to expect and help you get your feet wet without investing too much here yet.

Intro to Game Development with Unity covers topics such as:

• Install and set up Unity projects
• Manipulate object size, position, and rotation
• Change aesthetics with materials
• Code variables, operators, and more with C#
• Combine various skills to create interactive games
• Build and deploy your games

Skill level: Beginner level. No prior experience is needed.

Duration: 2h 7m

How to access: Access the course here.

How to Make VR Games in 2022

How to Make VR Games in 2022 by Justin P Barnett teaches you how to set up your first VR project on the fairly recent version of Unity, including basics on how to use the “grab interactable” tool to pick up objects in VR and the locomotion system. This fairly short but straightforward course is designed to give you the very basics you need to work with VR. While there is a lot more to explore, the foundations established here will set you on the right path forward!

Key topics covered in this course include:

• How to set up a new Unity project for VR
• How to import the Unity XR Interaction Toolkit package
• How to set up an introductory VR scene
• How to set up basic VR movement
• How to pick up objects in VR
• How to test your app on PC, Mac, or Linux
• How to add our VR template to Unity

Skill level: Beginner

Duration: 26m

How to access: Access the course here.

Build a Micro-VR Game

In the Build a Micro-VR Game course, created by Zenva, you’ll explore some basic VR coding techniques while creating a small outdoor grilling VR experience. The course covers some of the most fundamental concepts – including how to grab things with controllers and how to use teleportation-style movement.

You’ll also learn how to adjust your game to be deployed on various VR devices, including Oculus Rift, Oculus Quest, Oculus Go, SteamVR, and more. All of this is to help prepare you to develop any VR rig.

Worth noting as well is that this course does not focus on Unity’s XR Interaction Toolkit. As this technology has become the predominantly covered aspect for VR, this course gives you the chance to explore other ways to create VR experiences that can be useful for the future!

Key topics covered:

• Understand the difference between virtual reality, augmented reality, and mixed reality
• Create an environment for grilling and change the color of assets
• Set up Unity for a variety of VR devices
• Implement hand controllers that can pick up and place objects down
• Develop a teleportation system so players can move around the map

Skill level: Beginner

Duration: 1h 56m

How to access: Access the course here.

Learn Unity – Beginner’s Game Development Tutorial

Learn Unity -Beginner’s Game Development Tutorial by freeCodeCamp.org is another entry on this list that isn’t really focused much on VR. Still, as stated in a previous item, learning the fundamentals of Unity first is not only recommended, but required if you want to learn VR.

For complete beginners, this course is a good place to start as you’ll learn the foundations of using Unity. You’ll explore a ton of C# programming fundamentals not covered elsewhere as well, so if you want a full gambit for C# this is also an excellent resource.

Key topics covered:

• Downloading Unity And Unity Hub
• Camera Follow Player
• Enemy Animations, Script, Spawner, and Collision
• Unity’s UI System
• Navigating Between Scenes
• Selecting A Character
• Static Variables
• Singleton Pattern
• Events And Delegates

Skill level: Beginner

Duration: 7h 24m

How to access: Access the course here.

Discover the XR Interaction Toolkit for VR

When it comes to Unity, the XR Interaction Toolkit is considered the new standard for building VR projects. This new system basically forgoes any form of coding. Instead, everything is component based – so making an item interactable is as easy as dragging on the right components and adjusting the settings.

In Zenva’s Discover the XR Interaction Toolkit for VR course, you’ll learn just that – how to use the XR Interaction Toolkit. This course covers all the basics you’ll need to get started, including teleportation and hand-grabbing controllers. All the while, you’ll also create a nifty kitchen simulator project to add to your portfolio!

Key topics covered:

• Set up the XR Interaction Toolkit
• Create interactable objects
• Implement teleportation-style movement
• Deal with hand-grabbing controllers
• Add particle effects based on object orientation

Skill level: Beginner to intermediate – Unity skills are expected.

Duration: 59m

How to access: Access the course here.

Unity User VR Developer Certification Wrap Up

And there we have it – the best courses to prepare for getting the User VR Developer Certification from Unity.

While we’ve given you a lot of material to work with, we encourage you to explore as many courses as physically possible. Remember, you have to pass the User Programmer Certification first, so you’re going to need to ramp up your Unity skills quickly in order to even prepare for this particular exam. So please continue to browse sites like Zenva and master all that you can. The more you learn Unity, the better position you’ll be in!

We hope these courses help you start your preparations, and we wish you the best of luck in becoming a VR expert!

BUILD GAMES

FINAL DAYS: Unlock 250+ coding courses, guided learning paths, help from expert mentors, and more.

ACCESS NOW

Things such as sparkles shot from magic wands or fire sparks coming from a bonfire are small details that can add much more credibility to the sceneries and games we create. They are also an important aspect of “game feel” that can just, in general, improve the user’s experience with the game. So – as you can imagine – it doesn’t hurt how to learn to do them as a developer.

In this quick tutorial, we’ll show you how to make fire particles in Unity. We’ll go over the settings and adjustments needed to bring your particles alive inside this powerful game engine. Moreover, you’ll also have a glimpse of the numerous features Unity has already available for you to explore when designing your particle systems.

Let’s dive in!

Project Files

You can download a copy of the source code files for the project done in this tutorial here.

This tutorial assumes you have a few basics of Unity and, most importantly, that you have Unity installed. Also, just to be clear, we are using Unity’s default particle system, not the VFX graph. That’s a tutorial for another day.

BUILD YOUR OWN GAMES

Get 250+ coding courses for

$1

LEARN MORE

AVAILABLE FOR A LIMITED TIME ONLY

Unity’s Particle System

First, let’s create a particle by right-clicking in the Hierarchy and selecting Effects > Particle System:

In the small pop-up menu at the bottom of the scene, we have several configuration options at the ready:

We can pause, stop or restart the particle emission by altering the playback time of the particles, and also slow it down by changing the playback speed. By checking the ‘ShowBounds‘ checkbox we can also see how far the particles are reaching:

This comes very in handy for us to quickly test how our particles are behaving. Nonetheless, we have a much richer range of settings for our particle system inside the Inspector:

Each tab has a different feature you can apply to your particle. We see that the Emission and Shape ones have a little check symbol in front of them, meaning that they are currently enabled for our particle system. The Emission tab controls how many particles we emit over time, while the Shape tab indicates the sort of shape we’re emitting from (a cone, a box, a circle, etc) and sets up the angle and radius, among other properties:

Another tab that’s checked in is Renderer, which allows us to customize how the particles face the camera. Right now they are set to ‘Billboard’ and if we change it to ‘Horizontal Billboard’ we’ll see the particles flat as well but facing the up direction instead:

We can also change the material of the particles in this tab, as well as the trail material. To add any trails to your particles, you need simply to enable the Trails tab:

Particle System Properties

Let’s see all these properties in action! We have:

• Start Lifetime – Dictates how long the particle exists in the world

Going back to the Particle System tab, if we bring down the Start Lifetime property from 5 seconds to 1 second we immediately see how it changes in height, as the particles are only alive for 1 second now:

To add a more organic feel to it, you can click on the arrow next to the value entered and select “Random Between Two Constants“. You can then enter two numbers, such as 0.5 and 1.5:

Note how the particles don’t all disappear at the same time anymore. We can do so with the Start Speed property as well to add more variety in how fast the particles are emitted.

We also have:

• Start Size – how large the particles are when they start out
• Start Rotation – the rotation of the particles when being emitted
• Start Color – the color we want the particles to be
• Simulation Space – designates the spread of the particles in the world

If we switch Simulation Space from ‘Local’ to ‘World‘, we see that the particles are now being moved along with our cursor to whatever position we place it:

Other interesting tabs are Velocity over Lifetime and Color over Lifetime, where we alter the speed and color of our particles over their lifetime periods. We can use the latter to make our particles fade out as time goes by:

Or have multiple colors to our gradient as follows:

Going to the Size over Lifetime tab, it allows us to change how large the particle is over time, based on an animation curve as seen below:

You can edit the curve by adding points to it and the particle will reflect the changes directly:

The Noise tab is also helpful to add some randomness and organic movement to our particles:

Remember to be careful of the Collision tab, as it adds a collider to every single particle and you may have an impact on performance by having too many of them. You can add colliders to make an explosion effect and also trigger an OnCollisionEnter function for that, for example.

Let’s put all this to use by creating our fire particle!

Fire Particle in Unity

Create a new particle system and name it “Fire Particle”. From there, let’s change how the particles look by setting the Render Mode to Mesh and the Material to Sprites-Default in the Renderer tab:

In the Particle System tab, set Start Lifetime to 1 – 1.5, Start Speed to 0.2, and Gravity Modifier to -1. Also set Shape to Sphere and Shape Radius to 1 (or 0.5) in the Shape tab:

Next, enable the Color over Lifetime tab, and set the Color gradient to the one below:

Back to the Particle System tab, set the Start Size to 1 – 1.5:

Enable the Rotation over Lifetime tab, and set the Angular Velocity to 45 – 90:

Also enable the Size over Lifetime tab, and set the Size curve to the one below:

You can bring the first point more to the left-up corner for the fire to get bigger faster as well, and then it’ll get smaller as time goes by. Feel free to tweak this as you like.

Finally, set Rate over Time to 20 in the Emission tab:

If we change the background color of the camera to a solid black, we can better visualize our fire particle all set up:

Notice how it’s changing color and has the fading-out effect, just as wanted!

Conclusion

Well done on concluding this tutorial!

Here you learned how to create simple fire particles in Unity in a fast and easy way! This is your first step towards designing all other sorts of particles, whether you want portal effects, magic attacks, or more. Unity allows us to customize our particles quite a lot through its default Particle System, and the more you explore it the more organic your particles will look.

We encourage you to practice with the Particle System more and try coming up with unique designs on your own! You may also want to take a look at Unity’s VFX Graph at some point as well, which takes particles to a whole new level with more power and performance – and much of the same fundamentals at play.

Regardless, good luck with your games, and we hope they “feel” that much more exciting!

Want to learn more about particles in Unity? Try our complete Intro to Particle Systems for Games course.

BUILD GAMES

FINAL DAYS: Unlock 250+ coding courses, guided learning paths, help from expert mentors, and more.

ACCESS NOW

With a ton of game engines available, though, how do you pick?

In this article, we’ll be exploring Unity and Godot – two powerful and popular game engines used for 2D & 3D games.

When looking for a game engine, it’s essential to assess its versatility, power, and popularity within the industry. We’ll be taking a look at several factors – such as their versatility and industry presence, and also get you learning resources so you can dive into the engine of your choice.

If you’re ready to pick your game engine, let’s get started!

What is a game engine?

Before we get started, for those new to game development, we first want to talk a bit about what a game engine is. In this way, the reason why a game engine can help you is more clear (and you can temper your ambitions by thinking you need to make your own).

A game engine, sometimes referred to as game architecture or game framework, is a software development environment complete with settings and configurations that improve and optimize the development of video games, integrating with various programming languages.

Game engines can include 2D and/or 3D graphics rendering engines that are compatible with different import formats. They will also often include a physics engine that simulates real-life properties, AI that is designed to respond to the player’s actions, and a sound engine that controls the sound effects within the game.

As stated previously, game engines are primarily designed to make your life easier. Without them, not only would you have to program your game mechanics, but instructions for your computer on how to access and play sounds, how to display your graphics, and so on. This quickly becomes a huge tedium of work – which is often why a big deal is made whenever a AAA company makes a new in-house engine; they really change everything about how a game runs in general.

To summarize, game engines are simply a powerful tool for your game development arsenal. They make sure you aren’t stuck programming every single tiny detail (unless you want to), and get to have fun with the stuff most players actually care about.

BUILD YOUR OWN GAMES

Get 250+ coding courses for

$1

LEARN MORE

AVAILABLE FOR A LIMITED TIME ONLY

Versatility

There are a variety of different types of games that you can choose to develop, from 2D to virtual reality. A good game engine will support coders in creating a wide range of games, and both Unity and Godot do this. Here are the different types of games you can choose to develop and how Unity and Godot can support your development journey:

• 2D. Both engines are more than capable of developing 2D games, with Unity giving its users a broad tool set. However, new updates to Godot 4 have significantly improved its ability to create 2D games, including 2D lighting, 2D materials, 2D light & shadow support, and 2D masking and clipping. It’s also worth noting that Godot offers an actual dedicated 2D engine, while Unity still technically uses its 3D engine to render 2D games. This has some performance implications for more complicated projects.
• 3D. While Godot is capable of making 3D games, it isn’t as powerful and doesn’t have as many features as Unity. In terms of graphic fidelity, Unity is therefore the superior choice. That said, Unity is consequently the heavier-duty engine and may not work as well on older computers as Godot.
• Augmented Reality (AR). There are currently no AR capabilities for Godot, whereas Unity has an established AR interface and has been contributing to AR output for years.
• Virtual Reality (VR). Unity is an excellent game engine in terms of VR, as the plugins used are versatile and are able to integrate into the XR infrastructure. While VR capabilities have improved with Godot 4, export doesn’t yet work for meta quests due to licensing issues. For now, Unity is still the superior choice.
• Mobile. Both Godot and Unity have mobile capabilities. That said, Unity perhaps offers a few more tools when it comes to the actual development process, such as the Device Simulator.
• Multiplayer. Both platforms have multiplayer features to offer. The Godot 4 update in particular has massively improved the ability to make complex multiplayer games. The update includes improvements in scene replications, RSET, and state updates. As for Unity, with the recent release of the Unity Multiplayer Networking features, it’s easier than ever to develop multiplayer projects. In this area, both over a relatively good basis to work from.

Coding

The coding language you are most comfortable with will have a determining factor in what game engine you decide to use.

Unity uses C# for its scripting logic, which is generally considered a fairly well-balanced language to learn. This language offers some enhanced readability compared to C++, but has a plethora of advantages that other high-level languages can’t offer.

If coding plainly isn’t your thing, Unity also does offer a visual scripting option in its newest versions. This drag-and-drop approach means you don’t have to learn tedious C# syntax, but still get all the game logic you would with regular coding.

In comparison, while Godot is compatible with a few languages, its main language focuses are GDScript and C#. We’ve spoken about C# already for Unity, but GDScript is perhaps Godot’s “main” language. This Python-like language is made to be super easy to read and use with the Godot engine specifically (as it was developed by the Godot team). While this doesn’t have the versatility of C#, it does come with a variety of benefits for making games that much easier to make.

Industry Presence & Popularity

The game engines that professional developers are using is a good way to judge the versatility and usability of the software. Unity and Godot are both popular game engines used to create high-powered games that are popular on the market. However, each has different uses.

Unity is popular with AAA and indie developers alike because of its abundant resources. These resources include things like instant assets, online community assistance, Unity-provided tutorials, and intuitive tools for a variety of applications. It offers a lot of developer support along the way, and makes the coding process easier compared to other similar game engines. Plus, Unity offers tons of companion services (such as monetization for mobile games), making it a one-stop shop for many users.

There’s also the benefit that the Unity game engine is as powerful as it is popular. Thus, it’s been able to spread to a ton of other industries such as film, architecture, and so much more.

Popular games created using Unity include Hearthstone, Cities: Skylines, Rust, Ori and the Blind Forest, and the majority of mobile games.

In comparison, Godot is a lot younger than Unity and doesn’t have the same presence. However, Godot is quickly rising to become a major competitor. Godot also has an advantage that Unity does not in terms of development: it’s open source. As such, developers get ultimate control over the engine itself and, if push comes to shove, can make the engine do what it wants.

Despite its youth, Godot has been used to create many successful games including Kingdoms of the Dump, Cruelty Squad, Rogue State Revolution, and Dungeondraft.

Community

A strong and supportive community is very important when choosing a game engine, as you’ll be able to seek support from subreddits, YouTube channels, Discord chats, and whatever else there is to offer (plus, asset stores count here too). Luckily, both Unity and Godot have thriving communities offering help to new and seasoned developers.

• Unity has a game developer convention held yearly called Unite. The event mostly focuses on how to use Unity with some YouTubers teaching engaging classes.
• Unity also has a subreddit providing expert advice and knowledge, and a YouTube channel with tutorials from expert developers.
• Godot also hosts many in-person and online events, such as Godot @ GDC 2023, where developers will showcase their new games made using Godot.
• Godot helps its community with a subreddit, and has their own YouTube channel as well.
• Godot is active in a ton of other channels such as Discord, Twitter, and so forth – all of which are viewable on their promoted Community page.

Both Unity and Godot also have an asset store – a marketplace for 3D models, textures, systems, etc. that can be used on the engine (with free and paid options). These assets are beneficial for developers who need extra assistance in design or coding, and are largely community supported.

This said, if we had to pick, we would note that Unity’s community is larger simply because of its longer-established reign as a popular game engine.

Cost

Last but certainly not least, let’s talk about money. What would using these game engines cost you?

Unity has a free plan – but there is a catch. In general, the rule of thumb is that once you’re earning $100K annually, you need to purchase a paid plan. That said, the majority of users will be fine with the free plan (so unless you become a AAA overnight, don’t worry too much about it).

This said, the free plan does come with fewer features, though this centers more so around developer support. For the most part, the free version still includes things like the platform itself, core features like visual scripting, and even the Unity Plastic SCM for version control (3 users and 5GB of storage).

The paid plans are as follows, though, if you’re interested:

• Plus – $399 per year per seat
• Pro – $2,040 per year per seat
• Enterprise – Custom quotes depending on need

By comparison, since its open-source Godot is entirely free, with absolutely no strings attached. Of course, this does mean it doesn’t offer the same sort of premium services Unity does, but it can be less stressful to know there can’t be any shenanigans.

Tutorials & Courses

At this point, you’re probably leaning one way or another on whether to pick Unity or Godot. However, the best way to find out your preference is simply to try them out. So, to get you started (and demonstrate the quality of learning materials available), we’ve listed out some of our favorite resources.

Unity

• Unity Game Development Mini-Degree, Zenva. With this curriculum, you’ll explore a variety of tools and features Unity has to offer. In addition, you’ll get the chance to build a ton of projects suitable for a professional portfolio. You’ll not only learn the fundamentals of game development, but make real games including RPGs, idle games, and FPS games.
• Unity 101 – Game Development Foundations, Zenva. This free course teaches you the very basics of how Unity works and allows you to start playing with your first game objects. You’ll also learn skills needed to build your own games in any genre you choose.
• How to Program in C#, Brackeys. This free YouTube course teaches you how to read, write, and understand C# coding from scratch, and lays the foundation for learning Unity.
• C# Tutorial, Derek Banas. In this tutorial, you’ll learn how to install Visual Studio and Xamarin. You’ll then cover key programming knowledge including input, output, loops, data types, and more.
• C# Basic Series, Allan Carlos Claudino Villa. In this free course, you’ll cover everything there is to know about C# to give you the knowledge needed to create games with Unity.

Godot

• Godot 101 – Game Engine Foundations, Zenva. With Godot 101, you’ll learn the fundamentals of working with the Godot 4 editor, including understanding the core difference between Nodes and scenes. Plus, you’ll get experience working with both 2D and 3D objects!
• Godot 4 Game Development Mini-Degree, Zenva. This comprehensive collection of courses gives you the knowledge needed to build cross-platform games using Godot. You’ll be given the tools needed to create 2D and 3D games including RTS games, platformers, and survival games.
• Make Your First 2D Game with Godot: Player and Enemy, GDQuest. Learn to create your own games using Godot in this beginner tutorial series, hosted on YouTube. This course gives you an entire run-through on using Godot to program different game types, perfect for complete novices.
• Make your first 2D platformer game In Just 10 Minutes, Eli Cuaycong. In this short tutorial, you’ll learn the basics to help you with your game development journey, including tile maps, world scene, and spritesheets.

Conclusion: Unity vs Godot – which is better?

Now we’ve covered the differences between Unity and Godot, let’s get back to the ultimate question – which game engine is better?

This entirely depends on what type of game you want to make, the game’s style and needs, and what kind of knowledge you’re bringing to the table.

For instance, for 3D, AR, or VR games, Unity is definitely the superior choice as it offers all the tools needed and the power to make those games work. However, on the opposite end of the spectrum, Godot is definitely the winner when it comes to 2D given it’s the dedicated and more performant rendering engine for this aspect.

Even then, there are exceptions even to the above! For example, a game like Paper Mario would probably work better with Unity, whereas a 3D game might work better with Godot in cases where you need to work with the engine’s code itself.

Regardless, both are truly great options, and you can’t go wrong with either. Plus, with plenty of courses available for both, they’re both easy to learn.

Regardless of your choice, we wish you the best of luck with your future games!

BUILD GAMES

FINAL DAYS: Unlock 250+ coding courses, guided learning paths, help from expert mentors, and more.

ACCESS NOW

That said – would it surprise you to learn that balancing audio is hard and not everyone wants that gushing waterfall overriding the character dialogue? This is why, for many players, having sound settings is super important so they can customize the experience to their needs.

In this Unity tutorial, we’ll go through how to set up sound settings for the master volume, as well as the volumes for sound effects and music. For that, we’ll take a look at the audio mixers in Unity, its different groups, and how to create a canvas with sliders for each group that the players can adjust to their liking.

Let’s get started!

Project Files

You can download a copy of the source code files for the project done in this tutorial here. This tutorial requires good familiarity with Unity and C# scripting.

BUILD YOUR OWN GAMES

Get 250+ coding courses for

$1

LEARN MORE

AVAILABLE FOR A LIMITED TIME ONLY

Audio Mixers

The Audio Mixer feature of Unity allows you to mix various audio sources, apply effects to them, and perform mastering. It is an asset that we can create by going Right-click > Create > Audio Mixer:

You can double-click on the icon to open up the Audio Mixer window:

By default, we have the Master group, which overrides every single audio source in the game. This allows us to adjust the Pitch and the Volume of the overall audio of the game in the Inspector:

Modifying Audio in Script

In order to modify the volume in a script, we need to right-click and select ‘Expose Volume (or pitch) to script‘:

Now it will appear in the Exposed Parameter dropdown list:

Audio Mixer Group

To create a new group, you can click on the + button in the Groups section. We’re going to create two new groups, which are Music and SFX for sound effects:

Now that we have SFX and music as children of the master group, we need to assign these to specific audio sources. For example, if you select the Player object of your project, you’ll see there is a property called Output inside the Audio Source component. This is where our Audio Mixer Group is going to be sending the modified audio in:

If you assign this to the SFX group, you will be able to modify the output inside of the Audio Mixer window:

Volume Settings

Next, we’re going to be setting up the visual UI (User Interface) for volume settings.

Creating UI Canvas

First of all, we’re going to create a new GameObject called Canvas, which contains all of the UI elements.

To create a canvas, right-click on the Hierarchy > UI > Canvas:

If you select the Canvas and press F, the screen will be zoomed out to focus on it:

Adding Image To Canvas

To add an Image object to the Canvas, we’re going to right-click on Canvas and go to UI > Image:

As you can see, it has created a brand new Image object, which is a child of Canvas:

Let’s rename this Image to ‘VolumeSettings‘:

Resizing Canvas Components

To change the size of the element, you can drag it around with the Rect tool selected:

You can then click and drag on the blue circles to change the size of the image:

Or you can click and drag on the sides to resize them along that specific axis:

Alternatively, you can set the specific Width and Height using Rect Transform in the Inspector:

We’re going to click on the Color property of the Image component and change it from white to black:

Adding Text

We recommend you use TMP (TextMeshPro) instead of Unity’s default Text because it provides more flexibility in font settings:

You can import the package when adding the first TMP object to the scene (Right-click > UI > Text – TextMeshPro):

Once that’s complete, you can give it a new name (e.g. ‘HeaderText‘), type in a header (e.g. ‘Volume‘), and modify the font settings in the Inspector:

What we’re going to do now is create three separate sliders for adjusting the Master Volume, the SFX Volume, and the Music volume as follows:

To create a new Slider, right-click on the sub-heading (e.g. “Master Volume”) and select UI > Slider:

You can then scroll down to the Slider component in the Inspector to set the Min Value and the Max Value of the slider. Since we’re working with dB (decibels), the maximum value would be the original volume of the audio clip, which is 0 dB, and the minimum value would be -40 dB:

We can then duplicate this by pressing Ctrl + D (or Cmd + D):

Scripting The UI

Now that the UI objects are all set up, let’s create a new C# script called “Volume UI” and attach it to the parent Canvas object:

Inside the script, first of all, we need to import the TMPro, Audio, and UI library at the top of our script to be able to utilize these features in our script:

using TMPro;
using UnityEngine.Audio;
using UnityEngine.UI;

And then we’re going to declare a few public variables so we can access and modify the UIs that we created earlier:

public class VolumeUI : MonoBehaviour
{
    public AudioMixer mixer;
    public GameObject window;
    public Slider masterSlider;
    public Slider sfxSlider;
    public Slider musicSlider;
}

Then we need to create a new function called “SetSliders” to load the saved volume settings (float) from PlayerPrefs, for instance.

PlayerPrefs is an easy way to store and access important data between game sessions. For more information, refer to the documentation: https://docs.unity3d.com/2020.1/Documentation/ScriptReference/PlayerPrefs.html

// called at the start of the game
// set the slider values to be the saved volume settings
void SetSliders ()
{
    masterSlider.value = PlayerPrefs.GetFloat("MasterVolume");
    sfxSlider.value = PlayerPrefs.GetFloat("SFXVolume");
    musicSlider.value = PlayerPrefs.GetFloat("MusicVolume");
}

This function is going to be called at the start of the game, so the player doesn’t have to reset the volume settings every time they open up the application. That being said, if there is any saved volume property found in PlayerPrefs (HasKey), then we need to set the mixer volume levels based on the saved PlayerPrefs before setting the sliders:

void Start ()
{
    // do we have saved volume player prefs?
    if(PlayerPrefs.HasKey("MasterVolume"))
    {
        // set the mixer volume levels based on the saved player prefs
        mixer.SetFloat("MasterVolume", PlayerPrefs.GetFloat("MasterVolume"));
        mixer.SetFloat("SFXVolume", PlayerPrefs.GetFloat("SFXVolume"));
        mixer.SetFloat("MusicVolume", PlayerPrefs.GetFloat("MusicVolume"));
        SetSliders();
    }
    // otherwise just set the sliders
    else
    {
        SetSliders();
    }
}

Now what we need to do is set up a new function for when we modify the master slider value:

// called when we update the master slider
public void UpdateMasterVolume ()
{
}

The UpdateMasterVolume function is going to be called whenever we modify the master volume slider. Inside here, we’re going to set the MasterVolume exposure parameter to be the masterSlider‘s value. Then we can save it in PlayerPrefs using SetFloat (which is similar to saving data, whereas GetFloat is similar to loading data):

// called when we update the master slider
public void UpdateMasterVolume ()
{
    mixer.SetFloat("MasterVolume", masterSlider.value);
    PlayerPrefs.SetFloat("MasterVolume", masterSlider.value);
}

We can do the exact same thing with the SFX volume and the Music volume:

// called when we update the master slider
public void UpdateMasterVolume ()
{
    mixer.SetFloat("MasterVolume", masterSlider.value);
    PlayerPrefs.SetFloat("MasterVolume", masterSlider.value);
}

// called when we update the sfx slider
public void UpdateSFXVolume()
{
    mixer.SetFloat("SFXVolume", sfxSlider.value);
    PlayerPrefs.SetFloat("SFXVolume", sfxSlider.value);
}

// called when we update the music slider
public void UpdateMusicVolume()
{
    mixer.SetFloat("MusicVolume", musicSlider.value);
    PlayerPrefs.SetFloat("MusicVolume", musicSlider.value);
}

Toggling A Window

Now what we need to do is make it so that whenever we press a certain key (e.g. V), we’re able to toggle this window open. To detect a key press, we can use the Input.GetKeyDown function:

void Update ()
{
    // toggle the window when we press V
    if(Input.GetKeyDown(KeyCode.V))
    {
    }
}

When the window is active in the hierarchy, window.activeInHierarchy will return true, otherwise, it will return false. We can utilize this to activate/deactivate the window:

void Update ()
{
    // toggle the window when we press V
    if(Input.GetKeyDown(KeyCode.V))
    {
        window.SetActive(!window.activeInHierarchy);
    }
}

If the window is active, we want to enable the mouse cursor (CursorLockMode.None) so the player can click and drag the sliders.

Otherwise, if we’re disabling the window, we’re going to lock the cursor again (CursorLockMode.Locked):

void Update ()
{
    // toggle the window when we press V
    if(Input.GetKeyDown(KeyCode.V))
    {
        window.SetActive(!window.activeInHierarchy);
        // enable or disable the cursor
        if(window.activeInHierarchy)
            Cursor.lockState = CursorLockMode.None;
        else
            Cursor.lockState = CursorLockMode.Locked;
    }
}

We also don’t want our camera to be able to look around when we’re in the volume settings, so inside the Update function of the PlayerController script, we’re going to run the Look function only if the cursor is locked:

void Update ()
{
    Move();
    if(Cursor.lockState == CursorLockMode.Locked)
        Look();
}

Make sure to save the script and drag all the UI objects into the corresponding fields:

Adding Script Events To Buttons

We need to link each of those sliders to the VolumeUI script. To do that, we need to select each slider and add an On Value Changed event by clicking on the + icon:

Inside here, we’re going to drag in the Canvas object and select the Update (Master/SFX/Music) Volume function as the function to be called whenever the slider value changes:

The volume settings window shouldn’t be open at the beginning of the game, so we can deactivate it for now, and press V to open it up in Play mode:

And here we have it:

Conclusion

Well done on reaching the end of this tutorial!

With this tutorial, you’ve learned how to allow your players to have much finer control over the audio channels of your game in Unity. Whether for user satisfaction or accessibility, this can sometimes make or break your game depending on how needed sounds are for an optimal experience.

However, the learning doesn’t stop here. Feel free to practice by adding more audio channels to the canvas we’ve created. For instance, if your game has dialogues, maybe it’d be interesting for your players to change the volume of that as well. Or, you may want to add a slider for UI sound effects, and so on.

That said, we do encourage you to dive even deeper into more advanced topics and wish you the best of luck in your projects!

Want to learn more about audio in Unity? Try our complete Game Audio Effects for Beginners course.

BUILD GAMES

FINAL DAYS: Unlock 250+ coding courses, guided learning paths, help from expert mentors, and more.

ACCESS NOW