Um editor de conjuntos de regras personalizadas pode trazer mais variedade a um RPG de batalha de cartas, mas afeta áreas como a validade dos baralhos, as funções dos personagens, os efeitos das cartas, a resolução das batalhas, a progressão e os jogos salvos. Use o editor para organizar a escolha das opções compatíveis e preserve a lógica de combate. Comece com um editor local de escopo reduzido, valide os dados antes de cada partida e mantenha o conjunto de regras original como opção padrão segura.

Este guia é para quem quer ampliar um RPG de cartas que já funciona. O exemplo, o conjunto de cartas, as funções dos personagens e os resultados dos testes são fictícios. Não havia repositório, módulo de resolução de batalhas, dados de baralhos, build ou teste de jogabilidade disponível. Os testes propostos a seguir não devem ser interpretados como testes já executados ou bem-sucedidos.
Registre as regras atuais antes de adicionar controles
Faça um commit com o projeto em um estado limpo ou trabalhe em uma cópia separada. Registre o conjunto de regras original, como uma partida começa, como um baralho é validado, como as funções dos personagens restringem as cartas e qual serviço resolve os turnos e os efeitos. Anote onde as regras e a progressão são salvas. Se o jogo não rodar localmente, documente o código inspecionado e deixe o comportamento em execução como não verificado.
Liste as condições que o editor deve preservar. Por exemplo, os custos das cartas devem continuar não negativos, cada função de personagem deve manter suas famílias de cartas permitidas, a ordem dos turnos deve continuar determinística e o modo original deve manter a configuração atual. Confirme essas condições no projeto em questão, pois elas não se aplicam necessariamente a todos os RPGs de cartas.
| Sistema | O que registrar no estado inicial | O que preservar por padrão |
|---|---|---|
| Módulo de resolução de batalhas | Responsabilidade pelos turnos e efeitos, ordem dos eventos | Não duplicar nem substituir o módulo |
| Regras dos baralhos | Tamanho, compatibilidade com a função, limites de cópias | Manter as verificações de validade existentes |
| Dados das cartas | Campos de custo, alvo e efeito, além dos IDs | Não editar o catálogo de cartas em todo o jogo |
| Modos e jogos salvos | Predefinições originais, progressão, esquema dos dados salvos | Manter os rascunhos personalizados separados |
Peça à IA que inspecione apenas os arquivos fornecidos e apresente um plano de alterações arquivo por arquivo. Exija que ela identifique o componente atualmente responsável pela validação das regras e pela execução das batalhas. Evite aceitar uma reescrita ampla do código antes de entender a precedência das regras e os limites entre os dados do projeto.
Defina um escopo reduzido para as regras
Comece com algumas opções que o jogo já consegue aplicar com segurança, como a duração da partida, uma predefinição de restrições de baralho ou uma regra compatível para uma família de cartas. Cada opção deve ter um rótulo claro, valores permitidos, um valor padrão e uma interação bem definida com as funções dos personagens. A primeira versão do editor não deve dar acesso a scripts arbitrários nem a todos os campos numéricos das cartas.
No exemplo fictício de Ashen Archive, uma predefinição personalizada local permite escolher o limite inicial de recursos, o número máximo de cópias e se uma família específica de cartas é permitida. É apenas um exemplo didático. Um projeto real pode não ser compatível com esses controles e só deve adicioná-los quando o sistema de batalha tiver um significado definido para cada um deles.

