Commencez avec la démo des ScriptableObjects Unity

Avant de plonger dans le projet de démonstration ScriptableObject et cette série de mini-guides, rappelez-vous qu'à leur cœur, les modèles de conception ne sont que des idées. Ils ne s'appliqueront pas à chaque situation. Ces techniques peuvent vous aider à apprendre de nouvelles façons de travailler avec Unity et ScriptableObjects.

Chaque modèle a ses avantages et ses inconvénients. Choisissez uniquement ceux qui bénéficient de manière significative à votre projet spécifique. Vos concepteurs s'appuient-ils fortement sur l'éditeur Unity ? Un modèle basé sur ScriptableObject pourrait être un bon choix pour les aider à collaborer avec vos développeurs.

En fin de compte, la meilleure architecture de code est celle qui correspond à votre projet et à votre équipe.

Le PaddleBallSO tourne autour du jeu classique qui a donné naissance aux jeux vidéo modernes, mettant en vedette deux joueurs, deux palettes et une balle.

L'accent ici est mis sur l'infrastructure plutôt que sur la mécanique du jeu. Considérez cela comme de la "plomberie de jeu" – la fondation moins glamour mais vitale qui maintient votre application en fonctionnement.

Ce projet se concentre sur la façon dont les ScriptableObjects peuvent fonctionner en coulisses pour construire une application unifiée. Utilisez-les pour construire des systèmes de jeu polyvalents qui peuvent simplifier la maintenance du projet et promouvoir la réutilisabilité du code. Vous pouvez également les utiliser pour les données des joueurs, la gestion de l'état du jeu, les comportements en jeu, et plus encore.

Le projet PaddleBallSO est compatible avec la dernière version de Unity Long Term Support (LTS), actuellement 2022 LTS. Il intègre l'UI Toolkit pour créer des interfaces utilisateur à l'exécution, et le système d'entrée pour gérer les entrées utilisateur.

Localisez et téléchargez le projet dans le répertoire GitHub.

Chargez la Bootloader_scene ou activez Charger la scène de démarrage en jouant depuis le menu GameSystems. Entrez en mode Play pour commencer.

Bien que ceux-ci ne soient pas spécifiques aux ScriptableObjects, le projet de démonstration utilise quelques techniques courantes pour aider à démarrer l'application de jeu dans un état cohérent et prévisible.

Un Scene Bootstrapper (ou chargeur de démarrage) est un script d'extension de l'éditeur responsable de la configuration de l'état initial du jeu. Ce code d'initialisation est séparé de la logique du jeu et garantit que toutes les dépendances sont correctement configurées pour les objets de la scène.

Pour éviter les problèmes de dépendance, le bootstrapper configure les objets de jeu essentiels, les gestionnaires ou les services lors du chargement d'une scène.

Si votre application Unity s'étend sur plusieurs scènes, le chargeur de démarrage peut forcer le chargement d'une scène de démarrage spécifique, qui est la première scène des paramètres de construction. Lors de la sortie du mode Play, l'éditeur recharge la scène précédente.

Un autre composant de la scène de démarrage, le Sequence Manager, peut alors instancier des Prefabs essentiels lors du chargement de la scène. Dans ce projet de démonstration spécifique, tout ce qui est nécessaire pour créer le jeu est un Prefab, y compris une caméra, un écran de démarrage, des menus UI et un SceneLoader.

Le SceneLoader charge ensuite de manière additive (et décharge) toutes les scènes de jeu au besoin. Dans la plupart des cas, ces scènes sont principalement composées de Prefabs.

Scènes de projet

Chaque niveau de mini-jeu est une scène Unity distincte et apparaît dans les paramètres de construction. Désactivez le SceneBootstrapper dans le menu GameSystems si vous souhaitez explorer ces scènes individuelles.

De nombreux projets incluent également une zone de staging pour le menu principal après la scène de démarrage. Ce projet de démonstration simplifié omet une scène de menu principal.

Utilisez les menus Play et Pattern pour tester PaddleBallSO, qui comprend :

• démos de Design pattern, ou exemples courts, qui montrent des techniques spécifiques et illustrent chaque modèle de manière isolée.
• Mini-jeux qui combinent ceux-ci en échantillons fonctionnels et opérationnels

Le dossier Core contient des parties du code qui ne sont pas spécifiques à l'application, comme les scripts de modèle de base, la gestion des scènes et la logique de l'interface utilisateur. Ce sont des classes plus générales qui pourraient s'appliquer à une variété d'applications.

Le jeu d'échantillon recrée une simulation physique 2D emblématique et met en valeur le potentiel des modèles de conception basés sur ScriptableObject.

Avant de plonger dans les modèles, cependant, vous voudrez vous familiariser avec les MonoBehaviours qui composent l'application. Comme vous pouvez vous y attendre, des composants comme les scripts Paddle, Ball, Bouncer et ScoreGoal régissent le gameplay de base.

Plusieurs scripts de gestion de niveau supérieur contrôlent le flux du jeu :

• Le GameManger contrôle les états du jeu (début, fin, réinitialisation), initialise les composants du jeu, gère l'interface utilisateur et répond aux événements.
• Le GameSetup travaille avec le GameManager pour configurer la balle, les palettes, les murs et les buts.
• Le ScoreManager met à jour les valeurs de score, gère les événements du jeu et contrôle les mises à jour de l'interface utilisateur pour les affichages de score.

Ces MonoBehaviours fonctionnent avec vos ScriptableObjects. Ils jouent un rôle vital dans le lien entre ces composants afin qu'ils puissent communiquer et partager des données entre eux.

Les événements sont essentiels pour la communication entre différentes parties du projet. Ils connectent ces scripts de gestion avec d'autres objets de scène et l'interface utilisateur. Cette architecture orientée événements peut aider à rendre le code plus organisé et débogable.

Nous avons également fourni des exemples de démonstration simplifiés pour chacun des modèles ScriptableObject les plus courants. Au fur et à mesure que vous vous familiarisez avec eux, vous commencerez à reconnaître comment les ScriptableObjects sous-tendent l'architecture du mini-jeu.

Nous aurions pu créer le mini-jeu présenté avec beaucoup moins de lignes de code, mais cette démonstration se concentre spécifiquement sur les modèles de conception avec ScriptableObjects. Notez que vous pouvez également mettre en œuvre bon nombre de ces modèles sans ScriptableObjects.

Décidez en équipe comment chaque modèle pourrait s'appliquer à votre projet et choisissez l'approche qui fonctionne le mieux pour vous.

La modularité dans le développement logiciel consiste à diviser une application en morceaux plus petits et plus indépendants. Ces modules servent des objectifs spécifiques et peuvent être développés et testés séparément.

Chaque petit ensemble d'objets fonctionne comme une unité et gère un aspect du jeu. Cela peut être n'importe quoi, du contrôle de l'entrée du joueur, à la gestion de la physique, ou au comptage des points.

En explorant les scripts du projet, faites attention aux points clés suivants :

• Construisez vos scènes à partir de Prefabs : Vous remarquerez que la plupart des scènes du projet sont simplement des collections de Prefabs avec des remplacements minimes. Les Prefabs offrent intrinsèquement un niveau de modularité. Le dépannage d'une fonctionnalité devient une question de test de ce Prefab particulier en isolation. Comme les ScriptableObjects, les Prefabs sont des actifs au niveau du projet qui peuvent être réutilisés et partagés entre plusieurs scènes.
  
• Utilisez les ScriptableObjects pour le stockage de données (et plus) : Évitez d'utiliser les MonoBehaviours pour stocker des données de jeu statiques. Au lieu de cela, tirez parti des ScriptableObjects pour une meilleure réutilisabilité. Vous pouvez également déléguer certaines logiques de jeu aux ScriptableObjects ou les faire faciliter la communication entre vos objets de scène.
  
• Séparer les préoccupations : Maintenez une distinction claire entre les données, la logique et l'interface utilisateur dans votre projet. Cela améliore la maintenabilité du code et simplifie le débogage. Notre système d'écran de menu utilise le nouveau UI Toolkit. Ce système d'interface utilisateur impose un flux de travail qui sépare l'interface de sa logique sous-jacente. Pour plus de détails, consultez le Conception et mise en œuvre de l'interface utilisateur dans Unity e-book.
  
• Minimiser les dépendances : Réduire les dépendances entre les composants facilite la modification ou le remplacement de parties de votre projet sans causer de problèmes imprévus.
  
• Utiliser des événements pour la communication : Les événements permettent un couplage lâche entre les composants, leur permettant d'envoyer des messages les uns aux autres sans dépendances directes. Vous pouvez les découpler davantage avec des "canaux d'événements" basés sur ScriptableObject.
  
• Éviter les singletons inutiles : Les modèles de conception singleton peuvent être utiles, mais seulement lorsqu'une seule instance d'une classe est essentielle. Une utilisation excessive des singletons peut entraîner un code fortement couplé et entraver les tests. Ignorez le singleton s'il n'est pas nécessaire.

Refactoriser un grand script monolithique en morceaux plus petits favorise la réutilisabilité et l'évolutivité. Cela conduit à une meilleure collaboration d'équipe et à des tests simplifiés.

Nous avons créé le projet PaddleBallSO pour démontrer des cas d'utilisation de ScriptableObject. Voici quelques endroits spécifiques où vous les verrez en action :

• Le GameDataSO ScriptableObject sert de conteneur de données central pour les paramètres du jeu. Modifiez vos données communes une fois, puis partagez-les avec les autres objets qui en ont besoin.
  
• Les mini-jeux s'appuient sur de nombreux canaux d'événements pour communiquer de manière découplée. Ces événements basés sur ScriptableObject forment l'épine dorsale de la façon dont les objets s'envoient des messages les uns aux autres.
  
• La lecture du son utilise un objet délégué basé sur ScriptableObject pour séparer la logique du composant MonoBehaviour.
  
• Nous utilisons un PlayerIDSO basé sur ScriptableObject enum pour différencier les "équipes" entre Player1 et Player2.
  
• Le LevelLayoutSO ScriptableObject sert de conteneur de données pour les positions de départ des éléments de jeu comme les palettes, les buts, les murs et la balle. Cela permet une modification facile des mises en page de niveau dans Unity et à l'extérieur via des fichiers JSON exportés. La modification des conceptions de niveau en dehors d'Unity peut encourager la créativité des joueurs et le partage de mises en page personnalisées.

Assurez-vous de consulter les démos de modèles de conception pour quelques extras également !

Bien que les ScriptableObjects puissent être un outil puissant pour stocker des données de jeu et rationaliser votre flux de travail, il est essentiel de les utiliser efficacement pour éviter d'encombrer votre projet.

Voici quelques bonnes pratiques pour utiliser les ScriptableObjects dans Unity :

• Gardez les données modulaires et organisées : Utilisez des ScriptableObjects séparés pour différents types de données (par exemple, un pour les statistiques des joueurs, un pour le comportement des ennemis, etc.). Décomposez les données complexes en morceaux plus petits qui peuvent être facilement gérés.
  
• Utilisez des dossiers et des conventions de nommage : Les ScriptableObjects peuvent aider à réduire le code dans vos scripts, mais le compromis consiste à gérer plus d'actifs dans vos dossiers de projet. Un bon nommage et une organisation des répertoires peuvent aider à gérer ces ScriptableObjects efficacement. Consultez notre guide de style de code pour des conseils sur le nommage.
  
• Évitez l'utilisation excessive de ScriptableObjects : Les ScriptableObjects sont d'incroyables conteneurs de données, mais il est important de ne pas les surutiliser. Gardez à l'esprit que les ScriptableObjects peuvent ajouter de la complexité à votre projet, donc déployez-les uniquement lorsqu'ils offrent un avantage clair. (Par exemple, ne les utilisez pas pour sauvegarder des données persistantes.)
  
• Sauvegardez les données régulièrement : Les modifications des ScriptableObjects se produisent « en direct » à l'exécution et sont enregistrées en tant que fichiers d'actifs. Assurez-vous de sauvegarder régulièrement votre projet pour éviter de perdre des données. Utilisez un logiciel de contrôle de version pour suivre les modifications de vos ScriptableObjects.
  
• Utilisez la fenêtre Inspector : Un des principaux avantages des ScriptableObjects est qu'ils sont sérialisables et apparaissent dans l'Inspector. Profitez de l'interface de l'éditeur pour visualiser et manipuler les données stockées dans les ScriptableObjects.
  
• Utilisez des scripts d'éditeur personnalisés à votre avantage : Les ScriptableObjects ne peuvent pas référencer des objets d'exécution de la hiérarchie de scène nativement. Utilisez le scripting d'éditeur pour rendre l'Inspector une interface plus conviviale si vous devez visualiser ces objets.
  

En suivant ces directives, vous pouvez éviter les pièges courants du développement.

Lisez-en plus sur les modèles de conception avec les ScriptableObjects dans l'e-book Créez une architecture de jeu modulaire dans Unity avec les ScriptableObjects. Vous pouvez également en savoir plus sur les modèles de conception de développement Unity courants dans l'e-book Améliorez votre code avec des modèles de programmation de jeux.