Geekly articles weekly

Unity: apprendre à connaître les objets scriptables

image

Dans ce didacticiel, vous apprendrez à créer et à utiliser des objets scriptables dans Unity. Les objets scriptables peuvent aider à améliorer votre flux de travail, réduire l'empreinte mémoire et même vous permettre de diviser l'architecture de code.

Selon la documentation Unity , ScriptableObject est un code de classe qui vous permet de créer des objets scriptables dans le jeu pour stocker de grandes quantités de données partagées qui sont indépendantes des instances de script.

Il existe de nombreuses raisons d'utiliser des objets scriptables dans Unity. Ils peuvent réduire la quantité de mémoire utilisée pour chaque préfabriqué supplémentaire, car l'objet scriptable suit essentiellement le modèle de conception Flyweight .

Un autre avantage des objets scriptables, qui sera le thème principal de ce didacticiel, est leur utilisation pour un transfert de données pratique. Nous considérerons cette propriété comme un exemple de création d'une boutique de marchands d'épées, qui affichera les paramètres, les prix et les descriptions des différentes épées.

Remarque: ce didacticiel suppose que vous connaissez bien l'éditeur Unity. Vous devez comprendre comment modifier le code dans un éditeur de code et avoir des connaissances de base en C #. Si vous devez améliorer vos compétences Unity, consultez d'autres didacticiels Unity .

Se rendre au travail


Commençons par télécharger le matériel dont nous avons besoin.

Décompressez le fichier téléchargé à un endroit qui vous convient et ouvrez le projet Scriptable Object Tutorial-Starter dans Unity.

Vous devriez voir le dossier suivant créé dans le cadre de l'approvisionnement du projet:


  • _Setup : pour le tutoriel ce dossier n'est pas nécessaire.
  • Scènes : contient une scène Sword Merchant que nous couvrirons tout au long du tutoriel. Ouvrez cette scène.
  • Scripts : jusqu'à présent, il n'y a qu'un seul script, mais pendant le tutoriel, nous en créerons de nouveaux.
  • Icônes d'épée : contient des images fixes d'épées individuelles.
  • Sword Prefabs : contient les prefabs de toutes les épées de la scène Sword Merchant.

Création d'un objet scriptable


Pour commencer, accédez à la scène Sword Merchant . Cela devrait ressembler à ceci:


Préparation d'un objet scriptable


Il est temps de créer le premier objet scriptable!

Dans le dossier Scripts , créez un nouveau script appelé SwordData . Cette classe sera utilisée comme conteneur pour toutes les données d'épée affichées dans la boutique du marchand d'épée.

Dans cette classe, commencez par hériter de ScriptableObject au lieu de MonoBehaviour :

 public class SwordData : ScriptableObject { }

Cette action indique à Unity que nous voulons toujours utiliser les fonctionnalités et les méthodes d'Unity, tout comme le MonoBehaviour normal, mais nous n'avons plus besoin d'attacher ce script à GameObject. Au lieu de cela, il sera traité comme n'importe quel élément standard, qui peut être créé de la même manière que la création d'un préfabriqué, d'une scène ou d'un matériau.

Remplissez le script avec des champs sérialisés, qui contiendront toutes les données correspondant aux informations affichées dans l'interface utilisateur de Sword Merchant.

 public class SwordData : ScriptableObject { [SerializeField] private string swordName; [SerializeField] private string description; [SerializeField] private Sprite icon; [SerializeField] private int goldCost; [SerializeField] private int attackDamage; }

  • swordName : string dans laquelle le nom de l'épée sera stocké.
  • description : string , dans laquelle la description de l'épée sera stockée.
  • icône : le sprite qui contiendra l'icône de l'épée.
  • goldCost : int pour stocker la valeur de l'épée en or.
  • attackDamage : int pour stocker les dégâts lors d'une attaque avec une épée.

Remarque: SerializeField

Dans Unity, l'attribut SerializeField vous permet d'avoir des variables de script privées disponibles dans l'inspecteur. Il vous permettra de définir des valeurs dans l'éditeur sans donner accès à la variable à partir d'autres scripts.

Chaque épée nécessitera sa propre implémentation unique de l'objet scriptable SwordData . Mais avant de pouvoir créer ces implémentations, nous devons ajouter un objet scriptable au menu des ressources.

