Le guide ultime du débutant pour le développement de jeux dans Unity

Unity est un excellent outil pour tout prototyper, des jeux aux visualisations interactives. Dans cet article, nous passons en revue tout ce que vous devez savoir pour commencer à utiliser Unity.

Tout d'abord, un peu sur moi: je suis un développeur d'unité amateur, un modeleur 3D et un graphiste qui travaille avec Unity et Blender depuis plus de 5 ans. Je suis maintenant étudiant en mathématiques financières à l'University College Dublin, et je fais occasionnellement de la conception graphique indépendante, du prototypage Web et du prototypage de jeux.

introduction

Cet article s'adresse à tous ceux qui n'ont jamais utilisé Unity auparavant, mais qui ont une certaine expérience en programmation ou en conception / développement Web. À la fin de cet article, vous devriez avoir un bon aperçu général du moteur ainsi que toutes les fonctions et le code nécessaires pour commencer à faire un jeu de base.

Pourquoi Unity?

Si vous voulez créer des jeux

Il y a vraiment très peu d'options en matière de développement de jeux indépendants. Les trois choix principaux si vous souhaitez créer des jeux sont Unreal, Unity ou GameMaker.

Unity est probablement la moins avisée des 3 plates-formes. Il vous donne un produit très brut prêt à l'emploi, mais il est très flexible, bien documenté et hautement extensible pour créer à peu près n'importe quel genre de jeu auquel vous pouvez penser.

Il existe de nombreux jeux très réussis tels que Escape from Tarkov (FPS), Monument Valley (Puzzler) et This War of Mine (Strategy / Survival), tous construits dans Unity.

En réalité, le moteur sur lequel vous construisez votre premier jeu n'est probablement pas critique, donc mon conseil est simplement d'en choisir un et de l'utiliser.

Si vous souhaitez prototyper des expériences utilisateur

Étant donné que l'unité n'est qu'un moteur avec un tas de physique, d'animation et de rendu 3D en temps réel, c'est également un excellent espace pour créer des prototypes interactifs à part entière pour les études UX.

Unity prend entièrement en charge la RV et la RA et pourrait donc être un excellent outil pour explorer l'architecture, les automatisations et les simulations avec les clients.

Sections de cet article

  • Pourquoi Unity?
  • Fenêtre de l'éditeur Unity
  • Objets de jeu Unity
  • Composants intégrés Unity
  • Création de composants personnalisés
  • Structure d'un mono-comportement
  • Manipulation de GameObjects
  • Raycasting
  • Détection de collision
  • Fonctionnalités avancées
  • Conseils aux nouveaux arrivants
  • Nice Ressources et Communautés
  • Conclusion

Fenêtre de l'éditeur Unity

La fenêtre de l'éditeur est divisée en deux sections. Nous couvrirons cela très brièvement car nous y ferons référence constamment tout au long de l'article. Si vous êtes familier avec cela, sautez déjà!

Scène Vue: Permet le placement et le mouvement de GameObjects dans la scène Jeu Vue: Previews comment le joueur verra la scène de l'appareil photo Inspecteur: Fournir des détails sur le gameobject sélectionné dans la scène. Actifs / Projet: Tous les préfabriqués, textures, modèles, scripts, etc. sont stockés ici Hiérarchie: permet l'imbrication et la structuration des GameObjects dans la scène

Maintenant, nous sommes prêts à commencer!

Objets de jeu Unity

Que sont les GameObjects

GameObjects est la pierre angulaire de tout ce qui se trouve dans le moteur de jeux Unity. Le nom le donne presque:

Tout ce que vous placez dans une scène dans Unity doit être enveloppé dans un «objet de jeu».

Si vous avez une formation en conception Web, vous pouvez penser que GameObjects ressemble beaucoup à des éléments! Conteneurs extrêmement ennuyeux, mais hautement extensibles pour créer des fonctionnalités ou des visuels complexes.

Littéralement, tout, des effets de particules, des caméras, des lecteurs, des éléments de l'interface utilisateur,… (la liste est longue) est un GameObject.

Créer une hiérarchie

Comme un développement Web, un GameObject est également un conteneur. Tout comme vous créez des mises en page ou des abstractions variées et souhaitables, vous souhaiterez peut-être faire de même avec les objets de jeu.

