When we started the development of our game, we managed all our objects locally within the scene. We didn't want or need to worry about the lifetime of our services/managers. However, as almost always is the case, our game matured, and we started using multiple scenes. Now, we needed our services or manager classes to be easily accessible by child scenes and almost anywhere in our code.

In games of old, we would have just created a global or static variable to track game state across scenes or scripts. A global static class could work, but suffers from a number of limitations, as follows:

Let's take a look at the difference in declaring a standard MonoBehaviour game object and one that uses Singleton with the updated GPSLocationService script.

The previous implementation of the GPSLocationService was declared as follows:

public class GPSLocationService : MonoBehaviour 

This, as we saw many times now, is the standard way to declare a Unity component. Compare that to the new class declaration of the GPSLocationService:

public class GPSLocationService : Singleton<GPSLocationService> 

This may look strange: declaring an object to inherit from generic type called Singleton with itself as the type. Think of the Singleton class as a wrapper that converts the instance to a global static variable that is accessible anywhere in code. Here is an example of how the GPS service was accessed before and is now:

//before, GPS service object was set as a field of the class which had to be set in the editor 
public GPSLocationService gpsLocationService; 
gpsLocationService.OnMapRedraw += gpsLocationService_OnMapRedraw; 
 
//after, the GPS service is now accessible anywhere as a Singleton 
GPSLocationService.Instance.OnMapRedraw +=  GpsLocationService_OnMapRedraw; 

There is one critical element that you should be aware of when working with our implementation of Singleton. We will always make sure that we instantiate a Singleton manager or service as a game object in a scene. This is done, so we can take advantage of the Start, Awake, Update, and other methods. However, if you do not add these objects into a scene and then try to directly access them in code, they will be accessible but will likely be missing important initialization set in the Awake or Start methods.

Take a look at the classes that consume the GPSLocationService: the MonsterService, CharacterGPSCompassController, and GoogleMapTile. As you will appreciate, the differences are subtle but significant.

In this chapter, we will add another consumer of the GPSLocationService and also make the new service a Singleton. This new service will be the GooglePlacesAPIService, and we will cover it in the next section.