Um conjunto de regras de equipe pode transformar um roguelike de construção de dados em um jogo de decisões cooperativas, mas afeta a quem pertencem os dados, como funcionam as melhorias e as novas rolagens, quem escolhe o resultado, como o estado da partida é mantido e como funciona a geração aleatória. Preserve primeiro o ciclo atual de rolar, modificar e escolher. Defina quais elementos do estado serão compartilhados, adicione um único modo cooperativo de escopo limitado e compare seu funcionamento com o de uma partida solo conhecida antes de alterar o restante do jogo.

Este guia orienta a continuidade de um projeto existente. Os personagens, as regras, a partida de exemplo, a semente e os resultados dos testes são inventados. Como não havia código-fonte, build nem partida real disponível, todas as verificações abaixo são propostas e ainda precisam ser executadas no projeto real.
Mapeie o ciclo atual dos dados e quem controla cada parte do estado
Antes de alterar o código, crie uma branch limpa ou faça uma cópia e registre como uma partida funciona hoje. Acompanhe a rolagem, a modificação dos dados, a seleção do resultado, o pagamento dos custos com recursos, a resolução do encontro e a atualização das recompensas. Identifique qual componente controla cada valor e se ele persiste de uma sala para outra, de um andar para outro, entre partidas ou ao salvar e carregar o jogo. Se não for possível iniciar o jogo, diferencie o que foi observado no código do que foi verificado em execução.
Para cada campo do estado, determine se ele pertence atualmente a um jogador, a um dado, à equipe, a um encontro ou à partida. As regras do modo cooperativo podem permitir que os jogadores compartilhem uma moeda ou discutam uma recompensa, enquanto cada personagem mantém seus próprios dados e melhorias. Explicite a quem pertence cada elemento. Se isso ficar implícito, uma nova rolagem pode ser cobrada duas vezes ou uma perda de recurso pode deixar de ser registrada quando o jogador ativo mudar.
| Estado | De quem é ou quem controla? | Como preservar o modo atual |
|---|---|---|
| Dados e modificações | A quem pertencem o dado e suas melhorias? | Mantenha o funcionamento das rolagens no modo solo |
| Custo de rolar novamente ou modificar | Reserva individual ou da equipe? | Preserve a ordem atual dos pagamentos |
| Seleção do resultado | Jogador ativo, votação ou líder? | Mantenha as opções de resultado determinísticas em cada cenário |
| Vida e recompensas | Total compartilhado na partida ou valor por jogador? | Preserve os saves atuais da campanha |
| Controle do turno | Quem age e quando o controle passa para outra pessoa? | Preserve quem tem autoridade para resolver o encontro |
No exemplo fictício de Ember Relay, a equipe compartilha um recurso de rota, cada aventureiro mantém um conjunto próprio de dados e o jogador ativo propõe um resultado. Ambos os jogadores podem usar uma assistência uma vez por encontro. Essas escolhas servem apenas para ilustrar. Em um projeto real, parta do modelo atual de atribuição de dados e recursos e mude apenas o necessário para criar a dinâmica de cooperação desejada.
Preserve a sequência de rolar, modificar e escolher
Para adicionar um modo em equipe, mantenha o sistema de dados que já funciona. Preserve a ordem atual de rolar os dados, modificar as faces, pagar os custos e selecionar o resultado. Insira a regra de equipe no ponto específico em que o jogo já determina a quem algo pertence ou confirma uma escolha. Assim, você pode investigar se uma divergência vem do fluxo dos turnos, da atribuição dos recursos ou da lógica atual de resolução dos dados.

