1/ Présentation de l'interface
Après avoir téléchargé, installé et enregistré Unity depuis https://unity3d.com/, lancez le logiciel.
On va légèrement configurer l'espace de travail en allant dans [Window >> Layout >> Revert Factory Setting...]. Dès lors on ajuste comme dans la vidéo suivante :
Finalement, on se retrouve dans cette configuration là :
Détaillons cette interface ensemble. Si vous vous sentez prêt et que la description d'interface c'est du bullshit à vos yeux, sautez directement en section 2/.
1-1/ Menu principal
C'est à partir de là que nous créerons les éléments de notre scène.
1-2/ Boutons en dessous du menu princpial
Ces boutons servent à naviguer dans la scène 3D.
- La main sert à déplacer le point de vue. Les objets de la scène ne sont pas cliquables dans ce mode.
Pour déplacer le point de vue, il faut cliquer gauche dans la scène et laisser appuyé tout en bougeant la souris.
- Appuyer sur la touche "Alt" dans ce mode permet de faire apparaître un oeil à la place de la main qui s'utilise comme la main mais qui fait tourner le point de vue au lieu de la faire se translater.
- Cliquer à droite dans le mode main ou oeil sert à rapprocher/éloigner le point de vue à la manière d'un zoom/dézoom.
- Les flèches croisées servent à rendre les objets de la scène cliquables pour les positionner.
- Les flèches arrondies enchevêtrées servent à rendre les objets de la scène cliquables pour les rotationner.
- Le carré surmonté de 4 petites flèches en coin sert à rendre les objets de la scène cliquables pour changer leur taille.
1-3/ Le player
Ce panneau de boutons sert à lancer le jeu, ce qui lance tous les scripts, menus, sons... comme si on jouait à la version finale du jeu.
1-4/ Les layouts
Permet de dispatcher les éléments de la scène dans plusieurs "calques" afin de simplifier la recherche ou le travail à plusieurs sur une même map sans trop se marcher dessus les uns les autres. On n'aura pas besoin de manipuler ceci pour notre premier tutoriel.
1-3/ Onglets amovibles
Unity dispose de tout un tas de minis éditeurs présentés sous la forme d'onglets.
Parmis ceux présents par défaut dans l'interface de départ, on trouve:
L'onglet "Scene", que l'on appelera 3D View
C'est dans cet onglet que se trouve la scène 3D relative à l'édition. Tous les objets que nous créerons seront cliquables depuis cette vue.
On pourra alors les manipuler directement grâce à des helpers (des grosses flèches apparaissant autour de l'objet).
L'onglet "Game"
Cet onglet montre le résultat "in game" du jeu. Le point de vue utilisé ici est celui de la caméra joueur. Cette vue est active seulement quand l'utilisateur presse le bouton "Play" du player.
Les inputs du clavier/joystick sont alors interprétés pour le jeu et non plus pour l'interface graphique d'édition.
L'onglet "Hierarchy"
C'est un onglet qui répertorie tous les objets que possède la scène. Dans la scène par défaut d'Unity, on voit qu'une caméra est présente (un "Main Camera" apparait dans la liste).
Cette liste est très utile pour sélectionner les objets, plutôt que de les cliquer dans la Vue 3D.
L'onglet "Projet"
Cet onglet va nous être très peu utile aujourd'hui, mais il contient tous les "assets" du jeu. Si on veut ajouter une texture dans notre jeu, on va d'abord l'ajouter au projet via cet onglet, et ensuite on pourra l'utiliser dans le jeu. Idem pour les modèles 3D, ils sont d'abord "importés" dans le projet avant d'être utilisés dans telle ou telle map.
Cet onglet référence aussi toutes les "maps" que nous avons créé. Au départ de notre tutoriel, cet onglet sera vide.
L'onglet "Inspector"
Onglet très souvent utilisé ! Il va permettre de paramétrer un peu tous les objets que nous allons manipuler.
Dès que l'on clique sur un objet dans la 3D View, ou que l'on sélectionne un objet dans l'onglet "Hierarchy", son menu de description apparait dans l'onglet "Inspector".
Ici, la capture montre ce que l'inspector affiche quand la caméra par défaut de la scène est cliquée.
On aperçoit tous les paramètres de la caméra, que ce soit l'angle de champ ("field of view", ici réglé à 60 degrés) ou encore la position de de la caméra (en (0 ; 1 ; -10) ici).
Voilà pour ce rapide tour de l'interface outil.
Dans le prochain paragraphe, nous commencerons à créer notre premier jeu : un labyrinthe en bois. Ce sera l'occasion de jouer avec le moteur physique tout en restant le plus possible porter vers une approche de construction visuelle, avec très peu de code à écrire.
- - - - - - - - - -
2/ Game Object et Component
Dans la précédente partie, nous avons juste effleuré l'interface d'Unity. Maintenant nous allons aborder les 2 notions principales d'Unity que sont les "Game Objects" et les "Components".
2-1/ Game Object
Un game object (ou GAO pour les intimes) représente une position, une orientation et un scale. Et c'est tout !
Voici à quoi ressemble un GAO dans l'inspector :
Pour la position, je pense que tout le monde voit de qui il s'agit, ce sont les coordonnées en X, Y et Z du GAO.
L'orientation est souvent représentée par 3 rotations autour de 3 axes X/Y/Z.
Enfin le scale est en facteur de grossissement/étirement, nous allons l'utiliser plus tard donc vous verrez en image de quoi il en découle.
Un GAO tout seul ne sert à rien puisqu'il ne fait rien de spécial si ce n'est représenter un point dans l'espace. Pour apporter des caractéristiques à notre GAO, on va lui rajouter des composants (components en anglais).
2-2/ Component
Un composant va utiliser les attributs (position, orientation, scale) d'un GAO, mais apporter quelque chose à ce GAO.
Le cas le plus commun est celui d'un modèle 3D. Si on veut afficher un modèle 3D pour notre personnage principal, on va tout d'abord poser un GAO dans la scène puis rajouter à ce GAO un composant "mesh" où l'on indiquera quel maillage 3D charger.
Dans le même ordre d'idée, la caméra déjà présente dans la scène est elle aussi un composant associé à un GAO.
Les composants associés à un GAO rajoutent des morceaux d'interfaces graphiques (boutons, sliders...) dans l'inspector d'un GAO.
- - - - - - - - - -
3/ Notre premier GAO
Nous allons poser notre premier GAO avec un composant mesh représentant un plan.
Nous pourrions créer le GAO seul, puis lui rajouter le composant mesh et paramétrer ce composant dans l'inspector pour charger un maillage de plan. Mais Unity propose des sortes de raccourcis pour créer des choses "basiques".
3-1/ Création d'un plan
Ainsi, au lieu de faire [GameObject >> Create Empty], nous allons plutôt faire [GameObject >> Create Other >> Plane]. Dès lors un plan est automatiquement posé un peu devant votre point de vue dans la 3D View.
On note que l'onglet "Hierarchy" a un nouvel élément dans la liste : "Plane", et on voit aussi dans l'inspector que notre plan est en fait un GAO avec 3 composants :
- "Plane (Mesh Filter)" qui pointe vers un maillage de plan (certainement un fichier contenu dans tous les projets Unity)
- "Mesh collider" qui permet à notre GAO d'être au courant des collisions physiques qui pourraient survenir sur sa surface
- "Mesh Renderer" qui est le module qui permet d'afficher le plan à l'écran
Utiliser [GameObject >> Create Other >> Plane] plutôt que [GameObject >> Create Empty] nous a donc évité de créer et de paramétrer 3 composants ! (on essaie d'être le plus "lazy" possible).
3-2/ Positionnement
Les GAO créés dans Unity apparaissent un peu devant vos yeux dans la 3D View. De ce fait, ils ont des positions quelque peu exotiques.Dans mon cas le GAO à une position de (1,618681 ; 1,981054 ; 1,455877).
On clique donc sur le plan, soit dans la 3DView, soit dans la "Hierarchy" View. De là, on va éditer la position du plan pour le mettre en (0, 0, 0). On en profite aussi pour le renommer le plan en "Ground" dans le champ texte de l'inspector et on valide par "entrée". On obtient l'inspector suivant.
- - - - - - - - - -
4/ Orienter la caméra
Pour le moment, tout le monde doit voir un plan repositionné/renommé et une caméra dans la 3DView... mais on ne voit pas forcément grand chose dans la vue de l'onglet "Game".
Pour voir quelque chose, nous allons repositionner la caméra. Cliquez sur la caméra depuis la 3DView ou depuis l'onglet "Hierarchy".
Allez dans l'onglet Inspector et positionnez la caméra comme suit:
- position : (0; 6; -8)
- rotation : (45 ; 0; 0)
On obtient alors quelque chose comme ceci
Maintenant, on doit voir notre plan dans l'onglet "Game" puisque la caméra devrait être bien positionnée.
On remarque cependant que notre plan est d'une couleur uniforme dans l'onglet "Game". Ceci est du au fait qu'il n'y a pas de lumière dans notre scène.
- - - - - - - - - -
5/ Ajouter une lumière
Comme d'habitude, pour ajouter un élément à la scène, on doit d'abord insérer un GAO. Pour ajouter une lumière, on doit rajouter un composant "Light" à notre GAO. Mais Unity dispose aussi d'un raccourci pour créer une lumière.
Pour se faire, allez dans [GameObject >> Create Other >> Point Light], ce qui nous évite de faire [GameObject >> Create Empty] puis [Component >> Rendering >> Light].
On positionne la lumière comme on le souhaite, personnellement je place la mienne en (-1 ; 5 ; 0) et je change l'attribut "Range" dans l'inspector pour le placer à 15 au lieu de 10.
"Range" contrôle la portée de notre lumière. Au delà de 15 unités de distance (admettons que ce sont des mètres), les objets ne seront plus éclairés par cette lampe.
Alors vous allez me dire : "pourquoi les gens de Unity ont-ils mis un menu "Component" si on utilise tout le temps [GameObject >> Create Other] ... Et bien car pour le moment nous restons sur des choses simples.
Le menu "Component" prend tout son sens si on veut par exemple créer un bonhome 3D (donc un Mesh) qui se déplace dans la map en portant sur lui une lumière tout en jouant un son... Là il n'y aura pas de [GameObject >> Create Other >> MonBonhommeAvecSaLampeEtSonBruitage] dans l'interface !
Je pense que vous commencez à comprendre le schéma : on pose des GAO dans la 3DView, on les sélectionne, on leur ajoute des composants et on tweak (règle) le tout dans l'inspector.
Maintenant, allons rajouter notre bille...
- - - - - - - - - -
6/ Ajouter une sphère
J'aurais envie de ne rien vous dire sur comment ajouter une sphère à la scène... car la méthode est assez similaire à celle utilisée pour le plan.
Aller dans [GameObject >> Create Other >> Sphere]. Là, votre sphère devrait se pointer dans la 3D View. On en profite pour la sélectionner si ce n'est déjà fait et tweaker sa position pour la poser en (0; 3; 0).
Voici ce qu'on obtient dans la 3D View à ce stade.
- - - - - - - - - -
7/ Jouer avec la physique
7-1/ Jouer la scène
Maintenant que nous avons nos éléments de base pour notre scène, nous allons faire tomber la boule automatiquement grâce au moteur physique qui va appliquer une gravité à la sphère.
Si vous jouez la scène actuelle via le petit triangle du player:
vous remarquerez ... qu'il ne se passe rien dans la scène ! Rien ne bouge... pas pour très longtemps. Pour arrêter de jouer la scène, rappuyez sur le triangle lecture quand celui-ci est bleu, il redeviendra gris foncé.
7-2/ Ajouter un composant physic à la sphère
Sélectionnez votre sphère (en cliquant sur celle-ci dans la 3D View ou en lui cliquant dessus dans la liste des objets de l'onglet "Hierarchy").
Quand la sphère est sélectionnée, faites [Componant >> Physics >> Rigidbody]. Ceci a pour but d'indiquer au moteur que vous voulez qu'il fasse bouger votre GAO et sa sphère.
On obtient alors l'inspector suivant quand notre sphère est sélectionnée:
Maintenant, appuyez sur le triangle lecture dans le player en haut... et normalement votre sphere devrait tombée !
Lorsque vous arrêtez de jouer la scène, vos objets reprennent automatiquement leurs positions originelles.
C'est presque magique. Le composant "Rigidbody" a bien été rajouté à la liste des composant. Et ce composant va aller lire les informations d'autres composants pour savoir quelle forme physique doit avoir votre objet. Il va chercher cette forme dans les composants de type "collider".
Lorsque nous avons créé notre sphère avec le menu "Create Other", Unity nous a rajouté un composant "Sphere Collider" qui indique au moteur la forme physique potentielle de notre GAO si jamais nous lui ajoutions un composant "Rigidbody".
La forme physique utilisée n'est donc pas forcément la forme visuelle exhibée à l'écran. Dans les faits, rien ne nous aurait empêché de créer un cube ayant un collider de type "Sphere Collider". Et notre cube dans le jeu se serait mis à rouler.
C'est comme cela que l'on crée les collisions pour les personnages dans un jeu 3D : la forme qui collisionne avec le décor n'est pas la forme que l'on voit visuellement mais une autre forme, plus simple.
On va maintenant attaquer la partie la moins drôle du tutoriel, puisque l'on va devoir écrire quelques lignes de code... mais n'ayez crainte, on va essayer de s'expliquer clairement.
- - - - - - - - - -
8/ Script : faire bouger le plan avec les touches clavier
8-1/ De l'utilité du script
Maintenant que notre boule tombe sur le plan (nommé "Ground"), on veut pouvoir faire pivoter le sol avec les touches du clavier.
Avec Unity (et de nombreux éditeurs/moteurs), le seul moyen d'implémenter cette fonctionnalité est d'avoir recours aux scripts.
Le script est un peu la glu qui va permettre de lier tous les aspects du jeu. Que ce soit la gestion du clavier, ou encore la gestion des règles du jeu (savoir quand on gagne et quand on perd). Tout ou presque passe par le script.
Mais ne vous inquiétez pas, le script que nous allons voir est très compréhensible et très succinct.
Pour créer un script, nous allons utiliser pour la première fois l'onglet "Project" qui contient toutes les données inhérentes à notre projet. Cette fenêtre doit être vide sauf si vous avez sauvegardé votre scène ([File >> Save Scene]). Ici ma scène s'appelle "Tuto"
8-2/ Notre premier script
Création du fichier
Nous allons créer notre fichier script dans l'onglet "Project". Avant cela nous allons créer un répertoire pour ranger nos petites affaires.
Faites un clic droit dans un emplacement vide de la vue "Project" et dans le menu contextuel, choisissez [Create >> Folder]. Vous obtenez donc un répertoires "New Folder" que vous pouvez renommer "Scripts" soit en appuyant sur F2 pour le renommer, soit un cliquant 2 fois lentement dessus (comme dans le navigateur Windows en fait).
Dès lors, effectuez un clic droit sur le fichier et, dans le menu contextuel, choisissez [Create >> C Sharp Script].
Unity propose plusieurs langage de script, je pense que C# (se lit C Sharp) est le plus approprié.
Nous venons d'obtenir un fichier "NewBehaviourScript" dans notre dossier "Scripts". On pourrait renommer ce fichier mais pour des questions de facilité nous laissons ce nom par défaut.
Si on sélectionne ce fichier, on note que l'inspector montre son contenu sans que l'on puisse éditer quoique ce soit.
Si on double clic sur ce fichier dans l'onglet "Project" ou si on clique sur le bouton "Edit" dans l'inspector, un éditeur additionnel s'ouvre.
Décortivage du contenu par défaut du fichier
On va prendre ligne par ligne et vous allez voir que tout s'explique.
using UnityEngine;
using System.Collections;
Ces lignes permettent à notre fichier d'inclure du code qui n'est pas tapé dans notre fichier mais qui pourra être utiliser depuis notre fichier.
Ainsi UnityEngine contient tout les éléments du moteur accessibles depuis les scripts, et System.Collections est une "librairie" C# pour aider le programmeur à gérer des structures de données comme les tableaux ou les listes, pour y ranger des choses.
public class NewBehaviourScript : MonoBehaviour {
Cette ligne indique que nous déclarons une classe "NewBehaviourScript" qui hérite d'une autre classe "MonoBehaviour".
Une classe est une structure qui permet de décrire des choses en programmation.
Imaginons que je veuille représenter des voitures dans mon programme. Je ferais alors une classe qui ressemblerait à ça:
public class Voiture
{
Color ma_couleur;
Son mon_son_klaxon;
Voiture(Color _coleur, Son _sonKlaxon)
{
ma_couleur = _coleur;
mon_son_klaxon = _sonKlaxon;
}
void Klaxoner()
{
Jouer un son
}
}
Ma classe Voiture aurait un attribut couleur et un attribut son, mais elle ne spécifie pas la couleur ni le son, elle décrit juste qu'une voiture possède une couleur et un son. La classe est un moule (un patron) utile pour créer des objets.
Si dans mon jeu, je veux créer une voiture, alors je vais instancier un objet de la classe Voiture.
Voiture uneVoiture = new Voiture(rouge, sonKlaxonItalien);
"uneVoiture" est donc un objet de la classe Voiture.
Voiture == le moule, uneVoiture == une instance de Voiture fait avec le moule en spécifiant la couleur "rouge" pour la couleur et le son "sonKlaxonItalien".
L'object "uneVoiture" est concret puisqu'il propose une couleur rouge et un son de klaxon italien.
Une classe est donc une description plutôt abstraite, dans le sens où les attributs ont un type - Color, Son, etc...- mais pas de valeur précise, comme Color qui est un type mais qui ne dit pas quelle est la couleur de la voiture.
Le plus fort, c'est que je peux créer un autre objet voiture différent du premier, mais se basant sur le moule de construction qu'est la classe Voiture:
Voiture uneAutreVoiture = new Voiture(vert, sonKlaxonCloche);
Bref, tout ça pour dire que notre classe NewBehaviourScript est un moule. Et le moteur de Unity va créer des choses avec ce moule.
// Use this for initialization
void Start () {
}
// Update is called once per frame
void Update () {
}
}
A noter que les lignes commençant par "//" sont des lignes de commentaires, elles ne sont pas prises en compte et on peut y écrire n'importe quoi !
Le fait que l'on hérite de MonoBehaviour va permettre au moteur de savoir à peu prêt à quoi ressemble notre classe dans les grandes lignes. Car ici nous héritons de 2 fonctions "Start" et "Update".
"Start" est exécutée quand un objet (objet == ma voiture verte au klaxon italien) est créé avec le moule "NewBehaviourScript" (le moule == la Classe). On effectue "Start" une fois par création de d'objet, pour chaque objet.
"Update" est une autre fonction qui est appelée à chaque image rendue dans le jeu. C'est à dire qu'à toutes les frame, le moteur Unity va parcourir tous les objets qu'il a créé grâce au moule "NewBehaviourScript" et leur faire exécuter "Update" pour qu'ils se mettent à jour. Si on avait une fonction Update dans notre classe Voiture, elle servirait surement à calculer les trajectoires de la voiture ainsi que sa vitesse actuelle, etc...
Affectation du script à notre plan (ground)
Pour que notre plan ait une chance de faire quelque chose, il faut que nous lui associons le script "NewBehaviourScript". Pour se faire, il suffit de sélectionner le plan (soit dans la 3D View, soit dans la liste des objets de l'onglet "Hierarchy").
Une fois le plan sélectionné, l'inspector affiche ses composants. On effectue alors un glissé-déposé du fichier "NewBehaviourScript" depuis l'onglet "Project" vers l'onglet "Inspector".
On voit qu'un nouveau composant a été rajouté à notre plan : "NewScriptBehaviour Script (Script)".
Si on s'amuse à jouer le jeu, il ne se passe évidemment rien, puisque les fonctions "Start" et "Update" sont restées vides.
Modification du script pour répondre à nos attentes
Rappelons l'objectif : nous voulons faire bouger notre plan en fonction des flèches du clavier.
Pour se faire, nous allons avoir besoin de rajouter du code dans la fonction "Update" de notre script.
Ouvrez l'éditeur de script en double cliquant sur le fichier "NewBehaviourScript" de l'onglet "Project" (ou sur le bouton "Edit" dans l'inspector.
Dans la fonction Update, on rajoute les lignes :
if(Input.GetKey("left"))
{
transform.Rotate(Vector3.forward, 10.0f);
}
Ici on dit la chose suivante (en français) :
Si la touche "left" est appuyée Alors
{
on transforme la rotation du GAO associé au script courant en ajoutant à la rotation en Z 10 degrés
}
Ce qui veut dire que si on appuie sur la flèche gauche, alors la rotation de l'objet va augmenter de 10 degrés chaque image. Si le jeu est à 60 images par seconde, alors on augmente de 60 * 10 = 600 degrés par seconde !
Vous pouvez sauvegarder avec la petite disquette, et retourner dans la fenêtre principale d'Unity pour mettre le jeu en route. Lorsque vous appuyez sur la flèche gauche du clavier, le plan devrait tourner.
Il se peut qu'il tourne très vite selon la puissance de votre PC, car Unity ne limite pas le framerate. Si votre PC joue la scène à 1000 images par seconde, le plan tourne de 1000 * 10 = 20000 degrés par seconde !
Pour contrecarrer ce problème, Unity peut nous donner le temps écoulé depuis la dernière image rendue, ce qui fait que le plan va plus ou moins tourner selon que l'image prenne plus ou moins de temps à être rendue. La durée de rendue de l'image précédente est contenue dans "Time.deltaTime".
if(Input.GetKey("left"))
{
transform.Rotate(Vector3.forward, 10.0f * Time.deltaTime);
}
On en profite aussi pour faire les autres directions :
if(Input.GetKey("left"))
{
transform.Rotate(Vector3.forward, 10.0f * Time.deltaTime);
}
else if(Input.GetKey("right"))
{
transform.Rotate(Vector3.forward, -10.0f * Time.deltaTime);
}
if(Input.GetKey("up"))
{
transform.Rotate(Vector3.right, 10.0f * Time.deltaTime);
}
else if(Input.GetKey("down"))
{
transform.Rotate(Vector3.right, -10.0f * Time.deltaTime);
}
A noter le mot clé "else" qui interdit d'appuyer sur gauche/droite en même temps et sur haut/bas en même temps. Il n'est toutefois pas indispensable de placer des "else" ici.
Notre fenêtre de script ressemble donc à ceci:
Maintenant, vous allez essayer le "jeu" en ne touchant aux flèches que lorsque la boule a touché le sol. Essayez maintenant d'orienter le plateau de jeu avec les flèches... Si tout ce passe "bien" la boule ne devrait pas bouger ! Comment qu'est-ce ? me direz vous.
Ce n'est pas un problème de Script car notre script se contente de faire bouger le GAO du plan... non, il s'agit d'un problème de composant à rajouter sur notre plan... un composant "Rigidbody"...
- - - - - - - - - -
9/ Jouer avec la physique Bis
9-1/ Rendre notre plan réactif à la physique
Notre sphère c'est bien arrêtée sur le plan, car le plan a été créé à l'aide du menu "Create Other" de Unity. Un composant "Mesh collider" avait été ajouté pour nous.
Pour que la simulation physique soit exacte, et par conséquent pour que la boule glisse le long du plan lorsque celui-ci est incliné, nous avons besoin de rajouter un composant "Rigidbody" à notre plan (qui doit normalement s'appeler "Ground").
Vous devriez avoir une idée de comment faire, mais voici la démarche :
- sélectionnez le plan dans la 3D View ou dans l'onglet "Hierarchy".
- faites [Component >> Physics >> Rigibody] depuis le menu principal.
Si vous exécutez le jeu maintenant, nous verrez que le plan tombe dans le vide... tout comme la sphère ! Ceci est normal car nous n'avons pas précisé que le plan devait être considéré comme "fixe" par le moteur physique.
Pour corriger se léger problème, on se rend dans l'inspector après avoir sélectionné le plan, et on coche "Is Kinematic" dans les paramètres du composant "Rigidbody".
Cette fois-ci, en rejouant la scène, on s'aperçoit que la sphère glisse bien le long du plan lorsque celui-ci est incliné !
9-2/ Ajouter des bords à l'aire de jeu
Création d'un bord
On voit que la boule peut chuter avec notre scène en l'état. Je vous propose donc de rajouter des bordures le long des limites du plan.
Pour se faire, nous allons créer un cube.
Comme d'habitude, on exécute [GameObject >> Create Other >> Cube] depuis le menu principal.
Cela nous crée un joli cube dont on s'empresse de paramétrer la position en (0 ; 0 ; 5,5) et qu'on renomme en "BoundRight".
A ce stade, le cube ne risque pas de bloquer la boule sur toute la longueur du plan. C'est ici qu'intervient le paramétrage du scale.
Ainsi dans l'inspector, on modifie le "scale" de sorte à ce que le cube devienne un cube "allongé". Ici, je règle le scale en X sur 12.
On n'oublie pas de rajouter un composant "Rigidbody" à ce cube étiré pour éviter les déboires rencontrés sur le plan.
Pour cela, on sélectionne le cube, puis on va dans [Component >> Physics >> Rigidbody].
Ensuite, on n'oublie pas non de se rendre dans l'inspector et de cocher "Is Kinematic" dans les paramètres du composant "Rigidbody".
Duplication
Une fois un bord créé, on peut le sélectionner et aller dans [Edit >> Duplicate] depuis le menu principal. Dès lors un nouveau cube étiré et possédant un composant Rigidbody est créé. Ce dernier est juxtaposé à son modèle de duplication, il faut donc modifier sa position pour le voir apparaître.
On répète l'opération de duplication 3 fois au total. A chaque fois on change les positions des dupliqués ainsi que le nom (BoundRight, BoundLeft, BoundTop, BoundBottom constitueront les noms).
Pour 2 de ces cubes, il sera nécessaire de changer la rotation (rotation de 90 en Y), et le scale (10 à la place de 12 en X).
Faisons un petit point en faisant tourner le jeu...
On s'aperçoit que les bords ne bouge pas... Logique puisque le script que nous avons fait est seulement appliqué au plan.
On pourrait créer des scripts pour les bords... mais c'est fastidieux car les rotations n'auraient pas lieues sur le même centre de rotation que celui utilisé pour le plan.
Le plus simple est de créer une hiérarchie de GAO.
Hiérarchisation des GAO
Dans Unity, il est facilement possible de dire qu'un GAO est le fils d'un autre. Ainsi, quand un GAO dit père bouge (ou tourne, ou s'étire), alors tous ses fils font de même.
Pour se faire, rendez-vous dans l'onglet "Hierarchy". Dans la liste des GAO, vous devriez avoir "Ground", "BoundRight", "BoundLeft", "BoundTop" et, "BoundBottom".
Nous allons rendre tous les BoundXXX fils de Ground. Pour rendre un Bound fils, il suffit de glisser/déposer un élément de la liste "Hierarchy" sur un autre élément de la liste "Hierarchy". En l'occurence ici tous les "BoundXXX" vont être glissés/déposés sur "Ground".
Au final, on se retrouve avec quelque chose de la sorte dans l'onglet "Hierarchy"
Quand on sélectionne "Ground" dans l'onglet "Hierarchy", on notre que les fils sont automatiquement sélectionnés dans la 3D View, ce qui peut faciliter la mise en place des GAO dans une scène complexe.
Rejouons la scène maintenant... tout devrait bouger !
- - - - - - - - - -
10/ Conclusion
Nous avons abordé ici de nombreux points comme :
- les GAO, GameObject qui représentent des points/rotations/scale dans l'espace
- les composants (Component) sont des éléments qui apportent des fonctionnalités aux GAO, un GAO peut avoir plusieurs composants
- un composant peut accéder aux autres composants d'un GAO, et accéder aux attributs du GAO lui-même (exemple : le composant script accède à la rotation de l'objet dans notre cas)
- nous avons abordé les composants "Rigidbody", "Light", "Mesh", "Renderer" et "Script"
- nous avons souvent utilisé le menu GameObject >> Create Other ... afin qu'Unity nous facilite le travail en créant pour nous des listes de composants.
- - - - - - - - - -
11/ Plus loin
Vous avez maintenant un support de jeu composé d'un plan et de cubes allongés sur les bords. Rien ne vous empêche de créer un véritable labyrinthe pour votre boule en ajoutant des cubes étirés qui vous positionnerez à votre convenance.
Dans le prochain tutoriel, nous reviendrons sur ce jeu et créerons ce qu'il faut pour avoir un labyrinthe complet (des chemins et des trous) ainsi que des scripts pour vérifier les règles de jeu (si on gagne ou perd), sans oublier un affichage (Hud) pour indiquer au joueur son score et l'écran titre ou de game over.
Et nous verrons aussi comment corriger le problème de "Gimbal Lock" que l'on observe dans cette version... je vous expliquerai bien entendu par la même la signification de ce terme barbare.