← Voltar para Here To Slay

Here To Slay, parte 7: uma engine nova para as regras

Por que o sistema de efeitos da parte 2 parou de escalar quando chegou o baralho de verdade, como cada carta virou um roteiro de passos que pode parar para esperar o jogador e como foi pensar essa troca.

#tecnico

A interface nova da parte 5 assumia coisas que a engine antiga não fazia. Ela foi desenhada para efeitos que fazem uma pergunta, mostram o resultado e fazem outra, e para um baralho com todas as cartas do jogo base. Por baixo, as regras ainda rodavam sobre o sistema de efeitos da parte 2, e esse sistema tinha chegado ao limite.

Onde o modelo antigo travou

Até aqui, o jogo tinha 14 cartas jogáveis: 12 heróis e 2 magias. As outras não existiam, e não por falta de tempo. O próprio comentário no topo da fábrica de cartas admitia o problema: várias cartas usavam uma “simplificação de MVP”, porque o efeito real precisaria de uma segunda rodada de seleção que a máquina de estados não suportava.

Os motivos eram os dois detalhes que deixei registrados no fim da parte 2, agora com o baralho de verdade em cima deles:

  • A escolha morava dentro do efeito. Os alvos escolhidos ficavam guardados no próprio objeto do efeito. Por isso, a fábrica precisava criar instâncias novas de cada efeito para cada cópia da carta, senão duas cópias iguais dividiriam os mesmos alvos.
  • O Match descobria as perguntas por instanceof. Esses testes de tipo estavam espalhados pela classe do herói e pela partida. Cada tipo novo de alvo pedia um if novo em vários métodos.
  • Um estado para cada tipo de pergunta. SELECTING_CARDS, SELECTING_HAND_CARDS e SELECTING_PLAYER, cada um com a sua mensagem própria para o cliente. E uma carta só podia fazer uma pergunta, sempre antes de começar.

Adicionar uma carta nova significava mexer em três ou quatro lugares diferentes, e muitas cartas simplesmente não cabiam. O Bear Claw, por exemplo, diz: “puxe uma carta da mão de outro jogador; se for um herói, puxe outra”. Isso são duas decisões, com uma condição no meio que depende do resultado da primeira. No modelo antigo, a segunda carta teria que ser sorteada.

Efeitos antes e depois: de efeitos que guardavam a escolha e eram descobertos por instanceof para uma única GameCard com um Script, montado com blocos do Ctx

Como pensar a troca

A virada veio de olhar para o texto da carta em vez de olhar para o código. O texto de uma carta de Here To Slay já é um roteiro: escolha um jogador, puxe uma carta, se for herói, puxe outra. São passos em ordem, e alguns deles param para perguntar alguma coisa a alguém.

Então o efeito não deveria ser um objeto que executa tudo de uma vez, e sim uma lista de passos que a partida vai executando. E a partida deveria ser uma fila que sabe pausar: quando um passo precisa de uma resposta, ela para, espera o jogador e continua exatamente de onde estava.

Com essa ideia, a engine foi escrita do lado do sistema antigo, sem mexer nele: primeiro o núcleo, depois os catálogos de cartas e monstros. Só quando as peças estavam prontas a partida passou a rodar sobre elas, numa troca só.

As peças

Agora existe uma única classe de carta, GameCard, com um tipo (herói, magia, item, modificador ou desafio), e o efeito de cada carta é um Script: uma função que devolve a lista de passos.

@FunctionalInterface
public interface Script {
    List<Runnable> steps(Ctx ctx);
}

Os passos são montados com blocos prontos do Ctx, o contexto da carta em execução: choosePlayer, pull, draw, discard, destroy, searchDiscard, when e outros. O Ctx também guarda o que cada passo escolheu, numa espécie de memória de variáveis, e era exatamente isso que faltava: um passo grava "target", o seguinte lê. O Bear Claw ficou quase igual ao texto da carta:

hero("Bear Claw", FIGHTER, 7, c -> List.of(
        c.choosePlayer("target", p -> !p.getHand().isEmpty()),
        c.pull(c.varOf("target"), 1, "pulled"),
        c.when(() -> c.firstIs("pulled", HERO), c.pull(c.varOf("target"), 1, "pulled2")))),

O Bear Claw em três passos: escolher um alvo com cartas na mão, puxar uma carta e, se ela for um herói, puxar outra

Um detalhe importante: os métodos do Ctx não fazem nada quando são chamados. Cada um devolve um Runnable, o passo, que só roda quando chegar a vez dele. Quando um passo precisa de uma decisão, ele não decide: pergunta e diz o que fazer com a resposta.