Documente explicitamente a precedência das regras. Se uma predefinição global limitar uma carta e uma função de personagem também definir uma restrição, decida qual regra prevalece e se a carta precisa atender às duas. Para substituições específicas de uma carta, defina quais campos podem ser sobrescritos e mantenha estáveis os IDs das cartas. Não use a ordem visual dos controles no editor para determinar o comportamento da partida.
Mantenha os dados das regras separados da resolução das batalhas
Prefira um objeto de valor para o conjunto de regras que possa ser lido pela configuração atual da partida e pelos validadores existentes. O editor altera esses dados. O módulo de resolução existente continua executando os turnos e os efeitos. Essa separação entre a edição das regras e o combate facilita a comparação de uma partida personalizada com a predefinição padrão.
Um possível registro de dados pode conter a versão do esquema, um ID para o conjunto de regras, a versão do jogo de origem, os valores das opções compatíveis e um nome de exibição. Armazene apenas dados e exclua expressões executáveis. Deixe que o jogo associe as opções validadas às regras existentes. Se o módulo de resolução atual não puder representar um valor, o editor não deve dar a entender que salvar esse valor fará o efeito funcionar.
A documentação de JSON do Godot descreve como converter texto JSON em um Variant e serializar os dados novamente em JSON. O guia de arquivos em tempo de execução descreve o uso de FileAccess para ler e gravar arquivos, com exemplos que incluem conteúdo fornecido pelo usuário. Essas referências confirmam a existência das APIs do motor, mas não prescrevem o esquema deste exemplo, não garantem segurança nem mostram uma implementação funcional de Ashen Archive.
Para dados criados por jogadores, valide a versão e todos os campos antes do uso. Rejeite IDs de regras desconhecidos, a menos que o projeto tenha uma política de compatibilidade com versões futuras. Aplique os limites mínimos e máximos definidos no projeto e exija identificadores de famílias de cartas conhecidos e chaves válidas para as funções dos personagens. Não instancie recursos arbitrários nem execute como código o texto de um arquivo de regras. Se o jogo aceitar conteúdo importado, teste esse fluxo e documente suas restrições separadamente.
Preserve os modos originais e os jogos salvos antigos
Armazene os rascunhos personalizados separadamente dos modos oficiais e da progressão. Quando um jogador editar uma predefinição, crie uma cópia para evitar sobrescrever o original sem aviso. Mantenha separados os resultados de partidas com regras personalizadas se o jogo tiver conquistas, partidas ranqueadas ou um estado de campanha salvo. A política do produto deve definir explicitamente se partidas com regras personalizadas podem usar esses sistemas.
Controle a versão do esquema e registre a versão do jogo de origem. Quando um campo mudar, defina como migrar os dados ou como recusar o carregamento de forma clara. Teste os dois caminhos com cópias dos jogos salvos existentes e dos conjuntos de regras criados pelos usuários. Se um campo estiver ausente, só use um valor que afete o balanceamento se o responsável pelo projeto o tiver definido como padrão.
| Caso de compatibilidade | Pergunta a responder | Evidência para a verificação |
|---|---|---|
| Arquivo personalizado antigo | É possível migrar esta versão do esquema? | Arquivo de teste copiado antes da migração |
| Opção ausente | Há um valor padrão documentado? | Aplicação do valor padrão verificada em teste |
| Família de cartas desconhecida | O carregamento deve ser recusado ou deve gerar um aviso? | Erro visível, sem substituição silenciosa |
| Predefinição original | A edição pode alterar o valor distribuído com o jogo? | Hash ou cópia da predefinição original |
| Resultado de partida personalizada | Afeta a campanha ou o ranking? | Política explícita do modo |
Implemente apenas o fluxo inicial do editor
Uma interface mínima precisa de uma lista de controles compatíveis, uma prévia das regras que serão aplicadas, um resumo da validação e opções para salvar como, duplicar e restaurar os padrões. Mostre quais restrições vêm da função de personagem selecionada. Se a opção escolhida entrar em conflito com uma função ou um conjunto de cartas, explique o conflito antes do início da partida para evitar uma falha durante o combate.
Use unidades claras e campos de entrada com limites definidos. Só rotule uma opção como “equilibrada” ou “competitiva” se houver evidências no projeto que sustentem essa classificação. Ofereça um conjunto de regras padrão que corresponda ao comportamento da versão distribuída do jogo e facilite o retorno a ele. Mantenha os campos avançados ocultos até que o jogo em execução, a interface e os testes possam dar suporte a eles.
A interface fictícia da ilustração gerada serve apenas como conceito visual. Ela não apresenta um editor real de conjuntos de regras, dados reais do jogo nem uma validação concluída. No projeto real, siga os padrões de interface já estabelecidos e reutilize o serviço de regras existente.
Planeje uma alteração mínima e como revertê-la
Anote quais arquivos podem mudar antes de aceitar o código. Uma primeira versão de escopo reduzido pode incluir uma tela do editor, um modelo ou adaptador para o conjunto de regras, um ponto de entrada para a validação, um serviço local para salvar rascunhos e testes focados. Preserve o módulo de resolução de batalhas, o banco de dados completo de cartas, a lógica das funções dos personagens, as predefinições originais e o leitor de jogos salvos da campanha, a menos que a inspeção do projeto comprove uma dependência que exija a alteração.
Revise o diff completo. Peça à IA que explique cada arquivo alterado e aponte mudanças nos valores padrão, na ordem dos eventos, nos valores das cartas ou nos pontos de integração com a progressão. Compare o código com a lista de alterações permitidas. Se a tarefa passar a incluir o balanceamento de todo o conjunto de cartas ou a refatoração do combate, pare e trate esse trabalho como uma alteração separada, com escopo próprio.
Mantenha o trabalho em uma branch ou em uma cópia limpa. Guarde uma amostra da predefinição padrão e uma cópia de cada arquivo de regras legado antes da migração. Se um conjunto de regras personalizado alterar um modo existente ou se um baralho conhecido se tornar inválido inesperadamente, volte ao estado inicial e reduza o escopo da alteração. Defina uma ação concreta no controle de versão para fazer a reversão.
Teste as interações entre regras em cópias
Teste cada opção isoladamente antes de testar combinações. Em seguida, verifique como as restrições globais, as regras de baralho específicas de cada função, os limites de cópias de cartas e as configurações da partida interagem. Verifique uma partida personalizada válida, um baralho inválido, um valor incompatível, um esquema antigo, um campo ausente e a restauração da predefinição original. Execute esses testes no projeto real antes de afirmar que há compatibilidade ou equilíbrio.