Ajoutez notre objet scriptable au menu d'actif en ajoutant l'attribut suivant à la classe SwordData :

 [CreateAssetMenu(fileName = "New SwordData", menuName = "Sword Data", order = 51)] public class SwordData : ScriptableObject

  • fileName : nom par défaut lors de la création de l'actif.
  • menuName : nom de l' actif affiché dans le menu de l'actif.
  • ordre : placement des actifs dans le menu des actifs. Unity divise les actifs en sous-groupes avec un facteur de 50. Autrement dit, une valeur de 51 place le nouvel actif dans le deuxième groupe du menu des actifs.

Si tout est fait correctement, vous pouvez aller dans Actifs >> Créer et voir le nouvel actif Sword Data dans le menu. Il doit être situé dans le deuxième groupe sous l'actif Dossier:


Vous pouvez également cliquer avec le bouton droit dans la fenêtre Projet et voir également le nouvel actif Sword Data:


Ajout de données


Nous organiserons le projet en créant un dossier appelé Scriptable Objects dans le dossier Scripts, et à l'intérieur de ce dossier un autre dossier appelé Sword Data .

Dans le dossier Sword Data nouvellement créé, créez notre premier élément Sword Data.

Le nouvel actif Sword Data doit toujours avoir le nom de fichier par défaut spécifié précédemment. Sélectionnez un actif et dupliquez-le six fois ( Ctrl / Cmd + D ) pour créer sept actifs Sword Data, un pour chaque épée. Renommez maintenant chaque élément en fonction des préfabriqués:


Cliquez sur le premier élément Sword Data dans le dossier Sword Data et regardez la fenêtre Inspector :


Nous voyons ici un atout dans lequel les informations sur une épée particulière seront stockées. Remplissez les informations pour chaque épée. Essayez de leur donner une description unique, une valeur en or et des dégâts lors d'une attaque. Dans le champ Icon Sprite, utilisez les sprites correspondants situés dans le dossier Sword Icons :


Félicitations! Vous avez créé un objet scriptable et configuré plusieurs actifs avec cet objet scriptable.

Utilisation d'un objet scriptable


Nous allons maintenant commencer à obtenir des données de ces objets scriptables.

Tout d'abord, nous devons ajouter des méthodes getter publiques afin que d'autres scripts puissent accéder aux champs privés à l'intérieur de l'objet scriptable. Ouvrez SwordData.cs et ajoutez ce qui suit dans les champs ajoutés précédemment:

  public string SwordName { get { return swordName; } } public string Description { get { return description; } } public Sprite Icon { get { return icon; } } public int GoldCost { get { return goldCost; } } public int AttackDamage { get { return attackDamage; } }

Ouvrez Sword.cs et ajoutez le code suivant:

  [SerializeField] private SwordData swordData; // 1 private void OnMouseDown() // 2 { Debug.Log(swordData.name); // 3 Debug.Log(swordData.Description); // 3 Debug.Log(swordData.Icon.name); // 3 Debug.Log(swordData.GoldCost); // 3 Debug.Log(swordData.AttackDamage); // 3 }

Voici ce que nous avons ajouté avec ce code:

  1. Le conteneur de données pour les données de cette épée.
  2. OnMouseDown est une fonction MonoBehaviour intégrée qui est appelée lorsque l'utilisateur appuie sur le bouton gauche de la souris.
  3. Exemples sur la façon d'obtenir des données de notre ressource d'objet scriptable

Revenez à Unity et accédez à la fenêtre Hiérarchie . Sélectionnez l'objet de jeu 1_Longsword dans le préfabriqué de l'épée. Ajoutez l'actif 1_Longsword Data approprié à la variable Sword Data du script Sword.cs dans la fenêtre Inspector:


Cliquez sur Lecture ( Ctrl / Cmd + P ) dans l'éditeur Unity, puis cliquez sur l'épée la plus à gauche:


La console doit afficher des informations qui ressemblent à des données transférées depuis l'actif Sword Data.

Les objets scriptables facilitent le remplacement de ces données. Essayez d'insérer différents objets scriptables Sword Data dans le champ Sword Data de l'épée.

