Redgate Hub

Supposons que vous créez un jeu vidéo de rôle et que vous ayez besoin d’un moyen plus simple d’attribuer des statistiques, des propriétés et bien plus encore à divers éléments. Bien que vous puissiez utiliser des préfabriqués Unity pour ce faire, puis modifier les valeurs de chaque copie individuelle du préfabriqué, c’est une façon peu pratique de s’acquitter de la tâche. Pour commencer, cette méthode utilise plus de votre mémoire, quelque chose que vous devrez peut-être conserver si vous prévoyez de faire un grand jeu. De plus, si vous devez apporter des modifications aux objets du jeu, il n’est tout simplement pas aussi efficace de le faire lorsqu’il y a plusieurs copies de préfabriqués qui traînent. Cela devient particulièrement problématique si vous avez une équipe plus importante avec laquelle travailler, vous voudrez donc faciliter les changements pour les autres membres de l’équipe. Même si vous n’êtes pas en équipe, cette méthode serait plus difficile pour vous lorsque vous travaillez.

Pour faciliter les choses dans une situation comme celle-ci, vous avez des objets Scriptables à votre disposition. Et que sont les Objets Scriptables ? En termes simples, ce sont des conteneurs de données. Le développeur Unity crée un modèle de base pour ces conteneurs, définissant les informations que chaque objet doit contenir. Ensuite, les Objets Scriptables sont créés à partir de ce modèle, qui sont ensuite utilisés par les objets de jeu Unity. Dans l’exemple ci-dessus, un seul objet Scriptable peut être utilisé pour définir les différentes propriétés d’un élément. Ensuite, cet objet Scriptable est référencé par toutes les copies de l’élément. Avant, si vous vouliez modifier les statistiques d’un élément, vous deviez modifier les valeurs de chaque copie de l’élément. Maintenant, avec les objets Scriptables, il vous suffit de changer un seul objet (l’Objet Scriptable) et tous les objets obtenant des données de cet Objet Scriptable changent en même temps.

Il est toujours utile de voir ces choses en action, de créer un nouveau projet. Ce projet montre les objets scriptables et comment ils peuvent vous aider. Le projet se compose de trois objets de jeu destinés à représenter trois personnages. Chaque caractère hérite de certaines valeurs d’un Objet Scriptable. Ces valeurs sont la santé maximale, l’attaque, la défense, la vitesse et un nom et une couleur pour le personnage. Une interface utilisateur simple affiche ces valeurs afin que vous puissiez facilement voir les résultats de l’application d’objets Scriptables. Maintenant que vous avez un objectif final, il est temps de créer.

Configuration du projet

En supposant que vous allez implémenter ces idées dans un nouveau projet, ouvrez l’application Unity Hub et créez un nouveau projet comme illustré à la figure 1.

Figure 1: Création d’un nouveau projet

Dans la fenêtre suivante, donnez au projet le nom de votre choix et choisissez le chemin du fichier. Bien que vous puissiez exécuter ce projet dans n’importe quel modèle, cet exemple utilise le modèle de projet 3D comme illustré à la figure 2. Il est recommandé d’utiliser ce modèle si vous souhaitez suivre.

Figure 2: Définition du nom, du type et de l’emplacement du projet

Une fois le projet créé, vous voudrez vous organiser. Dans votre fenêtre Assets, vous devrez créer trois dossiers en cliquant avec le bouton droit de la souris sur la fenêtre et en naviguant dans Create-> Folder, comme le montre la figure 3, Nommez les dossiers Matériaux, Objets Scriptables et Scripts.

Figure 3: Créer un nouveau dossier

Pendant que vous êtes ici, c’est une bonne idée d’aller de l’avant et de faire fabriquer trois matériaux. Ces matériaux sont utilisés pour changer les couleurs de différents objets suivant le matériau spécifié par l’Objet Scriptable. Pour créer ces matériaux, accédez au dossier Matériaux et cliquez à nouveau avec le bouton droit de la souris, en sélectionnant cette fois Créer -> Matériau. Lorsque vous nommez le matériau, il est recommandé de lui donner un nom en corrélation avec sa couleur. Par exemple, ce premier matériau peut être nommé rouge. Pour définir cette couleur, vous devez sélectionner le matériau nouvellement créé et accéder à la fenêtre de l’inspecteur. Dans le champ d’albédo, il y a un sélecteur de couleurs illustré à la figure 4 sur lequel vous pouvez cliquer pour ouvrir le sélecteur de couleurs.

Figure 4: Ouverture du sélecteur de couleurs

La couleur est modifiée soit en déplaçant le petit cercle dans le sélecteur de couleurs, soit en entrant directement les valeurs RVB dans la moitié inférieure de la fenêtre du sélecteur de couleurs. Dans l’exemple ci-dessus, les valeurs RVB seraient 255, 0, 0. Après cela, vous devez créer deux autres matériaux et attribuer leurs couleurs. Cet exemple utilise le vert et le bleu, mais ils peuvent être n’importe quelle couleur de votre choix.

Vient maintenant le temps de créer la scène réelle où se déroule ce jeu. Il se compose de deux parties principales – il y a l’interface utilisateur qui affiche les statistiques données aux différents objets scriptables et les trois capsules représentant les personnages. Les « personnages » sont la partie la plus facile, vous pouvez donc commencer par là. Tout ce que vous avez à faire est d’aller dans la fenêtre de hiérarchie, de cliquer sur le bouton Créer et de choisir Objet 3D – Capsule > illustrée à la figure 5. Faites-le trois fois ou copiez le premier objet, et vous pouvez également leur donner des noms si vous le souhaitez. Cet exemple donne aux capsules les noms Char1, Char2, Char3.

Figure 5: Création d’un objet capsule

Vous devrez modifier leurs positions afin qu’elles ne se chevauchent pas. Pour modifier la position de l’objet, vous en sélectionnez une dans la hiérarchie et accédez au composant Transform dans l’Inspecteur. Modifiez ensuite les champs de positionnement x, y et z pour déplacer les objets où vous les souhaitez.

Figure 6: Modification de la position de l’objet

Le tableau 1 montre les positions exactes des trois capsules dans cet exemple.

Tableau 1: Tous les objets et leurs positions dans le monde

Bien sûr, n’hésitez pas à ajuster l’un de ces chiffres si vous le souhaitez. La prochaine étape est l’interface utilisateur, qui affiche les valeurs données aux objets Scriptables. Pour commencer, vous devrez cliquer sur le bouton Créer de la hiérarchie, mais cette fois, choisissez UI-> Canevas. Ensuite, avec le nouvel objet Canevas sélectionné, cliquez à nouveau sur le bouton Créer et sélectionnez cette fois Créer un enfant vide. Enfin, une fois de plus, vous cliquez sur le bouton Créer et cette fois, choisissez UI-> Text. Faites glisser l’objet Texte nouvellement créé sur l’objet de jeu vide et dupliquez le texte quatre fois en utilisant Ctrl + D pour qu’il y ait un total de cinq objets texte sous GameObject. Une fois terminé, votre hiérarchie devrait ressembler à celle de la figure 7.

Figure 7 : La hiérarchie actuelle

de chaque objet texte est corrélée au nom et aux statistiques données via un Objet Scriptable, ces statistiques étant la santé maximale, l’attaque, la défense et la vitesse. Il est utile de changer les noms des objets texte en la valeur qu’ils représentent. Ainsi, le premier objet texte peut être appelé name_text, et le second peut être appelé attack_text, et ainsi de suite. De plus, vous devrez modifier le texte par défaut pour fournir un visuel de l’apparence de l’interface utilisateur. Pour ce faire, accédez au composant Texte dans l’Inspecteur et modifiez la valeur du texte. Et enfin, ajustez leurs positions pour qu’elles ne soient pas toutes empilées les unes sur les autres. Pour que cela reste facile, le tableau 2 montre tous les différents noms d’objets et quelles devraient être leurs valeurs respectives.

Tableau 2: Tous les objets Texte et leurs valeurs de texte et de positionnement par défaut

Renommez GameObject (sous Canevas) en quelque chose d’un peu plus descriptif, tel que Char1Description, puis dupliquez l’objet parent. Renommez les deux doublons en Char2Description et Char3Description et positionnez les trois objets afin qu’ils soient au-dessus des objets capsule. Cet exemple place Char1Description à une position X de -300, Char2Descrption à 0 et Char3Position à 250. Toutes les valeurs de position Y et Z sont laissées à 0.

