Tag Archives: development

View/model separation in Unity using events

In the last post I discussed the Model-View-Controller pattern and sketched a Unity-specific implementation for it. In this post I want to dive into the details. In particular I want to talk about the ‘observer’ pattern and the subtleties of using C# events. In a subsequent post I’ll cover how reactive extensions via the UniRx library can make your life easier.

Did you change yet? Did you change yet? Did you change yet?

One of the conceptual challenges of Model-View-Controller separation or any layer-based architecture, particularly for newcomers to programming, is how to propagate information from layer A to layer B without A’s code referring to B’s code.

It’s tempting, with Unity’s model of explicit update loops, to simply check every ‘tick’ in an Update() method if some property in the game model changes. But we want to avoid this – it’s performance unfriendly when you have large numbers of objects, and moreover it’s just ugly.

One answer is the Observer pattern. In essence, a subject type provides a contract allowing any interested observers to say ‘notify me whenever such-and-such happens.’ In our case, the game model is the subject and the controller layer is the observer.

C# implements the Observer pattern as a first-class language feature via ‘event’ declarations. For example:

public class Terrain
        private int _terrainElevation;
        public int TerrainElevation
            get { return _terrainElevation; }
                var elevationHasChanged = value != _terrainElevation;
                _terrainElevation = value;
                if (elevationHasChanged && ElevationChanged != null)
        public event Action<int> ElevationChanged;

    public class TerrainController : MonoBehaviour
        private Terrain _terrain;

        public TerrainController(Terrain terrain)
            _terrain = terrain;
            _terrain.ElevationChanged += OnElevationChanged;

        private void OnElevationChanged(int newElevation)

Now TerrainController will be notified whenever the TerrainElevation property changes, and it can adjust its view accordingly.

The beauty is that anybody can subscribe to the ‘ElevationChanged’ event as long as they have a Terrain object. This achieves the layer separation that we talked about: the Terrain object in the game model layer doesn’t ‘know about’ the TerrainController in the controller layer. This makes development much easier: when you change your game logic, you just change the code pertaining to game logic – you don’t have to make a bunch of changes to your display code.

Once in a lifetime

So we’re golden, right?

Not quite; there’s one essential consideration we’re neglecting, which is lifetime management.

When you subscribe to the event on Terrain, you effectively pass a reference to TerrainController, so that its callback can be called. Now, remembering that Terrain is a Component attached to a Unity GameObject, what happens if you unload the scene it’s in – perhaps because you’re navigating back to the menu screen, say? You’re expecting TerrainController to be destroyed, but Terrain (which is sitting in your model layer, not going anywhere) still has a reference to it. We’ve created a memory leak.

The good news: there’s an easy fix. We simply unsubscribe from the event:

    public class TerrainController : MonoBehaviour

        private void OnDestroy() {
            _terrain.ElevationChanged -= OnElevationChanged;

Voila, leak patched, crisis averted.

The bad news? Well, if you have more such event subscriptions, or if deciding when they should be unsubscribed is a bit more complicated, it rapidly becomes easy to accidentally introduce bugs. Even writing the example just now, I almost forgot to change the + to a – when I copy-pasted.

In the next post, I’ll discuss a nifty toolset for making lifetime management less error-prone.


Finding the energy

Why is the world’s wealth distributed as it is?

At the end of the last post, looking at Gapminder, we took note that the rich countries of the world could be divided up into roughly four groups. There are the states of western Europe; a few former English colonies, most notably the US; the oil-rich countries of the Persian Gulf; and finally the highly-industrialised countries of east Asia.

How did it come to be that way? Well, how long has it been that way? Continue reading

For richer or poorer

I want to write about a topic I don’t fully understand. In my defense, it seems like nobody else does, either. But the posts to follow will be as much about documenting my own learning process as about sharing what I already know.

Why are some countries rich, and other countries poor? That’s the question I’m interested in. How did that state of affairs come about? Why does it persist? Continue reading