Objets scriptables événementiels


Nous avons donc créé un objet scriptable et vous avez vu comment accéder à ses données dans le jeu. Mais nous devons encore intégrer Sword Data à l'interface utilisateur!

Vous pouvez utiliser le modèle Singleton rapide et sale pour cela. Cependant, nous avons maintenant d'autres possibilités ...

... à savoir, les objets scriptables! Nous les utiliserons pour créer du code propre et bien divisé.

Dans cette section, vous apprendrez à créer des événements de jeu à l'aide de la classe UnityEvent .

Événements de jeu et auditeurs


Dans le dossier Scripts, créez deux scripts: GameEvent.cs et GameEventListener.cs . Ils dépendent les uns des autres, donc pour vous débarrasser des erreurs, vous devez créer les deux.

 using System.Collections.Generic; using UnityEngine; [CreateAssetMenu(fileName = "New Game Event", menuName = "Game Event", order = 52)] // 1 public class GameEvent : ScriptableObject // 2 { private List<GameEventListener> listeners = new List<GameEventListener>(); // 3 public void Raise() // 4 { for (int i = listeners.Count - 1; i >= 0; i--) // 5 { listeners[i].OnEventRaised(); // 6 } } public void RegisterListener(GameEventListener listener) // 7 { listeners.Add(listener); } public void UnregisterListener(GameEventListener listener) // 8 { listeners.Remove(listener); } }

Voici ce que fait le code ci-dessus:

  1. Ajoute un GameEvent en tant qu'actif au menu des actifs.
  2. GameEvent est un objet scriptable, il doit donc hériter de ScriptableObject.
  3. Liste des GameEventListeners à abonner à GameEvent.
  4. Méthode pour appeler tous les abonnés GameEvent.
  5. Le dernier GameEventListener signé sera le premier appelé (dernier arrivé, premier sorti).
  6. Appelez chaque UnityEvent GameEventListeners.
  7. Une méthode qui permet à GameEventListeners de s'abonner à ce GameEvent.
  8. Une méthode qui permet à GameEventListeners de se désinscrire de ce GameEvent.


 using UnityEngine; using UnityEngine.Events; // 1 public class GameEventListener : MonoBehaviour { [SerializeField] private GameEvent gameEvent; // 2 [SerializeField] private UnityEvent response; // 3 private void OnEnable() // 4 { gameEvent.RegisterListener(this); } private void OnDisable() // 5 { gameEvent.UnregisterListener(this); } public void OnEventRaised() // 6 { response.Invoke(); } }

Dans le code ci-dessus, le projet continue de se développer:

  1. Obligation d'utiliser la classe UnityEvent.
  2. Le GameEvent auquel ce GameEventListener sera abonné.
  3. La réponse UnityEvent qui sera déclenchée lorsque l'événement GameEvent lance ce GameEventListener.
  4. Liaison d'un GameEvent à un GameEventListener lorsque ce GameObject est activé.
  5. Liaison d'un GameEvent à partir d'un GameEventListener lorsque ce GameObject est désactivé.
  6. Appelé lorsqu'un GameEvent est généré et que GameEventListener appelle l'événement UnityEvent.

Est-ce difficile? Rien, vous le comprendrez avec le temps!

Formation des éditeurs


Revenez à l'éditeur Unity et créez un nouveau dossier d' événements de jeu dans Scripts >> ScriptableObjects. Créez ensuite sept événements de jeu à partir du menu des ressources, comme nous l'avons fait pour chaque ressource Sword Data. Placez-les dans le nouveau dossier Game Events.


Remplacez le code à l'intérieur du script Sword.cs par les lignes suivantes:

  [SerializeField] private GameEvent OnSwordSelected; // 1 private void OnMouseDown() { OnSwordSelected.Raise(); // 2 }

Ce code ajoute deux possibilités à la boutique du marchand d'épée:

  1. Génération d'un événement de jeu lors du choix d'une épée.
  2. Génération d'événements lorsque vous cliquez sur l'épée.

Enregistrez le script. Maintenant, dans chaque objet hiérarchique GameObject de l'épée, connectez l'événement OnSwordSelected correspondant.


