How To Improve Code in Unity by Using Enums

Are you using a lot of value types like integers, and booleans in your code to keep track of things? For example, do you use an integer that holds the value of the currently held weapon? Perhaps you determine whether the player is alive or dead through a boolean variable. In this article, we will show you how you can improve code in Unity by using Enums.

In This Article

• What is an Enum in C#
• How to Use Enums in Unity
• The Advantages of Using Enums in Unity
  • How Enums Improve the Readability of Code
  • How Enums Make Code More Flexible
  • How Enums Make Code Easier to Debug
• Where to Use Enums in Unity
  • Using Enums to Create a Constant
  • Using Enums to Create a State
  • Using Enums to Create an Indexer
• Advanced Enum Features
• Best Practices for Using Enums in Unity
• Summary
• Conclusion

What is an Enum in C#

public enum PlayerSkills
{
    Melee,
    Magic,
    Sneaking,
    Crafting
}

How to Use Enums in Unity

In order to start using Enums in Unity, you don’t need to do anything. This is because Enums are a standard language feature of C# and Unity understands how to work with them. After declaring and using an Enum in your code, they instantly appear inside the Unity inspector. In the code below, we are using the PlayerSkills Enum that we previously declared inside a Player class using the SerializeField Attribute.

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
 
public class Player : MonoBehaviour
{
    [SerializeField]
    private PlayerSkills m_CurrentSkill;
}

The Advantages of Using Enums in Unity

Now that we know how to use Enums inside of Unity, you might also wonder why we should bother. After all, whether your code works or not is the most important thing, right? Actually, good code is not just measured by whether it works or not. To be clear, good code is also measured by how maintainable it is, meaning how easy it is to change code in the future. We can improve the maintainability of our code in Unity using Enums.

How Enums Improve the Readability of Code

One way to ensure the maintainability of your code is to make it more Human Readable. The more Human Readable your code is, the easier it is to understand for yourself and other developers. When it comes to enums, they make the code more intuitive and easier to read.

In the code below, the Enum version of the LoadSaveGame method is much easier to read through compared to the boolean version. Instead of returning false, you will see that the method is returning an error named SaveGameNotFound.. Rather than asking yourself what true or false means for this method, the code documents itself.

public enum ErrorCode
{
    None = 0,
    SaveGameNotFound
}
 

using System.IO;
using UnityEngine;
 
public class GameManager : MonoBehaviour
{
    // Load a SaveGame using a method that returns an Enum
    public ErrorCode LoadSaveGameUsingEnum(string filename)
    {
        if(!File.Exists(filename))
        {
            return ErrorCode.SaveGameNotFound;
        }
 
        return ErrorCode.None;
    }
 
    // Load a SaveGame using a method that returns a boolean
    public bool LoadSaveGame(string filename)
    {
        if(!File.Exists(filename))
        {
            return false;
        }
 
        return true;
    }
}

How Enums Make Code More Flexible

Next, compared to other constants, Enums can be expanded and given default values. Another neat feature is that the values of an Enum increment automatically in the order that you define them. This means that when you expand an enum, newly added values will automatically be greater than the values before it.

Continuing the earlier example, we now add new functionality that checks if the save game that we are loading is still compatible with the game. To start, we add a new SaveGameNotCompatible value to our Enum and return it in the LoadSaveGame method whenever the save game is not compatible. As you can see, this would have been more tedious using the method that simply returned a boolean.

public enum ErrorCode
{
    None = 0,                   // Has Value of 0
    SaveGameNotFound,           // Has Value of 1
    SaveGameNotCompatible,      // Has Value of 2
}

using System.IO;
using UnityEngine;
 
public class GameManager : MonoBehaviour
{
    // Load a SaveGame using a method that returns an Enum
    public ErrorCode LoadSaveGameUsingEnum(string filename)
    {
        if(!File.Exists(filename))
        {
            return ErrorCode.SaveGameNotFound;
        }
 
        if(!SaveGameNotCompatible(filename))
        {
            return ErrorCode.SaveGameNotCompatible;
        }
 
        return ErrorCode.None;
    }
}

Of course, loading a save game is not the only problem that can occur in your game., For example, you might run into problems while storing the settings as well. Luckily, it is really easy to expand the error codes that we are supporting by extending the Enum: We can even reserve some space for future save game error codes.

public enum ErrorCode
{
    None = 0,                   // Has Value of 0
 
    SaveGameNotFound,           // Has Value of 1
    SaveGameNotCompatible,      // Has Value of 2
 
    // (3-9 Reserved for future SaveGame Error Codes)
 
    SettingsFileNotFound = 10,  // Has Value of 10
    SettingsFileNotCompatible   // Has Value of 11
}

How Enums Make Code Easier to Debug

Another advantage of using Enums is that they make it easier to debug code. Not only because they improve the readability of the code, but also because Enumerations make debugging more intuitive. Instead of dealing with constant values, you will be reading code that is more akin to human language.

In the example below, we added some extra debug logging that will print the result of the LoadSaveGame method. In this case, we are attempting to load the most recent save game and log the results to the Unity Console if it fails. However, rather than printing out the value of the constant (either 1 or 2), it will actually print out SaveGameNotFound or SaveGameNotCompatible.

