Padrão State

O padrão State dá a um objeto um objeto de estado separado para cada modo em que pode estar. O objeto delega seu trabalho ao estado atual, então seu comportamento muda quando o estado muda.

Para poucos estados, um enum e um match são suficientes. Quando cada estado reage a várias ações à sua maneira, esse match cresce a cada estado e a cada ação. O padrão State move as regras de cada estado para sua própria classe:

# hero_state.gd
@abstract
class_name HeroState
extends RefCounted

@abstract func get_state_name() -> String
@abstract func handle(action: String) -> HeroState

handle() retorna o próximo estado: um novo objeto de estado para o qual mudar, ou self para permanecer.

# idle_state.gd
class_name IdleState
extends HeroState

func get_state_name() -> String:
	return "Idle"

func handle(action: String) -> HeroState:
	if action == "run":
		return RunState.new()
	return self

RunState é escrito da mesma forma: seu nome é "Running", e "stop" retorna IdleState.new(). O herói, o contexto, mantém o estado atual e pergunta a ele o que fazer:

# hero.gd
class_name Hero
extends RefCounted

var state: HeroState = IdleState.new()

func handle_action(action: String) -> void:
	var next := state.handle(action)
	if next != state:
		print(state.get_state_name(), " -> ", next.get_state_name())
		state = next

# main.gd
var hero := Hero.new()
for action in ["stop", "run", "run", "stop"]:
	hero.handle_action(action)

Idle -> Running
Running -> Idle

A mesma ação significa coisas diferentes em estados diferentes: "stop" não faz nada enquanto está ocioso e para um herói em movimento. Cada regra fica na classe de seu estado, então um novo estado, como pular, é uma nova classe.

Os estados retornam o próximo estado em vez de armazenar o herói. Um estado que mantivesse o herói enquanto o herói mantém o estado criaria um ciclo de referências, e nenhum dos objetos seria liberado.