| Verificação proposta | Ação | O que registrar |
|---|---|---|
| Regressão do comportamento padrão | Iniciar uma partida conhecida com as regras originais | Build, predefinição, baralhos e fluxo de resolução observado |
| Compatibilidade com as funções | Usar uma carta sujeita a restrições com cada função de personagem | Resultado da validação e explicação |
| Limites | Inserir valores fora dos limites permitidos | Rejeição, correção e ausência de ajuste silencioso aos limites |
| Conteúdo malformado | Carregar dados com campos ausentes, inválidos e de versões futuras | Recusa segura e mensagem de erro que indique como proceder |
| Migração de dados salvos | Carregar uma cópia de um conjunto de regras personalizado legado | Migração ou recusa documentada |
| Reversão | Restaurar a branch limpa que serviu de referência | Funcionamento dos modos padrão como antes |
Esta matriz apresenta testes planejados, ainda por executar. Durante os testes, registre a versão do jogo, a versão do conjunto de regras, as funções dos personagens, os IDs dos baralhos, a ação, o comportamento esperado, o comportamento observado e qualquer divergência. Uma maquete não demonstra que uma combinação de regras é justa nem que um jogo salvo antigo ainda pode ser carregado.
Perguntas frequentes
O que um editor de conjuntos de regras personalizadas deve controlar?
Disponibilize apenas as opções de partida que o sistema de batalha existente consegue aplicar com segurança, como limites de turnos ou um pequeno conjunto de restrições de cartas documentadas. Mantenha os valores das regras dentro de limites definidos e fáceis de entender. A primeira versão do editor não deve permitir reescrever o núcleo do módulo de resolução de batalhas, a progressão dos personagens ou todos os efeitos das cartas.
Como evitar que regras personalizadas prejudiquem as batalhas de cartas?
Mantenha o módulo de resolução atual como responsável pelas decisões de combate e passe a ele um objeto de conjunto de regras já validado. Defina a precedência quando regras globais, funções de personagens e textos das cartas interagirem. Teste uma partida conhecida com as regras padrão e compare o resultado após adicionar o editor.
Os jogadores devem poder editar todos os valores das cartas?
Comece com uma lista curta de opções permitidas e compatíveis. Deixe de fora alterações arbitrárias de dano ou custo e scripts de efeitos arbitrários. Defina limites para os valores numéricos e rejeite combinações incompatíveis. Adicione um controle só quando o jogo tiver uma regra bem definida para ele e um caso de teste para suas interações.
Como salvar e atualizar conjuntos de regras personalizados?
Use um formato de dados versionado, identifique a versão do jogo de origem e separe as regras criadas pelos usuários das predefinições originais. Valide os campos antes do carregamento e defina como migrar ou recusar dados antigos de forma clara. Teste as alterações em uma cópia para preservar os jogos salvos existentes e os modos oficiais.
A IA consegue balancear um conjunto de regras personalizado para o meu jogo de cartas?
A IA pode ajudar a inspecionar as regras fornecidas, listar interações e elaborar casos de teste, mas não pode comprovar o equilíbrio sem o conjunto real de cartas, a lógica de batalha e os dados de partidas. Trate os valores gerados como propostas. Revise o diff completo e execute partidas representativas antes de compartilhar um conjunto de regras.
Adicione opções de regras sem substituir o combate
Registre o comportamento original, disponibilize uma lista curta de configurações permitidas, valide um registro de dados versionado e passe apenas os valores compatíveis ao módulo de resolução de batalhas existente. Mantenha os rascunhos personalizados separados das predefinições originais e dos jogos salvos antigos. Revise o diff completo, teste em cópias e mantenha um ponto de reversão limpo antes de afirmar que o editor funciona.
Para explorar um conceito separado de RPG de batalha de cartas, experimente o SEELE AI Game Maker. A ferramenta serve para criar conceitos e não edita projetos existentes.