La route a été un peu longue, mais la configuration du projet est terminée! Vient maintenant le temps de coder et de voir comment les objets scriptables sont créés en ce qui concerne la programmation. Dans votre fenêtre Assets, accédez au dossier Scripts et créez deux nouveaux scripts en cliquant avec le bouton droit de la souris et en naviguant vers Create-> Script C#. Ces scripts doivent être appelés CharStats et LoadStats. Une fois ceux-ci créés, vous commencerez dans le script CharStats, alors double-cliquez sur ce script pour ouvrir Visual Studio et commencer le processus de codage.

Script CharStats

Pour créer un objet Scriptable, vous devez d’abord ajouter au menu Create que vous avez utilisé pour créer des matériaux et des scripts. Pour ce faire, vous utiliserez l’attribut CreateAssetMenu et spécifierez le nom de fichier et l’emplacement par défaut dans le menu. En outre, vous devrez changer de quelle classe CharStats hérite. Par défaut, chaque classe C # d’un projet Unity hérite de MonoBehaviour, mais ce script doit hériter de ScriptableObject à la place.

Notez lors de la définition de menuName qu’un caractère barre oblique est utilisé, indiquant l’utilisation de sous-menus. Si vous le souhaitez, vous pouvez supprimer la barre oblique et simplement avoir l’option Unités de joueur présente sans avoir besoin de naviguer plus loin dans le menu Créer. Dans ce cas, le sous-menu a été ajouté principalement pour montrer que vous pouvez organiser vos Objets Scriptables par ce que vous souhaitez. Dans ce cas, le menu est Créer – > Création de personnage – > Unités de joueur. Si vous le souhaitez, dans un autre objet Scriptable, vous pouvez créer l’objet à partir du même chemin mais avec une option de création différente, telle que Item.

Étant un objet Scriptable, les méthodes Start et Update par défaut ne sont pas nécessaires, vous pouvez donc les supprimer. Le but principal de cet objet est de contenir des données qui sont données à un autre objet, mais deux méthodes personnalisées sont également créées pour démontrer comment les objets scriptables peuvent faire plus que simplement contenir des données. En parlant de données, le code pour définir les données que contient cet objet se présente comme suit:

Comme mentionné précédemment, chaque objet scriptable contient un nom et des valeurs pour quatre statistiques différentes. Il contient également des informations sur la nouvelle couleur du personnage une fois que l’Objet Scriptable est appliqué. Les valeurs de chacun sont définies dans l’éditeur Unity, et bien sûr, elles seront différentes pour chaque objet créé.

Les deux méthodes restent simples. On imprime simplement un message sur la console de débogage indiquant que le caractère a été chargé. Ce message est imprimé dans la méthode Start du script LoadStats.

RandomizeStats, la deuxième méthode, fait exactement comme son nom l’indique. Il change les valeurs de l’Objet Scriptable en un nombre aléatoire compris entre 1 et 20. Plus tard, vous programmerez le projet pour mettre à jour automatiquement l’interface utilisateur avec les nouvelles valeurs. Mais ce n’est même pas la partie la plus intéressante! Les données d’un objet scriptable sont persistantes, ce qui signifie qu’elles resteront les mêmes pendant la session jusqu’à la fermeture du jeu. Ceci est particulièrement utile si vous créez un jeu composé de plusieurs scènes, car les objets habituellement anciens sont supprimés et les nouveaux sont rechargés lorsqu’une nouvelle scène est ouverte. Cependant, les données d’objet scriptables sont intactes dans la transition entre les scènes. De plus, les données restent les mêmes lorsque vous travaillez dans l’éditeur Unity jusqu’à ce que l’éditeur lui-même soit fermé. Cela signifie que les modifications apportées aux données dans les objets Scriptables lors de l’exécution du jeu à partir de l’éditeur sont présentes une fois que vous jouez à nouveau au jeu à partir de l’éditeur, à condition qu’aucune modification ne soit apportée aux données elles-mêmes.

C’est tout ce qu’il y a au script CharStats. Cela peut sembler assez simple, mais le projet n’est pas terminé. Vous avez programmé la possibilité de créer des Objets scriptables avec ses propres méthodes et données, mais vos personnages capsule ne savent rien de ces objets. En ce qui les concerne, les Objets Scriptables n’existent pas. Pour résoudre ce problème, vous devrez ouvrir le script LoadStats et le coder afin que les objets puissent utiliser les données d’un objet Scriptable pour mettre à jour l’interface utilisateur et changer leur couleur. Le code devrait ressembler à la figure 8.

