The Ultimate Guide to Unity Designpatterns

Name: The Ultimate Guide to Unity Designpatterns
Rating: 4.5 (364 reviews)

Improve your Coding Skills in the Unity3D Engine beyond beginner Level with Designpatterns for Unity.

Created byAndreas Metz

Last updated 1/2020

English

English [Auto],

What you'll learn

Queue Actions of the player, so they are executed one after another
Create a history of player-actions with an undo-Functionality
Write cleaner code
Improve the performance of your game
Improve your game's data-structure by using ScriptableObjects
Implement the Singleton, Objectpool, Flyweight and Command - Designpatterns in your game

Course content

6 sections • 43 lectures • 4h 22m total length

Course Overview0:48
Course Image was designed by Freepik.

Introduction to Singleton4:20
Singleton - Overview10:13
The slides are attached as a resource
Static - Keyword12:46
Implementation of Singleton14:19
Exercise - Simple Singleton0:47
The Exercise is attached as a resource
Exercise - Solution3:00
Implement a singleton in Unity by declaring a private static instance, exposing a getter without a setter, and using Awake to enforce a single instance and log duplicates.
GameManagers9:12
Illustrates how game managers use the singleton pattern to control essential, high-level game systems such as win and lose conditions, timing, pausing, level loading, and spawning.
Advanced Implementations - Don'tDestroyOnLoad7:34
Advanced Implementations - Lazy Instantiation5:05
Singleton - Summary2:25
Learn how a singleton streamlines accessing a single game manager, enforces one instance, and can persist across scenes. It also notes lazy instantiation and dependency injection for larger projects.

Introduction to ObjectPool5:55
You can download the Slides from the attachment
Implementing an ObjectPool6:20
ObjectPool Exercise1:08
You can find the Example project in the attached .zip-File. Also the instructions for the exercise can be found in the .pdf.
ObjectPool Exercise Solution15:15
Performance Comparison of different ObjectPools6:03
Compare object pool patterns in Unity, showing how none, array, list, and queue pooling affect instantiation costs, script performance, and frame rates using the Unity profiler.
Queues - Theory3:01
Learn how queues implement a first-in, first-out object pool by enqueuing at the back and dequeuing from the front, and why a queue suits pooling better than a list.
Implementing Objectpool with Queues2:29
Switch the object pool from a list to a queue, using enqueue to add and dequeue to retrieve the front item, for a cleaner Unity pooling pattern.
Advanced Objectpool with Lazy Instantiation5:05
Explore lazy instantiation in the object pool pattern by dynamically resizing the pool on demand, instantiating new bullets only when needed, to reduce memory usage and boost shooting performance.

Flyweight - Basics9:35
Apply the flyweight design pattern to manage huge numbers of game objects by sharing data like max HP and move speed, while storing current HP per instance.
Comparison of different Approaches10:01
You can test the different apporaches yourself in the attached project.
Basic Implementation6:06
ScriptableObject - Basics8:34
ScriptableObject - Implementation6:02
(Optional) ScriptableObject - Pitfalls10:02
Learn common ScriptableObject pitfalls in Unity, including proper instantiation without new, serialization of custom classes, and keeping ScriptableObjects as data containers rather than functional logic.
(Optional) ScriptableObject Singletons6:20
Implementing Flyweight with ScriptableObjects7:49
You can find the project of the video in the attached .zip-file.
Solution for Exercise11:24
Leverage scriptable objects to define bullet stats like speed and damage, and reference them in player and enemy behavior in Unity to improve flexibility and performance.

Command - Overview4:56
Explore the command design pattern and its use in game programming, including runtime controller remapping, queuing actions in real-time and turn-based games, and undo/history capabilities.
Command Introduction5:03
Basic Implementation4:56
The project I'm working on in this video can be found in the next video where you will be challenged with an exercise.
Exercise1: Remappable Input1:21
In order to do this exercise you need to download the instructions and the demo project.
Example - RemappableInput Solution10:55
Formal Definition of the Designpattern4:25
Queue Commands3:19
Queue Commands Implementation3:03
Exercise2: Queue Commands1:01
In order to do this exercise you need the demo-project from lecture 22: Exercise - Remappable Input
Exercise Queue Commands - Solution13:11
implement a clean command queue for the player, adding move up, down, left, right and attack commands, executing them in order with completion events and preparing for undo.
(Optional) More Sophisticated Implementation3:06
Explore how the command design pattern handles complex input across games, switching the active invoker for cars and players and coordinating shooting and reloading.
Undo Commands5:43
Exercise3: Undo Commands0:56
In order to implement this exercise you need the finished Version of Exercise2: Queue Commands.
Exercise Undo Commands - Solution7:28
Implement undo functionality in the command pattern by checking current command index, updating is executing command, calling Undo, and firing on undo completed to refresh history UI.

Requirements

Fundamental understanding of Unity, C# and objectoriented Programming

Description

If you already possess a fundamental understanding of C# and the Unity Engine and want to improve your coding skills further, then this course is for you.

The Ultimate Guide to Unity Designpatterns introduces you to best practice solutions for common problems in gameprogramming. You will discover how you can improve the quality of your code by using these important Designpatterns, which are specifically adapted to make use of the unique features of the Unityengine, like for example ScriptableObjects.

In this course you will:

Implement best practice Solutions to common problems in gameprogramming
Discover the Singleton - Designpattern

- Structure your game more elegantly
Discover the ObjectPool - Designpattern
- Improve the performance of your game
Discover the Command-Designpattern
- Implement a history of player-actions with an Undo-Functionality
- Queue Actions of a player, so they are executed one after another
Discover the Flyweight - Designpattern
- Improve your game's data-structure by using ScriptableObjects
- Reduce the RAM-Usage of your game

This course is very project-based and practical, so you will implement the concepts directly in small games.

For each Concept you will be challenged to implement it yourself, but if you don't feel up to the task you will also be shown a well explained step-by-step guide how to implement it.

The course also features several Demo-Projects, where you can look up best practice implementations.

It also features Projects which are specifically designed to compare the performance of different approaches for implementing these Designpatterns.

Why learn from me?

I have been a game-programming teacher for more than 5 years now and as a result have plenty of experience in what works and what doesn't when teaching programming. Also I am a firm believer, that you can only learn the high craft (some might even say art) of programming, if you practice it. Which is why I put much effort into making the advantages of these designpatterns clear by giving you small practical assignments where you are challenged to improve an existing game's code with these designpatterns.

Become a better Programmer, now! I'll meet you inside the course!

Who is the target Audience?

Unity users who want to improve their programming skills beyond basic tutorials
Programmers who want to improve the Performance, Quality and Expandability of their Code
Coders who want to add a few battle-proven solutions for common problems in gameprogramming to their toolkit

Who this course is for:

Unity users who want to improve their programming skills beyond basic tutorials
Programmers who want to improve the Performance, Quality and Expandability of their Code
Programmers who want to add a few battle-proven solutions for common problems in gameprogramming to their toolkit

The Ultimate Guide to Unity Designpatterns

What you'll learn

Explore related topics

Course content

Introduction1 lecture • 1min

Singleton10 lectures • 1hr 10min

Object Pool - Designpattern8 lectures • 45min

Flyweight - Designpattern9 lectures • 1hr 16min

Command - Designpattern14 lectures • 1hr 9min

Summary1 lecture • 1min

Requirements

Description

Who this course is for: