A máquina de estado finito (FSM)

Você provavelmente seguiu alguns dos tutoriais para iniciantes e decidiu criar seu
próprio projeto com base na mecânica de jogo que aprendeu. Mas assim que você
adicionou ações mais complexas, você rapidamente se perdeu em uma selva de
condições aninhadas que levam a bugs difíceis de encontrar. No final, você
provavelmente sairá do projeto.
A maioria dos tutoriais que você encontra na internet (independente do mecanismo
do jogo) apenas tenta mostrar uma maneira de atingir o objetivo daquele tutorial
específico com o mínimo de distração possível. Infelizmente, isso geralmente resulta
em código que não se preocupa com a extensibilidade.
Este tutorial mostrará como estruturar seu projeto de forma a encapsular a lógica de
seu jogador (inimigos ou outros objetos dinâmicos).

O que é uma máquina de estado?

Uma máquina de estado divide a lógica de um objeto em um conjunto fixo de
estados bem definidos, que operam independentemente uns dos outros. Cada
Estado contém apenas a lógica que lhe é aplicável. Por exemplo, quando o jogador
está em um estado de "caindo", você não precisa verificar os botões de movimento
para a esquerda e para a direita, nem o botão de pular, porque não há chão sob
seus pés. Quando condições específicas são atendidas, o o estado do jogador é
mudado para um diferente.
Então imagine que o jogador está em estado de “queda”. Enquanto estiver no ar,
não deve ser capaz de realizar nenhuma ação. É apenas passivamente puxado para
baixo pela gravidade. Para transitar para outro estado, certas condições devem ser
atendidas. No caso de um estado de "queda", esta condição seria "em colisão com o
solo". Quando isso acontece, o jogo muda o estado de “falling” para “idle”. Agora, no
estado “ocioso”, o jogo verifica constantemente se um botão de movimento foi
pressionado, o que por sua vez muda o estado do jogador de “ocioso” para
“andando”. No estado "andando", o jogador continua se movendo até que algum
outro evento aconteça (por exemplo, o botão de movimento é liberado). Você
entendeu?

A máquina de estado finito (FSM) 1

Começando
Então, vamos começar baixando os ativos do “" tutorial. Crie um jogador como um
“objeto de plataforma” e algumas plataformas (comportamento de “plataforma”) para
andar e pular conforme descrito no tutorial mencionado
acima. 

Abra as propriedades do objeto do jogador e crie as animações “idle”, “walking”,

“jumping” e “falling”. Em seguida, crie uma variável de string no objeto do jogador e

A máquina de estado finito (FSM) 2

chame-a de “direção” com o valor “direita”.

Mude para o editor de eventos (cena “principal”) e crie esses eventos externos
“playerstateinit”, “playerstatefalling”, “playerstateidle”, “playerstatewalking”,
“playerstatejumping”. Nos eventos de sua cena principal, crie um novo grupo de
eventos no menu suspenso à direita. Chame-o de “Lógica do jogador”. Agora
adicione uma condição "No início da cena". Adicione um subevento à condição e
vincule na folha de evento externa “playerstateinit” através do botão
“add”/”other”. Faça o mesmo para todos os outros estados do jogador.
Observação
Em vez da animação, poderíamos ter criado aqui um "estado"  de variável de
cena  dedicado para controlar o estado do jogador. Isso é mais avançado, mas permite
uma melhor flexibilidade. No entanto, a abordagem apresentada aqui tem o benefício de
agrupar a lógica com a animação correspondente, permitindo clareza e simplicidade na
planilha de eventos. Além disso, você tem acesso aos quadros da animação/estado atual
e pode acionar alguma lógica em um determinado quadro dentro da animação.

A máquina de estado finito (FSM) 3

Informações de depuração
Para saber em que estado o jogador está atualmente durante o jogo, crie um objeto
de texto e chame-o de “debug_state”. Adicione-o à cena principal e crie as ações
abaixo (com uma condição vazia), para exibir o estado atual do jogador logo acima
de sua cabeça. Sempre que algo não funcionar como deveria, saberemos em qual
estado devemos investigar para encontrar o erro.

A máquina de estado finito (FSM) 4

