Un tableur peut contenir bien plus que des notes d’équilibrage. Il peut décrire des personnages, des objets, des rencontres, des améliorations ou des conditions qui déterminent ce qui se passe après une action du joueur. Pour transformer ces lignes en prototype de jeu, il faut définir précisément le sens de chaque donnée, son rôle dans le jeu à l’exécution et la façon de vérifier que la règle s’est bien appliquée.
Ce guide prend pour exemple Ember Circuit, un jeu d’exploration fictif au tour par tour. Ses personnages, son classeur, ses règles, son implémentation et ses résultats sont inventés. Aucun tableur source, fichier de projet ni build jouable n’a été fourni ou testé.
Choisissez une question à vérifier en jeu
Partez d’une question à laquelle le prototype doit répondre, par exemple « Dépenser une unité d’énergie pour scanner une pièce révèle-t-il un passage avant que le danger ne progresse ? » C’est plus facile à vérifier que de se demander « Peut-on convertir tout le tableur de conception ? » Sélectionnez les quelques lignes nécessaires pour définir un état initial, une action du joueur, un changement d’état produit par la règle et un retour visible.
Décrivez simplement l’état attendu avant et après l’action. Dans le tableur fictif d’Ember Circuit, un éclaireur commence avec trois unités de charge, un scan coûte une unité et, s’il réussit, il révèle le symbole d’une porte scellée. Ces chiffres et ce comportement servent uniquement d’exemples. Dans un projet réel, le concepteur devrait les confirmer avant qu’ils ne soient transposés en code ou en contenu.

Traitez le tableur comme une source de données
Recensez les onglets du classeur et précisez le rôle de chacun. Un onglet intitulé « Objets » peut mêler des définitions d’objets, des prix en boutique et des déblocages liés à la progression. Une colonne « Puissance » peut désigner des dégâts à un endroit et un niveau de fabrication à un autre. Les libellés, les couleurs, les formules et les cellules fusionnées ne suffisent pas à définir un contrat stable pour l’exécution du jeu.
Pour chaque champ dont le prototype a besoin, identifiez la personne qui en est responsable et son type parmi les possibilités suivantes : identifiant textuel, entier, nombre décimal, booléen, catégorie ou référence à une autre ligne. Indiquez si le champ est obligatoire, si les doublons sont autorisés et ce que signifie une cellule vide. Si une colonne a plusieurs significations ou contient des notes en texte libre, demandez à la personne responsable des règles de lever l’ambiguïté avant de l’exploiter.
Créez un tableau de correspondance succinct qui associe chaque onglet et chaque colonne de la source à un concept de jeu, à une règle de validation et à la partie du jeu qui utilise la donnée à l’exécution. L’identifiant d’une ligne peut devenir l’identifiant stable d’un objet, une valeur « coût » peut servir à vérifier que le joueur dispose des ressources nécessaires pour agir et une catégorie « résultat » peut déterminer la transition d’état à appliquer. Expliquez ces liens dans le tableau pour aller au-delà d’une simple reprise des noms de colonnes comme noms de variables.
Définissez le contrat de données avant de générer du code
Définissez une structure minimale pour chaque type de ligne. Une rencontre fictive pourrait par exemple comporter un identifiant, une valeur d’énergie initiale, un identifiant d’action, un coût en énergie, un état suivant et un message de retour. Séparez les définitions de l’état courant du jeu. Le tableur source peut indiquer qu’un scan coûte une unité d’énergie, tandis que l’état du joueur en cours de partie indique si celui-ci a déjà scanné la pièce.
La stabilité des identifiants est plus importante que la position des lignes. Si une autre ligne renvoie au « troisième objet », un tri dans le tableur risque de rompre le lien. Préférez des références comme item_crystal_lantern, puis vérifiez que chacune pointe vers une entrée existante. Si les noms affichés peuvent être traduits ou modifiés, évitez de les utiliser comme identifiants.
L’IA peut proposer un schéma ou résumer les dépendances probables, mais ses suggestions restent des hypothèses. Demandez au concepteur de confirmer les formules ambiguës, les unités, les règles de cumul et l’ordre d’application. Consignez la version du tableur utilisée pour qu’une personne chargée de la revue puisse retrouver l’origine de chaque valeur générée ou importée.
Importez et validez un petit échantillon
La documentation d’Unity cite le CSV et le JSON parmi les formats importés sous forme de Text Assets, dont le texte est accessible au code du projet. L’importation du fichier laisse ouverte la question du sens de chaque colonne. Le jeu a encore besoin d’un analyseur et de contrôles explicites. Selon le projet, l’équipe peut choisir un autre mode de gestion des données. Vérifiez que la méthode retenue fonctionne dans le moteur et la configuration de build du projet.
Avant que le prototype utilise les données, vérifiez les champs obligatoires, les identifiants en double, les plages de valeurs numériques, les catégories inconnues, les références manquantes et les lignes mal formées. Affichez un message d’erreur qui indique la ligne et le champ concernés. Un message comme « données invalides » peut éviter un plantage, mais il aide peu le concepteur à corriger le tableur. Ne remplacez pas silencieusement une valeur de dégâts manquante par zéro, sauf si cette valeur de repli est délibérée et visible.
Quand c’est possible, testez l’analyseur séparément de la boucle de jeu. Soumettez-lui une ligne valide et des exemples volontairement invalides, comme un identifiant vide, un coût négatif, une action inconnue, un identifiant répété ou une référence à une porte inexistante. Le but est de vérifier que les erreurs sont détectées dès leur entrée dans le système, avant qu’elles ne perturbent une rencontre en jeu.

