Avant de vous plonger dans le projet de démonstration ScriptableObject et dans cette série de mini-guides, n'oubliez pas qu'à la base, les modèles de conception ne sont que des idées. Elles ne s'appliquent pas à toutes les situations. Ces techniques peuvent vous aider à apprendre de nouvelles façons de travailler avec Unity et ScriptableObjects.

Chaque modèle présente des avantages et des inconvénients. Ne choisissez que ceux qui bénéficient de manière significative à votre projet spécifique. Vos concepteurs utilisent-ils beaucoup 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 s'adapte à votre projet et à votre équipe.

PaddleBallSO est centré sur le jeu classique qui a donné naissance aux jeux vidéo modernes, avec deux joueurs, deux pagaies et une balle.

L'accent est mis ici sur l'infrastructure plutôt que sur les mécanismes de jeu. Il s'agit de la "plomberie du jeu", la base moins glamour mais d'une importance vitale qui permet à votre application de fonctionner.

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éutilisation du code. Vous pouvez également les utiliser pour les données des joueurs, la gestion de l'état du jeu, les comportements dans le jeu, etc.

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

Localisez et téléchargez le projet dans le dépôt GitHub.

Chargez la scène Bootloader_scene ou activez Load Bootstrap Scene on Play dans le menu GameSystems. Entrez dans le mode lecture pour commencer.

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

Un Scene Bootstrapper (ou bootloader) est un script d'extension de l'éditeur responsable de la mise en place 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, les gestionnaires ou les services essentiels du jeu lorsqu'une scène est chargée.

Si votre application Unity s'étend sur plusieurs scènes, le chargeur de démarrage peut forcer le chargement d'une scène d'amorçage spécifique, qui est la première scène des paramètres de construction. Lorsque l'on quitte le mode lecture, l'éditeur recharge la scène précédente.

Un autre composant de la scène d'amorçage, le gestionnaire de séquence, peut alors instancier les 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 SplashScreen, des menus d'interface utilisateur et un SceneLoader.

Le SceneLoader charge (et décharge) de manière additive toutes les scènes de jeu nécessaires. 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 prévoient également une zone d'attente pour le menu principal après la scène d'amorçage. Ce projet de démonstration simplifié ne comporte pas de scène de menu principal.

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

• des démonstrations de modèles de conception, ou des exemples de taille réduite, qui montrent des techniques spécifiques et illustrent chaque modèle de manière isolée
• Mini-jeux qui combinent ces éléments en échantillons fonctionnels.

Le dossier Core contient les parties de la base de code qui ne sont pas spécifiques à l'application, comme les scripts de base, la gestion des scènes et la logique de l'interface utilisateur. Il s'agit de classes plus générales qui peuvent s'appliquer à un grand nombre d'applications.

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

Cependant, avant de plonger dans les modèles, vous devez vous familiariser avec les MonoBehaviours qui composent l'application. Comme on peut s'y attendre, des composants tels que les scripts Paddle, Ball, Bouncer et ScoreGoal régissent le gameplay de base.

Plusieurs scripts de gestion de niveau supérieur contrôlent le déroulement 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 le ballon, les pagaies, les murs et les buts.
• Le ScoreManager met à jour les valeurs des scores, gère les événements du jeu et contrôle les mises à jour de l'interface utilisateur pour l'affichage des scores.

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

Les événements sont essentiels à la communication entre les différentes parties du projet. Ils relient ces scripts de gestion à d'autres objets de la scène et à l'interface utilisateur. Cette architecture pilotée par les événements peut contribuer à rendre le code plus organisé et plus facile à déboguer.

Nous avons également fourni des exemples de démonstration simplifiés pour chacun des modèles ScriptableObject les plus courants. En vous familiarisant avec eux, vous commencerez à comprendre comment les ScriptableObjects sous-tendent l'architecture du mini-jeu.

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

Décidez en équipe de la manière dont chaque modèle peut s'appliquer à votre projet et choisissez l'approche qui vous convient le mieux.

La modularité dans le développement de logiciels consiste à diviser une application en éléments 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. Il peut s'agir de contrôler les entrées du joueur, de gérer la physique ou de comptabiliser le score.

En explorant les scripts du projet, prêtez attention aux éléments clés suivants :

• Construisez vos scènes à partir de préfabriqués : Vous remarquerez que la plupart des scènes du projet sont simplement des collections de Prefabs avec un minimum d'adaptations. Les préfabriqués offrent intrinsèquement un niveau de modularité. Le dépannage d'une fonctionnalité devient une question de test de ce préfabriqué particulier de manière isolée. Comme les ScriptableObjects, les Prefabs sont des actifs au niveau du projet qui peuvent être réutilisés et partagés dans plusieurs scènes.
  
• Utiliser les ScriptableObjects pour le stockage des données (et plus encore) : Évitez d'utiliser les MonoBehaviours pour stocker des données statiques sur le jeu. Il est préférable d'utiliser les objets scriptables pour une meilleure réutilisation. Vous pouvez également reléguer certaines logiques de jeu aux ScriptableObjects ou leur demander de faciliter la communication entre les objets de votre scène.
  