Nosso primeiro estado “init”
Abra o estado externo “playerstateinit”. Este estado é usado para inicializar nosso
objeto jogador quando o jogo começa. No campo “editar como se os eventos fossem
incluídos na cena” escolha a cena “principal”.
Como já definimos a condição sobre quando executar o código do estado init na
planilha de eventos da cena principal, podemos omitir a condição aqui e apenas
adicionar ações.
Em primeiro lugar, precisamos desabilitar os controles padrão do comportamento do
jogo de plataforma, porque eles atrapalhariam o uso de uma máquina de estado.
Em seguida, definimos a animação do sprite do jogador para “caindo”. Portanto, na
próxima iteração do loop do jogo, os eventos do estado “caindo” serão
executados. Escolhemos o estado de queda aqui porque o jogador foi colocado no
ar e eventualmente cairá no chão onde podemos transitar para o estado inativo.
Você também pode usar este estado para (re)definir os pontos de vida, munição ou
outras coisas do jogador. Se você decidir reiniciar o nível, sempre poderá voltar ao
estado “início” para redefinir os atributos do jogador.

A máquina de estado finito (FSM) 5

O estado de “queda”
A queda é o estado mais universal de todos. Sempre que você não tiver certeza de
qual estado transitar para o estado “caindo”, geralmente é uma boa escolha, porque
acabará levando a um outro estado sensato assim que o jogador colidir com um
objeto. Ao cair, o jogador não poderá realizar nenhuma ação ativa. Ele só será
afetado passivamente pelas forças que foram aplicadas a ele antes de entrar no
estado de queda. Por exemplo, se você entrar no estado de queda após realizar um
salto, você ainda se moverá passivamente na direção em que estava pulando, mas
não poderá mais ajustar a direção. (consulte a seção de exercícios na parte inferior
deste tutorial para alterar esse comportamento). Portanto, tudo o que estamos
fazendo neste estado é verificar se o jogador colide com o chão. Nesse caso,
passamos o jogador para o estado “ocioso”.

O estado “ocioso”
O estado ocioso é acionado sempre que a pessoa na frente do computador não faz
nada. Em outras palavras, nenhuma tecla é pressionada e o objeto do jogador está
parado. Como no estado “caindo”, não há nenhuma ação ativa a ser
executada. Apenas verificamos as condições que nos fazem sair do estado
“ocioso”. Então, primeiro verificamos se o jogador está no chão. Se não, transitamos
para o estado de queda. Em seguida, verificamos se o jogador pressionou as teclas
de seta para a esquerda ou para a direita. Se assim for, transitamos para o estado
ambulante. Por último, mas não menos importante, a tecla de seta para cima é
verificada e, se pressionada, mudamos o jogador para o estado de salto. Parece
lógico, não é?

A máquina de estado finito (FSM) 6

O estado “andando”
No estado de caminhada, finalmente conseguimos integrar algumas ações ativas
para o nosso jogador realizar. Como usamos apenas um estado para andar para a
esquerda e para andar para a direita, primeiro temos que determinar a direção que o
jogador deve se mover. Portanto, verificamos novamente qual tecla foi pressionada e
definimos a variável de direção do jogador de acordo uma vez ao entrar no estado
de caminhada. Depois disso, faremos o jogador se mover nessa direção, desde que
esteja no estado de caminhada.
Agora que o jogador é capaz de andar, voltaremos às condições que o fazem sair do
estado atual. Então, o que pode acontecer enquanto estamos caminhando? A coisa
mais óbvia seria que a chave de caminhada é liberada. Nesse caso, transitaremos
para o estado “ocioso”. Se caminharmos sobre a borda da plataforma atual,
transitamos para o estado de “queda”. E se a tecla de salto for pressionada,
mudamos para o estado de salto.

A máquina de estado finito (FSM) 7

O estado de “salto”
Como você deve ter adivinhado, a primeira coisa que faremos é acionar a ação de
pular assim que entrarmos no estado. A força será aplicada passivamente, então
não precisamos mais nos preocupar com isso depois de realizarmos o salto. Como
sempre, a última coisa que precisamos fazer é encontrar condições que nos façam
transitar para outro estado. Neste caso, verificaremos se o jogador não está pulando
ou caindo. Se for esse o caso, o jogador é transferido para o estado de “queda”.

E é sobre isso.

Conclusão
Agora dividimos a lógica do jogador em cinco estados diferentes, que lidam apenas
com a lógica aplicável a eles e nada mais. Se você deseja que seu jogador ganhe
habilidades adicionais como voar, mergulhar, morrer ou ser esmagado contra uma
parede, basta criar um novo estado e lidar com a lógica lá.

Você pode baixar todo o projeto aqui.

exercícios
1) Como você já deve ter notado, o jogador está agindo um pouco diferente enquanto está no ar
do que com os controles padrão ativados. Isso ocorre porque atualmente não temos nenhuma
entrada ativa no estado “caindo”. Portanto, sua tarefa é permitir que o jogador se mova enquanto
estiver caindo. Verifique se as teclas de movimento estão pressionadas e aplique metade da força
de movimento usual ao jogador.

A máquina de estado finito (FSM) 8