Figure 8 : Script CharStats complet

Script LoadStats

Ne vous inquiétez pas de changer la classe dont hérite ce script. La valeur par défaut MonoBehaviour est précisément ce dont vous avez besoin. Au lieu de cela, incluez une nouvelle instruction using en haut.

Cela vous permet d’obtenir le texte de l’interface utilisateur et de le mettre à jour pour afficher les valeurs trouvées dans les objets Scriptables. Maintenant, sur la classe elle-même, en commençant par les variables.

Comme indiqué dans le commentaire, la variable charStat est l’objet Scriptable utilisé. Vous pouvez voir ici que l’obtention de ces objets scriptables n’est pas différente de la déclaration d’une autre variable. Plus tard dans le script, vous obtiendrez les variables et les méthodes dans l’objet et les utiliserez dans ce script. En fait, la méthode PrintMessage trouvée dans CharStats est utilisée dans la méthode LoadStats Start en ce moment.

Comme avec tout autre script extérieur, il vous suffit d’appeler charStat suivi de PrintMessage pour obtenir la méthode trouvée dans cet objet Scriptable. Cela peut s’avérer particulièrement utile si vous avez des objets qui ont tous des comportements similaires ou identiques. Dans ce cas, il peut également être utile au développeur, comme dans cet exemple, d’imprimer des messages sur la console de débogage. Si quelque chose devait mal tourner et que vous soupçonniez que l’objet Scriptable était en faute, vous pouvez utiliser les messages de la console de débogage pour trouver le problème.

En ce moment, il y a une erreur disant que DisplayStats n’existe pas. Pour résoudre ce problème, naviguez sous la méthode Update et ajoutez ce code.

Voici où les valeurs stockées dans l’Objet Scriptable sortent pour jouer. Toutes ces variables de texte déclarées plus tôt? Ils recevront des données à afficher, de sorte que les points d’interrogation que vous avez définis dans l’éditeur affichent maintenant une certaine valeur. De plus, bien que ce ne soit pas vraiment une statistique en soi, la couleur du caractère est modifiée ici en appelant currentColor.material et en le définissant sur le matériau défini dans l’Objet Scriptable.

La deuxième méthode charStats, RandomizeStats, n’a pas encore été utilisée, vous devriez donc y trouver une place. Dans la méthode Update, le programme vérifie si la barre d’espace a été enfoncée. Si c’est le cas, il appelle RandomizeStats et donne à l’objet Scriptable de nouvelles valeurs. Ensuite, DisplayStat est à nouveau appelé et les nouvelles valeurs sont affichées.

Ceci conclut le script LoadStats, mettant ainsi fin à la partie de codage de ce projet. Le code devrait ressembler à la figure 9. Il ne reste plus qu’à créer quelques objets scriptables, à les appliquer à l’objet capsule en utilisant LoadStats et à essayer cette nouvelle fonctionnalité. Bien sûr, assurez-vous d’enregistrer votre travail avant de retourner dans l’éditeur Unity.

Figure 9 : Terminer le script LoadStats

Terminer le Projet

Pour utiliser des Objets Scriptables, vous devez d’abord les créer. Dans la fenêtre Actifs, sous le dossier Objets Scriptables, cliquez avec le bouton droit de la souris et naviguez jusqu’à Créer – > Création de personnage – > Unités de joueur, comme indiqué dans la Figure 10.

Figure 10: Création d’une nouvelle unité de lecteur, un objet Scriptable

Vous pouvez nommer l’objet comme vous le souhaitez. L’exemple base ces objets sur les classes de jeux de rôle traditionnels, il y aura donc un guerrier, un chasseur et un mage. Sélectionnez le nouvel objet, puis accédez à la fenêtre de l’inspecteur et donnez des valeurs aux différents champs. Pour remplir le nouveau champ de couleur, accédez simplement à votre dossier Matériaux, puis cliquez et faites glisser le matériau souhaité vers le champ, comme indiqué à la figure 11.

Figure 11: Définir le nouveau matériau de couleur de l’objet

