← Voltar para Here To Slay

Here To Slay, parte 11: os bots, com a mão na massa

Na metade do desenvolvimento dos bots do Here To Slay. Como o bot recebe a partida e age como um jogador, como ele dá nota para cada jogada e a conta exata dos dados.

#tecnico

Agora que já estou com a mão na massa no bot, acho que já posso falar um pouco mais do que está sendo feito. Na parte 10 eu contei o que li antes de começar e terminei com uma lista do que eu queria: um bot honesto, leve, com estilo, atento à mesa e com ritmo de gente. Ainda estou no meio do caminho, então este texto cobre a base, que já está de pé: onde o bot roda, como ele recebe a partida e como dá nota para as jogadas. Os números que aparecem aqui são provisórios e devem mudar quando eu começar a calibrar.

Todo o código dos bots fica num pacote só, bot/, dentro do servidor Java.

Como o bot recebe a partida e joga

O bot não é um processo separado nem um cliente conectado por WebSocket. Ele roda dentro do servidor, ligado à partida, mas joga como um jogador comum.

Toda vez que o estado da partida muda, o Match publica esse estado para cada lugar da mesa. Para os humanos, ele vai pelo Kafka até o WebSocket, como antes. Para os bots, ele vai para o BotDriver:

Ciclo de decisão de um bot: recebe o mesmo estado que um humano pelo BotView, avalia as opções no BotBrain, espera no BotDriver e envia a mesma ação que o cliente enviaria

O estado que o bot recebe é exatamente o mesmo que um humano naquele lugar receberia: a própria mão aberta e as cartas dos outros viradas. O BotView só organiza esse JSON com métodos como hand(), heroes(id) e handCount(id). Ele não tem acesso a nenhuma estrutura interna do Match. Com isso, a regra da parte 10, de o bot só saber o que uma pessoa naquele lugar saberia, é garantida pela própria arquitetura: não existe caminho no código para o bot ler a mão de outro jogador.

Do mesmo jeito, o bot age chamando performAction, a mesma porta pela qual chegam as mensagens dos humanos. O Match valida a jogada dele como validaria qualquer outra. Se o bot tentar algo ilegal, a ação é recusada.

Alguns detalhes do BotDriver:

  • decidir e agir em momentos diferentes: o onView é chamado com o lock da partida, então ali o bot só decide. A ação em si é agendada numa thread separada e roda depois da espera;
  • uma thread para todos: todos os bots de todas as partidas dividem uma única thread agendada. Uma decisão leva microssegundos, e enquanto ninguém está pensando, os bots não gastam nada;
  • não repetir trabalho: cada situação da partida vira uma chave. Se o estado for publicado de novo sem mudar nada para o bot, ele não replaneja;
  • saída de emergência: se o bot manda uma ação e a situação continua igual, ele tenta de novo. Depois de três tentativas, cai numa resposta que é sempre válida: passar a janela, escolher as primeiras opções ou encerrar o turno. Assim uma partida nunca fica travada esperando um bot;
  • janelas com prazo: as janelas de desafio e de modificador têm tempo limite. O bot nunca deixa para responder nos últimos 700 ms.

Uma nota para cada jogada

A IA de utilidade da parte 10 virou a classe CardValues, que diz quanto cada coisa vale em “pontos” naquele momento da partida:

static final double CARD = 4;       // uma carta na mão
static final double NEW_CLASS = 12; // uma classe nova no grupo
static final double WIN = 1000;     // vencer a partida

Por cima disso, cada herói tem um valor base para o efeito dele. Por exemplo, um efeito que só compra uma carta vale pouco, e um que destrói o herói de alguém vale bem mais. Um monstro derrotado vale perto de 30, e o terceiro, que dá a vitória, vale WIN.

No turno, o TurnPlanner monta a lista de todas as opções legais (comprar uma carta, jogar cada carta da mão, usar cada herói do grupo, atacar cada monstro disponível) e calcula o valor de cada uma por ponto de ação:

private record Option(String action, JSONObject payload, double value, int cost) {
    double perPoint() {
        return value / cost;
    }
}

Atacar um monstro custa dois pontos de ação, e o resto custa um, então essa divisão impede o bot de gastar o turno inteiro em algo só porque o valor total é alto. Ele pega a opção com a maior nota, manda a ação e, quando o estado volta, monta a lista de novo para o próximo ponto de ação.

Dois exemplos de como essas notas são calculadas:

  • jogar um herói: começa em 3. Se for uma classe nova, soma 12; se for a sexta classe, que vence a partida, soma mais 300. Como o herói pode rolar o efeito assim que entra, soma também a chance de a rolagem dar certo multiplicada pelo valor do efeito. E, se esse herói fizer o grupo cumprir o requisito de algum monstro, soma mais um pouco;
  • atacar um monstro: é a chance de derrotar vezes a recompensa, menos a chance de o monstro revidar vezes o que se perde (um herói ou duas cartas, dependendo do monstro).

A conta dos dados

Quase toda nota passa por uma probabilidade, e no Here To Slay ela é fácil de calcular de forma exata. As rolagens são sempre dois dados de seis lados, então existem só 36 resultados possíveis. A classe Odds guarda quantas combinações dão cada soma e conta:

/** WAYS[s] = quantos dos 36 resultados somam s. */
private static final int[] WAYS = {0, 0, 1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1};

/** P(2d6 + bonus >= target). */
static double atLeast(int target, int bonus) {
    int need = target - bonus;
    int ways = 0;
    for (int s = 2; s <= 12; s++) if (s >= need) ways += WAYS[s];
    return ways / 36.0;
}

Nos desafios, os dois jogadores rolam e quem desafia vence no empate. A conta passa pelas 36 × 36 = 1.296 combinações das duas rolagens. Não tem simulação nem sorteio, por isso a decisão custa quase nada e o resultado é sempre o mesmo para a mesma situação.

O que vem agora

Com essa base, o bot já consegue olhar a mesa e dizer quanto vale cada jogada do próprio turno. Mas ele ainda joga como se estivesse sozinho. Falta a parte que transforma isso num adversário de verdade:

  • reagir fora do turno: decidir quando vale a pena desafiar a carta de alguém ou jogar um modificador numa rolagem;
  • olhar para os outros: medir quem está perto de vencer e fazer os bots se unirem contra essa pessoa, como na ideia do MP-Mix da parte 10;
  • estilos e dificuldade: dar a cada bot uma personalidade e separar um nível normal, que erra como gente, de um avançado;
  • o modo solo: um painel na taverna para começar uma partida contra um, dois ou três bots.