Uma planilha pode guardar mais do que anotações de balanceamento. Ela pode descrever personagens, itens, encontros, melhorias ou condições que determinam o que acontece depois que o jogador age. Para transformar essas linhas em um protótipo de jogo, é preciso definir o significado de cada dado, onde ele será usado durante a execução e como demonstrar que a regra funcionou.
Este guia usa como exemplo Ember Circuit, um jogo fictício de exploração por turnos. Os personagens, a planilha, as regras, a implementação e os resultados são inventados. Nenhuma planilha de origem, nenhum arquivo de projeto e nenhuma versão jogável foram fornecidos ou testados.
Escolha uma pergunta para responder jogando
Comece com uma pergunta que o protótipo deve responder, como “Gastar uma unidade de energia para escanear uma sala revela uma rota antes que o perigo avance?” É mais fácil validar isso do que responder “Dá para converter a planilha de design inteira?” Selecione as poucas linhas necessárias para definir um estado inicial, uma ação do jogador, uma mudança provocada pela regra e um retorno visível.
Descreva em linguagem simples como o estado deve ficar antes e depois da ação. Na planilha fictícia de Ember Circuit, um explorador começa com três unidades de carga, escanear a sala custa uma unidade e, se a ação for bem-sucedida, o símbolo de uma porta selada é revelado. Os números e o comportamento servem apenas como exemplo. Em um projeto real, o designer deve confirmá-los antes que alguém os converta em código ou conteúdo.

Trate a planilha como fonte de dados
Liste as abas da planilha e anote a finalidade de cada uma. Uma aba chamada “Itens” pode reunir definições de itens, preços de loja e desbloqueios de progressão. Uma coluna chamada “Poder” pode representar dano em um lugar e um nível de fabricação em outro. Não presuma que rótulos, cores, fórmulas ou células mescladas definam um contrato estável para a execução do jogo.
Para cada campo de que o protótipo precisa, identifique o responsável e o tipo de dado, como identificador textual, número inteiro, número decimal, valor booleano, categoria ou referência a outra linha. Registre se o campo é obrigatório, se aceita valores duplicados e o que significa uma célula em branco. Se uma coluna tiver vários significados ou contiver anotações em texto livre, peça ao responsável pelas regras que esclareça a ambiguidade antes de usar esses dados.
Monte uma tabela de mapeamento enxuta que associe cada aba e coluna de origem a um conceito do jogo, a uma regra de validação e ao componente que usa o dado durante a execução. O identificador de uma linha pode virar um ID estável de item, um valor de “custo” pode servir para verificar se o jogador tem recursos suficientes para agir, e uma categoria de “resultado” pode determinar a transição de estado. Use o mapeamento para explicar essas relações. Copiar nomes de colunas para nomes de variáveis é insuficiente.
Defina o contrato de dados antes de gerar código
Defina a estrutura mínima de cada tipo de linha. Um encontro fictício, por exemplo, pode ter um ID, a energia inicial, o ID da ação, o custo em energia, o próximo estado e uma mensagem de retorno. Separe as definições do estado em tempo de execução. A planilha de origem pode indicar que escanear a sala custa uma unidade de energia, enquanto o estado do jogador registra se ele já escaneou a sala.
IDs estáveis são mais importantes do que a posição das linhas. Se outra linha apontar para “o terceiro item”, ordenar a planilha pode quebrar a relação. Prefira referências como item_crystal_lantern e verifique se cada referência aponta para um registro existente. Evite usar nomes de exibição como identificadores se esses nomes puderem ser traduzidos ou editados.
A IA pode sugerir um esquema ou resumir dependências prováveis, mas essas sugestões ainda são hipóteses. Peça ao designer que confirme as fórmulas ambíguas, as unidades, as regras de acúmulo e a ordem de aplicação. Registre a revisão da planilha usada como fonte para que quem fizer a revisão consiga rastrear cada valor gerado ou importado.
Importe e valide uma pequena amostra
A documentação do Unity inclui CSV e JSON entre os formatos importados como Text Assets, cujo texto pode ser lido pelo código do projeto. A importação do arquivo, por si só, não define o significado de cada coluna. O jogo ainda precisa de um parser e de verificações explícitas. A equipe pode adotar outro fluxo de dados, dependendo do projeto. Verifique a opção escolhida no motor de jogo e na configuração de build que a equipe usa.
Antes de o protótipo usar os dados, verifique campos obrigatórios, IDs duplicados, intervalos numéricos, categorias desconhecidas, referências ausentes e linhas malformadas. Exiba uma mensagem de erro que identifique a linha e o campo. Uma mensagem como “dados inválidos” pode evitar que o jogo trave, mas pouco ajuda o designer a corrigir a planilha. Só substitua um valor de dano ausente por zero se esse comportamento for intencional e visível.
Sempre que for viável, teste o parser separadamente do ciclo de jogo. Passe a ele uma linha válida e exemplos deliberadamente inválidos, como um identificador vazio, um custo negativo, uma ação desconhecida, um ID repetido ou uma referência a uma porta inexistente. Verifique se os erros são detectados na entrada dos dados, antes que apareçam como falhas em um encontro.