Reliez les données à une boucle de jeu aux effets visibles
Limitez le premier scénario d’exécution à l’essentiel. Chargez l’état initial, présentez l’action, vérifiez ses conditions, déduisez son coût, mettez à jour l’état du monde et affichez ce qui a changé. Si un scan doit révéler le symbole d’une porte, le joueur doit voir le résultat, par exemple une modification de la carte, un nouvel élément avec lequel interagir ou un court message. Une valeur qui change en mémoire ne suffit pas à montrer que la règle est compréhensible.
Déterminez quelles données font foi. Le tableur est-il la source de référence, ou les concepteurs modifient-ils des ressources natives du moteur qui sont ensuite exportées vers le tableur ? Si deux copies peuvent être modifiées indépendamment, elles finiront par diverger. Choisissez un seul sens de circulation des données pour le prototype et documentez l’étape d’importation ou d’exportation.
Faites en sorte que l’application de chaque règle importante puisse être examinée. Dans un prototype au tour par tour, un journal peut indiquer l’énergie actuelle, le coût de l’action, le résultat de la vérification de la condition, la transition d’état et l’identifiant du retour au joueur. Il est alors plus facile de comparer le comportement observé à celui attendu d’après la ligne source. Le journal aide aussi à comprendre pourquoi une règle a emprunté la mauvaise branche d’exécution.
Testez les cas courants et les cas limites
Définissez les résultats attendus avant d’essayer le prototype. Prévoyez un cas de réussite ordinaire, un cas d’échec lorsque le joueur manque d’une ressource et un cas limite, par exemple lorsque le joueur dispose tout juste de l’énergie nécessaire pour agir. Ajoutez un cas de données manquantes ou invalides si l’analyseur fait partie des modifications. Assurez-vous que chaque test renvoie à une ligne source stable ou à un jeu de données de test documenté.
Comparez l’état réel du jeu et le retour affiché au joueur avec le résultat attendu. Consignez la version des données sources, la version du build, le cas testé, le résultat observé et tout écart constaté. Si le tableur change, revoyez explicitement les cas attendus. Une version plus récente du tableur n’est pas automatiquement correcte.
Demandez à une personne qui n’a pas implémenté la règle de jouer cette boucle. Peut-elle expliquer pourquoi l’action a réussi ou échoué ? Le résultat affiché correspond-il à l’état réel du jeu ? Cette vérification ciblée porte sur la compréhension de la règle. Une évaluation plus large de l’équilibrage ou de l’accessibilité reste distincte.