• Des préoccupations distinctes : 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 la nouvelle boîte à outils de l'interface utilisateur. Ce système d'interface utilisateur applique un flux de travail qui sépare l'interface de sa logique sous-jacente. Pour plus de détails, consultez la page Conception et mise en œuvre de l'interface utilisateur dans Unity livre électronique.
  
• Réduire les dépendances : En réduisant les dépendances entre les composants, il est plus facile de modifier ou de remplacer des parties de votre projet sans provoquer de problèmes imprévus.
  
• Utiliser les événements pour la communication : Les événements permettent un couplage lâche entre les composants, en leur permettant d'envoyer des messages les uns aux autres sans dépendance directe. Vous pouvez les découpler davantage en utilisant des "canaux d'événements" basés sur des objets scriptables.
  
• Évitez les singletons inutiles : Les modèles de conception singleton peuvent être utiles, mais uniquement lorsqu'une seule instance d'une classe est essentielle. L'utilisation excessive de singletons peut entraîner un couplage étroit du code et entraver les tests. Ne pas utiliser le singleton s'il n'est pas nécessaire.

La refonte d'un grand script monolithique en éléments plus petits favorise la réutilisation et l'évolutivité. Cela permet d'améliorer la collaboration au sein de l'équipe et de simplifier les tests.

Nous avons créé le projet PaddleBallSO pour démontrer les cas d'utilisation de ScriptableObject. Voici quelques endroits spécifiques où vous les verrez à l'œuvre :

• L'objet scriptable GameDataSO sert de conteneur de données central pour les paramètres du jeu. Modifiez vos données communes une seule 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 les objets scriptables constituent l'épine dorsale de la manière dont les objets s'envoient des messages les uns aux autres.
  
• La lecture des sons utilise un objet délégué basé sur ScriptableObject pour séparer la logique du composant MonoBehaviour.
  
• Nous utilisons un enum PlayerIDSO ScriptableObject 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 du jeu tels que les palettes, les buts, les murs et le ballon. Cela permet de modifier facilement la disposition des niveaux dans Unity et à l'extérieur via des fichiers JSON exportés. La modélisation de niveaux en dehors d'Unity peut encourager la créativité des joueurs et le partage de modèles personnalisés.

N'oubliez pas de jeter un coup d'œil aux démonstrations des modèles de conception pour obtenir quelques extras !

Si les ScriptableObjects peuvent ê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 l'utilisation des ScriptableObjects dans Unity :

• Garder les données modulaires et organisées : Utilisez des ScriptableObjects distincts pour les différents types de données (par exemple, un pour les statistiques du joueur, un pour le comportement de l'ennemi, etc.) Décomposer les données complexes en éléments plus petits qui peuvent être facilement gérés.
  
• Utiliser des dossiers et des conventions de dénomination : Les ScriptableObjects peuvent contribuer à réduire le code dans vos scripts, mais la contrepartie est la gestion d'un plus grand nombre d'actifs dans vos dossiers de projet. Une bonne organisation des noms et des répertoires peut aider à gérer efficacement ces objets scriptables. Consultez notre guide de style du code pour obtenir des conseils sur le nommage.
  
• Éviter l'utilisation excessive de ScriptableObjects : Les ScriptableObjects sont de formidables conteneurs de données, mais il est important de ne pas en abuser. Gardez à l'esprit que les ScriptableObjects peuvent ajouter de la complexité à votre projet, donc ne les déployez que lorsqu'ils offrent un avantage clair. (Par exemple, ne les utilisez pas pour sauvegarder des données persistantes).
  
• Sauvegarder régulièrement les données : Les modifications apportées aux objets scriptables sont effectuées "en direct" au moment de l'exécution et sont enregistrées en tant que fichiers d'actifs. Veillez à 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 apportées à vos objets scriptables.
  
• Utilisez la fenêtre de l'inspecteur : L'un des principaux avantages des objets scriptables est qu'ils sont sérialisables et qu'ils apparaissent dans l'inspecteur. Tirer parti de l'interface de l'éditeur pour visualiser et manipuler les données stockées dans les objets scriptables.
  
• Utilisez les scripts personnalisés de l'éditeur à votre avantage : Les ScriptableObjects ne peuvent pas faire référence à des objets d'exécution de la hiérarchie de scène de manière native. Utilisez les scripts de l'éditeur pour faire de l'inspecteur une interface plus conviviale si vous avez besoin de visualiser ces objets.
  

En suivant ces lignes directrices, vous éviterez les pièges les plus courants en matière de développement.

Pour en savoir plus sur les modèles de conception avec ScriptableObjects, consultez l'e-book Create modular game architecture in Unity with ScriptableObjects (Créer une architecture de jeu modulaire dans Unity avec ScriptableObjects). Vous pouvez également en savoir plus sur les modèles de conception courants du développement Unity dans l'e-book Level up your code with game programming patterns.