MVC (Model-View-Controller) est un schéma qui implique de diviser les données d'application, l'interface utilisateur et la logique de contrôle en trois composants distincts afin que chacun d'eux puisse être modifié indépendamment. Le développeur
Cem Ugur Karacam a partagé son expérience de programmation chez Unity et a brièvement parlé des objets scriptables. Nous présentons une traduction de son article publié sur dev.to.
Bienvenue dans la première partie de mon exposé sur l'implémentation de MVC dans Unity à l'aide d'objets scriptables. Dans cet article, j'ai écrit uniquement sur les bases du travail avec des objets scriptables, et en général, le texte sera simple et clair.
Tout d'abord, découvrez ce que les développeurs Unity disent des objets scriptables:
- Il s'agit d'une classe dont vous pouvez hériter pour créer un objet qui ne doit pas être attaché à un autre objet de la scène.
- Le plus grand avantage d'un tel objet créé sera si vous l'utilisez uniquement pour enregistrer des données.
Maintenant, il est logique de se demander: pourquoi les objets scriptables?
Les objets scriptables font partie des fonctionnalités du moteur Unity, de sorte que ces objets ont de nombreuses fonctionnalités intégrées pour travailler avec l'éditeur.
J'aime l'approche utilisée lors du développement de projets sur Unity. Vous pouvez créer vos propres outils et personnaliser facilement ceux qui sont installés par défaut. Les objets scriptables étendent considérablement vos capacités, car ils vous permettent de créer des conteneurs personnalisés pour les données et de les stocker en tant qu'actifs dans le projet.
L'image ci-dessus est un exemple d'utilisation de l'objet scriptable dans Unity. Un seul fichier .asset créé dans un projet peut contenir les informations nécessaires au fonctionnement de plusieurs systèmes et assurer la préservation de leurs paramètres. Si vous voulez en savoir plus, il y a une excellente vidéo sur YouTube avec une présentation sur SO (Scriptable Object) intitulée "
Overshrowing the MonoBehaviour Tyranny in a Glorious Scriptable Object Revolution ".
Un autre excellent exemple est illustré ci-dessus. Ici, les objets de jeu font référence à un objet d'inventaire et le système de sauvegarde les gère tous. Cette image provient d'une autre excellente conférence, «Architecture de jeu avec des objets scriptables» (
Architecture de jeu avec des objets scriptables ), je recommande fortement de la lire.
Une autre grande fonctionnalité est que lorsque vous comprenez les objets scriptables, vous ne voulez probablement pas utiliser d'autres formats de stockage de données, tels que JSON ou XML, car SO est le format le plus pratique pour stocker des données dans Unity.
Eh bien, regardons les objets scriptables en action.
using UnityEngine; public class ItemData : ScriptableObject { public string itemName; public ItemType type; public float attack; } public enum ItemType { Dagger, Axe, Sword, Staff }
Nous avons écrit une classe appelée
ItemData et plusieurs propriétés typiques des jeux RPG. Ensuite, nous allons créer plusieurs de ces éléments dans le projet, y accéder à partir du script et afficher les valeurs dans la console. Mais d'abord, ajoutez une ligne importante à notre code.
using UnityEngine; [CreateAssetMenu] public class ItemData : ScriptableObject { public string itemName; public ItemType type; public float attack; } public enum ItemType { Dagger, Axe, Sword, Staff }
L'attribut
CreateAssetMenu que nous avons ajouté avant la classe
ItemData indique à Unity que nous voulons créer des fichiers .asset dans lesquels notre classe sera stockée via le menu. Sinon, nous ne pourrons pas le faire en utilisant le bouton droit de la souris ou le bouton Créer dans le dossier du projet.
Créez un dossier appelé
Items et essayez de créer un objet
ItemData dans ce dossier.
Nous allons maintenant écrire un autre script appelé
Inventory pour travailler avec le fichier de données.
using UnityEngine; public class Inventory : MonoBehaviour { public ItemData[] inventory; }
Ajoutez-y une méthode qui produira des informations sur la console. Nous effectuons également une vérification afin de ne pas dépasser les limites du tableau, mais de contourner le tableau en cercle.
using UnityEngine; public class Inventory : MonoBehaviour { public ItemData[] inventory; int index = 0; public void NextItemInfo() { if (index > inventory.Length) { index = 0; } Debug.Log("Item name: " + inventory[index].name); Debug.Log ("Attack power: " + inventory[index].attack); switch(inventory[index].type) { case ItemType.Axe: Debug.Log("Item type: Axe"); break; case ItemType.Dagger: Debug.Log("Item type: Dagger"); break; case ItemType.Staff: Debug.Log("Item type: Staff"); break; case ItemType.Sword: Debug.Log("Item type: Sword"); break; } index ++; } }
J'attribuerai un appel à notre méthode à la barre d'espace. Dans Unity, c'est très simple. Grâce à la classe
Input , nous pouvons vérifier dans la méthode
Update si la touche requise a été pressée.
using UnityEngine; public class Inventory : MonoBehaviour { public ItemData[] inventory; int index = 0; private void Update() { if (Input.GetKeyDown(KeyCode.Space)) { NextItemInfo(); } } public void NextItemInfo() { if (index > inventory.Length) { index = 0; } Debug.Log("Item name: " + inventory[index].name); Debug.Log ("Attack power: " + inventory[index].attack); switch(inventory[index].type) { case ItemType.Axe: Debug.Log("Item type: Axe"); break; case ItemType.Dagger: Debug.Log("Item type: Dagger"); break; case ItemType.Staff: Debug.Log("Item type: Staff"); break; case ItemType.Sword: Debug.Log("Item type: Sword"); break; } index ++; } }
Il est temps de revenir à l'éditeur Unity. Nous remplirons notre tableau d'
inventory avec les fichiers
ItemData créés précédemment à partir du dossier
Items . Mais d'abord, créez un objet vide dans la scène et ajoutez-y notre script d'
Inventory .
Maintenant, exécutons le projet et testons-le.
Ça marche! Et maintenant, je veux vous montrer que l'objet scriptable peut stocker non seulement des données, mais aussi des méthodes pour les utiliser. Par exemple, ajoutons une méthode pour calculer le prix dans la classe
ItemData . Pour plus d'informations à ce sujet, consultez les documents
ici et
ici .
using UnityEngine; [CreateAssetMenu] public class ItemData : ScriptableObject { public string itemName; public ItemType type; public float attack; public float GetPrice() { return attack * 40; } }
Ensuite, nous utilisons notre nouvelle méthode dans la classe
Inventory .
using UnityEngine; public class Inventory : MonoBehaviour { public ItemData[] inventory; int index = 0; private void Update() { if (Input.GetKeyDown(KeyCode.Space)) { NextItemInfo(); } } public void NextItemInfo() { if (index == inventory.Length) { index = 0; } Debug.Log("Item name: " + inventory[index].name); Debug.Log ("Attack power: " + inventory[index].attack); switch(inventory[index].type) { case ItemType.Axe: Debug.Log("Item type: Axe"); break; case ItemType.Dagger: Debug.Log("Item type: Dagger"); break; case ItemType.Staff: Debug.Log("Item type: Staff"); break; case ItemType.Sword: Debug.Log("Item type: Sword"); break; } Debug.Log("Item price: " + inventory[index].GetPrice()); index ++; } }
Maintenant, nous allons tout reproduire et regarder le résultat.
Des exemples de ce tutoriel sont sur
GitHub !
La première partie de l'histoire a pris fin. Dans le prochain article, nous parlerons de l'utilisation de MVC dans Unity. Mais, comme nous connaissons déjà les objets scriptables, nous allons ajouter quelques nouvelles fonctionnalités pour le rendre plus cool et plus dur comme le font les vrais gourous d'Unity.