Crée deux autres objets Scriptables et effectue la même chose qu’auparavant, en leur donnant des valeurs différentes pour les différents champs. Une fois cela fait, accédez à la fenêtre de hiérarchie et sélectionnez l’un des objets char. Ensuite, donnez-leur le script LoadStats en tant que composant en accédant au dossier Scripts dans la fenêtre Assets, en trouvant LoadStats et en le faisant glisser dans la fenêtre de l’inspecteur, comme indiqué à la figure 12.

Figure 12: Attacher un script LoadStats à un objet

Ensuite, vous devrez remplir les champs LoadStats. Pour commencer, recherchez un objet scriptable que vous souhaitez utiliser sur votre premier « caractère » et appliquez-le au champ Char Stat comme indiqué sur la figure 13. N’oubliez pas que les objets Scriptables se trouvent dans la fenêtre Assets sous Objets Scriptables.

Figure 13: Réglage de l’emplacement de l’objet Scriptable Char1 pour obtenir des données

Remplissez maintenant les champs de texte. Dans la hiérarchie, vous développerez Canevas, puis développerez l’objet description du personnage en corrélation avec celui que vous modifiez actuellement. Par exemple, la modification de Char1 signifie que vous souhaitez développer Char1Description. Ensuite, prenez les objets texte trouvés sous l’objet parent et appliquez-les aux champs correspondants comme indiqué à la figure 14.

Figure 14: Définir tous les champs de texte

Une fois les champs de texte remplis, il vous suffit d’obtenir le moteur de rendu de maillage de l’objet, pour avoir accès au matériau, permettant ainsi le changement de couleur. Tout ce que vous devez faire est de cliquer et de faire glisser le composant de rendu de maillage dans la fenêtre de l’inspecteur et de le faire glisser dans le champ de couleur actuel comme indiqué sur la figure 15.

Figure 15: Définition du champ de couleur actuel

Répétez les étapes précédentes pour les deux autres objets de caractères, et vous aurez terminé le projet. Lorsque vous êtes prêt, cliquez sur le bouton de lecture en haut de l’éditeur et observez que trois objets presque identiques ont des valeurs très différentes qui leur sont attachées. Si, pour une raison quelconque, quelque chose ne semble pas correct, le premier endroit à vérifier serait vos objets scriptables et assurez-vous que les valeurs et les couleurs affichées sont celles que vous vouliez. N’oubliez pas de vérifier également le nouveau champ de couleur.

Tous ces nombres et leurs couleurs proviennent d’objets Scriptables, qui eux-mêmes proviennent d’un seul modèle. Vous pouvez également créer des objets encore plus scriptables et les brancher dans le champ Char Stat dans le composant Load Stats d’un objet et avoir un caractère très différent. Lors de l’exécution du jeu (figure 16), vous devriez voir un message dans la console de débogage dans le coin inférieur gauche indiquant qu’un personnage a été chargé. Il y a deux autres messages, mais vous ne pouvez voir qu’un seul message sans ouvrir la console de débogage complète, trouvée dans la console Window-> General->. Vous pouvez également appuyer sur la barre d’espace pour obtenir de toutes nouvelles statistiques pour vos personnages. Si vous arrêtez le jeu puis le relancez, vous remarquerez que les valeurs que vous avez générées aléatoirement persistent, démontrant la persistance des objets scriptables. Ils reviendront à leurs valeurs d’origine soit en entrant manuellement les valeurs dans les objets vous-même, soit en fermant et en rouvrant l’éditeur.

Figure 16: Objets scriptables en action

Conclusion

Naturellement, vous pouvez créer plusieurs types d’Objets Scriptables pour de nombreux types d’objets. Cet exemple a démontré leur utilisation via des classes de caractères, mais il y a aussi l’exemple des éléments susmentionnés. Il peut même être utilisé pour des objets beaucoup plus petits, tels que des power-ups rappelant ceux que l’on trouve dans les jeux d’arcade. En utilisant des objets scriptables, vous créez un système simple et propre où vous pouvez modifier et charger des données en quelques touches et voir les résultats presque instantanément. L’utilisation d’objets scriptables signifie également moins de scripts à créer, car vous pouvez utiliser un modèle pour plusieurs objets. Que votre projet soit grand ou petit, que votre équipe compte de nombreux membres ou simplement vous-même, les objets scriptables peuvent faciliter un peu le développement de chacun.