Registre a ordem de precedência das regras. Por exemplo, uma habilidade do jogador pode modificar um dado próprio, uma ficha da equipe pode afetar um resultado escolhido e, em seguida, o encontro é resolvido com base no resultado selecionado. Especifique se um efeito de equipe se aplica antes ou depois das melhorias individuais, se ele pode se acumular e o que acontece quando o dado-alvo está indisponível. Só considere criar um sistema genérico de modificadores para modos futuros depois de definir o primeiro caso de uso em equipe.
A documentação estável do Godot para RandomNumberGenerator descreve a semente e o estado por instância e informa que a mesma semente produz uma sequência pseudoaleatória reproduzível. Esse recurso é específico do motor. A documentação, por si só, não demonstra que o jogo em questão usa esse recurso, mantém um comportamento determinístico entre versões do motor ou é balanceado. Investigue como o gerador aleatório do jogo realmente funciona antes de escolher uma estratégia de teste. Mantenha as sugestões sobre fixtures determinísticas separadas das afirmações verificadas sobre a implementação.
Defina um conjunto enxuto e versionado de regras de equipe
Mantenha os dados das regras separados da execução do jogo. Um conjunto enxuto de regras pode identificar o modo, a versão do esquema, o número de jogadores, a ordem dos turnos, as regras que determinam a quem pertencem os recursos e como o resultado é escolhido, além de uma pequena lista de efeitos de equipe aceitos. Prefira enums explícitos e valores com limites definidos a scripts livres. O motor de regras deve rejeitar de forma explícita as opções que não reconhece.
Use uma configuração padrão que preserve o modo já lançado. A adoção das regras de equipe deve ser opcional, e elas devem ser armazenadas separadamente da progressão atual da campanha, salvo quando os requisitos do projeto pedirem explicitamente uma migração. Se os saves antigos não incluírem informações sobre o modo de jogo, defina e documente qual modo será assumido por compatibilidade e teste essa escolha em cópias dos saves. O tutorial do Godot sobre como salvar jogos mostra como selecionar campos persistentes e serializá-los em um exemplo do próprio motor. O alcance desse exemplo se limita à implementação demonstrada.
Para regras criadas pelo usuário ou configuráveis, valide, antes de iniciar a partida, a versão do esquema, os identificadores reconhecidos de jogadores, as regras de atribuição dos recursos, os IDs dos efeitos, os limites dos turnos e a presença dos valores padrão obrigatórios. Mantenha os nomes exibidos separados dos identificadores das regras. Salve um conjunto de regras personalizado como rascunho e preserve as predefinições do jogo enquanto o jogador experimenta.
Deixe claro como a equipe toma decisões
O modo em equipe deve oferecer escolhas que façam diferença. Se um jogador sempre puder escolher o resultado, o outro pode acabar como espectador. Se toda escolha exigir uma votação, o jogo pode perder o ritmo. Decida quando os jogadores podem discutir, se cabe a quem está no turno confirmar a escolha, se há um critério de desempate e como o jogo reage quando alguém se desconecta, caso já exista um modo multijogador. Só prometa um modo cooperativo em rede se o jogo já oferecer suporte a partidas em rede.
Agrupe visualmente os recursos compartilhados e os individuais de formas distintas. Antes de aplicar um efeito de equipe, mostre quem paga e quais dados ou qual resultado o efeito pode afetar. Após a resolução, mostre o que mudou e a quem pertence a melhoria obtida. Mantenha a opção solo disponível e, se incluir regras exclusivas da equipe nos menus do modo comum, identifique-as claramente.
Planeje as mudanças mínimas e como revertê-las
Peça à IA que examine os arquivos reais e proponha, antes de editar, um patch detalhado arquivo por arquivo. Uma primeira etapa pode incluir um modelo para o conjunto de regras, um ponto de integração para a seleção do modo, um adaptador que determine a quem pertencem os elementos usados na escolha atual do resultado e testes específicos. Preserve as faces dos dados, os algoritmos de modificação, a lógica central de resolução dos encontros, os valores de balanceamento do modo solo e o código que lê saves antigos, salvo se houver evidências no projeto de que é necessário alterá-los.
Defina uma lista de arquivos autorizados e exija o diff completo. Se o patch propuser alterações inesperadas em todos os dados, nas tabelas de recompensas, no gerenciador de partidas ou em um modo de jogo existente, pause a implementação. Faça um commit limpo antes de aplicar o patch. Se a estrutura de dados escolhida para a equipe exigir a migração dos saves da campanha, trate a migração como uma mudança separada e teste-a em cópias. Assim, ela pode ser avaliada antes de ser incorporada à funcionalidade.
| Escopo provável | Possível adição | O que preservar por padrão |
|---|---|---|
| Conjunto de regras | Uma definição versionada para o modo em equipe | Predefinição do modo solo já lançado |
| Atribuição de recursos | Mapeamento dos IDs de recursos individuais e da equipe | Regras de modificação dos dados |
| Escolha | Uma etapa de decisão do resultado em equipe | Rolagem básica e lógica de resolução dos encontros |
| Save | Campo opcional para o modo, com valor padrão se estiver ausente | Chaves de progressão existentes |
| Testes | Casos de teste para a atribuição de recursos da equipe e para regressões no modo solo | Tabelas de recompensas em produção |
Teste partidas com semente definida e verifique regressões no modo solo
Use o mecanismo de teste compatível com o projeto real. Se houver um gerador que aceite uma semente, registre a semente, a versão do jogo, a ordem dos jogadores e as ações. Caso contrário, recorra a fixtures determinísticas ou a uma sequência documentada de rolagens de teste. Só trate uma partida aleatória como reproduzível se houver um mecanismo que permita repeti-la. Observar a mesma rolagem é apenas uma das verificações. Confira também as modificações, o custo, quem faz a escolha e o estado final.

