Como adicionar regras personalizadas sem substituir o sistema de batalha de cartas

Adicione um editor local de conjuntos de regras a um RPG de cartas, com limites explícitos e validação. Preserve a resolução das batalhas, os baralhos por função de personagem, os modos originais e os jogos salvos existentes.

Seele Editorial TeamAtualizado 16 de novembro de 2026

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.

Um editor de conjuntos de regras de um RPG fictício de batalha de cartas aparece ao lado de uma prévia dos baralhos de dois personagens.
Ashens Archive e todas as cartas e modos exibidos são fictícios. Nenhuma batalha foi executada.

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.

SistemaO que registrar no estado inicialO que preservar por padrão
Módulo de resolução de batalhasResponsabilidade pelos turnos e efeitos, ordem dos eventosNão duplicar nem substituir o módulo
Regras dos baralhosTamanho, compatibilidade com a função, limites de cópiasManter as verificações de validade existentes
Dados das cartasCampos de custo, alvo e efeito, além dos IDsNão editar o catálogo de cartas em todo o jogo
Modos e jogos salvosPredefinições originais, progressão, esquema dos dados salvosManter 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.

Um painel fictício de conjuntos de regras envia opções validadas a um fluxo separado de resolução de batalhas de cartas.
Os dados estruturados das regras passam por validação antes de serem usados pelo sistema de batalha existente.

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 compatibilidadePergunta a responderEvidê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 ausenteHá um valor padrão documentado?Aplicação do valor padrão verificada em teste
Família de cartas desconhecidaO carregamento deve ser recusado ou deve gerar um aviso?Erro visível, sem substituição silenciosa
Predefinição originalA edição pode alterar o valor distribuído com o jogo?Hash ou cópia da predefinição original
Resultado de partida personalizadaAfeta 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.

Uma maquete de interface de um RPG fictício de cartas mostra exemplos de partidas, baralhos por função de personagem e um ponto de restauração para testar conjuntos de regras.
Planejamento de testes meramente ilustrativo. O balanceamento, a validade dos baralhos e os resultados das partidas não foram testados.
Verificação propostaAçãoO que registrar
Regressão do comportamento padrãoIniciar uma partida conhecida com as regras originaisBuild, predefinição, baralhos e fluxo de resolução observado
Compatibilidade com as funçõesUsar uma carta sujeita a restrições com cada função de personagemResultado da validação e explicação
LimitesInserir valores fora dos limites permitidosRejeição, correção e ausência de ajuste silencioso aos limites
Conteúdo malformadoCarregar dados com campos ausentes, inválidos e de versões futurasRecusa segura e mensagem de erro que indique como proceder
Migração de dados salvosCarregar uma cópia de um conjunto de regras personalizado legadoMigração ou recusa documentada
ReversãoRestaurar a branch limpa que serviu de referênciaFuncionamento 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.

Fontes

SEELE AI

Transforme este guia em um projeto jogável.

Comece com um briefing claro e evolua sua ideia no Workspace da Seele AI.

Começar a criar