Command Pattern

The Command pattern turns an action into an object. The object stores everything needed to run the action, so you can keep it in a list, run it later, or undo it.

Every command has the same two methods, declared by an abstract parent class:

# command.gd
@abstract
class_name Command
extends RefCounted

@abstract func execute() -> void
@abstract func undo() -> void

A concrete command keeps the object it acts on, called the receiver, and the data of the action. Here the receiver is a Hero with a var x := 0:

# move_command.gd
class_name MoveCommand
extends Command

var hero: Hero
var dx: int

func _init(target: Hero, step: int) -> void:
	hero = target
	dx = step

func execute() -> void:
	hero.x += dx

func undo() -> void:
	hero.x -= dx

The invoker runs commands and remembers them. It never needs to know what a command does:

# command_history.gd
class_name CommandHistory
extends RefCounted

var done: Array[Command] = []

func run(command: Command) -> void:
	command.execute()
	done.append(command)

func undo_last() -> void:
	if done.is_empty():
		return
	var last: Command = done.pop_back()
	last.undo()

# main.gd
var hero := Hero.new()
var history := CommandHistory.new()
history.run(MoveCommand.new(hero, 3))
history.run(MoveCommand.new(hero, 2))
print(hero.x)
history.undo_last()
print(hero.x)

5
3

The history is a stack: pop_back() takes the newest command, so undo walks back through the actions in reverse order. The same objects give you key rebinding (a key maps to a command), replays (run the saved list again) and turn queues.

References go one way: the commands point at the hero, and the hero knows nothing about them. If the hero also stored its commands, the objects would keep each other alive and never be freed.