La logique derrière l'imbrication des objets de jeu est sensiblement la même que celle du développement web, je vais donner quelques exemples…

Clutter et efficacité

Analogie avec le Web: vous avez de nombreux éléments similaires qui peuvent être générés dynamiquement à la volée en réponse à l'interaction de l'utilisateur et que vous souhaitez les garder en ordre. Traduction Unity: lorsque vous construisez un clone de Minecraft et que vous avez beaucoup de blocs dans la scène, vous devez ajouter et supprimer des `` morceaux '' de blocs de la scène pour des raisons de performances. Ainsi, les avoir parentés à un GameObject vide pour chaque bloc a du sens, car la suppression du parent de bloc supprime tous les blocs enfants.

Positionnement

Analogie Web: Vous souhaitez conserver la position du contenu contenu «par rapport» au conteneur et non à la page Web. Traduction Unity: Vous avez créé un groupe de drones d'assistance qui planent autour du joueur. Vous ne préférez vraiment pas écrire du code pour leur dire de courir après le joueur, donc vous les instanciez en tant qu'enfants de l'objet de jeu joueur.

Composants intégrés Unity

Le modèle de composant acteur

Les GameObjects seuls sont assez inutiles - comme nous l'avons vu, ils ne sont quasiment que des conteneurs. Afin de leur ajouter des fonctionnalités, nous devons ajouter des composants, qui sont essentiellement des scripts écrits en C # ou en Javascript.

Unity fonctionne sur un modèle de composant d'acteur, en termes simples, les GameObjects sont les acteurs et les composants sont vos scripts.

Si vous avez déjà écrit des applications Web, vous serez familiarisé avec l'idée de créer de petits composants réutilisables tels que des boutons, des éléments de formulaire, des mises en page flexibles qui ont différentes directives et des propriétés personnalisables. Ensuite, assembler ces petits composants dans de plus grandes pages Web.

Le grand avantage de cette approche est le niveau de réutilisabilité et des canaux de communication clairement définis entre les éléments. De même dans le développement de jeux, nous voulons minimiser le risque d'effets secondaires involontaires. Les petits bogues ont tendance à devenir incontrôlables si vous ne faites pas attention et sont extrêmement difficiles à déboguer. Ainsi, la création de petits composants robustes et réutilisables est essentielle.

Principaux composants intégrés

Je pense qu'il est temps de donner quelques exemples des composants intégrés fournis par le moteur Unity Games.

  • MeshFilter: vous permet d'assigner des matériaux à un maillage 3D à un GameObject
  • MeshRender: vous permet d'attribuer des matériaux à un maillage 3D
  • [Boîte | Mesh] Collider: Active la détection de GameObject lors de collisions
  • Rigidbody: permet une simulation physique réaliste pour agir sur GameObjects avec des mailles 3D et déclenchera des événements de détection sur les collisionneurs de boîtes
  • Lumière: illumine des parties de votre scène
  • Caméra: définit la fenêtre du lecteur à attacher à un GameObject
  • Divers composants de canevas d'interface utilisateur pour afficher les interfaces graphiques

Il y en a beaucoup plus, mais ce sont les principaux avec lesquels vous devrez vous familiariser. Un conseil est que vous pouvez accéder à tous les documents pour ceux-ci via le manuel unity et la référence de script hors ligne où que vous soyez:

Création de composants personnalisés

Les composants intégrés contrôlent principalement la physique et les visuels, mais pour vraiment créer un jeu, vous devrez accepter les entrées de l'utilisateur et manipuler ces composants standard ainsi que les GameObjects eux-mêmes.