public Runnable choosePlayer(String var, Predicate<PlayerState> filter) {
    return () -> {
        List<JSONObject> options = t.others(owner).stream().filter(filter).map(Ctx::playerOption).toList();
        t.ask(owner, "choose_player", params(), options.isEmpty() ? 0 : 1, 1, options, source,
                sel -> set(var, sel.isEmpty() ? null : sel.get(0)));
    };
}

Esse t é a Table, uma interface com tudo o que um efeito pode fazer na partida: comprar, descartar, destruir, roubar, perguntar. A partida implementa essa interface, e os efeitos não conhecem mais nada dela.

Juntando as peças, o diagrama de classes ficou bem menor que o da parte 2. A carta não tem mais subclasses nem efeitos pendurados: ela só carrega um Script, e tudo o que muda durante a partida (a fila de passos, a pergunta em aberto, a rolagem em andamento) mora no Match.

Diagrama de classes da engine nova: Match implementa Table e guarda a fila de passos, a escolha pendente e o estado de cada jogador; cada GameCard tem um Script, que devolve passos montados com o Ctx; o CardCatalog monta o baralho

A fila que pausa

O coração da engine é pequeno. A partida guarda os passos pendentes numa fila, e um laço executa um por vez até a fila acabar ou alguém precisar responder:

public void push(List<Runnable> steps) {
    for (int i = steps.size() - 1; i >= 0; i--) flow.addFirst(steps.get(i));
}

private void pump() {
    // ...
    while (!waiting && !flow.isEmpty() && phase == Phase.GAMEPLAY) flow.pollFirst().run();
}

Quando um passo pergunta algo, a fila pausa. Quando a resposta chega, ela vai para o Ctx e a fila continua. E como passos como when colocam os seus sub-passos na frente da fila, tudo funciona como uma chamada de função no meio da carta: o “se for herói, puxe outra” roda logo depois do primeiro pull, antes de qualquer outra coisa.

Isso também mudou a máquina de estados. Na parte 2, cada tipo de pergunta era um estado da partida. Agora a partida tem só cinco fases, e dentro do jogo existe uma coisa só acontecendo: a fila executando passos. Perguntas, janelas de desafio, duelos e rolagens não são mais estados da partida, e sim motivos para a fila esperar. No código, o estado é o enum Phase mais o campo pendente que estiver preenchido no Match (choice, challengeWindow, duel, roll ou modifierWindow), e cada transição acontece por uma mensagem do cliente, um evento ou um prazo:

Máquina de estados implementada: o enum Phase com LOADING, ORDER_SELECTION, PARTY_LEADER_SELECTION, GAMEPLAY e FINISHED; dentro do GAMEPLAY, idle() espera a action do jogador da vez, pump() executa a fila e pausa quando choice, challengeWindow, roll, duel ou modifierWindow ficam preenchidos; cada transição traz a mensagem que a dispara, como order_selection, choose_party_leader, play_card, challenge, process_challenge_roll, select_effect_target, play_modifier e pass, e os eventos como order_finalized, duel_start e match_finished

Repare que toda pausa tem um prazo. Uma escolha que ninguém responde ganha uma resposta automática em 60 segundos, quem não rola os dados tem os dados rolados por ele, e as janelas de desafio e de modificadores fecham sozinhas. Nenhum jogador consegue travar a mesa, nem quando cai no meio de uma pergunta.

Uma pergunta de um jeito só

Com isso, escolher um jogador, uma carta da mão ou um herói da mesa virou a mesma coisa: um Choice, com o texto da pergunta, as opções e quantas podem ser escolhidas. Os três estados SELECTING_* e os instanceof sumiram.

Ter um tipo só de pergunta também abriu espaço para uma melhoria que veio logo depois: todo mundo vê a mesma tela de escolha. Quem escolhe vê as opções de verdade. Os outros veem as mesmas opções quando elas já são públicas, como um herói na mesa, ou viradas para baixo quando vêm de um lugar escondido, como a mão de alguém. Ninguém mais fica olhando para uma mesa parada sem saber o que está acontecendo.

O cliente também passou a receber um único estado da partida, completo, em vez de várias mensagens soltas para cada situação. É esse estado que alimenta as animações da parte 5, e foi ele que permitiu, mais tarde, voltar para a partida no ponto exato depois de recarregar a página.

Na parte 8, o que aconteceu quando eu tirei o jogo da minha máquina e outras pessoas começaram a jogar.