Pattern Command

Il pattern Command trasforma un'azione in un oggetto. L'oggetto memorizza tutto ciò che serve per eseguire l'azione, così puoi conservarlo in un elenco, eseguirlo in seguito o annullarlo.

Ogni comando ha gli stessi due metodi, dichiarati da una classe genitore astratta:

# command.gd
@abstract
class_name Command
extends RefCounted

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

Un comando concreto mantiene l'oggetto su cui agisce, chiamato ricevitore, e i dati dell'azione. Qui il ricevitore è un Hero con un 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

L'invoker esegue i comandi e li ricorda. Non ha mai bisogno di sapere cosa fa un comando:

# 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

La cronologia è uno stack: pop_back() prende il comando più recente, quindi annullare ripercorre le azioni in ordine inverso. Gli stessi oggetti ti permettono di rimappare i tasti (un tasto corrisponde a un comando), riprodurre le azioni (eseguire di nuovo l’elenco salvato) e gestire code di turni.

I riferimenti vanno in una sola direzione: i comandi puntano all'eroe, e l'eroe non sa nulla di loro. Se anche l'eroe memorizzasse i suoi comandi, gli oggetti si terrebbero in vita a vicenda e non verrebbero mai liberati.