| Verificação proposta | Ação | Evidências a coletar |
|---|---|---|
| Referência do modo solo | Jogue uma sequência conhecida com as regras atuais | Build, estado da partida e registro das rolagens e dos resultados |
| Recursos da equipe e individuais | Gaste um recurso compartilhado e pague por uma nova rolagem individual | Valores antes e depois e IDs de quem detém os recursos |
| Ordem dos turnos | Alterne quem age primeiro usando a mesma fixture | Ordem esperada e resultado selecionado |
| Regras inválidas | Tente carregar regras com identificadores ausentes ou desconhecidos | Rejeição segura e mensagem que indique como corrigir o problema |
| Compatibilidade dos saves | Abra uma cópia do save de uma partida solo anterior | Aplicação do valor padrão documentado e progresso preservado |
| Reversão | Restaure a branch limpa usada como referência | O ciclo original do modo solo continua disponível |
A matriz acima descreve verificações propostas. Ao executá-las, registre o que de fato aconteceu, incluindo a versão do projeto, a versão do conjunto de regras, a semente ou fixture, a ordem dos jogadores, o estado antes e depois de cada escolha e qualquer diferença em relação à referência do modo solo. Uma imagem ilustrativa da mesa de jogo não permite verificar a reprodutibilidade do RNG, a atribuição de recursos à equipe, o balanceamento ou a compatibilidade dos saves.
Faça afirmações sobre balanceamento apenas com base em evidências
Um modo pode ter mecânicas consistentes e ainda assim gerar decisões repetitivas ou injustas. Faça testes de jogo com uma amostra representativa de funções dos jogadores, configurações de dados e tipos de encontro antes de fazer afirmações sobre balanceamento. Acompanhe quais jogadores contribuem para as decisões, se a assistência compensa o custo e se um recurso da equipe torna um desafio fácil demais. Uma revisão de código ou alguns exemplos inventados, por si sós, são insuficientes para dizer que uma configuração é balanceada.
Para explorar um conceito independente de roguelike de construção de dados, experimente o SEELE AI Game Maker. A ferramenta serve para explorar conceitos e não oferece edição de projetos existentes.
Perguntas frequentes
O que as regras de equipe de um roguelike de dados devem definir?
Defina se os dados, as melhorias, a vida, a moeda e as escolhas de rota pertencem a cada jogador ou à equipe. Especifique quem escolhe o resultado de uma rolagem e como os turnos são resolvidos. Comece com uma única mudança de regra para introduzir a cooperação e evite misturar por engano os recursos compartilhados com a progressão atual do modo solo.
Como preservar as mecânicas atuais de modificação dos dados?
Use a sequência atual de rolar, modificar e escolher como referência. Defina a quem pertence cada elemento do estado resultante no modo em equipe, preservando as faces dos dados e as regras de novas rolagens. Use uma partida solo conhecida para comparar o antes e o depois do patch e confira se as escolhas, os custos e os resultados permanecem consistentes.
Os jogadores da equipe devem compartilhar uma reserva de dados ou manter dados separados?
Escolha com base em como o jogo já atribui dados e recursos e no tipo de decisão cooperativa que você quer criar. Uma reserva compartilhada pode tornar os turnos mais colaborativos, enquanto reservas separadas preservam as configurações individuais. Documente como as melhorias, as novas rolagens e as perdas se aplicam e teste as duas ordens dos jogadores antes de ampliar as regras.
Como testar resultados aleatórios dos dados?
Use sementes registradas ou outra fixture determinística compatível com o projeto, quando disponível, e deixe claro quais etapas dependem do gerador aleatório. Execute o mesmo cenário antes e depois da alteração nas regras de equipe. Uma sequência gerada a partir de uma semente pode facilitar a reprodução, mas é insuficiente para comprovar o balanceamento ou um comportamento idêntico entre versões do motor.
A IA pode adicionar regras cooperativas ao meu jogo de dados existente?
A IA pode examinar os arquivos fornecidos, mapear o fluxo atual do estado e sugerir um patch de escopo limitado e uma matriz de testes. Confirmar a compatibilidade exige acesso ao seu código e partidas executadas. Forneça uma lista de arquivos autorizados, uma partida de exemplo, as regras esperadas para determinar a quem pertence cada elemento e um commit ao qual seja possível voltar. Depois, revise cada arquivo alterado.
Adicione o modo em equipe ao ciclo de dados que já funciona
Comece mapeando a quem pertence cada elemento, defina um conjunto versionado de regras de equipe e adicione uma decisão compartilhada bem definida, preservando a sequência atual de rolar, modificar e escolher. Proteja o modo solo e os saves antigos. Use uma cópia do projeto para testar o estado da equipe, a ordem dos jogadores e possíveis regressões, e mantenha uma forma concreta de reverter as mudanças. Trate as verificações ainda não executadas e os exemplos fictícios como propostas.


