Tutoriel Unity

Shoot’èm Up

Pour commencer, tu vas devoir créer un nouveau projet Unity. Pour cela, ouvre UnityHub, clique sur la
flèche à côté du bouton “new” puis sélectionne la version d’Unity que nous vous avons fait installer.
UnityHub va alors te demander plusieurs informations : le template que tu souhaites utiliser, 2D suffira
pour notre projet ; le nom du projet ainsi que son emplacement dans tes dossiers. Une fois remplies,
clique sur “Create”.

Le projet va donc se créer et Unity sera lancé automatiquement après ça.

Premier petit point, sur Unity les éléments du jeu sont référencés avec différents noms.
En premier, on va trouver les « Scene », c’est elles qui vont s’occuper de tous les autres éléments du
jeu. On peut donc créer plusieurs « Scene » qui vont posséder des éléments différents, ce qui permet
de faire par exemple une « Scene » pour le menu, pour le jeu, pour les options, …

Ensuite, on va trouver les « GameObject » stockés dans les « Scene ». Chaque entité de ton jeu est un
« GameObject » : les personnages, les ennemis, les plantes, le sol, le ciel, les armes, la lumière, les
liquides, … Tout est « GameObject » !
Cependant, chacune de ces entités devra se comporter différemment pour faire son rôle de
personnage ou de liquide par exemple. Pour cela, il va falloir leurs ajouter des « Component »
(comportement) qui seront donc lié aux entités et vont définir les comportements qu’ils auxquels ils
devront se plier. Il existe différents « Component » par défaut dans Unity, on appelle « Script » les
components que toi, développeur, va créer (en c# sur Unity) pour les entités de ton jeu.

Petit tour de l’application :

- Sur la gauche, il y a la fenêtre « Hierarchy » qui va contenir tous les « GameObject » de la
« Scene » en train d’être visualisé. Tu vas pouvoir, dans cet onglet, les déplacer, leur donner
des liens de parenté, …
- La visualisation de la « Scene » dont j’ai parlé se fait sur la fenêtre du milieu, il y a un onglet
« Scene » qui te permet de voir tes éléments sous tous les points de vue en te déplaçant et
même de procéder à des modifications comme la position ou la rotation d’un « GameObject ».
- Sur la même fenêtre, il y a l’onglet « Game » qui te permettra de visualiser ta « Scene » comme
si tu en étais le joueur. Tu peux même lancer une simulation en appuyant sur le buton play
juste au-dessus de la fenêtre.
- Également sur cette même fenêtre centrale, tu trouveras l’onglet « Asset Store » qui te
permettra de trouver des assets graphique ou sonore à implémenter dans ton jeu. (Je te
conseille tout de même d’y aller depuis un navigateur internet)
- La fenêtre de droite, « Inspector », te permet de visualiser le « GameObject » que tu auras au
préalable sélectionné dans la liste de l’onglet « Hierarchy » (En cliquant dessus par exemple).
Tu y trouveras tous ses components avec les différentes variables de ces derniers afin de
pouvoir les régler en fonction des besoins. Tu pourras également lui ajouter d’autres
components, modifier son nom, son tag ou encore son layer.
- Dans la fenêtre du bas, tu trouveras l’onglet « Project ». Pas besoin de traduire, c’est tous
simplement un explorateur de dossier basé sur le dossier Unity de ton jeu. Tu peux
glisser/déposer des fichiers, créer tes scripts, …
- Sur la même fenêtre, tu trouveras également l’onglet « Console » qui t’avertira des erreurs et
warnings que Unity détectera. Tu pourras également lui demander d’afficher des messages
depuis les scripts que tu écriras.

Création d’un GameObject :

Pour pouvoir créer un GameObject, assure-toi tout d’abord d’être dans une Scene (son nom sera
affiché en haut de l’onglet Hierarchy). Ensuite, soit tu utilises l’onglet « GameObject » qui se situe sur
la barre des tâches de la fenêtre, soit tu fais clique droit dans l’onglet Hierarchy. Une liste s’affichera
alors te proposant de soit « Create Empty » (Un GameObject vide, donc sans component) soit créer un
GameObject par défaut (3D/2D object, UI, Effects, audio, ...) qui posséderont donc déjà certains
components.

Pro-Tips : Il existe un système de parent/enfant pour les GameObject dans Unity. En glissant déposant
un GameObject dans un autre sur l’onglet Hierarchy, cela permet de créer ce lien de parenté. Ce lien
sert par exemple pour le Component « Transform » qui gère la position, la rotation et la mise à
l’échelle, à ce que l’enfant hérite de ces transformations. Donc si tu déplace le parent, les enfants
bougeront également avec le même vecteur de déplacement.

Ajout des components :

Pour définir un comportement à un GameObject, il te faudra passer par les Components. Afin d’en
ajouter un, sélectionne d’abord ton GameObject et, la même que pour la création de GameObject, soit
tu passe par la barre des tâches de la fenêtre, soit par l’onglet Inspector en cliquant sur le buton « Add
Component ». Une liste va donc apparaître et te proposer diverses Component (là t’as du choix), ceux
que tu auras le plus à utiliser seront dans « Physic2D », « Rendering » et « UI » principalement.

Création d’un Script :

Pour créer un script, fait comme si tu ajouté un Component, à la différence qu’il te faudra rentrer le nom
du script que tu souhaites créer dans la barre de recherche. Unity te proposera automatiquement de
créer un script si le component recherché n’est pas trouvé. Clique sur « New Script », puis sur « Create
and Add » afin de créer un nouveau script avec le nom donné.
Maintenant que tu as un script, et qu’il est lié à un GameObject, tu peux modifier son code en double
cliquant dessus dans l’onglet Project pour l’ouvrir. Tu arriveras sur l’éditeur de code Visual Studio, avec
la « class » qui porte le nom de ton script et deux fonctions pré-écrites : « start » et « update ». Comme
leur nom l’indique elles vont respectivement se lancer une fois au démarrage et s’exécuter à chaque
frame du jeu.

Dans un Script, tu as la possibilité de créer des variables propres à la class, ainsi que des fonctions
qui seront utilisable depuis Start() ou Update().

Avant de te montrer comment faire, petite explication du principe de protection en c# :

Lorsque tu crées un élément (variable ou fonction par exemple) tu peux préciser le niveau de sa
protection. Il y a deux niveaux : Private et Public. Par défaut, un élément est public à moins que tu ne lui
spécifies. Un élément Private ne sera pas accessible par les autres class et ne sera pas visible dans
l’onglet Inspector d’Unity, alors qu’un élément Public sera utilisable par d’autre class et visible dans
l’onglet Inspector.

Pro-Tips : Si la protection te tient à cœur, tu peux rajouter le mot-clé [SerializeField] devant une
variable Private, de cette façon elle sera tout de même affichée dans l’onglet Inspector.
Ensuite, en c# les variables n’ont pas de types automatique, tu vas donc devoir le préciser également.
Il existe de nombreux type de variable, en voici quelques-uns :

« int » est souvent utilisé pour les nombres,

« char » est souvent utilisé pour stocker un caractère,

« String » est utilisé pour les chaînes de caractères,

« float » est utilisé pour les chiffres à virgule (en code, on utilise un point, attention),

« bool » est utilisé pour faire un booléen (true/false (vrai/faux)).

Une class est également un type. Tu auras sûrement à utiliser « GameObject » pour stocker une
référence d’une autre entité ou « NomD’unComponent » pour stocker la référence d’un Component,
porté par ce GameObject ou un autre.

Donc, pour créer une variable, tu dois : préciser sa protection, définir son type puis lui donner un nom.
Comme ceci :

Pour créer une fonction, tu vas devoir : préciser sa protection, écrire le type de la valeur qui sera
retourné à la fin de la fonction (si aucun type, utilise « void »), puis tu lui donnes un joli nom, et ensuite
viens les parenthèses. Elles servent à récupérer des arguments que tu as besoin pour l’exécution de
ta fonction. Tu peux donc, soit ne rien mettre dedans, tu ne recevras donc rien, soit demandé des
variables en écrivant sous la forme type plus nom. Tu peux en demander autant que tu veux tant que tu
sépares les variables avec des virgules.
 Input Clavier

Première étape, crée un script, genre « PlayerMovement ».

Nous avons besoin de savoir si une touche est appuyé ou non, pour ça nous allons utiliser :

Cette fonction nous renvoie true si la touche spécifiée est appuyée ou non. Pour spécifier la touche tu
dois utiliser KeyCode.[Key], ce qui donne pour Z :

Pour bouger un GameObject, nous devons utiliser son Transform.

gameObject.transform nous permet de récupérer les informations (position, rotation, et mise à

l’échelle) d’un GameObject. Dans notre cas, celui de gameObject (le GameObject actuel).

La fonction Translate(int x, int y, int z) de transform permet de déplacer le GameObject du nombre de

pixel donnée sur leur axes respectifs.

Et voilà tu as toutes les clés en main pour faire bouger ton GameObject.

Si tu as besoin d’inspiration, voici à quoi devrait ressembler ton code pour déplacer un GameObject
dans toutes les directions avec ZQSD. (En remplaçant les ? par des valeurs bien sûr)

Si tu veux plus d’information sur les inputs, suivez ce lien.

 Collision

Dans Unity tu as plusieurs types de collisions à ta disposition (Box, Sphère, …). Elles sont représentées
en vert dans l’Editeur.

Prenons pour exemple le Box Collider :

Edit Collider : te permet manuellement d’ajuster la
collision.

Is Trigger : définie si la collision est un trigger1.

Material : prend un objet Physic Material, permet de

définir comment le collider interagie avec les autres.

Center : Permet de redéfinir le centre de la collision

Size : Définie la taille de la collision

Une fois les propriétés de ta collision définie, il faut pouvoir réagir quand une collision se fait. Pour
cela Unity te met à dispositions plusieurs fonctions que tu as juste à définir.

La liste complète est dispo ici dans la catégorie Message.

Par exemple, si tu veux afficher un message à chaque collision, tu peux faire comme ça :

1Un trigger est une zone ou une entité peut entrer (contrairement à une collision classique), elle permet de lancer un
évènement quand un joueur est dans une zone par exemple.
 Instantiate
La fonction Instantiate est une fonction proposer par Unity pour pouvoir créer un GameObject lors de
l’exécution du jeu.

Cette fonction a besoin de 3 paramètres :

- Le GameObject original, c’est lui qui va être copié.

- La position, sous la forme d’un Vector 3 (x, y, z) pour les coordonnées.
- La rotation, sous la forme d’un Quaternion (x, y, z, w).

Pour l’utiliser voici un exemple :

A chaque frame je regarde si la touche A est appuyée. Si elle l’est, je vais créer un objet avec comme
modèle l’objet copy que je définis dans l’éditeur.

gameObject.transform.position permet de définir la position du nouveau GameObject à la même

position que le GameObject actuel. Et Quaternion.identity permet de créer un Quaternion par default
avec une rotation Null.
 Destroy
La fonction Destroy est encore plus simple à utiliser, il te suffit de mettre en paramètre de la fonction
l’objet que tu veux détruire.

Par exemple :

A chaque frame je regarde si la touche A est appuyée, si elle l’est je vais détruire le GameObject qui
contient le script. (Le destroy supprime le GameObject juste du jeu, pas du projet)