Conecte os dados a um ciclo de jogo com resultados visíveis
Mantenha simples o primeiro fluxo de execução. Carregue o estado inicial, apresente a ação, verifique suas condições, aplique o custo, atualize o estado do mundo e mostre o que mudou. Se escanear a sala deve revelar o símbolo de uma porta, o jogador precisa ver algum retorno, como uma mudança no mapa, um novo alvo de interação ou uma mensagem curta. A mudança de um número na memória ainda é insuficiente para demonstrar que a regra é compreensível.
Deixe claro onde os dados oficiais são mantidos. A planilha é a fonte oficial ou os designers editam recursos nativos do motor e os exportam para a planilha? Se duas cópias puderem ser editadas de forma independente, acabarão divergindo. Escolha um sentido para o fluxo de dados no protótipo e documente a etapa de importação ou exportação.
Represente cada regra importante de modo que seja possível inspecioná-la. Em um protótipo por turnos, um log pode mostrar a energia atual, o custo da ação, o resultado da verificação da condição, a transição de estado e o ID da mensagem de retorno. Isso facilita a comparação do comportamento com o que se espera a partir da linha de origem e dá pistas a quem faz a revisão quando a regra segue o caminho errado.
Teste casos normais e casos-limite
Defina os resultados esperados antes de testar o protótipo. Inclua um caso normal de sucesso, um caso de falha por falta de um recurso e um caso-limite, como ter exatamente a energia necessária para executar a ação. Se o parser fizer parte da alteração, inclua também um caso com dados ausentes ou inválidos. Garanta que cada teste corresponda a uma linha de entrada estável ou a um conjunto documentado de dados de teste.
Compare o estado real e o retorno exibido ao jogador com o resultado esperado. Registre a revisão dos dados de origem, a versão da build, o caso de entrada, a saída observada e a divergência. Se a planilha mudar, revise conscientemente os resultados esperados dos testes. Evite presumir que a versão mais recente da planilha está correta só por ser mais nova.
Peça a alguém que não implementou a regra para jogar esse ciclo. A pessoa consegue dizer por que a ação funcionou ou falhou? O resultado exibido corresponde ao estado interno do jogo? Esse teste pontual verifica a compreensão da regra. Uma avaliação mais ampla de balanceamento ou acessibilidade continua sendo uma etapa à parte.

Use a IA como apoio e mantenha a revisão
A IA pode ajudar a resumir colunas, identificar referências prováveis, esboçar regras de validação, montar a estrutura de um parser de exemplo ou gerar propostas visuais provisórias. As decisões pendentes sobre o significado das regras do jogo exigem confirmação. Uma fórmula pode conter uma exceção intencional, uma célula em branco pode significar “herdar” e a unidade de um valor pode estar documentada apenas em outro lugar.
Peça a alguém que revise cada mapeamento gerado e compare uma amostra representativa com a fonte. Mantenha os artefatos de entrada e saída versionados em conjunto. Quando um mapeamento mudar, rode novamente os testes de validação que dependem dele. Assim, o fluxo fica rastreável e a equipe consegue explicar como os dados foram importados.
Amplie o protótipo quando o primeiro ciclo estiver confiável
Quando um ciclo baseado em dados se comportar como esperado, adicione linhas em pequenos grupos. Mantenha a validação de conteúdo visível, preserve os IDs estáveis e inclua verificações automatizadas quando houver suporte no projeto. Importar a planilha inteira de uma vez pode dificultar desnecessariamente o diagnóstico de um valor problemático ou de uma regra contraditória.
Os dados da planilha ajudam a levar o design ao protótipo quando seu significado é explícito e seus resultados podem ser revisados. Comece com uma pergunta sobre o jogo, estabeleça o contrato, valide os dados e compare o ciclo em execução com os casos de origem. Para orientações mais abrangentes sobre fluxos de trabalho com IA na criação de jogos, consulte estas notas práticas.
Perguntas frequentes
Como transformar regras de uma planilha em um protótipo de jogo jogável?
Organize a planilha em entidades, ações, condições, efeitos e progressão. Em seguida, associe cada coluna importante a uma função explícita durante a execução do jogo. Importe uma pequena amostra, valide os valores obrigatórios e as referências e implemente um ciclo curto com um caso de sucesso e outro de falha. Compare o comportamento em execução com as linhas de origem antes de ampliar o conteúdo ou considerar o protótipo correto.
A IA pode transformar uma planilha em um jogo?
A IA pode ajudar a explicar colunas, identificar relações prováveis, esboçar um esquema de dados ou sugerir um pequeno protótipo. Sem o contexto do projeto e sem testes, ela não consegue saber se uma fórmula ambígua expressa a regra pretendida ou se os dados importados se comportam corretamente. Guarde uma cópia da fonte, revise os mapeamentos gerados e valide casos-limite representativos com o jogo em execução.
As regras de jogo devem ser armazenadas em CSV ou JSON?
Escolha o formato com base em como a equipe edita, valida e carrega os dados. O Unity importa arquivos CSV e JSON como Text Assets, que disponibilizam seu texto ao código do projeto, mas a aplicação ainda precisa de lógica de leitura e validação. Um formato estruturado pode representar objetos aninhados de forma mais direta. O CSV pode ser prático para conteúdo organizado em linhas. Teste o fluxo escolhido no motor de jogo e na build de destino.
Como evitar erros em dados de planilha usados em um jogo?
Defina as colunas obrigatórias, os intervalos de valores permitidos, os identificadores únicos e as regras de referência antes da importação. Verifique se há células vazias, IDs duplicados, categorias desconhecidas, fórmulas inválidas e referências ausentes. Informe a linha e a coluna de cada problema. Para evitar mudanças silenciosas na regra, interrompa o carregamento ou aplique uma alternativa definida de antemão. Mantenha juntas as versões dos dados de origem e dos dados importados para facilitar a revisão.
Quanto do conteúdo da planilha um protótipo deve usar?
Use apenas as linhas necessárias para demonstrar um ciclo relevante, com um estado inicial, uma escolha do jogador, uma mudança no estado do jogo e um resultado visível. Inclua um caso normal e um caso-limite, como um valor ausente ou um valor máximo. Uma amostra pequena é mais fácil de rastrear até a origem. Adicione mais conteúdo quando o fluxo dos dados e o comportamento das regras estiverem claros.


