Intro to Design Patterns

A design pattern is a known, named way to arrange classes for a problem that comes back in program after program. It is not a library and not code to copy: it describes which objects exist, what each one is responsible for, and how they work together. You write the code yourself, shaped to your game.

Patterns also give developers shared words. "Enemies come from a factory" or "the health bar observes the player" tells a teammate how the code is organized before they open a file.

Here is a problem a pattern solves. Starting a level means talking to three objects, and every script that starts a level repeats these lines:

var music := MusicPlayer.new()
var level_map := LevelMap.new()
var hud := Hud.new()
music.play("forest.ogg")
level_map.load_map(1)
hud.show_hearts(3)

The Facade pattern puts one class in front of those objects and gives it one simple method:

# game_facade.gd
class_name GameFacade
extends RefCounted

var music := MusicPlayer.new()
var level_map := LevelMap.new()
var hud := Hud.new()

func start_level(number: int) -> void:
	music.play("forest.ogg")
	level_map.load_map(number)
	hud.show_hearts(3)

# main.gd
var game := GameFacade.new()
game.start_level(1)

Music: playing forest.ogg
Map: level 1 loaded
HUD: hearts 3

The rest of the program calls start_level(), and when starting a level changes, you edit one file.

Patterns are grouped by the problem they solve:

• Creational patterns control how objects are created: Singleton, Factory.
• Structural patterns combine objects into larger structures: Facade, Adapter, Decorator, Composite.
• Behavioral patterns organize how objects work together: Observer, Strategy, Command, Template Method, State.

This chapter and the next one cover these patterns. Each one is built from what you already know: classes in their own files, inheritance, polymorphism, composition and signals.