Want to create code that is robust, optimized and reusable? Then you need to learn about programmming design patterns.
Want to create code that is robust, optimized and reusable? Then you need to learn about programmming design patterns.
Game Programming Design Patterns are templates for building modularised code that are generally a repeatable solution to a commonly occurring mechanic applied in computer games. They are general solutions that aren’t tied to a particular problem, making them reusable. One such pattern is object pooling. Whether a game needs an onslaught of constantly spawning zombies or bullets fired from a gun or asteroids to pummel the player’s spaceship, an object pool is a group of classes that can be reused, exactly as they are, across not only these scenarios but a plethora of others whenever game objects need a spawn manager.
In this course, Penny will take you through the top 12 game programming design patterns with C# and the Unity Game Engine using her internationally acclaimed Holistic teaching style and expertise from over 25 years teaching, researching and writing about games. Throughout the course you will follow along with hands-on workshops designed to teach you these core programming concepts that will take your games to the next level.
Learn how to program and work with patterns such as:
commands
flyweight
observer
prototype
singleton
states
object pools
game loops
updates
components
...and more.
Contents and Overview
The course begins with a brief introduction and then you are straight into hands-on exercises, working through each of the design patterns as listed above. There are a variety of scenarios you will work on in both 2D and 3D from an asteroid shooter, to a radar object finding system to a programmable prototype prefab system. All starter files and Unity assets (including models and scenes) are provided for you.
If you want to become a knowledgeable and skilled game developer, then this course is for you.
What students are saying about Penny's courses:
Excellent course. I am already in game development industry and there is one quote here from the course that says it all "Whenever you are not able to solve complex problem, its the right time to get back to the BASICS".
She is the best teacher ever in this platform
I do like Penny de Byl's courses and way of teaching, they are much more specific than your average "master Unity" kind of courses and usually you don't learn just the engine, but also how things work behind the scenes (albeit briefly, at least it gives you an idea if you want to investigate more on your own). She's really amazing.
This lecture gives you an overview of the content of the course and the concepts you will learn about.
H3D has a bustling online student community. Here's how to get involved.
How to contact us
Regularly asked questions you should check out before starting the course.
While this course was developed in a previous version of Unity, we've tested the projects and they work with Unity 6. This video is a guide to help you adjust your learning in this course to use Unity 6.
In this lecture we look at the command design pattern and start building an abstract class to encompass it's simple functionality.
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 lecture we will walk through the process of making a scriptable object and adding them to an existing project to store data about game objects.
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 the observer pattern will be introduced and a project setup to apply it.
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.
This lecture introduces the state design pattern and starts setting up a project for building a finite state machine for a patrolling and attacking NPC.
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?
OpenCourser helps millions of learners each year. People visit us to learn workspace skills, ace their exams, and nurture their curiosity.
Our extensive catalog contains over 50,000 courses and twice as many books. Browse by search, by topic, or even by career interests. We'll match you to the right resources quickly.
Find this site helpful? Tell a friend about us.
We're supported by our community of learners. When you purchase or subscribe to courses and programs or purchase books, we may earn a commission from our partners.
Your purchases help us maintain our catalog and keep our servers humming without ads.
Thank you for supporting OpenCourser.