Pour commencer à créer des composants, allez dans le GameObject souhaité> Ajouter un composant> tapez le nom de votre nouveau composant dans la barre de recherche> nouveau script (c #).

En règle générale, je déconseille d'utiliser Javascript dans Unity. Il n'a pas été mis à jour avec tous les trucs géniaux fournis avec ES6, et la plupart des trucs plus avancés reposent sur des trucs C # portés vers Javascript… Cela devient juste une solution de rechange géante selon mon expérience.

Structure d'un mono-comportement

Fonctions clés

Tous les composants héritent de la classe MonoBehaviour. Il comprend plusieurs méthodes standard, notamment:

  • void Start () qui est appelé chaque fois qu'un objet contenant le script est instancié dans la scène. Ceci est utile chaque fois que nous voulons exécuter un code d'initialisation, par exemple. définir l'équipement d'un joueur après son apparition dans un match.
  • void Update () qui est appelé à chaque image. C'est là que la majeure partie du code impliquant une entrée utilisateur ira, mettant à jour diverses propriétés telles que le mouvement du joueur dans la scène.

Variables de l'inspecteur

Souvent, nous voulons rendre les composants aussi flexibles que possible. Par exemple, toutes les armes peuvent avoir des dégâts, une cadence de tir, un viseur différents, etc.

Un autre exemple où nous pourrions vouloir faire cela est lors de la création d'un composant d'interface utilisateur qui suit les mouvements de la souris de l'utilisateur et place un curseur dans la fenêtre. Ici, nous pourrions vouloir contrôler la sensibilité du curseur aux mouvements (si l'utilisateur utilisait un joystick ou une manette de jeu contre une souris d'ordinateur). Ainsi, il serait logique que ces variables soient faciles à modifier à la fois en mode d'édition et à les expérimenter pendant l'exécution.

Nous pouvons le faire facilement en les déclarant simplement comme des variables publiques dans le corps du composant.

Accepter l'entrée utilisateur

Bien sûr, nous voulons que notre jeu réponde aux entrées des utilisateurs. Les moyens les plus courants de le faire utilisent les méthodes suivantes dans la fonction Update () d'un composant (ou partout ailleurs que vous voulez):

  • Input.GetKey (KeyCode.W) Renvoie True La touche W est maintenue enfoncée
  • Input.GetKeyDown (KeyCode.W) Renvoie True lorsque la touche W est enfoncée pour la première fois
  • Input.GetAxis («Vertical»), Input.GetAxis («Horizontal») Renvoie entre -1,1 mouvement d'entrée de la souris

Manipulation de GameObjects

Une fois que nous avons les entrées de l'utilisateur, nous voulons que GameObjects dans notre scène réponde. Nous pouvons envisager plusieurs types de réponses:

  • Translation, rotation, échelle
  • Créer de nouveaux GameObjects
  • Envoi de messages aux GameObjects / composants existants

Transformations

Les GameObjects ont tous une propriété de transformation qui permet d'effectuer diverses manipulations utiles sur l'objet de jeu actuel.

Les méthodes ci-dessus sont assez explicites, notez simplement que nous utilisons gameObject en minuscules pour faire référence au GameObject qui possède cette instance spécifique du composant.

En général, il est recommandé d'utiliser local [Position, Rotation] plutôt que la position / rotation globale d'un objet. Cela facilite généralement le déplacement des objets d'une manière qui a du sens, car l'axe spatial local sera orienté et centré sur l'objet parent plutôt que sur l'origine du monde et les directions x, y, z.

Si vous avez besoin de convertir entre l'espace local et l'espace mondial (ce qui est souvent le cas), vous pouvez utiliser ce qui suit:

Comme vous pouvez l'imaginer, il y a une algèbre linéaire assez simple derrière cela suggérée par l '«inverse» dans le nom de la méthode.

Créer de nouveaux GameObjects

Puisque les GameObjects sont fondamentalement tout dans votre scène, vous voudrez peut-être pouvoir les générer à la volée. Par exemple, si votre joueur a une sorte de lanceur de projectiles, vous voudrez peut-être être en mesure de créer des projectiles à la volée qui ont leur propre logique encapsulée pour voler, infliger des dégâts, etc.

Nous devons d'abord introduire la notion de préfabriqué . Nous pouvons les créer simplement en faisant glisser n'importe quel GameObject de la hiérarchie de la scène dans le dossier des ressources.

Cela stocke essentiellement un modèle de l'objet que nous venons d'avoir dans notre scène avec toutes les mêmes configurations.

Une fois que nous avons ces composants préfabriqués, nous pouvons les affecter à des variables d'inspecteur (comme nous en avons parlé plus tôt) sur n'importe quel composant de la scène, afin que nous puissions créer de nouveaux GameObjects comme spécifié par le préfabriqué à tout moment.

Nous pouvons ensuite effectuer une «instanciation» du préfabriqué et le manipuler à l'emplacement souhaité dans la scène et établir les relations parentales nécessaires.

Accéder à d'autres GameObjects et composants

Nous avons souvent besoin de communiquer avec d'autres GameObjects ainsi qu'avec leurs composants associés. Une fois que vous avez une référence à un objet de jeu, c'est assez simple.

ComponentName comp = some_game_object.GetComponent ();

Après cela, vous pouvez accéder à l'une des méthodes / variables publiques du composant afin de manipuler le GameObject. C'est la partie la plus simple, mais l'obtention de la référence au GameObject peut se faire de plusieurs manières ...

Accès via la variable inspecteur

C'est le plus simple. Créez simplement une variable publique pour le GameObject, comme nous l'avons montré précédemment avec les préfabriqués, puis faites-la glisser et déposez-la manuellement sur le composant via l'inspecteur. Accédez ensuite à la variable comme ci-dessus.

Accès via le marquage

Nous pouvons étiqueter des GameObjects ou des préfabriqués via l'inspecteur, puis utiliser les fonctions de recherche d'objets de jeu pour localiser leurs références.

Ceci est simplement fait comme ci-dessous.

GameObject some_game_object = GameObject.FindGameObjectWithTag («Brick»);

Accès via transformation

Si nous souhaitons accéder aux composants d'un objet parent, nous pouvons facilement le faire via l'attribut transform.

ComponentName comp = gameObject.transform.parent.GetComponent ();

Accès via SendMessage

Alternativement, si nous voulons envoyer un message à de nombreux autres composants ou si nous souhaitons envoyer un message à un objet qui est loin dans une hiérarchie imbriquée, nous pouvons utiliser les fonctions d'envoi de message, qui acceptent le nom de la fonction suivi des arguments.

gameObject.SendMessage («MethodName», paramètres); // Diffusion du messagegameObject.SendMessageUpwards (“MethodName”, params); // Reçu uniquement par les composants imbriqués ci-dessus.

Raycasting

Vous en avez peut-être déjà entendu parler lorsque les gens comparent des jeux FPS «basés sur la physique» ou «basés sur les rayons». Raycasting est essentiellement comme avoir un pointeur laser qui, lorsqu'il entre en contact avec un «collisionneur» ou un «corps rigide», il renvoie un «coup» et renvoie les détails de l'objet.

Il y a deux scénarios où cela est utile (il y en a probablement beaucoup plus):

  1. Si vous conceviez un système d'arme pour un jeu, vous pourriez utiliser la diffusion de rayons pour la détection des coups, et même personnaliser la longueur du rayon afin que les objets de mêlée ne `` frappent '' qu'à courte distance
  2. Créez un rayon du pointeur de la souris vers un point de l'espace 3D, c'est-à-dire si vous souhaitez que l'utilisateur puisse sélectionner des unités avec sa souris dans un jeu de stratégie.

Comme vous pouvez le voir, le code est un peu plus complexe. La chose clé à comprendre est que pour projeter un rayon vers l'endroit où la souris pointe dans l'espace 3D, il faut la transformation ScreenPointToRay. La raison en est que la caméra rend un espace 3D en tant que fenêtre d'affichage 2D sur l'écran de votre ordinateur portable, il y a donc naturellement une projection impliquée pour revenir en 3D.

Détection de collision

Nous avons mentionné précédemment les composants Collider et Rigidbody qui peuvent être ajoutés à un objet. La règle pour les collisions est qu'un objet dans la collision doit avoir un corps rigide et l'autre un collisionneur (ou les deux ont les deux composants). Notez que lors de l'utilisation de raycasting, les rayons n'interagiront qu'avec les objets auxquels sont attachés des composants de collisionneur.

Une fois installé dans un composant personnalisé attaché à l'objet, nous pouvons utiliser les méthodes OnCollisionEnter, OnCollisionStay et OnCollisionExit pour répondre aux collisions. Une fois que nous avons les informations de collision, nous pouvons obtenir le GameObject responsable et utiliser ce que nous avons appris plus tôt pour interagir avec les composants qui y sont attachés.

Une chose à noter est que les corps rigides fournissent de la physique telle que la gravité pour les objets, donc si vous voulez que cette option soit désactivée, vous devrez cocher is_kinematic .

Fonctionnalités avancées

Nous n'entrerons pas dans tout cela maintenant mais peut-être dans un prochain article - juste pour vous faire prendre conscience qu'ils existent.

Création d'interfaces graphiques

Unity dispose d'un moteur d'interface utilisateur à part entière pour la présentation de l'interface graphique de votre jeu. En général, ces composants fonctionnent de manière assez similaire au reste du moteur.

Extension de l'éditeur Unity

Unity vous permet d'ajouter des boutons personnalisés à vos inspecteurs afin de pouvoir affecter le monde en mode édition. Par exemple, pour aider à la construction du monde, vous pouvez développer une fenêtre d'outils personnalisée pour la construction de maisons modulaires.

Animation

Unity dispose d'un système d'animation basé sur des graphiques qui vous permet de mélanger et de contrôler des animations sur divers objets tels que des joueurs mettant en œuvre un système d'animation basé sur l'os.

Matériaux et PBR

Unity utilise un moteur de rendu physique qui permet un éclairage en temps réel et des matériaux réalistes. La réalité est que vous devrez d'abord apprendre la modélisation 3D ou utiliser des modèles créés et optimisés par quelqu'un d'autre avant d'y arriver, afin de créer des choses qui semblent vraiment bonnes.

Conseils aux nouveaux arrivants

Si vous prévoyez d'écrire votre premier jeu, ne sous-estimez pas la complexité et le temps qu'il faut pour écrire même le plus trivial des jeux. N'oubliez pas que la plupart des jeux qui sortent sur Steam ont des équipes qui travaillent dessus pendant des années à plein temps!

Choisissez un concept simple et décomposez-le en petits jalons réalisables. Il est fortement recommandé de séparer votre jeu en aussi petits composants indépendants que possible, car vous êtes beaucoup moins susceptible de rencontrer des bogues si vous gardez les composants simples plutôt que des blocs de code monolithiques.

Avant d'écrire du code pour une partie de votre jeu, cherchez ce que quelqu'un d'autre a déjà fait pour résoudre le même problème - il y a de fortes chances qu'il ait une solution beaucoup plus astucieuse.

Nice Ressources et Communautés

La conception de jeux a l'une des meilleures communautés qui soient, et il y a beaucoup de professionnels hautement qualifiés dans l'industrie qui mettent du contenu gratuitement ou pour presque rien. C'est un domaine qui nécessite des modélisateurs 3D, des artistes conceptuels, des concepteurs de jeux, des programmeurs, etc. J'ai lié quelques excellentes ressources générales que j'ai rencontrées pour chacun de ces champs ci-dessous:

Art conceptuel

  • École de design Feng Zhu (plus de 90 heures de tutoriels d'art conceptuel)
  • Tyler Edlin Art (Grande communauté artistique BST avec commentaires de pros sur les défis mensuels)
  • Art Cafe (interviews et ateliers avec des artistes conceptuels célèbres)
  • Trent Kaniuga (illustrateur et artiste 2D qui crée également son propre jeu)

Modélisation 3D

  • CG Cookie (Les meilleures bases de la modélisation de maillage dans Blender jamais, ils ont beaucoup d'autres excellents contenus pour blender)
  • Tor Frick (modeleurs et sculpteurs de surfaces dures dans Blender)
  • Gleb Alexandrov (courts tutoriels de rendu puissants dans Blender)

Le design du jeu

  • DoubleFine Amnesia Fortnight (GameDevs qui font un hackathon de 2 semaines et enregistrent l'ensemble de leur processus de conception)
  • Boîte à outils GameMakers (examine les principes de conception de jeux)

Programmation

  • Handmade Hero (Ecrire un jeu et un moteur à partir de zéro en C)
  • Jonathan Blow (développeur indépendant qui diffuse en direct le développement de son jeu)
  • Brackeys (Tutoriels Nice Unity)

Conclusion

J'espère que vous avez aimé ce tutoriel! Je fais un peu de travail de conception graphique ainsi que des prototypes de jeux et d'interface utilisateur, alors consultez mon portfolio ! Je suis également connecté .

Portefeuille| LinkedIn