using UnityEngine;
 
public class GameManager : MonoBehaviour
{
    public void LoadRecentSaveGame()
    {
        ErrorCode result = LoadSaveGameUsingEnum("recent.save");
        if(result != ErrorCode.None)
        {
            Debug.LogError("Could not load save game: " + result);
        }
    }
}

Where to Use Enums in Unity

Now that we know how to use Enums in Unity and what some of the advantages are, you be wondering where to actually use them. After all, if we want to improve our code In Unity using enums, we have to know where to use them. Generally, we use an enumeration in Unity when dealing with constants or storing state.

Using Enums to Create a Constant

To start, the obvious usage of Enums is to use them to create some sort of a constant. Imagine the scenario where you are prototyping a racing game where, due to various reasons, the player might not finish. As the game is still in a very early stage of production, it is not exactly known yet what can cause the player not to cross the line. In this scenario, it makes sense to implement the different reasons for finish as an Enumeration. The reasons why the race ended is flexible and can be used throughout the game as constants.

public enum RaceEndReason
{
    Finished,
    RanOutOfFuel,
    Crashed,
    DidNotFloat,
    CarGotTeleportedToAnotherDimension,
    Expired
}

Using Enums to Create a State

Another useful reason to use enums is to create and store a state. A simple example is a state that a developer can use to check whether the player is alive. Initially, it might make sense to implement this as a boolean. Yet, as the the game progresses, more complex player logic might be needed. For example, enemies can only attack when the player is alive. Yet, they should not immediately attack the player while (re)spawning. Simply put, the state of the player is no longer binary (either true or false). In this case, it also makes sense to implement the player state as a Enum.

public enum PlayerState
{
    Alive,
    Dead,
    Spawning,
    VictoryDance // Dance when level is complete.
}

Using Enums to Create an Indexer

Next, we can utilize Enums to create an indexer. For example, imagine you are developing a prototype where a player has to actively manage their inventory. Despite the fact that the designers assure you there won’t be more than 3 different inventory slots, you decide to implement the slots using an Enumeration. In the code below, you can see how an Enumeration is used to change an item in a list.

public enum SlotType
{
    Primary,
    Secondary,
    Utility
}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
 
public class Player : MonoBehaviour
{
    [SerializeField]
    private List<GameObject> m_Weapons;
 
    public void ChangeWeaponForSlot(GameObject weapon, SlotType slot)
    {
        m_Weapons[(int)slot] = weapon;
    }
}

Advanced Enum Features

Next to using enums to improve your unity code, they come with a few other cool tricks that we want to mention. Firstly, they allow you to a create default values which van be referenced throughout the project. Secondly, similarly to defining a default value, you can create a size value. This value represents the total number of values in your enum. You can see how both these advanced features work in the snippets below:

public enum ClassType
{
    Warrior,
    Paladin,
    Bard,
 
    Size,               // The number of useful values in this enum
    Default = Warrior   // A value that can be used as default.
}

using UnityEngine;
 
public class Player : MonoBehaviour
{
    [SerializeField]
    private ClassType m_ClassType = ClassType.Default; // A warrior by default
 
    private void Awake()
    {
        // Print out all available class types..
 
        for(int i = 0; i < (int)ClassType.Size; i ++)
        {
            Debug.Log((ClassType)i); // Cast integer to class type.
        }
    }
}

Best Practices for Using Enums in Unity

Below you can find some best practices for using Enums in Unity. Using these practices, it should be easy to improve your unity code using enums in a variety of ways.

• Create a unique .cs file for your Enum or place all Enums into a Constants.cs file.
• Generally, it is a bad idea to define a Enum inside a class when that Enum will be used by other classes. To prevent abuse, consider making the Enum private.
• When defining Enums, make sure that the naming is consistent everywhere. This again improves the readability of your code.
• Try to avoid using Enums as a way to identify types (e.g. SmallEnemy, BigEnemy or FinalBoss). There are better ways to handle this than through Enums.

Summary

What you learned in this article:

• Enums offer developers a way to create a list of constants that can be managed more easily than regular constants.
• Enums are a standard language feature of C# and Unity understands how to work with them.
• Enums make code more intuitive and easier to read.
• Enums can be expanded and given default values.
• Values of an Enum increment automatically in the order that you define them.
• Enumerations make debugging more intuitive.
• Generally, we use an enumeration in Unity when dealing with constants or storing state
• Try to avoid using Enums as a way to identify types.

Conclusion

To conclude, we have learned what enums are and what advantages they have over regular constants. Not only do enums offer more flexibility, but they also improve the readability of our code. Next, we now also know how to improve code in Unity by using enums. During this article we have examined cases where Enums should be used and what their advantages are. Finally, we shortly discussed some best practices when it comes to using Enumerations with Unity.

Further Reading

Other articles you may find interesting:

• How To Improve Code in Unity by Reducing Hardcoding
• How to Improve Code in Unity Using SerializeField
• C# Enumerations on MSDN