To get started:

1. Download or clone the GitHub repository at https://github.com/PacktPublishing/C-Design-Patterns-with-Unity-First-Edition.
2. Open the Ch_02_Starter project folder in Unity Hub.
3. Navigate to Assets | Scenes, and double-click on SplashScreen.

The starter project for this chapter has two scenes – a splash screen with the title of our little game and a button to start the adventure. When you click Start, the game transitions to a new scene, where you can move a capsule around a small arena and collect spheres.

As for the scripts:

• Item.cs is attached to each Item prefab that is responsible for destroying itself when there’s a collision.
• Manager.cs stores our score and loads the next scene.
• Player.cs is responsible for moving our character around the scene using the WASD or arrow keys.
• ScoreUI.cs stores a Text object so that we can set an initial score value on our scene canvas...

First, it’s important to recognize scenarios where the Singleton pattern is useful and doesn’t just add unnecessary complexity to your code. The original Gang of Four text says you should consider using the Singleton pattern when:

You need to limit a class to a single instance and have that unique instance be accessible to clients through a global access point.

For example, your computer should only have one filesystem, in the same way that your body should only have one heart (for best performance). A global variable can take care of the accessibility, and in the case of C#, a static variable fits the bill nicely. When you put it all together, a singleton class is responsible for initializing, storing, and returning its own unique instance, as well as protecting against duplicate instance requests.

Figure 2.1 describes a game scenario where a manager script stores game state data and maybe some shared functionality.

In this...

Imagine you are building a platforming game where the player collects items through multiple levels. Your team lead asks you to create a manager script to track the player’s score, handle scene transitions, and ensure there’s always one unique instance in a scene. Our first task is to ensure that the game manager class in the starter project only ever has one active instance.

Open Manager.cs and update the code to match the following code, which sets the singleton instance or destroys the GameObject that the script is attached to if an instance already exists:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.SceneManagement;
public class Manager : MonoBehaviour
{
    // 1
    public static Manager Instance;    
    public int score = 0;
    public int startingLevel = 1;
    // 2
    void Awake()    
    {
        // 3
        if(Instance...

Imagine you want to make the singleton more flexible, reusable, and maintainable. The previous implementation works, but it’s hardcoded into Manager.cs, which won’t help us if we want different classes to act like singletons. A better solution is to write a generic singleton that other classes can easily subclass.

Figure 2.13 describes a generic singleton script that other manager classes can inherit from. Each subclassed manager has the same underlying Singleton structure, but each one can also add its own unique functionality and variables.

Figure 2.13: Multiple manager classes...

In this section, we’re going to focus on making our generic singleton thread-safe by guarding against different threads potentially creating more than one instance of the singleton. For example, imagine you need to process an algorithm that finds all enemies within a set distance, as well as their positions and orientations. Doing this on the main thread might decrease your frame rate and slow down other processes in your game. However, if you separate the algorithm into a separate thread, Unity’s main thread is free to keep running the essential parts of the game while the sub-thread does its work.

If you’re new to the concept of threading, it helps to think of your...

Imagine you and your design team need to create, configure, and test singleton classes in the Unity Editor. Using ScriptableObjects as data containers not only frees you from attaching your scripts to GameObjects but also gives you the freedom to create singleton assets from the Asset menu. Both added features make scriptable objects a good fit to address testing concerns with the Singleton pattern, and it is much easier for non-programming members of your team to work with them.

Your last task in this chapter is to create a generic singleton as a ScriptableObject asset in the project. In the Scripts folder, create a new C# script, name it ScriptableSingleton, and update its code to match the following code. This script creates a generic ScriptableObject class that we can use to fetch a unique instance from the project resources when queried:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
// 1
public...

If this was your first foray into design patterns, congrats and welcome to the club! We’ve covered quite a bit in this chapter, from a super-vanilla singleton hardcoded into a single class all the way to lazy instantiation, generics, and thread safety – not to mention using ScriptableObject assets as containers for design pattern code.

Keep in mind that your singleton classes are most useful when you only want a single class instance, a global point of access, and persistence throughout the Unity game lifecycle. You have the choice of lazily instantiating your singleton objects, which helps with accessing information your project may only have after compiling (not to mention the singleton itself won’t be created until it’s needed). You can also go for a generic solution, which can be a subclass or even a ScriptableObject!

However, it’s important to remember that any globally accessible objects can have adverse effects if you’...

• Generics open up a whole new world of programming possibilities (which is why I included a generic solution in this chapter), but I’d recommend reading up on the topic at https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/types/generics.
• ScriptableObjects are the perfect way to create data containers in your Unity projects (and we’ll use them in almost every chapter going forward), but I’d also recommend checking out the documentation at https://docs.unity3d.com/Manual/class-ScriptableObject.html.
• Multithreading is a bit of an advanced topic outside the scope of this book, but being able to perform multiple operations at the same time is a useful tool in your toolbox. If you want to know more about this topic, head over to the documentation at https://learn.

Leave a review!

Enjoying this book? Help readers like you by leaving an Amazon review. Scan the QR code below to get a free eBook of your choice.