Appuyez-vous sur l’IA et conservez une revue humaine
L’IA peut aider à résumer le contenu des colonnes, à repérer des références probables, à rédiger des règles de validation, à ébaucher un analyseur ou à générer des pistes visuelles provisoires. Les décisions sur le sens des règles de jeu encore ambiguës doivent rester humaines. Une formule peut contenir une exception voulue, une cellule vide peut signifier « hériter » et l’unité d’une valeur peut n’être documentée qu’ailleurs.
Confiez à une personne la revue de chaque correspondance générée et demandez-lui de vérifier un échantillon représentatif par rapport à la source. Gérez ensemble les versions des fichiers d’entrée et de sortie. Lorsqu’une correspondance change, relancez les tests de validation qui en dépendent. Vous pourrez ainsi retracer chaque étape de l’importation et en expliquer le résultat.
Élargissez le prototype une fois la première boucle fiable
Une fois qu’une première boucle alimentée par les données fonctionne comme prévu, ajoutez des lignes par petits groupes. Faites en sorte que les résultats de la validation du contenu restent visibles, conservez des identifiants stables et ajoutez des contrôles automatisés lorsque le projet le permet. Importer une feuille entière d’un coup peut compliquer inutilement la recherche d’une valeur erronée ou d’une règle contradictoire.
Les données d’un tableur font le lien entre la conception et le prototype lorsque leur sens est explicite et que leurs effets peuvent être vérifiés. Partez d’une seule question de jeu, établissez le contrat de données, validez les données et comparez le comportement de la boucle en jeu aux cas définis dans la source. Pour en savoir plus sur l’utilisation de l’IA dans la création de jeux, consultez ces notes pratiques sur le processus de création.
Questions fréquentes
Comment transformer les règles d’un tableur en prototype de jeu jouable ?
Organisez les données du tableur en entités, actions, conditions, effets et éléments de progression, puis attribuez à chaque colonne importante un rôle précis dans l’exécution du jeu. Importez un petit échantillon, validez les valeurs obligatoires et les références, puis construisez une courte boucle de jeu avec un cas de réussite et un cas d’échec. Comparez le comportement en jeu aux lignes sources avant d’ajouter du contenu ou de considérer le prototype comme correct.
L’IA peut-elle transformer un tableur en jeu ?
L’IA peut aider à expliquer le contenu des colonnes, à repérer des relations probables, à ébaucher un schéma de données ou à suggérer un petit prototype. Sans le contexte du projet et des tests, elle ne peut pas déterminer si une formule ambiguë exprime la règle voulue ni si les données importées produisent le comportement attendu. Conservez une copie de la source, révisez les correspondances générées et validez des cas limites représentatifs en faisant tourner le jeu.
Faut-il stocker les règles du jeu en CSV ou en JSON ?
Choisissez un format en fonction de la façon dont l’équipe modifie, valide et charge les données. Unity importe les fichiers CSV et JSON sous forme de Text Assets, dont le texte est accessible au code du projet, mais l’application a encore besoin d’une logique d’analyse et de validation. Un format structuré peut représenter plus directement des objets imbriqués. Le CSV peut être pratique pour du contenu organisé en lignes. Testez la méthode choisie dans le moteur et le build cibles.
Comment éviter les erreurs liées aux données d’un tableur dans un jeu ?
Avant l’importation, définissez les colonnes obligatoires, les plages de valeurs autorisées, les identifiants uniques et les règles de référence. Détectez les cellules vides, les identifiants en double, les catégories inconnues, les formules invalides et les références manquantes. Pour chaque problème, indiquez la ligne et la colonne. Interrompez le chargement ou appliquez une solution de repli prévue afin d’éviter toute modification silencieuse de la règle. Conservez ensemble les versions des données sources et des données importées pour faciliter leur revue.
Quelle quantité de données du tableur faut-il utiliser dans un prototype ?
Utilisez juste assez de lignes pour vérifier une boucle de jeu significative, avec un état initial, un choix du joueur, un changement d’état du jeu et un résultat visible. Prévoyez un cas courant et un cas limite, comme une valeur manquante ou une valeur maximale. Avec un petit échantillon, il est plus facile de remonter à la source. Ajoutez du contenu une fois que vous comprenez comment les données arrivent dans le jeu et comment les règles s’appliquent.