Chaque épée possède désormais un lien vers l'événement qui se déclenche lorsque l'utilisateur clique sur l'épée.

Intégration UI


Vous devez maintenant faire fonctionner l'interface utilisateur. Notre objectif est d'afficher les données d'épée correspondantes en cliquant sur chaque épée.

Liens UI


Avant de mettre à jour l'interface utilisateur, vous devez obtenir un lien vers chaque élément de l'interface utilisateur. Commençons par créer un nouveau script appelé SwordMerchant.cs et en ajoutant le code suivant à ce nouveau script:

 using UnityEngine; using UnityEngine.UI; public class SwordMerchant : MonoBehaviour { [SerializeField] private Text swordName; // 1 [SerializeField] private Text description; // 2 [SerializeField] private Image icon; // 3 [SerializeField] private Text goldCost; // 4 [SerializeField] private Text attackDamage; // 5 }

En utilisant ce code, nous avons ajouté ce qui suit:

  1. Une référence au composant Text de l'objet de jeu NameText .
  2. Lien vers le composant Texte de l'objet de jeu DescriptionText .
  3. Lien vers le composant Image de l'objet de jeu Sword_Icon .
  4. Lien vers le composant Texte de l'objet de jeu GoldText .
  5. Un lien vers le composant Texte de l'objet de jeu AttackText .

Les objets de jeu ci-dessus sont situés dans SwordMerchantCanvas >> SwordMerchantPanel de la fenêtre Hiérarchie. Ajoutez le script à GameObject SwordMerchantCanvas , puis configurez tous les liens:


Auditeurs et réponses de l'interface utilisateur


Toutes les épées ont un événement auquel l'interface utilisateur peut s'abonner à l'aide du script GameEventListener . Ajoutez un GameEventListener pour chaque événement OnSwordSelected à GameObject SwordMerchantCanvas :


Comme vous pouvez le voir, notre écouteur d'événement de jeu comporte deux champs: l'événement d'événement de jeu qu'il écoute et la réponse qui est déclenchée lorsque l'événement de jeu est généré.

Dans notre cas, la réponse sera mise à jour par l'interface utilisateur. Ajoutez la méthode suivante au script SwordMerchant.cs :

  public void UpdateDisplayUI(SwordData swordData) { swordName.text = swordData.SwordName; description.text = swordData.Description; icon.sprite = swordData.Icon; goldCost.text = swordData.GoldCost.ToString(); attackDamage.text = swordData.AttackDamage.ToString(); }

Cette méthode reçoit un actif Sword Data, puis met à jour chaque champ d'interface utilisateur avec la valeur du champ Sword Data correspondant. Notez que GoldCost et AttackDamage renvoient un entier , vous devez donc le convertir en chaîne de texte.

En utilisant notre nouvelle méthode, nous pouvons ajouter une réponse à chaque GameEventListener .

Pour chaque réponse que vous ajoutez, vous avez besoin d'un lien vers notre objet de jeu SwordMerchantCanvas comme valeur du champ Aucun (objet) . Après cela, sélectionnez SwordMerchant.UpdateDisplayUI dans le menu déroulant à droite de la liste déroulante Runtime Only .

Soyez prudent et utilisez la ressource Sword Data correcte pour chaque événement OnSwordSelected .


Maintenant, nous pouvons commencer le jeu, cliquez sur l'épée et voyez que l'interface utilisateur est mise à jour en conséquence!


Puisque nous utilisons des événements de jeu, vous pouvez simplement SwordMerchantCanvas , et tout fonctionnera toujours, uniquement sans interface utilisateur. Cela signifie que les préfabriqués d'épée sont distincts des SwordMerchantCanvas .

Où aller ensuite?


Si vous avez manqué quelque chose pendant l'histoire, vous pouvez télécharger le projet terminé , qui se trouve dans le matériel du tutoriel.

Si vous voulez continuer, essayez de faire reproduire à chaque épée son propre son. Essayez d'étendre les données d'épée d'objet OnSwordSelected et d'écouter les événements OnSwordSelected .

Vous voulez en savoir plus sur Unity? Consultez notre série de vidéos Unity ou lisez les didacticiels Unity .

Source: https://habr.com/ru/post/fr421523/

More articles:


All Articles