Design Patterns for Game Programming

In this lecture we will finish creating the initial version of a command class and use it to control the animations of two animated characters.

In this video we will extend the command pattern by adding replay and undo functionality.

In this video we complete the undo facility to generate animations that run backwards when they are taken away from the replay list.

In this lecture we will begin with a small experiment that illustrates the importance and workings of the flyweight design pattern.

In this section tutorial on examining scriptable objects you will learn how to grab the data added to a prefab from them and display it on the screen.

In this lecture we will a Perlin landscape from cube prefabs readying for a comparison with Unity's ECS System.

In this lecture we will begin putting together the game objects and components that will become entities in an ECS.

This lectures completes our brief look at how ECS conforms to the Flyweight design pattern and compares performance between using GameObjects versus Entities.

In this lecture we will optimise the performance of the ECS with a little rendering trick and then take a drive around the scene with the camera.

In this lecture we will complete the egg spawner and create the base classes for Events and Event Listeners.

In this lecture we will begin using the events and listeners to pass messages as well as extend this to have items appear on the radar.

In this video we will add in other objects to appear on the radar as well as work at taking them away.

In this video we will complete the process to take items away from the radar system as well as perform a challenge to display popup text on the screen.

In this lecture we will start to examine the prototype pattern.  Most game engines automatically take care of this functionality themselves, though we will try our best to illustrate the old way of doing things.

In this video you will learn how to turn your procedurally created cube into a cloneable object.

In this lecture you will learn how to create a dynamic game object that you can save into your assets folder as a prefab.

In this video you will be introduced to the singleton pattern and we will start working on a project to put it to good use.

In this lecture we will create the state base class and build an idle state that inherits from it.

In this lecture we will add in the patrolling state and set the npc to walk around a set route.

In this lecture we start writing the pursue and attack states to add to the NPCs behaviour.

In this video we will complete the code for getting the NPC to pursue and attack the player.

In this video you will be given a challenge to add a new state to the NPCs behaviour.

In this lecture we will cover object pooling and start building a classic game scenario in which pooling is critical for memory management and performance.

In this lecture we will add the code for an object pool to take care of the asteroid and bullet spawning.

In this video we will extend the object pool to make it expandable.

In this lecture we will examine some of the most powerful game programming design patterns that you use everyday without realising.

Some final worlds from Penny

You've finished this course....  what now?