jeux 3D

Développez des

Unity
avec
http://www.free-livres.com/

Codes
sources

Will Goldstone
LE P R O G RAM M E U R

Développez des jeux 3D

avec Unity
Will Goldstone

Traduit par Philippe Beaudran,

avec la contribution technique de Nicolas Colliot,
responsable développement chez Yamago
Pearson Education France a apporté le plus grand soin à la réalisation de ce livre ain de vous fournir
une information complète et iable. Cependant, Pearson Education France n’assume de responsa-
bilités, ni pour son utilisation, ni pour les contrefaçons de brevets ou atteintes aux droits de tierces
personnes qui pourraient résulter de cette utilisation.

Les exemples ou les programmes présents dans cet ouvrage sont fournis pour illustrer les descrip-
tions théoriques. Ils ne sont en aucun cas destinés à une utilisation commerciale ou professionnelle.

Pearson Education France ne pourra en aucun cas être tenu pour responsable des préjudices
ou  dommages de quelque nature que ce soit pouvant résulter de l’utilisation de ces exemples ou
programmes.

Tous les noms de produits ou marques cités dans ce livre sont des marques déposées par leurs
propriétaires respectifs.

Publié par Pearson Education France Titre original :

47 bis, rue des Vinaigriers Unity Game Development Essentials
75010 PARIS
Tél. : 01 72 74 90 00 Traduit de l’anglais par Philippe Beaudran
www.pearson.fr avec la contribution technique de Nicolas Colliot

Mise en pages : TyPAO ISBN original : 978-1-847198-18-1

Copyright original : © 2009 Packt Publishing
ISBN : 978-2-7440-4141-9 All rights reserved
Copyright © 2010 Pearson Education France
Tous droits réservés Édition originale publiée par
Packt Publishing Ltd
32 Lincoln Road, Olton
Birmingham, B27 6PA, UK
www.packtpub.com

Aucune représentation ou reproduction, même partielle, autre que celles prévues à l’article L. 122-5 2˚ et 3˚ a) du code de la
propriété intellectuelle ne peut être faite sans l’autorisation expresse de Pearson Education France ou, le cas échéant, sans le
respect des modalités prévues à l’article L. 122-10 dudit code.

No part of this book shall be reproduced, stored in a retrieval system, or transmitted by any means, electronic, mechanical,
photocopying, recording, or otherwise, without written permission from the publisher.
 Table des matières

Préface ................................................................ 1 2. Environnements............................................. 21

Les logiciels de modélisation externes ............. 22
1. Bienvenue dans la troisième dimension....... 7
Les ressources .................................................. 22
Comprendre la 3D .......................................... 7 Votre premier projet Unity ............................. 23
Les coordonnées ............................................... 8 L’éditeur de terrain ......................................... 24
L’espace local et l’espace global ..................... 8 Les fonctionnalités du menu Terrain ................ 24
Les vecteurs ...................................................... 9 Les outils de terrain ......................................... 28
Soleil, mer et sable : la création de l’île .......... 35
Les caméras...................................................... 9
Importer des modèles ....................................... 55
Les polygones, les arêtes, les sommets
Le paramétrage du modèle d’avant-poste........ 59
et les maillages ................................................. 10
En résumé....................................................... 61
Les matériaux, les textures et les shaders ........ 10
3. Personnages jouables .................................... 63
La physique des corps rigides .......................... 11
Le panneau Inspector ..................................... 64
La détection de collision .................................. 12
Les tags ............................................................ 65
Les concepts essentiels de Unity.................... 12 Les calques (layers) ......................................... 66
Le fonctionnement de Unity ............................. 13 Les éléments préfabriqués dans le panneau
L’interface ...................................................... 16 Inspector ........................................................... 67
L’objet First Person Controller en détail ........ 67
Les panneaux Scene et Hierarchy .................... 17
Les relations parent-enfant ............................. 68
Le panneau Inspector ....................................... 18
Les objets de First Person Controller .............. 69
Le panneau Project........................................... 19
Objet 1. L’objet First Person Controller (parent) 70
Le panneau Game ............................................ 19 Objet 2. L’objet Graphics ................................. 74
En résumé....................................................... 20 Objet 3. L’objet Main Camera ......................... 76
IV Développez des jeux 3D avec Unity

Les bases de la programmation ...................... 79 Restreindre l’accès à l’avant-poste ................ 144

Le script FPSWalker ...................................... 89 Restreindre l’accès ........................................... 145
Lancer le script ................................................ 89 La commande GetComponent() ....................... 146
Le script en détail............................................. 91 Des indices pour le joueur ............................... 147
En résumé....................................................... 97 En résumé....................................................... 153

4. Interactions .................................................... 99 6. Instanciation et corps rigides ....................... 155

Les collisions ................................................. 100 Présentation de l’instanciation ....................... 156

Le raycasting .................................................. 101 Le concept ........................................................ 156

L’image manquante .......................................... 102 Le script............................................................ 157

La détection de collision a priori...................... 103 Présentation des corps rigides ........................ 158

L’ajout de l’avant-poste.................................. 104 Les forces ......................................................... 159

Le composant Rigidbody ................................. 159
Positionner le modèle ....................................... 105
Redimensionner le modèle ............................... 106 Créer le mini-jeu ............................................ 160

Colliders et tag de la porte............................... 106 Créer l’élément préfabriqué

pour la noix de coco ......................................... 160
Désactiver l’animation automatique................ 109
Créer l’objet Launcher ..................................... 163
L’ouverture de la porte ................................... 110
Le script du lancer de noix de coco ................. 165
Méthode 1. La détection de collision ............... 110
Assigner le script et les variables .................... 170
Méthode 2. Le raycasting ................................. 124
Restrictions de l’instanciation ......................... 172
En résumé....................................................... 126
Ajouter la plate-forme ...................................... 176
5. Éléments préfabriqués, collections Gagner la partie ............................................... 183
et HUD................................................................ 129 La touche inale ................................................ 186
La création de l’élément En résumé....................................................... 189
préfabriqué batterie ........................................ 130
7. Systèmes de particules .................................. 191
Télécharger, importer et positionner ................ 130
Qu’est-ce qu’un système de particules ?........ 192
Ajouter un tag................................................... 131
Échelle, collider et rotation .............................. 132 L’émetteur de particules .................................. 192

Enregistrer comme élément préfabriqué .......... 133 L’animateur de particule.................................. 193

Le rendu des particules .................................... 193
Disperser les batteries .................................... 134
Le but du jeu .................................................. 195
L’afichage d’une interface graphique
pour la pile ..................................................... 135 Télécharger les ressources ............................... 195

Créer l’objet GUI Texture ................................ 136 Ajouter le tas de bois........................................ 196

Positionner l’objet GUI Texture ....................... 137 Créer les systèmes de particules pour le feu .... 197

Modiier l’interface graphique Allumer le feu ................................................... 206

à l’aide d’un script ........................................... 139 Tests et conirmation ...................................... 210
La collecte des piles avec des déclencheurs... 142 En résumé....................................................... 211
 Table des matières V

8. Conception de menus .................................... 213 Animer le texte avec l’interpolation linéaire.... 252
Les interfaces et les menus ............................ 214 Revenir au menu............................................... 255
Créer le menu principal ................................... 215 L’apparition en fondu
La création du menu – méthode 1 .................. 220 de la scène Island Level ................................. 258

Ajouter le bouton Play/Jouer ........................... 220 Le rendu de la texture UnityGUI ..................... 259

Ajouter le bouton des instructions ................... 224 Notiier la in du jeu ....................................... 260
Ajouter le bouton Quit/Quitter ......................... 224 En résumé....................................................... 261
Utiliser les commandes de débogage
10. Compilation et partage ............................... 263
pour vériier les scripts .................................... 226
Les paramètres Build Settings ....................... 264
La création du menu – méthode 2 .................. 227
Désactiver les Game Objects ........................... 227 L’option Web Player......................................... 265

Rédiger un script OnGUI() L’option Web Player Streamed ........................ 266

pour un menu simple ........................................ 228 L’option OS X Dashboard Widget ................... 267
L’heure des décisions ....................................... 237 Les options OS X/Windows Standalone............ 268
En résumé....................................................... 238 Générer le jeu ................................................. 268
Adapter les paramètres pour le Web ................ 268
9. Dernières retouches....................................... 239
La compression des textures et le débogage .... 271
Le volcan ........................................................ 240
Créer une version autonome ............................ 271
Positionner le système de particules ................ 240
Compiler pour le Web....................................... 274
Importer les ressources .................................... 242
Les paramètres de qualité............................... 275
Créer un matériau pour la fumée ..................... 243
Les paramètres d’entrée du lecteur ................ 278
Les paramètres du système de particules ........ 243
Ajouter le son du volcan................................... 245 Diffuser votre création ................................... 280

Tester le volcan ................................................ 246 En résumé....................................................... 280

Traînées de lumière ........................................ 246
11. Procédures de tests
Modiier l’élément préfabriqué ........................ 246 et lectures complémentaires ............................. 281
Le composant Trail Renderer ........................... 247 Les tests et la inalisation ............................... 282
Mettre à jour l’élément préfabriqué ................. 249
Les tests publics ............................................... 282
L’amélioration des performances ................... 249
Les méthodes d’apprentissage ....................... 286
Modiier la distance du rendu des objets
Couvrir le plus de bases possible..................... 286
et ajouter du brouillard .................................... 249
Ne pas hésiter à demander de l’aide................ 287
La lumière ambiante ........................................ 250
En résumé....................................................... 288
La scène Instructions...................................... 251
Ajouter du texte à l’écran ................................. 251 Index ................................................................... 289
À propos de l’auteur
Will Goldstone est concepteur et formateur dans le domaine de l’interactivité et vit dans
le Sud-Ouest de l’Angleterre. Il passe beaucoup de temps en ligne à concevoir des sites
web et développer des jeux, mais également à proposer des formations en ligne dans de
nombreuses disciplines liées à l’interactivité.
Ayant découvert Unity dans sa première version, il s’emploie depuis à promouvoir le
concept de «développement de jeux accessible à tous». Il utilise Unity pour créer des jeux
destinés au web et à l’iPhone d’Apple.
Vous pouvez contacter Will Goldstone par le biais de son blog – www.willgoldstone.com
–, sur lequel vous en apprendrez plus sur ces différentes activités en ligne. Il consacre son
temps libre à la conception graphique, à écrire de la musique et à jouer au frisbee sur la
plage.
Je voudrais remercier ma famille et mes amis pour leur soutien durant la réalisation de
cet ouvrage, qui n’existerait pas sans eux. Je remercie également les membres de l’équipe
Unity Technologies et les participants au canal IRC Unity pour leur patience lorsque j’ai
commencé à m’intéresser au développement dans Unity. Un grand merci à Dan Blacker,
Joachim Ante, Emil Johansen, Cliff Peters, Tom Higgins, Charles Hinshaw, Neil Carter,
ToreTank, Mike Mac, Duckets, Joe Robins, Daniel Brauer, Dock, oPless, Thomas Lund,
Digitalos et à tous ceux que j’oublie.
Préface
Unity est un outil de création 3D pour Mac  OS et Windows. Les moteurs de jeux sont
les mécanismes qui fonctionnent en coulisse de tous les jeux vidéo. Ce "moteur" prend les
décisions, qu’il s’agisse des graphismes ou des mathématiques qui régissent chaque image
à l’écran. À  partir du rendu – l’afichage des graphismes à l’écran, l’intégration d’une
méthode de contrôle et d’un ensemble de règles à suivre pour le jeu –, les développeurs
s’appuient sur le moteur pour "construire" le jeu. Les moteurs de jeu 3D actuels reposent
sur une quantité impressionnante de code méticuleusement écrit. C’est pourquoi ils sont
souvent revendus, modiiés et réutilisés, une fois que le jeu pour lequel ils ont été créés
est terminé. Le moteur Unreal Engine d’Epic Games en est un bon exemple. Développé à
l’origine, à la in des années 90 pour Unreal – un jeu de tir à la première personne (FPS) –,
il a ensuite été réutilisé sous licence par d’autres développeurs et a connu un énorme succès
dans des centaines de simulations et de jeux commerciaux plus récents.
En raison du niveau de complexité et du coût que représente la création de tels moteurs de
jeu commerciaux, il est très dificile de se lancer dans l’industrie du jeu vidéo sans étudier
en profondeur les langages de programmation comme le C++. En effet, les jeux sur console
et ordinateur sont construits autour du C++ car il s’agit du langage le plus eficace en termes
de rapidité de calcul actuellement, et que la structure et les commandes des moteurs de jeux
commerciaux exigent des milliers et des milliers de ces lignes de code pour fonctionner.
Le code de Unity utilise la compilation juste-à-temps (JIT, Just In Time) et la bibliothèque
C++ Mono (libre de droits et d’accès au code source). Grâce à la compilation JIT, le code
écrit pour Unity est compilé par Mono juste avant son exécution. C’est essentiel pour les
jeux qui doivent exécuter du code à des moments précis. En plus de la bibliothèque Mono,
les fonctionnalités Unity tirent également parti d’autres bibliothèques logicielles, comme le
moteur physique PhysX de Nvidia, OpenGL et DirectX pour le rendu 3D et OpenAL pour
l’audio. Toutes ces bibliothèques sont intégrées à l’application, si bien que vous n’aurez pas
besoin d’apprendre à utiliser chacune d’entre elles ; il vous sufit d’apprécier ce qu’elles
vous permettent de réaliser en toute transparence dans Unity.
Les développeurs de moteurs de jeux construisent également des outils pour commander
les fonctions de code qu’ils ont créées. Par exemple, un ensemble d’instructions déinit la
forme (ou topographie) d'un terrain, son aspect visuel, et même la façon dont sont gérées
ses déformations dans le jeu. Mais cet ensemble d’instructions serait ineficace en tant
qu’élément du moteur de jeu s’il n’était pas relié à un outil visuel permettant de contrô-
ler ces propriétés. Souvent, les développeurs de moteur de jeu créent donc une interface
2 Développez des jeux 3D avec Unity

graphique (GUI, Graphical User Interface) ain que les membres de l’équipe de déve-
loppement du jeu puissent plus facilement manipuler les éléments du moteur. Ces outils
facilitent non seulement le processus de création du jeu mais rendent également le moteur
accessible aux acheteurs potentiels et aux équipes de postproduction. Cela est également
vrai pour Unity, et une très importante communauté d’utilisateurs partage ses outils sous
forme de plugins. Pour en savoir plus, visitez le wiki de la communauté Unify à l’adresse :
http://www.unifycommunity.com/wiki.
Beaucoup de personnes tentées par le développement se heurtent à la dificulté d’apprendre
les langages de programmation comme C++ et les moteurs qui l’utilisent. Si on n’a pas
suivi des études de programmation ou d’animation par ordinateur, il est en effet dificile de
se lancer dans l’apprentissage des concepts, des méthodes et des principes de conception
nécessaires à la production de jeux vidéo. Unity Technologies est une des entreprises qui
a décidé de rectiier cette situation. Après avoir créé son propre moteur de jeu en 2001,
cette société de développement de jeux danoise a cherché à rendre ses outils abordables en
offrant une solution simple axée sur l’utilisateur que tout le monde puisse utiliser. L’équipe
a choisi de conserver le code source qui alimente le moteur dans les coulisses et de fournir
une interface graphique complète ain que l’utilisateur puisse contrôler le code source de
ce puissant moteur sans jamais avoir à créer lui-même de nouveaux éléments dans celui-ci.
Ce facteur a rendu Unity très populaire auprès des nouveaux développeurs et explique
probablement pourquoi vous lisez cet ouvrage. En déinissant des concepts logiques et en
regroupant par catégorie les méthodes communes utilisées pour produire des jeux, Unity
met la puissance de son moteur au service de l’utilisateur, lui permettant d’obtenir un maxi-
mum de résultats avec un minimum d’efforts, ain qu’il se concentre sur le facteur le plus
crucial de tous : le gameplay (la jouabilité).
En attirant de nombreux développeurs de jeux, Unity a comblé un vide sur le marché du
développement des jeux vidéo, ce que peu d’éditeurs peuvent prétendre. Unity est en effet
l’un des moteurs de jeux les plus dynamiques de son secteur car il permet de produire des
jeux 3D professionnels aussi bien sur Mac, sur PC ou sur le Web. Comme le moteur existe
également dans des versions destinées à la Nintendo Wii et à l’iPhone d’Apple, il offre un
accès au marché des ordinateurs mais aussi à celui des consoles et des mobiles une fois que
vous maîtrisez les bases.
L’évolution rapide de l’industrie du divertissement et du marketing nécessite que les jeux
soient produits rapidement. Aussi, de nombreuses entreprises se tournent vers des solutions
intégrées comme Unity pour que leurs créateurs sortent de meilleurs produits le plus facile-
ment possible. Depuis la sortie en 2009 de la version 2.5 et ses premiers pas sous Windows,
Unity est de plus en plus utilisé. Mais qu’est-ce que Unity ? Comment fonctionne-t-il ? Que
peut-il réaliser ? Et surtout, comment ce programme permet-il de développer des jeux 3D
en seulement quelques semaines ?
 Préface 3

Le contenu de cet ouvrage

Ce livre est conçu pour couvrir un ensemble d’exemples faciles à suivre, qui culminent dans
la production d’un jeu de tir à la première personne (FPS) en 3D dans un environnement
interactif (une île). En abordant les concepts communs aux jeux et à la production 3D, vous
allez voir comment utiliser Unity pour créer un personnage jouable qui interagit avec le
monde du jeu et comment réaliser des énigmes que le joueur devra résoudre pour terminer
la partie.
Voici un aperçu, chapitre par chapitre, des thèmes abordés :
∑ Chapitre 1. Bienvenue dans la troisième dimension. Ce chapitre couvre les concepts
clés que vous aurez besoin de comprendre pour compléter l’exercice de ce livre.
Il présente rapidement les concepts 3D et les processus utilisés par Unity pour créer des
jeux.
∑ Chapitre 2. Environnements. Votre monde virtuel est, à l’origine, totalement vide !
Vous allez donc commencer par étudier les différentes manières d’intégrer des terrains,
d’importer des modèles  3D créés en dehors de Unity. Vous découvrirez également
comment utiliser d’autres fonctionnalités du moteur Unity comme le son et les lumières
ain de déinir l’environnement du jeu et de le rendre fonctionnel.
∑ Chapitre 3. Personnages jouables. Chaque jeu a besoin d’un héros, n’est-ce pas ? Au
cours de ce chapitre, vous étudierez chacun des éléments qui constituent le personnage
incarné par le joueur, depuis les contrôles d’entrée en passant par les caméras et la
gestion des collisions. Une fois que vous aurez appris de quoi est formé le personnage
du joueur, vous l’intégrerez dans l’environnement du jeu et vous effectuerez une petite
promenade sur votre île.
∑ Chapitre 4. Interactions. Les jeux vidéo reposent avant tout sur les interactions dans
le monde virtuel. Que serait un personnage jouable s’il ne pouvait effectuer aucune
action ? Nous présenterons donc ici la détection de collision et le raycasting. Vous verrez
comment combiner ces techniques avec du code et des animations pour transformer votre
création statique en éléments qui réagissent aux actions du joueur.
∑ Chapitre 5. Éléments préfabriqués, collections et HUD. Il est essentiel de donner au
joueur un sentiment d’accomplissement dans le jeu. Pour cela, vous aurez besoin de lui
rappeler les actions qu’il a effectuées et de lui donner un but à atteindre. Pour cela, vous
créerez un système d’afichage tête haute ou HUD (Heads Up Display). Autrement dit,
vous apprendrez comment aficher du texte et des illustrations qui changent dynami-
quement au cours du jeu.
Vous réaliserez ensuite un mini-jeu de collecte d’objets, dans lequel le personnage du
joueur devra ramasser des piles pour pouvoir entrer dans un bâtiment de l’île.
4 Développez des jeux 3D avec Unity

∑ Chapitre 6. Instanciation et corps rigides. Presque tous les scénarios de jeu que vous
pouvez imaginer imposent de créer ou de "reproduire" des objets dans l’environnement.
Il est essentiel pour tous les développeurs débutants de connaître et de savoir utiliser
cette notion, appelée instanciation en programmation, qui consiste à créer des objets
lors de l’exécution du jeu.
Vous verrez comment améliorer l’interactivité de votre jeu en créant un jeu de tir simple ;
en lançant des objets sur des cibles, le joueur pourra débloquer une partie de l’envi-
ronnement. Vous découvrirez ainsi non seulement l’instanciation, mais aussi comment
utiliser les corps rigides.
∑ Chapitre 7. Systèmes de particules. De nos jours, un jeu en 3D doit impérativement
proposer quelques effets visuels intéressants pour attirer le joueur. Dans ce dessein,
vous créerez un feu de bois pour que le personnage du jeu se réchauffe. Pour cela, vous
utiliserez deux systèmes de particules, l’un pour les lammes et l’autre pour la fumée.
Vous verrez comment les systèmes de particules permettent d’imiter le comportement
d’un feu et comment rendre chaque particule réaliste en utilisant des images. Enin,
vous éteindrez ce feu ain de donner un objectif au joueur : l’allumer pour ne pas périr
de froid !
∑ Chapitre 8. Conception de menus. Pour qu’un jeu soit agréable, ses menus doivent
avoir un aspect professionnel et être faciles à utiliser. Qui voudrait d’un jeu dont le
bouton Démarrer est impossible à trouver ? Ce chapitre abordera les différentes façons
de créer des menus et d’autres interfaces utilisateur avec lesquelles le joueur pourra
interagir.
Vous élaborerez des menus en utilisant à la fois les textures GUI et la classe GUI ain
de créer des interfaces redimensionnables qui puissent être utilisées aussi bien dans les
jeux destinés au Web que dans les applications autonomes.
∑ Chapitre  9. Dernières retouches. Lorsque vous réalisez un jeu, en particulier dans
Unity, il arrive un moment où vous créez un élément interactif dont vous êtes si ier que
vous souhaitez lui ajouter une touche supplémentaire pour le mettre en valeur.
Au il de ce chapitre, nous détaillerons l’utilisation du son, les effets de lumière, le rendu
des traînées lumineuses et d’autres effets dynamiques simples à implémenter, ain de
transformer votre simple jeu fonctionnel en produit ini.
∑ Chapitre 10. Compilation et partage. Vous verrez comment exporter votre jeu pour le
Web et en tant que projet autonome. Nous étudierons les différents réglages dont vous
devez tenir compte lorsque vous préparez le produit ini, comme la qualité graphique,
les commandes de contrôles, et plus encore.
 Préface 5

∑ Chapitre 11. Procédures de tests et lectures complémentaires. Vous verrez comment

continuer votre apprentissage au-delà de cet ouvrage et comment recueillir des informa-
tions auprès des testeurs pour améliorer votre jeu. Nous vous aiderons à préparer votre
projet pour qu’il soit testé par un large public ain de recueillir des avis et des commen-
taires et produire des jeux encore meilleurs !

Ce dont vous avez besoin

Pour réaliser les exercices de cet ouvrage, il vous faut :
∑ Une copie installée du logiciel Unity (une version d’essai est disponible sur le site
Unity3D.com).
∑ Une connexion Internet ain de télécharger des modèles 3D et des ressources depuis la
page dédiée à cet ouvrage sur le site de Pearson (http://www.pearson.fr).
∑ Un ou plusieurs logiciels de modélisation 3D, bien que cela ne soit pas obligatoire. Tous
les matériaux utilisés sont fournis. Si vous débutez dans le domaine de la modélisation,
vous pouvez télécharger une application gratuite compatible avec Unity comme Blender
sur le site Blender.org.

À qui s’adresse cet ouvrage

Formateur sur Unity depuis plusieurs années, j’ai découvert que le principal grief de ses
utilisateurs ne portait pas sur le logiciel lui-même, mais plutôt sur le manque de didacticiels
destinés aux novices ne possédant pas une formation en programmation.
Dans le contexte actuel, cette situation est rare, bien sûr, mais un outil comme Unity, qui
facilite autant la production, accroît l’urgence d’un tel guide didacticiel.
Si vous êtes un concepteur ou un animateur qui souhaite faire ses premiers pas dans le
développement de jeux vidéo, ou si vous avez tout simplement passé de nombreuses heures
assis devant des jeux vidéo et que vous fourmilliez d’idées, Unity et ce livre pourraient
constituer le point de départ idéal. Nous supposons que vous n’avez aucune connaissance
en production de jeux vidéo et nous vous expliquons tout depuis le commencement. Nous
vous demandons simplement d’être passionné et de vouloir réaliser de grands jeux.
6 Développez des jeux 3D avec Unity

Conventions typographiques
Cet ouvrage utilise plusieurs styles de texte ain d’établir une distinction entre les diffé-
rents types d’informations. En voici quelques exemples ainsi qu’une explication de leur
signiication.
Le code qui apparaît dans le corps du texte est présenté de la manière suivante : "Nous
pouvons inclure d’autres contextes, par l’utilisation de la directive include".
Voici un exemple de bloc de code :
if(collisionInfo.gameObject.name == "matchbox"){
Destroy(collisionInfo.gameObject);
haveMatches=true;
audio.PlayOneShot(batteryCollect);

Les nouveaux termes et les mots importants sont en italiques. Les mots afichés à l’écran,
dans les menus ou les boîtes de dialogue, par exemple, seront en petites capitales comme
ceci : "Cliquez sur le bouton Suivant pour passer à l’écran suivant."
Dans la notation des raccourcis clavier, la première variante est toujours pour Mac OS, la
seconde pour Windows. Appuyez sur Entrée/F2 signiie donc Entrée sur Mac OS et F2 sur
Windows.

Codes sources en ligne

Les ichiers des exemples de code ainsi que les instructions permettant de les utiliser sont
disponibles depuis le site Pearson (http://www.pearson.fr) en suivant le lien "Codes
sources" à la page consacrée à cet ouvrage.
 1
Bienvenue dans
la troisième dimension
Avant de commencer à utiliser un programme 3D, vous devez impérativement comprendre
l’environnement dans lequel vous allez travailler. Comme Unity est avant tout un outil de
développement 3D, beaucoup de notions développées dans ce livre demandent que vous
compreniez en quoi consistent le développement 3D et les moteurs de jeux. Il est essentiel
de cerner ces notions avant d’aborder les questions pratiques des chapitres suivants.

Comprendre la 3D
Étudions les principaux éléments des mondes 3D et la façon dont Unity permet de développer
des jeux en trois dimensions.
8 Développez des jeux 3D avec Unity

Les coordonnées
Si vous avez déjà travaillé avec un programme d’illustration  3D auparavant, la notion
d’axe Z vous est probablement familière. L’axe Z représente la profondeur et s’ajoute aux
axes X, pour le plan horizontal, et Y, pour le plan vertical. Dans les applications 3D, les
informations sur les objets sont indiquées selon un système de coordonnées cartésiennes,
autrement dit au format X, Y, Z. Les dimensions, les valeurs de rotation et les positions
dans le monde 3D peuvent toutes être décrites de cette façon. Dans ce livre, comme dans
d’autres documents concernant la 3D, ces informations sont écrites entre parenthèses, de
la manière suivante :
(10, 15, 10)
Cette écriture s’explique principalement pour des raisons de clarté, mais aussi parce que ces
valeurs doivent être écrites de cette façon dans le code. Indépendamment de leur présen-
tation, vous pouvez partir du principe que tout ensemble de trois valeurs séparées par des
virgules est présenté dans l’ordre X, Y, Z.

L’espace local et l’espace global

La différence entre l’espace local et l’espace global est une notion essentielle. Dans
tout  logiciel  3D, le monde virtuel est techniquement inini, si bien que cela peut être
dificile de garder une trace de l’emplacement des objets qu’il contient. Dans tous les
univers 3D, il existe un point d’origine, aussi dénommé zéro, et représenté par les coor-
données (0, 0, 0).
Toutes les coordonnées des objets 3D sont relatives à l’origine globale. Cependant, pour
rendre les choses plus simples, on utilise également l’espace local (également appelé espace
de l’objet) pour déinir la position des objets les uns par rapport aux autres (voir Figure 1.1).
L’espace local suppose que chaque objet possède sa propre origine, qui correspond à celle
de ses poignées d’axes – il s’agit généralement du centre de l’objet. En créant des relations
entre les objets, on peut alors comparer leurs positions les uns par rapport aux autres. Ces
relations, appelées relations parent-enfant, permettent de calculer les distances entre les
objets en utilisant l’espace local, la position de l’objet parent devenant la nouvelle origine
pour chacun de ses objets enfants. Pour en savoir plus sur les relations parent-enfant, reportez-
vous au Chapitre 3, "Personnages jouables".
Chapitre 1 Bienvenue dans la troisième dimension 9

Figure 1.1 Y

Y Z

L'espace local
(de l'objet)
Z

L'espace global X

Les vecteurs
Vous verrez également des vecteurs 3D décrits en coordonnées cartésiennes. Comme leurs
homologues 2D, ce sont simplement des lignes tracées dans le monde en 3D qui possèdent
une direction et une longueur. Les vecteurs peuvent être déplacés dans l’espace global
mais restent inchangés. Ils sont utiles dans le contexte d’un moteur de jeu, car ils permet-
tent de calculer la direction des objets ainsi que les distances et les angles relatifs entre les
objets.

Les caméras
Les caméras sont essentielles dans le monde 3D, car elles offrent un point de vue sur ce qui
s’afiche à l’écran. Leur champ de vision ayant une forme de pyramide, elles peuvent être
disposées à n’importe quel point dans le monde, être animées ou attachées à des person-
nages ou des objets comme éléments du scénario d’un jeu.
Les caméras 3D ont un champ de vision (FOV, Field of Vision) réglable et offrent un point
de vue sur le monde  3D. Dans les moteurs de jeu, vous remarquerez que les effets de
lumière, les lous de mouvement et les autres effets sont appliqués à la caméra pour simuler
la vision de l’œil humain sur le monde du jeu – vous pouvez même ajouter quelques effets
cinématographiques, comme les effets de rélexion du soleil sur l’objectif.
La plupart des jeux 3D modernes utilisent plusieurs caméras pour montrer certaines parties
du monde du jeu que la caméra attachée au personnage n’est pas en train d’examiner –
comme un "cut", pour reprendre un terme cinématographique. Dans Unity, il est possible
d’utiliser plusieurs caméras dans une seule scène et de les contrôler à l’aide du code, pour
que chacune d’elles devienne à tout moment la caméra principale lors de l’exécution du jeu.
10 Développez des jeux 3D avec Unity

Plusieurs caméras peuvent aussi être utilisées dans un jeu pour contrôler séparément le
rendu de certains éléments 2D et 3D lors du processus d’optimisation. Vous pouvez, par
exemple, regrouper des objets sur des calques puis paramétrer les caméras ain qu’elles
procèdent uniquement au rendu des objets sur certains calques. Vous contrôlez mieux ainsi
les rendus individuels de certains éléments dans le jeu.

Les polygones, les arêtes, les sommets et les maillages

Tous les objets 3D se composent de formes 2D interconnectées appelées polygones.
Lorsque vous importez des modèles créés dans un programme de modélisation, Unity
convertit tous les polygones en polygones triangles (appelés également faces), qui sont,
à leur tour, formés de trois arêtes connectées. Les points de jonction des arêtes sont appe-
lés points ou sommets. Quand les moteurs de jeux connaissent ces sommets, ils peuvent
effectuer des calculs sur les points d’impact, connus sous le nom de collisions, en utilisant
une détection de collision complexe grâce aux Mesh Colliders (selon le maillage même
de l’objet), comme dans les jeux de tir pour détecter l’emplacement exact où une balle a
touché un autre objet. En combinant beaucoup de polygones reliés entre eux, les applica-
tions de modélisation 3D permettent de construire des formes complexes, les maillages.
Outre la construction de formes en 3D, les données stockées dans les maillages ont de
nombreuses autres utilisations, par exemple être utilisées comme surfaces sur lesquelles les
objets peuvent se déplacer, en suivant les sommets.
Il est crucial que le développeur d’un projet de jeu comprenne l’importance du décompte
de polygones. Cette quantité de polygones indique le nombre total de polygones utilisés
par un modèle mais aussi dans un niveau de jeu entier. Plus ce nombre est élevé et plus l’or-
dinateur est sollicité pour procéder au rendu des objets à l’écran. Cela explique pourquoi
le niveau de détail a augmenté au cours des dix dernières années, depuis les premiers jeux
en 3D à ceux d’aujourd’hui – il sufit pour s’en convaincre de comparer visuellement les
jeux Quake d’Id Software (1996) de Gears Of War d’Epic Games (2006). Grâce à l’amé-
lioration des technologies, les développeurs de jeux peuvent maintenant utiliser un nombre
beaucoup plus élevé de polygones pour les personnages et les mondes 3D de leurs jeux.
Et il n’existe aucune raison que cette tendance s’inverse.

Les matériaux, les textures et les shaders

Les matériaux sont un concept commun à toutes les applications  3D. Ils fournissent le
moyen de déinir l’apparence visuelle d’un modèle 3D. Ils gèrent tout, des couleurs de base
aux surfaces réléchissantes constituées d’images.
À partir d’une simple couleur et de la possibilité d’utiliser une ou plusieurs images – connues
sous le nom de textures – dans un seul matériau, celui-ci fonctionne avec le shader, qui est
Chapitre 1 Bienvenue dans la troisième dimension 11

un script chargé du style de rendu. Avec un shader de rélexion, par exemple, le rendu du
matériau réléchira les objets environnants tout en conservant sa couleur ou l’apparence de
l’image qui lui est appliquée comme texture.
Dans Unity, les matériaux sont simples à utiliser. Tous les matériaux créés dans votre logi-
ciel de modélisation 3D seront importés et recréés automatiquement par le moteur de Unity,
en tant que ressources que vous pouvez ensuite utiliser. Vous pouvez également créer vos
propres matériaux à partir de zéro, en déinissant des images comme ichiers de texture
et en sélectionnant un shader dans une grande bibliothèque intégrée. Vous pouvez aussi
rédiger vos propres scripts de shader ou implémenter ceux écrits par des membres de la
communauté Unity, ce qui vous offre une plus grande liberté par rapport aux éléments
fournis.
Fondamentalement, lors de la création de textures pour un jeu dans un logiciel graphique
comme Photoshop, vous devez être conscient de la résolution. Les textures d’un jeu doivent
être de forme carrée et leurs dimensions des puissances de  2. Autrement dit, elles
doivent avoir les dimensions suivantes :
∑ 128 × 128
∑ 256 × 256
∑ 512 × 512
∑ 1 024 × 1 024
Le moteur du jeu pourra utiliser des textures de ces dimensions comme tiles – les juxta-
poser pour former une surface. Vous devez également tenir compte de la taille du ichier de
texture, car ses dimensions ont un impact direct sur la puissance de traitement exigée par
l’ordinateur du joueur. Par conséquent, pensez toujours à donner à vos illustrations la plus
petite taille 2D possible, sans trop sacriier à la qualité.

La physique des corps rigides

Pour les développeurs de moteurs de jeux, le moteur physique constitue un moyen de simu-
ler les conditions du monde réel pour les objets dans les jeux. Dans Unity, le moteur du jeu
utilise PhysX de Nvidia, un moteur physique commercial très employé et très précis.
Dans les moteurs de jeux, un objet n’est pas soumis aux lois de la physique par défaut. La
raison en est que cela exigerait beaucoup de puissance de calcul, mais aussi parce qu’il
est inutile d’utiliser le moteur physique sur tous les objets. Dans un jeu de voitures en
3D, par exemple, il est logique que les voitures soient soumises à l’inluence du moteur
physique, mais il n’y a aucune raison que cela soit le cas de la piste ou des objets environ-
nants, comme les arbres, les murs, etc. C’est pourquoi vous devez assigner un composant
12 Développez des jeux 3D avec Unity

RigidBody (corps rigide) à chaque objet que le moteur physique doit contrôler lors de la
création du jeu.
Les moteurs physiques des jeux utilisent le système dynamique des corps rigides pour créer
un mouvement réaliste. Ainsi, au lieu d’être de simples objets statiques dans le monde en
3D, ils peuvent posséder les propriétés suivantes :
∑ Masse
∑ Gravité
∑ Vélocité
∑ Friction
Comme la puissance du matériel et des logiciels augmente, la physique des corps rigides,
qui permet des simulations variées et réalistes, est de plus en plus largement utilisée dans
les jeux (voir Chapitre 6, "L’instanciation et les corps rigides").

La détection de collision
Plus cruciale dans les moteurs de jeu que dans l’animation 3D, la détection de collision est
la façon d’analyser le monde 3D pour les collisions entre objets. En donnant un composant
Collider (composant de collision) à un objet, on place effectivement un ilet invisible
autour de ce dernier. Ce ilet imite la forme de l’objet et il est chargé de signaler toute
collision avec d’autres colliders ain que le moteur de jeu réagisse en conséquence. Dans
un jeu de bowling, par exemple, un simple collider sphérique entoure la boule, tandis que
les quilles ont soit un collider simple en forme de capsule, soit un Mesh Collider (un
composant de collision respectant le maillage de l’objet) pour une collision plus réaliste.
Au moment de l’impact, les colliders de tous les objets touchés envoient un rapport au
moteur physique qui leur dicte leur réaction en fonction de l’orientation de l’impact, de la
vitesse et d’autres facteurs.
Dans cet exemple, si on emploie un Mesh Collider qui suit exactement à la forme de la
quille, le résultat est plus précis mais aussi plus coûteux en termes de calcul. Autrement dit,
la puissance de calcul demandée à l’ordinateur est plus importante, ce qui se traduit par une
baisse des performances – d’où le terme coûteux.

Les concepts essentiels de Unity

Unity simpliie le processus de production d’un jeu en proposant une série d’étapes
logiques pour construire tous les scénarios de jeu que vous pouvez imaginer. Unity n’est
pas spéciique d’un type de jeu  ; le programme offre un canevas vierge et un ensemble
Chapitre 1 Bienvenue dans la troisième dimension 13

de procédures cohérentes ain que votre imagination soit la seule limite à votre créativité.
Grâce au concept de Game Object (GO), vous pouvez scinder les éléments du jeu en objets
faciles à gérer, constitués de nombreux composants individuels. En individualisant chaque
objet dans le jeu, puis en lui ajoutant des composants pour le rendre fonctionnel, vous êtes
en mesure d’étendre votre jeu à l’inini d’une manière progressive et logique. Les compo-
sants possèdent des variables – pour l’essentiel des paramètres permettant de les contrôler.
En ajustant ces variables, vous contrôlez totalement l’effet que ce composant a sur votre
objet. Prenons un exemple simple.

Le fonctionnement de Unity
Pour intégrer une balle qui rebondit dans le cadre d’un jeu, par exemple, on commence
par créer une sphère, ce qui peut rapidement être réalisé à partir des menus de Unity. On
obtient alors un nouveau Game Object possédant un maillage en forme de sphère (un ilet
de forme 3D) et un composant Renderer (de rendu) pour qu’il soit visible. On peut ensuite
ajouter un corps rigide (composant Rigidbody) pour indiquer à Unity que l’objet doit utiliser
le moteur physique. Ce composant intègre les propriétés physiques de masse et de gravité
ainsi que la capacité d’appliquer des forces à l’objet, soit lorsque le joueur agit dessus, soit
lorsqu’il entre en collision avec un autre objet. La sphère va maintenant tomber sur le sol
lors de l’exécution du jeu, mais comment la faire rebondir ? C’est simple ! Le composant
Collider possède une variable Physic Material – un paramètre du composant Rigidbody
qui déinit la réaction de celui-ci au contact des surfaces des autres objets. Il sufit donc de
sélectionner le paramètre prédéini Bouncy pour obtenir une balle qui rebondit en seulement
quelques clics.
Cette approche simpliiée pour les tâches les plus élémentaires, comme dans l’exemple
précédent, semble prosaïque au premier abord. Toutefois, vous découvrirez bientôt qu’elle
permet de réaliser très simplement des tâches plus complexes. Étudions rapidement les
concepts clés de Unity.

Les ressources

Ce sont les composants de base de tous les projets Unity. Des éléments graphiques sous
forme de ichiers image, aux modèles 3D en passant par les ichiers son, Unity désigne
tous les ichiers utilisés pour créer un jeu comme des ressources (assets). C’est pourquoi tous
les ichiers utilisés dans le dossier d’un projet Unity sont stockés dans un dossier enfant
nommé Assets.
14 Développez des jeux 3D avec Unity

Ce livre s’accompagne de ichiers de ressources disponibles sur la page dédiée à

Info cet ouvrage sur le site Pearson (http://www.pearson.fr). Téléchargez et décom-
pressez cette archive pour proiter de son contenu. Ce processus fait partie
intégrante du développement d’un jeu dans Unity.

Les scènes
Considérez les scènes comme des niveaux de jeu individuels ou des zones de contenu (les
menus, par exemple). En construisant votre jeu avec de nombreuses scènes, vous pourrez
répartir les temps de chargement et tester les différentes parties une par une.

Les objets de jeu (Game Objects)

Lorsqu’une ressource est utilisée dans une scène de jeu, elle devient un nouvel objet de
jeu, ou Game Object, que Unity désigne sous le nom de GameObject, en particulier dans
les scripts. Tous les GameObjects contiennent au moins un composant : Transform, qui
indique simplement au moteur de Unity la position, la rotation et l’échelle d’un objet – tous
décrits en coordonnées X, Y, Z (ou en dimensions dans le cas de l’échelle). La position, la
rotation ou l’échelle d’un objet peut également être déinie dans les scripts. À partir de ce
premier composant, vous allez construire d’autres objets de jeu possédant d’autres composants
ain d’ajouter les fonctionnalités nécessaires à la construction de toutes les parties du jeu.

Les composants
Les composants se présentent de différentes manières. Ils peuvent être utilisés pour créer un
comportement, déinir l’apparence ou exercer une inluence sur la fonction d’un objet dans
le jeu. En "attachant" les composants à un objet, vous pouvez appliquer immédiatement de
nouveaux éléments du moteur de jeu à votre objet. Les composants les plus courants pour
créer des jeux sont fournis avec Unity, depuis le composant Rigidbody, mentionné plus
tôt, jusqu’aux éléments plus simples comme les lumières, les caméras, les émetteurs de
particules, etc. Pour créer des éléments plus interactifs dans le jeu, vous écrirez des scripts,
qui sont considérés comme des composants dans Unity.

Les scripts
Tout en étant considérés comme des composants par Unity, les scripts sont un élément
essentiel de la création de jeux et méritent, à ce titre, d’être vus comme une notion clé. Dans
ce livre, vous écrirez vos scripts en JavaScript, mais Unity offre également la possibilité
Chapitre 1 Bienvenue dans la troisième dimension 15

d’utiliser les langages C# et Boo (un dérivé du langage Python). Nous avons choisi de
présenter Unity avec du code JavaScript car il s’agit d’un langage de programmation
fonctionnel dont la syntaxe est simple. En outre, certains d’entre vous ont peut-être déjà
rencontré JavaScript dans d’autres logiciels, comme son dérivé ActionScript dans Adobe
Flash, ou l’ont utilisé pour le développement web.
Unity ne nécessite pas d’apprendre le fonctionnement du code de son propre moteur ni de
savoir comment le modiier, mais vous utiliserez des scripts dans presque tous les scénarios
de jeu que vous développerez. Ces scripts sont assez simples et aisément compréhensibles
après quelques exemples, car Unity possède sa propre classe prédéinie de comportement
– un ensemble d’instructions auxquelles vous ferez appel. Les scripts peuvent être intimi-
dants, en particulier pour les nouveaux utilisateurs de Unity qui ne connaissent que la phase
de conception et découvrent le développement. Nous allons les présenter étape par étape,
ain de vous en montrer l’importance et les possibilités qu’ils offrent.
Pour écrire des scripts, vous pourrez utiliser l’éditeur de script autonome de Unity. Sous
Mac OS, cette application s’appelle Unitron, et sous Windows, Uniscite. Ces applications
distinctes se trouvent dans le dossier de Unity sur votre ordinateur. Elles s’ouvrent chaque
fois que vous créez ou modiiez un script. Lorsque vous modiiez les scripts et que vous les
enregistrez dans l’éditeur de script, celui-ci est immédiatement mis à jour dans Unity. Vous
pouvez également choisir votre propre éditeur de script dans les Préférences de Unity si
vous le souhaitez.

Les éléments préfabriqués

L’approche du développement dans Unity repose principalement sur la notion de Game-
Object, mais le programme propose également une façon astucieuse de stocker les objets
comme ressources ain de pouvoir les réutiliser dans différentes parties d’un jeu, en les
"reproduisant" ou les "clonant" à tout moment. En créant des objets complexes consti-
tués de différents composants et paramètres, vous construisez de fait un modèle que vous
pouvez réutiliser plusieurs fois, chaque instance pouvant être modiiée individuellement.
Prenons l’exemple d’une caisse : vous pouvez déinir la masse de cet objet dans le jeu et
écrire des comportements scriptés pour sa destruction. Vous utiliserez probablement cet
objet plus d’une fois dans le même jeu, voire peut-être dans d’autres jeux que celui pour
lequel il a été conçu.
Les éléments préfabriqués permettent de stocker l’objet complet, ses composants et sa
coniguration actuelle. Considérez simplement les éléments préfabriqués comme des conte-
neurs vides dans lesquels vous stockerez des objets pour former un modèle de données
réutilisable, comparable à la notion de MovieClip dans Adobe Flash.
16 Développez des jeux 3D avec Unity

L’interface
Les différents panneaux qui composent l’interface de Unity peuvent être ancrés et déplacés.
Comme dans de nombreux autres environnements de travail, vous pouvez donc personna-
liser l’apparence de l’interface. Étudions la disposition par défaut :

Figure 1.2

Comme le montre la Figure  1.2 (version Windows), l’interface se compose de cinq

panneaux :
∑ Scene [1]. Le panneau où le jeu est créé.
∑ Hierarchy [2]. Contient la liste des GameObjects présents dans la scène.
∑ Inspector [3]. Les paramètres de l’objet ou de la ressource actuellement sélectionné.
∑ Game [4]. Le panneau de prévisualisation, actif uniquement en mode Lecture.
∑ Project [5]. Contient la liste des ressources de votre projet et agit comme une
bibliothèque.
Chapitre 1 Bienvenue dans la troisième dimension 17

Les panneaux Scene et Hierarchy

Le panneau Scene est celui dans lequel se construit la totalité d’un projet de jeu dans Unity.
Il offre par défaut une vue en perspective (entièrement en 3D) mais il peut présenter une
vue de haut, du bas, de côté ou de face. Il s’agit du rendu complet et modiiable de l’univers
du jeu que vous créez. Faites glisser une ressource dans ce panneau pour qu’elle devienne
un objet de jeu. La vue du panneau Scene est liée au panneau Hierarchy, qui répertorie
tous les objets actifs dans la scène actuellement ouverte par ordre alphabétique croissant.

Figure 1.3

Le panneau Scene s’accompagne de quatre boutons de contrôle très utiles (voir Figure 1.3).
Ces contrôles, accessibles à l’aide des raccourcis clavier Q, W, E et R, permettent d’exécuter
les opérations suivantes :
∑ Hand (Main) [Q]. Permet de naviguer dans le panneau Scene ain de visualiser diffé-
rentes parties du monde ou depuis différents angles. Maintenez la touche Alt enfoncée
pour faire pivoter la vue et la touche Cmd (Mac OS) ou Ctrl (Windows) pour zoomer.
Appuyez également sur la touche Maj pour effectuer ces changements de perspective
plus rapidement.
∑ Translate (Translation) [W]. C’est l’outil de sélection. Vous pouvez totalement interagir
avec le panneau Scene et repositionner un objet à l’aide de ses poignées d’axe dans ce
panneau après l’avoir sélectionné dans les panneaux Hierarchy ou Scene.
∑ Rotate (Rotation) [E]. Il fonctionne de la même manière que l’outil Translate, les
poignées d’axe permettant de faire tourner l’objet sélectionné autour de chacun de ses
axes.
∑ Scale (Échelle) [R]. Là encore, le fonctionnement est identique à celui des outils
Translate et Rotate. Cet outil permet d’ajuster la taille ou l’échelle d’un objet à
l’aide de ses poignées.
Lorsque vous sélectionnez un objet dans le panneau Scene ou Hierarchy, il est immé-
diatement sélectionné dans les deux panneaux et ses propriétés s’afichent dans le panneau
Inspector. Toutefois il peut arriver que vous ne voyiez pas dans le panneau Scene un objet
sélectionné dans le panneau Hierarchy : la touche F vous permet alors de centrer la vue
sur l’objet en question. Il sufit de le sélectionner dans le panneau Hierarchy, de placer le
curseur sur le panneau Scene et d’appuyer sur la touche F.
18 Développez des jeux 3D avec Unity

Le panneau Inspector
Le panneau Inspector est le principal outil pour ajuster chaque élément des objets de jeu
et des ressources de votre projet. Tout comme l’Inspecteur de propriétés dans Adobe Flash
et Dreamweaver, le contenu de ce panneau est sensible au contexte. Autrement dit, il afiche
les propriétés correspondant à l’objet sélectionné – il est donc sensible au contexte dans
lequel vous travaillez.
Le panneau Inspector afiche tous les composants de l’élément sélectionné ce qui permet
d’en ajuster les variables à l’aide d’éléments simples comme des zones de saisie de texte,
des curseurs, des boutons et des menus déroulants. Beaucoup de ces variables utilisent
également le système de glisser-déposer de Unity, ce qui signiie qu’avec cette méthode
vous pouvez déinir des paramètres plutôt que de sélectionner une valeur dans un menu
déroulant, si cela est plus pratique.
Ce panneau n’a pas uniquement pour rôle d’aficher les éléments qui composent les objets.
Il peut également aficher les préférences de votre projet selon l’option que vous sélection-
nez dans le menu Edit (Édition). Les propriétés des composants s’afichent dès que vous
sélectionnez de nouveau un objet ou une ressource.

Figure 1.4

À la Figure 1.4, le panneau Inspector afiche les propriétés d’un objet cible dans le jeu.
L’objet lui-même possède deux composants – Transform et Animation –, dont vous
pouvez modiier les paramètres dans le panneau Inspector. Notez également que vous pouvez
désactiver temporairement un composant à tout moment, ce qui est très utile pour effectuer
Chapitre 1 Bienvenue dans la troisième dimension 19

des tests et expérimenter différentes possibilités. Pour cela, il sufit de décocher la case
située à gauche du nom du composant. De même, pour désactiver un objet entier, décochez
la case en regard de son nom en haut du panneau Inspector.

Le panneau Project
Le panneau Project (projet) offre une vue directe du dossier Assets (ressources) du projet.
Chaque projet de Unity se compose d’un dossier parent, qui contient trois sous-dossiers :
Assets, Library (bibliothèque) et Temp lorsque l’Éditeur de Unity est ouvert. Les ressources
placées dans le dossier Assets sont immédiatement visibles dans le panneau Project et sont
importées automatiquement dans le projet Unity. De même, si vous modiiez et enregistrez
une ressource du dossier Assets dans une application tierce comme Photoshop, Unity la
réimportera, si bien que les modiications effectuées s’aficheront immédiatement dans le
projet et dans toutes les scènes qui utilisent cette ressource en particulier.

L’emplacement et le nom des ressources doivent être uniquement modiiés dans

ce le panneau Project. L’utilisation du Finder (Mac OS) ou de l’Explorateur Win-
Astu
dows (Windows) risque en effet de rompre les connexions dans le projet Unity.
Pour déplacer ou renommer les objets du dossier Assets, utilisez le panneau
Project.

Le panneau Project s’accompagne d’un bouton Create (créer). Celui-ci permet la créa-
tion de tous les types de ressources disponibles dans Unity – scripts, éléments préfabriqués
et matériaux, par exemple.

Le panneau Game
Le panneau Game (jeu), qui s’afiche lorsqu’on clique sur Play, propose un aperçu réaliste
du jeu. Il dispose également de paramètres de résolution de l’écran, ce qui est utile pour
visualiser le point de vue du joueur dans certains ratios, comme le 4:3 (par opposition à un
écran large). Avant de cliquer sur Play, rappelez-vous ceci :

En mode Lecture, les ajustements que vous apportez à tous les éléments de la
ntion scène de jeu ne sont que temporaires. Ce mode est uniquement un mode de test,
Atte
si bien que, lorsque vous cliquez de nouveau sur Play pour arrêter le jeu, toutes
les modiications apportées en cours de lecture seront annulées. C’est souvent
très déroutant pour les nouveaux utilisateurs, alors n’oubliez pas !
20 Développez des jeux 3D avec Unity

Le panneau Game peut également être paramétré à l’aide de l’option Maximize. On obtient
alors un aperçu proche du plein écran en mode de lecture – la taille du panneau recouvre la
totalité de l’interface. Notez que vous pouvez également agrandir n’importe quel panneau
de l’interface. Il sufit pour cela de placer le curseur sur le panneau à agrandir puis d’appuyer
sur la barre d’espacement.

En résumé
Nous avons découvert au cours de ce chapitre les concepts clés que vous avez besoin de
comprendre pour compléter les exercices de ce livre. En raison de contraintes d’espace, nous
ne pouvons pas tout présenter en détail, car le développement 3D est un domaine d’étude
très vaste. C’est pourquoi nous vous conseillons de chercher des informations supplémen-
taires sur les sujets abordés, ain de compléter vos connaissances. Chaque logiciel dispose
de ses propres didacticiels et ressources consacrés à son apprentissage. Si vous désirez
apprendre à créer des modèles 3D pour les utiliser dans Unity, nous vous recommandons
de choisir et de vous familiariser avec le programme qui vous convient le mieux. Vous trou-
verez une liste des programmes compatibles avec Unity au Chapitre 2, "Environnements".
À présent que nous avons vu rapidement les concepts 3D et les processus utilisés par Unity
pour créer des jeux, vous allez commencer à utiliser le logiciel pour créer l’environnement
de votre jeu.
Au chapitre suivant, nous aborderons l’éditeur de terrain, un outil simple à utiliser pour
commencer la création d’un jeu situé dans un environnement extérieur. Avec lui, vous
construirez une île à laquelle vous ajouterez des fonctionnalités au il des chapitres suivants
ain de créer un mini-jeu dans lequel le joueur devra allumer un feu de camp après avoir
récupéré des allumettes dans un avant-poste dont la porte est verrouillée.
 2
Environnements
Pour construire votre monde en 3D, vous utiliserez deux types différents d’environnement :
les bâtiments et les éléments de décor créés dans une application de modélisation 3D tierce
mais aussi des terrains créés à l’aide de l’éditeur de terrain de Unity.
Vous verrez rapidement ici comment déinir les paramètres nécessaires à l’importation des
modèles créés en dehors de Unity, mais vous utiliserez principalement les outils propres à
Unity pour créer des terrains. Vous verrez en particulier comment :
∑ créer votre premier projet Unity ;
∑ créer et conigurer des terrains ;
∑ utiliser les outils de terrain pour construire une île ;
∑ éclairer les scènes ;
∑ utiliser le son ;
∑ importer des paquets de ressources ;
∑ importer des modèles 3D externes.
22 Développez des jeux 3D avec Unity

Les logiciels de modélisation externes

Étant donné que la conception 3D est une discipline à part entière, nous vous recomman-
dons de vous pencher sur un didacticiel analogue à celui-ci pour l’application de votre
choix. Si vous débutez, voici une liste des logiciels de modélisation 3D actuellement pris
en charge par Unity :
∑ Maya
∑ 3D Studio Max
∑ Cheetah 3D
∑ Cinema 4D
∑ Blender
∑ Carrara
∑ Lightwave
∑ XSI
Ce sont les huit applications de modélisation recommandées par Unity Technologies : elles
sont capables d’exporter les modèles dans un format qui peut être automatiquement lu
et importé par Unity, une fois qu’ils sont enregistrés dans le dossier Assets du projet.
Les formats de ces huit applications conservent l’ensemble des maillages, des textures,
des animations et des squelettes (une forme d’ossature) dans Unity, alors que le système
d’animation par squelette utilisé par des programmes moins connus peut ne pas être pris en
charge lors de l’importation dans Unity. Pour une liste exhaustive de compatibilité, consultez
le site : http://unity3d.com/unity/features/asset-importing.

Les ressources
Les modèles utilisés dans ce livre sont disponibles en ligne au format .fbx (format natif
pour Unity qui est commun à la plupart des applications de modélisation 3D).
Lors du téléchargement du contenu nécessaire pour les exercices de ce livre, vous aurez
besoin du système de paquets de ressources de Unity. L’importation et l’exportation de
paquets de ressources dans Unity à l’aide du menu Assets permettent de transférer des
ressources d’un projet à un autre en conservant les dépendances. Une dépendance est tout
simplement une autre ressource liée à celles que vous importez ou exportez. Lors de l’ex-
portation d’un modèle 3D dans le cadre d’un paquet de ressources Unity par exemple (à
destination d’un collaborateur, ou simplement entre vos propres projets Unity), vous devrez
Chapitre 2 Environnements 23

transférer les matériaux adéquats et les textures associées avec les modèles ; ces ressources
connexes sont alors appelées dépendances du modèle.
Dans ce livre, nous vous indiquerons quand télécharger des paquets Unity et les ajouter à
vos ressources. Pour cela, il vous sufira de cliquer sur Assets > Import Package.

Votre premier projet Unity

Unity existe sous deux formes différentes : une version gratuite et une version profession-
nelle1. Nous nous en tiendrons ici aux fonctionnalités accessibles aux débutants, autrement
dit aux options de la version gratuite.
Lors du premier lancement, le programme s’ouvre sur le projet de démonstration Island
Demo. Comme son nom l’indique, il s’agit effectivement d’un projet destiné à présenter les
capacités de Unity et à permettre aux nouveaux utilisateurs de découvrir certaines fonction-
nalités du programme en étudiant les créations de ses développeurs.
Vous allez commencer avec un projet vierge. Pour cela, cliquez sur File > New Project
ain de fermer le projet actuellement ouvert et d’ouvrir la boîte de dialogue Project Wizard
(assistant de projet). Vous pouvez sélectionner un projet existant ou en créer un en choi-
sissant parmi plusieurs Asset Packages (paquets de ressources) avec lesquels commencer.

Si vous souhaitez lancer Unity en ouvrant directement le Project Wizard,

Info appuyez simplement sur la touche Alt (Mac  Os et Windows) tout en lançant
l’Éditeur de Unity.

Choisissez l’emplacement où votre projet sera enregistré. Sélectionnez un chemin de

ichier dans le champ Project Location (emplacement du projet) ou cliquez sur Browse
(parcourir) et choisissez un emplacement dans la boîte de dialogue qui s’afiche. Notre
projet s’appelle Projet 1, mais vous pouvez choisir un autre nom. Cochez ensuite la case
en regard de Standard Assets ain de disposer des ressources fournies par Unity Techno-
logies. Cliquez enin sur le bouton Create2.

1. Il existe également des versions spéciiquement dédiées à la Wii ou à l’iPhone.

2. Sur certaines versions, Project Location, Browse et Create s’intitulent Project Directory, Set et
Create Project.
24 Développez des jeux 3D avec Unity

Figure 2.1

L’éditeur de terrain
Un éditeur de terrain est indispensable pour tout développeur qui souhaite créer un jeu se
déroulant en extérieur. Unity en intègre un depuis sa version 2.0, ce qui facilite et accélère
la construction des environnements.
Pour Unity, un terrain est simplement un objet de jeu sur lequel on applique certains compo-
sants en particulier. Le terrain que vous allez bientôt créer est, à l’origine, une surface
plane, une forme 3D à une seule face, mais il peut être transformé en un ensemble géomé-
trique complet et réaliste et inclure des détails supplémentaires – arbres, rochers, feuilles
– et même des effets atmosphériques, comme le vent.

Les fonctionnalités du menu Terrain

Pour découvrir les fonctionnalités suivantes, un terrain est nécessaire. Pour cela, commen-
cez par créer un objet Terrain dans le jeu. Vous pouvez le faire dans Unity en cliquant
simplement sur Terrain > Create Terrain.
Avant de pouvoir modiier le terrain, vous devez conigurer différents paramètres, notam-
ment ses dimensions et le niveau de détail. Le menu principal Terrain permet non seulement
de créer un terrain pour le jeu, mais aussi d’effectuer les opérations suivantes.
Chapitre 2 Environnements 25

Importer et exporter des heightmaps

Les heightmaps (cartes d’élévation) sont des graphismes en 2D, dont les zones claires et
foncées représentent la topographie du terrain. Elles peuvent être importées et représenter
une alternative aux outils permettant de déinir les élévations de terrain au pinceau dans
Unity.
Créées dans un logiciel d’illustration comme Photoshop et enregistrées dans un format
.RAW, les heightmaps sont souvent utilisées dans le développement des jeux, car elles sont
facilement exportées et transférées entre les applications de dessin et les environnements
de développement comme Unity.
Comme nous allons créer notre environnement avec les outils de terrain de Unity, nous
n’utiliserons pas de heightmaps externes dans le cadre de ce livre.

Déinir la résolution d’une heightmap

Figure 2.2

La boîte de dialogue Set Heightmap resolution permet de déinir un certain nombre de

propriétés du terrain que vous venez de créer. Vous devez toujours ajuster ces paramètres
avant de créer la topographie du terrain, sinon le terrain risque d’être partiellement réinitia-
lisé si vous les redéinissez par la suite.
∑ Terrain Width, Height and Length (largeur, hauteur et longueur). Ces valeurs sont
exprimées en mètres. Notez que Height déinit ici la hauteur maximale que la topo-
graphie du terrain peut avoir.
∑ Heightmap Resolution. C’est la résolution, exprimée en pixels, de la texture que
Unity  stocke pour représenter la topographie. Bien que les dimensions des textures
dans Unity doivent généralement être une puissance de deux dimensions (128, 256, 512,
26 Développez des jeux 3D avec Unity

etc.), les résolutions heightmap comptent toujours un pixel supplémentaire car chaque
pixel déinit un sommet. Ainsi, dans l’exemple d’un terrain de 4 × 4, quatre sommets
seraient présents le long de chaque section de la grille, mais les points où ces sommets se
rencontrent – y compris leurs extrémités – seraient au nombre de cinq.
∑ Detail Resolution. Connue sous le nom de Detail resolution map, c’est la résolution de
la surface stockée par Unity. Celle-ci déinit précisément la manière dont vous pouvez
placer des détails sur le terrain. Les détails regroupent les caractéristiques supplémen-
taires du terrain comme les plantes, les rochers et les arbustes. Plus cette valeur est
élevée et plus vous pouvez positionner les détails avec précision sur le terrain.
∑ Control Texture Resolution. C’est la résolution des textures (appelées Splatmap dans
Unity) lorsqu’elles sont peintes sur le terrain. La valeur de Control Texture Reso-
lution correspond à la taille et, par conséquent, au détail de toutes les textures sur
lesquelles vous allez peindre. Comme pour toutes les résolutions de texture, il est préfé-
rable de conserver une valeur assez basse pour obtenir de bonnes performances. Il est
généralement conseillé de la laisser à sa valeur par défaut (512).
∑ Base Texture Resolution. La résolution de la texture utilisée par Unity pour faire le
rendu des zones de terrain éloignées de la caméra dans le jeu, ou de toutes les textures
sur un ordinateur ancien et peu performant.

Créer la lightmap (la liste des lumières)

Figure 2.3

La boîte de dialogue Create Lightmap est utilisée pour générer un rendu semi-permanent
de l’éclairage sur les textures qui donnent l’apparence à la topographie. Si vous créez un
petit terrain accidenté, par exemple, puis que vous souhaitiez inclure une montagne au
centre, vous devrez choisir les outils de terrain. Toutefois, compte tenu de l’ombre projetée
sur le terrain par cette montagne, vous devez recréer la lightmap ain de faire le rendu des
zones sombres sur les textures situées dans la zone à présent ombragée.
Chapitre 2 Environnements 27

La section Lights de cette boîte de dialogue permet d’augmenter le nombre de lumières

utilisées pour le rendu de la lightmap. Par exemple, la scène peut être éclairée principa-
lement par une Directional Light (lumière directionnelle), qui agit comme la lumière du
soleil à partir d’une certaine direction. Vous pouvez également intégrer certaines Point
Lights (lumière en un point) pour des lampes d’extérieur ou des feux.
Lorsque vous créez une topographie à l’aide des outils de terrain, vous risquez de devoir
modiier les paramètres de création de la lightmap au fur et à mesure que le paysage évolue.
En créant une lightmap pour les zones claires et les zones sombres sur le terrain, vous
réduisez également la puissance de calcul nécessaire lors de l’exécution du jeu, car une
partie de l’éclairage est déjà calculée. À l’inverse, l’éclairage dynamique du terrain est plus
coûteux en termes de calcul.

La fonction Mass Place Trees

Cette fonction réalise exactement ce que son nom indique  : disposer un certain nombre
d’arbres sur le terrain. Les paramètres associés à un arbre en particulier sont déinis à la
section Place Trees du composant Terrain (Script) du panneau Inspector.
Cette fonction n’est pas recommandée pour une utilisation générale, car elle n’offre aucun
contrôle sur la position des arbres. Employez plutôt Place Trees (placement d’arbres) du
composant Terrain (Script) ain de peindre les arbres manuellement et ainsi obtenir une
disposition plus réaliste.

La fonction Flatten Heightmap

La fonction Flatten Heightmap (aplatir la carte d’élévation) permet de donner à tout le
terrain la même élévation. Par défaut, la hauteur du terrain vaut 0. Si vous souhaitez que
l’élévation par défaut soit supérieure, comme nous le faisons pour l’île, vous pouvez alors
utiliser cette fonction pour déinir la valeur Height.

La fonction Refresh Tree and Detail Prototypes

Si vous modiiez les ressources qui composent des arbres et des détails déjà peints sur le
terrain, vous avez alors besoin d’utiliser Refresh Tree and Detail Prototypes (rafraîchir les
prototypes d’arbres et des détails) pour les mettre à jour.
28 Développez des jeux 3D avec Unity

Les outils de terrain

Nous allons étudier les outils de terrain ain que vous puissiez vous familiariser avec leurs
fonctions avant de commencer à construire l’île.
Comme vous venez de créer le terrain, il doit être sélectionné dans le panneau Hierarchy.
Si ce n’est pas le cas, sélectionnez-le dès maintenant ain d’aficher ses propriétés dans le
panneau Inspector.

Le composant Terrain (Script)

Dans le panneau Inspector, les outils de terrain sont indiqués sous le nom Terrain
(Script). Le composant Terrain (Script) met à disposition les différents outils et para-
mètres spéciiques du terrain en plus des fonctions disponibles dans le menu Terrain.
À la Figure  2.4, vous voyez qu’il s’agit du deuxième de trois éléments en rapport avec
l’objet de jeu Terrain (les autres composants étant Transform et Terrain Collider).

Figure 2.4
Chapitre 2 Environnements 29

Le composant Terrain (Script) comprend sept sections, qui sont facilement accessibles à
l’aide des boutons situés en haut du composant. Voici un rapide aperçu de leurs capacités
respectives.

L’outil Raise/Lower Terrain (élever/abaisser le terrain)

Il permet d’élever certaines zones sur lesquelles vous peignez à l’aide de l’outil Transform
(touche W).

Figure 2.5

Vous pouvez également déinir le style de brosse, la taille et l’opacité (eficacité) de la

déformation que vous effectuez. Pour obtenir l’effet contraire, à savoir un abaissement de
la hauteur, appuyez en même temps sur la touche Maj.

Figure 2.6
30 Développez des jeux 3D avec Unity

L’outil Paint Height (peindre jusqu’à hauteur)

Il fonctionne de manière analogue à l’outil Raise/Lower Terrain mais il possède un para-
mètre supplémentaire : Height.

Figure 2.7

Cela signiie que vous pouvez déinir la hauteur que vous allez peindre. Lorsque la zone
de terrain dont vous modiiez l’élévation atteint la hauteur spéciiée, elle s’aplatit, vous
permettant de créer des plateaux (voir Figure 2.8).

Figure 2.8

L’outil Smooth Height (adoucir les dénivelés)

Il sert principalement en complément d’autres outils, comme Paint Height, pour adoucir
les dénivelés abrupts de la topographie.

Figure 2.9
Chapitre 2 Environnements 31

Le plateau de la Figure 2.9 présente, par exemple, une pente très abrupte. Pour adoucir les
contours de cette élévation, nous nous servirions de cet outil ain d’arrondir les angles (voir
Figure 2.10).

Figure 2.10

L’outil Paint Texture (peindre des textures)

Il s’utilise pour peindre les textures sur la surface du terrain (nommées Splats) dans Unity.

Figure 2.11

Avant de peindre avec des textures, vous devez d’abord les ajouter à la palette dans la zone
Textures de cet outil. Pour cela, cliquez sur le bouton Edit Textures, sélectionnez Add
Textures puis, dans le menu déroulant Splat, choisissez un des ichiers de texture actuel-
lement dans votre projet et déinissez les paramètres de taille de la texture choisie.
32 Développez des jeux 3D avec Unity

La Figure 2.12 montre trois textures ajoutées dans la palette. La première sera peinte sur
tout le terrain par défaut. En combinant ensuite plusieurs textures de différentes opacités et
en peignant à la main sur le terrain, vous pouvez donner un aspect réaliste à tous les types
de surface.
Pour choisir la texture avec laquelle peindre, cliquez simplement sur son aperçu dans la
palette : un contour bleu l’encadre alors.

Figure 2.12

L’outil Place Trees (disposer des arbres)

Comme son nom l’indique, cet outil permet de placer, à la souris (en peignant ou par de
simples clics), des arbres sur le terrain, après que les ressources à utiliser ont été déinies.

Figure 2.13

Comme pour les textures de l’outil Paint Texture, cet outil dispose d’un bouton Edit
Trees pour ajouter, modiier et supprimer des ressources de la palette.
Chapitre 2 Environnements 33

La section Settings dispose des options suivantes :

∑ Brush Size. Déinit la quantité d’arbres à peindre à chaque clic.
∑ Tree Density. Déinit la distance entre les arbres que vous peignez.
∑ Color Variation. Applique une variation de couleur aléatoire aux arbres lorsque vous
en peignez plusieurs à la fois.
∑ Tree Width/Height. Déinit la taille de la ressource arbre que vous peignez.
∑ Tree Width/Height Variation. Permet grâce à la variation aléatoire de la taille des
arbres de créer des zones boisées de manière plus réaliste.
Appuyer en même temps sur la touche Maj inverse également ses effets : les arbres déjà
peints sont effacés. Appuyer simultanément sur les touches Maj+Ctrl permet d’effacer
uniquement le type d’arbres sélectionné dans la palette.

L’outil Paint Details (peindre des détails)

Il fonctionne d’une manière analogue à l’outil Place Trees, mais il est conçu pour travailler
avec des objets de détails comme les leurs, les plantes, les rochers et le feuillage de petite taille.

Figure 2.14

Terrain Settings (les paramètres de terrain)

La section Terrain Settings du composant Terrain (Script) contient différents para-
mètres pour le dessin du terrain par le GPU (processeur graphique) de l’ordinateur.

Figure 2.15
34 Développez des jeux 3D avec Unity

Vous pouvez déinir ici différents paramètres qui inluent sur le niveau de détail (LOD,
Level of Detail). Dans le domaine du développement de jeux, le LOD correspond à la
quantité de détails représentés à une certaine distance du joueur. Dans notre exemple –
un terrain –, nous devons pouvoir régler les paramètres comme la distance d’afichage
(Draw Distance). Cette notion, courante dans les jeux 3D, permet de procéder au rendu des
éléments de façon moins détaillée lorsqu’ils se trouvent à une certaine distance du joueur
ain d’améliorer les performances.
La section Terrain Settings vous permet par exemple d’ajuster l’option Base Map
Distance (distance de base) ain de préciser à quelle distance doivent se situer les objets
avant que les graphismes en haute résolution ne soient remplacés par des graphismes en
plus basse résolution, ain de réduire le coût du rendu des objets les plus lointains.
La Figure 2.16 montre un exemple de terrain avec une valeur Base Map Distance faible
(environ 10  mètres). Comme vous pouvez le constater, le niveau de détail des textures
situées au-delà de la distance spéciiée est bien inférieur à celui du premier plan.

Figure 2.16

Vous allez étudier plus en détail les paramètres de la section Terrain (script) en commençant
à sculpter le terrain.
Chapitre 2 Environnements 35

Soleil, mer et sable : la création de l’île

Étape 1. La coniguration du terrain
Maintenant que vous connaissez les outils disponibles, vous pouvez commencer à créer le
terrain à partir du menu principal Terrain. Assurez-vous que le terrain est toujours sélec-
tionné dans le panneau Hierarchy, puis cliquez sur Terrain > Set Resolution (changer
la résolution).
Comme il s’agit de votre premier projet, vous n’allez pas créer une île trop grande. Aussi,
donnez la valeur 1000 aux deux paramètres Terrain Width et Terrain Length. Appuyez
sur la touche Entrée après avoir saisi ces valeurs pour les valider puis cliquez sur Set
Resolution.
La hauteur minimale de l’île doit ensuite être celle du niveau du sol et non être égale à 0 (la
valeur par défaut pour les nouveaux terrains). En effet, l’altitude 0 correspond au fond de
la mer, si bien que la hauteur minimale du sol doit être augmentée pour correspondre à la
partie émergée de l’île. Cliquez sur Terrain > Flatten Heightmap.
Dans le champ Height, entrez 30 mètres. Appuyez sur la touche Entrée pour conirmer,
puis cliquez sur le bouton Flatten.
Le changement est très rapide et il est possible que vous ne voyiez pas la différence dans
le panneau Scene, puisque vous avez augmenté légèrement la hauteur de tout le terrain.
Toutefois, cette opération permet de gagner énormément de temps, car vous pouvez à
présent aplanir les bords du terrain à l’aide de l’outil Raise/Lower Terrain ain que seule
la partie centrale reste surélevée. Partir d’une île plate et élever sa partie centrale demande-
rait beaucoup plus de temps.

Étape 2. Le contour de l’île

Dans le composant Terrain (Script) du panneau Inspector, sélectionnez l’outil Raise
Height – le premier des sept boutons.
Sélectionnez la première brosse dans la palette et donnez les valeurs  75 au paramètre
Brush Size et 50 à Opacity.
Cliquez sur l’axe Y (le cône vert) de l’axe 3D situé dans le coin supérieur droit du panneau
Scene pour passer en vue de dessus.

Figure 2.17
36 Développez des jeux 3D avec Unity

Maintenez la touche Maj enfoncée pour que l’outil réduise la hauteur du terrain, puis
peignez sur les contours du terrain pour créer un rivage en pente jusqu’à l’altitude 0 – vous
savez que vous atteignez l’altitude 0 car le terrain sera aplati à cette hauteur minimale.
Bien qu’il ne soit pas nécessaire que le contour de votre île soit identique au nôtre, essayez
de créer une forme assez semblable, car vous aurez besoin d’une étendue de terre plate par
la suite. Une fois que vous avez peint tout autour du contour, vous devriez obtenir un résultat
semblable à celui de la Figure 2.18.

Figure 2.18

Cliquez sur le cube au centre de l’axe 3D situé dans le coin supérieur droit du panneau
Scene pour revenir à une vue en perspective (3D) et admirez votre travail. Si vous n’êtes
pas sûr d’avoir obtenu le bon résultat, comparez votre île avec celle de la Figure 2.19.
Chapitre 2 Environnements 37

Figure 2.19

Continuez avec l’outil Raise/Lower Terrain sur l’île pour améliorer la topographie du
terrain, en augmentant voire en diminuant (avec la touche Maj) l’élévation de certaines
zones. Vous pouvez, par exemple, ajouter une baie ou un lac. Conservez un espace plat au
centre du terrain et une partie libre dans un coin de l’île pour ajouter un volcan.

Étape 3. Le volcan
Vous allez maintenant créer un volcan ! Pour cela, les outils Paint Height, Raise/Lower
Terrain et Smooth Height seront adaptés. Sélectionnez l’outil Paint Height pour
commencer.
Choisissez la première brosse dans la palette, donnez les valeurs 75 à Brush Size, 50 à
Opacity et 200 à Height. Sélectionnez de nouveau la vue Haut en cliquant sur l’axe Y de
l’axe 3D dans le panneau Scene, puis peignez un plateau dans le coin du terrain que vous
avez laissé libre. Rappelez-vous que cet outil arrête de modiier le terrain une fois que la
hauteur spéciiée (200) est atteinte.
Votre île devrait maintenant ressembler à celle de la Figure 2.20 dans la vue Perspective.
38 Développez des jeux 3D avec Unity

Figure 2.20

Ce plateau a un aspect assez peu réaliste. Vous allez remédier à cela, mais vous devez
d’abord créer la bouche du volcan. L’outil Paint Height toujours sélectionné, donnez la
valeur 20 à Height et la valeur 30 à Brush Size.
Cliquez et maintenez et commencez à peindre du centre du plateau vers l’extérieur dans
toutes les directions, jusqu’à ce que vous ayez effectivement creusé le plateau et laissé une
crête étroite autour de sa circonférence (voir Figure 2.21).
Si vous repassez dans la vue en perspective, vous voyez que l’aspect du bord du volcan
est toujours trop abrupt et assez peu réaliste. Vous allez corriger cela : sélectionnez l’outil
Smooth Height, puis donnez les valeurs 30 à Brush Size et 1 à Opacity. Peignez ensuite
avec cet outil sur le pourtour de la crête pour l’adoucir jusqu’à ce que l’arête soit sufisamment
arrondie (voir Figure 2.22).
Maintenant que vous avez donné sa forme au volcan, vous pouvez ajouter une texture à l’île
pour rendre le terrain plus réaliste.
Chapitre 2 Environnements 39

Figure 2.21

Figure 2.22
40 Développez des jeux 3D avec Unity

Étape 4. L’ajout de textures

Lorsque vous texturez un terrain, gardez à l’esprit que la première texture ajoutée le recou-
vrira entièrement. C’est pourquoi vous devez vous assurer que c’est bien la première texture
que vous ajoutez qui couvrira la plus grande partie de votre terrain.
Le paquet Standard Assets Package que vous avez incorporé au projet lors de sa création
contient plusieurs ressources possédant différentes caractéristiques. Ces ressources sont
regroupées dans le dossier Standard Assets du panneau Project. Cliquez sur la lèche grise
située à gauche du nom de ce dossier pour aficher son contenu, puis afichez le contenu du
sous-dossier Terrain Textures.

Figure 2.23

Ces quatre textures vous serviront à peindre le terrain de l’île. Vous devez donc commencer
par les ajouter à votre palette. Assurez-vous que l’objet de jeu Terrain est toujours sélec-
tionné dans le panneau Hierarchy, puis sélectionnez l’outil Paint Texture dans le composant
Terrain (Script) du panneau Inspector.

La procédure de peinture
Cliquez sur le bouton Edit Textures, puis sélectionnez Add Textures dans le menu qui
s’afiche. La boîte de dialogue Add Textures s’ouvre alors pour vous permettre de sélec-
tionner toutes les textures actuellement dans votre projet. Cliquez sur la lèche pointant
vers le bas à droite du paramètre Splat pour choisir une texture sur la liste. Sélectionnez la
texture Grass (Hill).
Chapitre 2 Environnements 41

Figure 2.24

Conservez la valeur 15 pour les paramètres Tile Size  X et Tile Size  Y. Cette texture
recouvrira toute la carte et cette petite valeur permettra d’obtenir une herbe plus détaillée.
Cliquez sur le bouton Add pour terminer. La texture d’herbe recouvre le terrain  : c’est
normal puisqu’il s’agit de la première texture que vous ajoutez. Celles que vous ajouterez
ensuite à la palette devront être peintes à la main.
Répétez l’étape précédente pour ajouter les trois textures Grass&Rock, Cliff (Layered
Rock) et GoodDirt dans la palette. Conservez les paramètres Tile Size, sauf pour Cliff
(Layered Rock), dont les paramètres Tile Size X et Tile Size Y doivent avoir une valeur
de 70. En effet, comme cette texture va être appliquée sur une zone étirée du terrain, elle
serait déformée avec une taille de carreau (unité de terrain ou tile) plus petite.

Figure 2.25
42 Développez des jeux 3D avec Unity

Les régions sablonneuses

Les quatre textures devraient maintenant être disponibles dans votre palette. Cliquez sur la
dernière texture ajoutée – GoodDirt, si vous avez respecté l’ordre. Un trait bleu s’afiche
sous sa vignette pour indiquer qu’elle est sélectionnée. Donnez les valeurs  60 à Brush
Size, 50 à Opacity et 1 à Target Strength. Vous pouvez peindre autour de la côte de
l’île en utilisant soit la vue Haut soit la vue Perspective.
En vue Perspective, sélectionnez l’outil Hand (touche  Q) ou Transform (touche  W),
appuyez sur la touche Alt et faites glisser la souris pour faire pivoter la vue.
Lorsque vous avez terminé, vous devriez obtenir un résultat proche de celui illustré à la
Figure 2.26.

Figure 2.26

Si vous faites une erreur pendant que vous peignez, vous pouvez soit annuler le dernier coup
de pinceau, c’est-à-dire le dernier clic, avec la commande Edit > Undo, soit sélectionner
dans la palette la texture qui doit recouvrir cette zone et repeindre avec celle-ci.
Chapitre 2 Environnements 43

L’herbe et les rochers

Cliquez ensuite sur la deuxième vignette que vous avez ajoutée – la texture Grass&Rock
– pour la sélectionner. Donnez les valeurs 25 à Brush Size, 30 à Opacity et 0,5 à Target
Strength. Peignez toutes les collines du terrain et la moitié supérieure du volcan (voir
Figure 2.27).

Figure 2.27

Les rochers du volcan

Vous devez maintenant rendre le volcan plus réaliste à l’aide de la texture Cliff (Layered
Rock). Sélectionnez-la dans la palette, puis donnez les valeurs 25 à Brush Size et 100 à
Opacity et à Target Strength.
Peignez le sommet et l’intérieur du volcan avec ces paramètres, puis diminuez peu à peu
les valeurs de Brush Size et d’Opacity au fur et à mesure que vous descendez le long des
pentes extérieures du volcan, ain que cette texture soit appliquée de façon plus subtile vers
le sol. Vous pouvez également peindre les cimes de certaines des collines les plus élevées
avec une opacité plus faible.
44 Développez des jeux 3D avec Unity

Après de nombreux essais, sans doute, votre volcan terminé devrait ressembler à celui de
la Figure 2.28.

Figure 2.28

Étape 5. Les arbres

Maintenant que l’île est entièrement texturée, vous devez l’embellir quelque peu en ajoutant
des arbres. L’arbre à utiliser avec l’éditeur de terrain que contient le paquet de ressources
Standard Assets convient parfaitement puisqu’il s’agit d’un palmier.
Cliquez sur le bouton Place Trees du composant Terrain (Script), puis sur le bouton
Edit Trees. Choisissez Add Tree dans le menu qui apparaît.
La boîte de dialogue Add Tree s’afiche alors. Vous pouvez y choisir, comme pour certains
des autres outils de terrain, n’importe quel objet du type approprié dans le dossier Assets de
votre projet. Cela ne se limite pas aux arbres fournis dans le paquet de ressources Standard
Assets. En effet, vous pouvez modéliser vos propres arbres, les enregistrer dans le dossier
Assets de votre projet ain de les utiliser ensuite. Cependant, ici, le palmier du paquet de
ressources Standard Assets est tout à fait adéquat. Cliquez sur la lèche pointant vers le bas
à droite du paramètre Tree et sélectionnez Palm.
Chapitre 2 Environnements 45

Avec le paramètre Bend Factor, les arbres semblent se balancer dans le vent. Le coût du
calcul de cet effet étant élevé, nous allons utiliser une valeur faible. Entrez 2 puis validez
(touche Entrée). Si vous remarquez, par la suite, que ce paramètre a un impact négatif sur
les performances du jeu, vous pourrez toujours le redéinir en lui donnant la valeur 0.
Cliquez sur le bouton Add. Un petit aperçu du palmier devrait apparaître dans la palette,
encadré de bleu pour indiquer qu’il s’agit de l’arbre sélectionné à placer.
Donnez les valeurs suivantes  : 15  à Brush Size (pour peindre quinze arbres à la fois),
10 à Tree Density (ain que les arbres soient assez dispersés sur la carte), 0,4 à Color
Variation (pour obtenir un ensemble d’arbres varié). Enin, attribuez 150 à Tree Height
et Tree Width avec, pour chacun, 30 comme valeur de Variation.
Disposez des arbres en cliquant simplement autour du rivage de l’île, à proximité des zones
de sable où ce type d’arbres est censé se trouver. Puis, pour compléter le relief de l’île,
placez d’autres palmiers à des emplacements aléatoires à l’intérieur des terres.
Vous pouvez à tout moment effacer des arbres mal placés : pour cela, appuyez sur la touche
Maj et cliquez ou peignez sur ces arbres.

Étape 6. Ajouter des touffes d’herbe

À présent que vous avez placé quelques arbres sur l’île, vous allez ajouter des touffes
d’herbe pour compléter la texture avec laquelle vous avez recouvert la plus grande partie
du terrain.
Sélectionnez la section Paint Details du composant Terrain (Script), cliquez sur le
bouton Edit Details puis sélectionnez Add Grass Texture dans le menu contextuel.
Ouvrez le menu déroulant situé à droite du paramètre Detail Texture et sélectionnez la
texture Grass, la texture d’herbe du paquet de ressources Standard Assets.
Conservez pour cette texture les valeurs par défaut des propriétés Width et Height et
assurez-vous que l’option Billboard, au bas de la boîte de dialogue, est activée. Comme
la texture d’herbe est en 2D, la technique du billboard (panneau d’afichage) est applicable.
Elle consiste à faire pivoter la texture d’herbe face à la caméra pendant le jeu ain de lui
donner un aspect moins bidimensionnel.
Utilisez les pipettes des options Healthy Color et Dry Color, pour obtenir les mêmes
teintes vertes que celles des textures que vous avez peintes sur le terrain. En effet, les
touffes d’herbe sembleraient artiicielles si vous conserviez la couleur vert clair par défaut.
46 Développez des jeux 3D avec Unity

Figure 2.29

Cliquez sur le bouton Add au bas de la boîte de dialogue pour conirmer l’ajout de cette
texture à votre palette.
Vous pouvez peindre l’herbe sur la carte avec la souris de la même façon qu’avec les autres
outils de terrain. Vous devez d’abord choisir une brosse et déinir ses paramètres ain de
créer des touffes d’herbe espacées et disparates sur la carte. Le rendu de l’herbe étant
également coûteux pour l’ordinateur, donnez des valeurs très faibles  : 100 pour Brush
Size mais seulement 0,05 pour Opacity et 0,6 pour Target Force de façon que les touffes
d’herbe soient clairsemées. En choisissant en outre une forme de brosse irrégulière (voir
Figure 2.30), vous pouvez peindre des zones d’herbe inégales.
Sélectionnez l’outil Hand, appuyez sur Cmd/Ctrl et faites glisser la souris vers la droite
pour zoomer sur la surface du terrain. Lorsque le niveau de zoom est sufisant, vous pouvez
cliquer sur le terrain pour peindre les zones d’herbe. Déplacez-vous sur l’île mais ne peignez
que quelques zones d’herbe pour des raisons de performances (vous pourrez toujours en
ajouter par la suite si les performances du jeu sont bonnes).

Il est crucial de zoomer en avant sur le terrain lorsque vous peignez des détails.
ce Ain d’économiser de la mémoire, le rendu des détails n’est, en effet, pas visible
Astu
dans le panneau Scene avec un facteur de zoom réduit. Lorsque vous zoomez
en arrière, les détails semblent ainsi souvent disparaître mais, ne vous inquiétez
pas, cela n’est pas le cas.
Chapitre 2 Environnements 47

Figure 2.30

Étape 7. Que les lumières soient !

Maintenant que votre île est prête à être explorée, vous devez éclairer la scène. Pour cela,
trois types de lumière sont disponibles :
∑ Directional Light (lumière directionnelle). La principale source de lumière, souvent
la lumière du soleil. Elle n’émane pas d’un seul point mais elle éclaire dans une seule
direction.
∑ Point Light (lumière point). Ces lumières proviennent d’un seul point dans le monde 3D
et sont utiliséespour toutes les autres source de lumière, comme l’éclairage à l’intérieur
des bâtiments, le feu, les objets incandescents, etc.
∑ Spot Light (lumière spot). Comme son nom l’indique, cette lumière éclaire dans une
direction unique, mais son rayon peut être déini, tout comme s’il s’agissait d’une lampe
torche.

Créer la lumière du soleil

Vous allez placer une lumière directionnelle comme source de lumière principale. Cliquez
sur GameObject > Create Other > Directional Light pour ajouter la lumière comme
un objet dans la scène. Vous constatez qu’elle est désormais répertoriée dans le panneau
Hierarchy.
48 Développez des jeux 3D avec Unity

Comme la lumière directionnelle n’émane pas d’un point en particulier, sa position

n’a généralement aucune importance car elle ne peut pas être vue par le joueur – il ne
perçoit que la lueur qu’elle projette. Toutefois, pour ce didacticiel, vous utiliserez une
lumière directionnelle pour représenter le soleil, en appliquant le paramètre Flare.
Vous allez positionner la lumière à une grande distance au-dessus de l’île puis vous
l’éloignerez sur l’axe  Z ain de vous assurer que son orientation soit conforme à sa
projection.
Entrez les valeurs (0, 500, –200) dans les champs Transform du panneau Inspector
pour positionner la lumière (appuyez sur Entrée pour conirmer chaque valeur). Donnez
la valeur 8 à la propriété X rotation ain que la lumière s’oriente vers le bas sur l’axe X
et qu’elle projette davantage de clarté sur le terrain.
Enin, vous devez rendre cette lumière visible. Pour cela, cliquez sur la lèche pointant
vers le bas, située à droite du paramètre Flare dans le composant Light (il indique
actuellement None), puis sélectionnez Sun dans le menu.

Figure 2.31

Étape 8. Quel est ce bruit ?

Le son est souvent un élément négligé dans le développement d’un jeu. Or, pour que
l’expérience vidéoludique soit vraiment immersive, le joueur a non seulement besoin de
découvrir l’environnement avec ses yeux, mais aussi avec ses oreilles.
Le son dans Unity est géré par deux composants  : Audio Source et Audio Listener.
Vous pouvez comparer Audio Source à un haut-parleur dans le monde du jeu, et Audio
Chapitre 2 Environnements 49

Listener à un microphone ou à l’oreille du joueur. Par défaut, les objets de jeu Caméra
de Unity possèdent un composant Audio Listener. Et comme vous disposez toujours d’une
caméra dans votre jeu, il est fort probable que vous n’aurez que les sources sonores à
déinir. Il est également intéressant de noter que le composant Audio Listener n’a pas de
propriétés ajustables – il fonctionne, tout simplement –, et que Unity afiche un message
d’erreur si vous supprimez par inadvertance le dernier écouteur dans une scène.

Stéréo et mono
Unity gère le comportement du son en stéréo (deux canaux) pour le volume sonore constant,
et en mono (un seul canal) pour le son dont le volume varie en fonction de la distance entre
la source d’émission et l’auditeur dans l’univers 3D.
Prenons deux exemples :
∑ La musique dans le jeu. Le son stéréo est préférable, le volume étant constant, où que se
trouve le joueur dans le jeu.
∑ Les effets sonores d’une chaîne hi-i à l’intérieur d’un bâtiment. Le son mono est le
mieux adapté. Bien que vous puissiez choisir de la musique comme effet sonore, l’uti-
lisation de ichiers audio mono permet d’augmenter le volume de la source sonore à
mesure que le joueur s’en approche.

Les formats audio

Unity accepte la plupart des formats audio courants – WAV, MP3, AIFF et OGG. Dans le
cas d’un format compressé comme le MP3, il convertit les ichiers audio au format Ogg
Vorbis mais il ne convertit pas les sons non compressés (les sons au format WAV, par
exemple).
Comme les autres ressources que vous importez, les ichiers audio sont convertis dès que
vous passez d’un autre programme à Unity, ce dernier scannant le contenu du dossier Assets
à la recherche de nouveaux ichiers chaque fois que vous basculez vers le programme.

Les collines sont pleines de vie !

Pour rendre l’île plus réaliste, vous allez ajouter une source sonore d’ambiance en utilisant
un son stéréo.
Commencez par sélectionner l’objet Terrain dans le panneau Hierarchy. Cliquez ensuite
sur Component > Audio > Audio Source pour ajouter un composant Audio Source au
terrain. Comme le volume des sons stéréo demeure constant, la position n’a pas d’importance,
50 Développez des jeux 3D avec Unity

si bien que cette source sonore pourrait se situer sur n’importe quel objet. Il est cependant
logique que l’ambiance sonore de l’île soit liée à cet objet de jeu.
Un composant Audio Source est à présent disponible dans le panneau Inspector du
terrain. Vous pouvez soit choisir le ichier qui doit être lu soit ne rien indiquer si vous avez
décidé de déclencher les sons à l’aide d’un script.

Importer le premier paquet de ressources

Pour cette étape, vous aurez besoin d’utiliser le premier paquet de ressources de l’archive
que vous avez téléchargée sur le site Pearson (http://www.pearson.fr). Décompressez cette
archive, localisez le ichier nommé Sound1.unitypackage dans le dossier 8181_02_code,
puis revenez à Unity et cliquez sur Assets > Import Package.
Dans la boîte de dialogue Import Package qui s’ouvre alors, parcourez votre disque dur
jusqu’à l’emplacement où vous avez enregistré l’archive décompressée. Sélectionnez ce
dossier, puis cliquez sur Ouvrir. La liste des ressources disponibles s’afiche – par défaut,
Unity part du principe que l’utilisateur souhaite importer toutes les ressources, mais il vaut
mieux importer seulement certaines ressources lors de l’utilisation de plus gros paquets de
ressources.
Le paquet sound1 ne contient qu’un ichier audio au format MP3 ichier appelé hillside.
mp3 placé dans un dossier Sound, si bien que seuls ces deux éléments s’afichent.
Cliquez sur Import pour conirmer l’ajout de ces ichiers dans votre projet. Après leur
conversion, ils devraient apparaître dans le panneau Project – vous devez cliquer sur
la lèche grise à gauche du dossier Sound pour aficher le ichier hillside qu’il contient.
Les ichiers audio s’accompagnent d’une icône en forme de haut-parleur dans le panneau
Project (voir Figure 2.32).

Figure 2.32

Le ichier hillside peut maintenant être appliqué au composant Audio Source du terrain.
Chapitre 2 Environnements 51

Cliquez sur la lèche pointant vers le bas, située à droite du paramètre Audio Clip dans
le composant Audio Source de l’objet de jeu Terrain, ain d’aficher la liste de tous les
ichiers audio disponibles dans le projet. Comme celui-ci ne contient que le ichier audio
hillside, seul ce dernier s’afiche dans le menu contextuel. Sélectionnez-le maintenant.

Les autres paramètres audio

Le composant Audio Source dispose de différents contrôles sur la lecture des sons. Pour
le son d’ambiance hillside, assurez-vous simplement que les options Play On Awake
(lecture à l’activation) et Loop (boucle) sont sélectionnées.
La lecture se déclenchera lors de l’entrée du joueur dans la scène (ou dans le niveau) et
continuera en boucle jusqu’à ce que la scène se termine.
Les paramètres de votre composant Audio Source devraient être les mêmes qu’à la
Figure 2.33.

Figure 2.33

Les paramètres Min/Max Volume et Rolloff Factor (facteur d’éloignement) n’ont

aucun effet sur ce son car il est en stéréo – le volume est indépendant de la distance entre
le joueur et la source sonore. Pour des sons mono, en revanche, ces options donnent les
résultats suivants :
∑ Min/Max Volume. Le volume le plus faible/élevé que le son peut avoir, indépendamment
de la proximité de l’écouteur audio.
∑ Rolloff Factor. La rapidité avec laquelle le volume sonore croît ou décroît lorsque
l’auditeur se rapproche ou s’éloigne de la source.

Étape 9. Regardez le ciel (la skybox)

Dans les environnements 3D, vous représentez l’horizon ou le lointain en ajoutant une
skybox. Une skybox est un cubemap (une vue cubique aplatie), c’est-à-dire une série de six
52 Développez des jeux 3D avec Unity

textures placées à l’intérieur d’un cube dont le rendu simule le ciel et l’horizon. Ce cube-
map recouvre le monde en 3D à tout moment et, tout comme l’horizon réel, il ne peut pas
être atteint par un joueur.
Pour appliquer une skybox à la scène, cliquez sur Edit > Render Settings. Le contenu
du panneau Inspector afiche alors les préférences de rendu de cette scène. Cliquez sur
la lèche déroulante située à droite du paramètre Skybox Material, puis sélectionnez
Sunset pour l’appliquer à la skybox. Il est crucial que vous compreniez que chaque skybox
ajoutée sera uniquement visible dans le panneau Game par défaut.
La skybox Sunset du paquet de ressources Standard, comme de nombreuses autres,
dispose d’un soleil prédéini. Cependant, votre scène en a déjà un, représenté visuel-
lement par le relet de la lumière directionnelle. Vous devez donc repositionner celle-ci
pour qu’elle corresponde au soleil de la skybox. Ain que vous puissiez juger de ce
problème par vous-même, vous ajouterez d’abord le personnage du joueur (First Person
Controller).

Étape 10. La mer

Vous avez créé une île, celle-ci doit donc être entourée d’eau. L’eau, dans Unity, est réali-
sée à partir d’un matériau animé appliqué à une surface. Bien qu’il soit possible de créer
d’autres effets dynamiques pour l’eau à l’aide des particules, la meilleure façon d’en ajouter
une grande étendue consiste à utiliser un des matériaux fournis avec Unity.
Le paquet de ressources Standard Assets contient deux surfaces prêtes à l’emploi sur
lesquelles le matériau Water est appliqué. Ces objets enregistrés en tant qu’éléments préfa-
briqués peuvent être facilement utilisés depuis le panneau Project. Il vous sufit en effet
d’ouvrir le dossier Standard Assets/Water.
Faites glisser l’élément préfabriqué Daylight Simple Water dans la scène, puis positionnez-
le à (500, 4, 500) en indiquant ces valeurs dans les champs Position X, Y et Z du composant
Transform dans le panneau Inspector. Ain d’augmenter l’échelle de l’élément préfabri-
qué Water pour qu’il forme une mer tout autour de l’île, donnez la valeur 1600 aux para-
mètres X et Z de Scale.
L’eau est ainsi placée au centre de la carte, quatre mètres au-dessus du fond marin. Cela
recouvrira les coins de l’île et masquera la nature carrée du terrain (voir Figure 2.34).
Chapitre 2 Environnements 53

Figure 2.34

Étape 11. Randonnée sur l’île

Dans le panneau Project, afichez le contenu du sous-dossier Prefabs du paquet de
ressources Standard Assets : il contient un seul élément préfabriqué : l’objet First Person
Controller (contrôleur à la première personne). Vous allez le faire glisser et le déposer
dans la scène ain de vous promener sur votre terrain à l’aide du clavier et de la souris.
Faites glisser cet élément préfabriqué depuis le panneau Project dans le panneau Scene.
Vous ne pouvez pas le positionner précisément lorsque vous le déposez dans la scène, mais
vous pouvez le faire par la suite.
Maintenant que l’objet First Person Controller est un objet de jeu actif, il apparaît dans
le panneau Hierarchy et ses composants dans le panneau Inspector.
Repositionnez-le à (500, 35, 500) en entrant ces valeurs dans le composant Transform du
panneau Inspector. Le personnage se place alors au centre de la carte, sur les axes X et Z,
car vous avez créé un terrain de 1 000 mètres de côté. La valeur 35 sur l’axe Y garantit que
le joueur se trouve au-dessus du niveau du sol – dans le cas contraire, il tomberait dans la
carte lors du lancement du jeu. Si vous avez créé une colline à cette position lorsque vous
avez sculpté votre terrain, augmentez simplement cette valeur Y pour placer le personnage
en haut de la colline au début de la partie.
54 Développez des jeux 3D avec Unity

Pour voir plus facilement où votre objet personnage est placé, assurez-vous
Info qu’il est sélectionné dans le panneau HierarcHy, placez le curseur sur le pan-
neau Scene et appuyez sur la touche F. La vue dans le panneau Scene se centre
alors sur l’objet sélectionné.

Cliquez maintenant sur le bouton Play pour tester le jeu. Vous devriez pouvoir vous promener
sur votre île !
Les contrôles par défaut du personnage sont les suivants :
∑ Haut/W : avancer ;
∑ Bas/S : reculer ;
∑ Gauche/A : pas sur le côté gauche (aussi connu sous le nom de straing) ;
∑ Droit/D : pas sur le côté droit ;
∑ Souris : examiner les alentours ou faire pivoter le joueur lorsqu’il se déplace.
Grimpez au sommet d’une colline et tournez-vous jusqu’à ce que vous puissiez voir le relet
du soleil. Regardez ensuite à droite du relet : vous constatez que la skybox possède égale-
ment une zone éclairée pour représenter le soleil. Vous devez donc repositionner l’objet
Directional Light ain qu’il corresponde au soleil de la skybox, comme nous l’avons
déjà mentionné.
Cliquez de nouveau sur le bouton Play pour interrompre le test du jeu. Il est essentiel
d’arrêter le jeu lorsque vous effectuez des modiications. Si vous le laissez s’exécuter ou
si vous cliquez sur Pause, les modiications que vous apportez à la scène ne seront que
temporaires – elles seront annulées dès que vous cliquerez de nouveau sur Play ou que vous
quitterez Unity.

Étape 12. Alignement du soleil et retouches inales

Sélectionnez l’objet Directional Light dans le panneau Hierarchy, puis repositionnez-
le à (–500, 500, 500) dans le composant Transform du panneau Inspector. La lumière se
place alors sur le côté de la carte où se trouve le soleil de la skybox. Faites ensuite pivoter
l’objet de 120 sur l’axe  Y (boîte centrale) pour que la position de l’objet Directional
Light corresponde à la lumière de la skybox.
Chapitre 2 Environnements 55

Enin, comme nous avons l’objet First Person Controller, nous n’avons désormais plus
besoin de l’objet Main Camera ajouté par défaut. Unity le signale d’ailleurs en afichant
un message (voir Figure 2.35) dans la zone d’aperçu de la console au bas de l’écran lorsque
vous testez le jeu.

Figure 2.35

Pour remédier à ce problème, il sufit de supprimer l’objet Main Camera. Pour cela, sélec-
tionnez-le dans le panneau Hierarchy, puis cliquez sur Edit > Delete ou appuyez sur
Cmd+Retour arrière (Mac OS) ou sur Suppr (Windows).
Maintenant que cet objet a disparu, l’île est terminée. Enregistrez votre scène ain de ne
rien perdre de votre travail. Pour cela, cliquez sur File > Save Scene et nommez la scène
Island Level, par exemple. Unity propose automatiquement de l’enregistrer dans le dossier
Assets de votre projet car toutes les ressources doivent s’y trouver. Pour organiser vos
éléments, vous pouvez créer un sous-dossier Niveaux où enregistrer votre scène.
Félicitations, votre île est prête à être explorée. Cliquez de nouveau sur le bouton Play et
promenez-vous ! N’oubliez pas de cliquer sur Play de nouveau lorsque vous aurez terminé.

Importer des modèles

Votre île est prête pour le jeu ! Vous allez donc apprendre à importer des modèles créés
dans des applications externes. Les modèles pour les exercices de ce livre étant fournis,
vous aurez besoin d’importer un autre paquet Unity pour ajouter le premier modèle – un
avant-poste – à votre projet.

Importer le paquet de ressources du modèle

Cliquez sur Assets > Import Package dans Unity puis parcourez votre disque dur jusqu’au
dossier Code_8181/8181_02_code/Outpost.unitypackage que vous avez extrait de l’archive
téléchargée (http://www.pearson.fr).
Cliquez ensuite sur Assets > Import Package.
56 Développez des jeux 3D avec Unity

Figure 2.36

Laissez tous les ichiers sélectionnés, puis cliquez sur le bouton Import pour valider. Une
fois le contenu du paquet importé, un nouveau dossier de ressources outpost est créé dans le
panneau Project, et donc également dans le dossier Assets de votre projet sur votre disque
dur. Cliquez sur la lèche grise située à côté du nom de ce dossier dans le panneau Project
pour aficher son contenu.

Figure 2.37

Le dossier importé contient le modèle lui-même ainsi que deux sous-dossiers : Materials
pour les matériaux et Textures pour les images qui composent les textures de ces matériaux.
Vous pouvez repérer un modèle 3D dans Unity grâce à son icône, un petit cube accompagné
d’une image de page. Cela permet de le différencier des éléments préfabriqués, dont l’icône
est un simple cube, comme vous le verrez plus loin.
Chapitre 2 Environnements 57

Les paramètres communs des modèles

Avant d’ajouter un modèle dans la scène active, vous devez toujours vous assurer dans le
panneau Inspector que ses paramètres conviennent. Lorsque vous importez de nouveaux
modèles dans un projet, Unity les interprète à l’aide de son format de ichier FBX.
Avec le composant FBX Importer du panneau Inspector, vous pouvez sélectionner le
ichier du modèle dans le panneau Project et régler ses paramètres Meshes, Materials
et Animations avant que le modèle ne devienne partie intégrante de votre jeu.

Le maillage (Meshes)
À la section Meshes du composant FBX Importer, vous pouvez déinir les paramètres
suivants :
∑ Scale Factor. Généralement ixé à la valeur 1, ce paramètre indique qu’une unité est
égale à un mètre dans le monde du jeu. Pour utiliser une échelle différente, il sufit
d’ajuster ce paramètre avant d’ajouter le modèle à la scène. Mais vous pouvez toujours
modiier l’échelle des objets lorsqu’ils se trouvent dans la scène grâce aux paramètres
Scale du composant Transform.
∑ Generate Colliders (générer les composants de collisions). Cette option attribue un
Mesh Collider à chaque composant individuel du modèle. Un Mesh Collider
(composant de collisions respectant le maillage) est un collider (composant de colli-
sions) complexe qui s’adapte à des formes géométriques complexes. Il s’agit par consé-
quent du type habituel de collider à appliquer à toutes les parties d’une carte ou d’un
modèle 3D de bâtiment.
∑ Calculate Normals. La normale est la face avant de chaque maillage du modèle 3D,
autrement dit le côté visible après le rendu. En activant cette option, vous permettez à
Unity de s’assurer que le rendu de toutes les surfaces est correctement déini dans le jeu.
∑ Smoothing Angle. Lorsque vous utilisez la fonction Calculate Normals, le lissage
permet de spéciier l’angle qu’une arête doit avoir pour être considérée comme une arête
en dur par le moteur du jeu. Les autres pourront être lissées par exemple pour le rendu
des lumières sur une sphère.
∑ Split Tangents. Ce paramètre permet au moteur de corriger les modèles importés avec
un placage de relief incorrect. Le placage de relief, ou Bump mapping, utilise deux
textures : une image qui représente l’apparence du modèle et une heightmap. En combi-
nant les deux, il permet au moteur de rendu d’aficher des surfaces planes de polygones
comme si elles comportaient des déformations en  3D. Lorsque vous créez ces effets
dans des applications tierces et que vous les transférez dans Unity, les effets d’éclairage
58 Développez des jeux 3D avec Unity

peuvent parfois ne pas être corrects. Cette option est conçue pour corriger ce problème
en interprétant leurs matériaux différemment.
∑ Swap UVs. Ce paramètre sert à corriger les erreurs d’importation des shaders de lumière
depuis des applications tierces.

Les matériaux (materials)

La section Materials permet de choisir la façon dont sont interprétés les matériaux créés
dans une application de modélisation 3D  tierce. Dans le menu déroulant Generation,
vous pouvez choisir l’option Per Texture, ain de créer un matériau Unity pour chaque
image de texture trouvée dans le ichier, ou l’option Per Material, ain de créer des maté-
riaux uniquement pour les matériaux existants dans le ichier original.

Les animations
À la section Animations du composant Importer, vous interprétez les animations créées
dans votre logiciel de modélisation de différentes façons. Vous pouvez choisir une des
méthodes suivantes dans le menu déroulant Generation :
∑ Don’t Import. Le modèle est importé sans aucune animation.
∑ Store in Original Roots. Le modèle conserve les animations de chaque objet parent, car
le parent ou la racine (root) des objets peut s’importer de manière différente dans Unity.
∑ Store in Nodes. Le modèle conserve les animations de chaque objet enfant, ce qui
permet un contrôle plus important de l’animation de chaque élément par le script.
∑ Store in Root. Le modèle ne conserve que l’animation de l’objet parent de l’ensemble
du groupe.
La section Animations contient trois cases à cocher supplémentaires :
∑ Bake Animations. Indique à Unity d’interpréter les articulations dans les modèles qui
utilisent une armature pour être animés (cinématique inverse).
∑ Keyframes Reduction. Supprime les images clés inutiles dans les modèles exportés
depuis des logiciels de modélisation. Cette option devrait toujours être sélectionnée car
elle améliore les performances du modèle d’animation puisque Unity n’a pas besoin de
ces images-clés.
∑ Split Animations. Lorsque les animateurs créent des modèles destinés à être utilisés
dans Unity, ils réalisent leurs animations sur une échelle de temps. Après en avoir noté
la durée, ils peuvent disposer chaque partie de l’animation dans son échelle de temps,
Chapitre 2 Environnements 59

en indiquant le nom et les images sur lesquelles chaque animation se déroule. De cette
manière, on peut ensuite appeler chaque animation par son nom à l’aide d’un script.

Le paramétrage du modèle d’avant-poste

Le modèle d’avant-poste que vous avez importé étant sélectionné dans le panneau Project,
vous allez utiliser le composant FBX Importer du panneau Inspector pour ajuster ses
paramètres. Assurez-vous des points suivants.
∑ À la section Meshes, l’option Scale Factor est déinie à 1 et les options Generate
Colliders et Calculate Normals sont sélectionnées.
∑ À la section Materials, l’option Per Texture est sélectionnée dans le menu
Generation.
∑ À la section Animations, les options Keyframes Reduction et Split Animations
sont sélectionnées.
Cliquez sur le bouton + (Ajouter un symbole) à droite du tableau situé au bas de la section
Animations pour ajouter trois séquences animées.
La première animation est automatiquement nommée idle (inactif), ce qui est parfait, mais
vous devez indiquer le nombre d’images à utiliser. Cliquez sur la première valeur dans
la colonne Start, saisissez  1 pour indiquer à Unity de commencer cette animation sur
l’image 1, puis indiquez une valeur de 2 dans la colonne End.
Répétez cette étape pour ajouter deux autres animations :
∑ dooropen : de l’image 3 à l’image 12 ;
∑ doorshut : de l’image 13 à l’image 24.

Les noms de ces animations sont sensibles à la casse quand vous les appelez
Info dans un script. Vous devez donc vous assurer de les écrire exactement comme
nous les indiquons.

L’option Loop du tableau Animations peut être trompeuse pour les nouveaux utilisateurs.
Elle n’est pas conçue pour que l’animation que vous paramétrez soit lue en boucle (c’est
le paramètre Wrap Mode qui gère cela, une fois l’animation insérée dans la scène). En
fait, la fonction Loop permet d’ajouter une image aux animations lues en boucle lorsque
la première et la dernière image des animations provenant d’applications de modélisation
tierces ne correspondent plus après leur importation dans Unity.
60 Développez des jeux 3D avec Unity

Figure 2.38

Lorsque votre modèle d’avant-poste est paramétré comme indiqué, cliquez sur le bouton
Apply pour conirmer ces paramètres d’importation. Le modèle est prêt à être inséré dans
la scène et utilisé dans votre jeu.
Chapitre 2 Environnements 61

En résumé
Ce chapitre vous a donné les bases du développement de votre premier environnement. À
partir d’une surface plate, vous avez créé en très peu de temps une île complète à explorer.
Vous avez également étudié l’éclairage et le son, deux principes de base qui s’appliquent
dans tous les types de projets de jeux que vous rencontrerez.
Souvenez-vous que vous pouvez réactiver à tout moment les outils de terrain décrits ici
ain d’ajouter des détails à votre terrain. Une fois que vous vous sentirez plus en coniance
dans l’utilisation du son, nous reviendrons sur ce sujet et nous montrerons comment ajouter
d’autres sources audio à votre île.
Continuez les exercices de ce livre et vous découvrirez tous les types de nuances supplé-
mentaires que vous pouvez apporter aux environnements ain de les rendre plus crédibles
pour le joueur.
Vous découvrirez comment ajouter une touche dynamique à l’île lorsque nous aborderons
l’utilisation des particules, en ajoutant des feux de camp ainsi qu’un panache de fumée et
des cendres au volcan !
Au prochain chapitre, vous allez intégrer le bâtiment d’avant-poste à votre scène et voir
comment déclencher ses animations lorsque le joueur s’approche de la porte. Pour cela,
nous allons présenter l’écriture de code JavaScript pour Unity ain que vous commenciez à
développer les interactions dans le jeu.
 3
Personnages jouables
Vous allez élargir le scénario de l’île que vous avez créée précédemment, en vous tour-
nant vers la construction du personnage du joueur que vous avez déjà ajouté à la scène.
Stocké sous forme d’élément préfabriqué (un modèle de données) offert par Unity Techno-
logies dans le paquet de ressources Standard Assets, cet objet est un exemple de personnage
jouable pour un jeu à la première personne. Vous allez voir comment la combinaison des
objets et des composants qui le constituent permet d’obtenir cet effet.
Vous étudierez les coulisses de cet élément préfabriqué et vous découvrirez comment chacun
de ses composants fonctionne pour constituer le personnage du joueur. Vous découvrirez
également les scripts JavaScript dans Unity. Cet élément préfabriqué étant déjà ajouté à la
scène du jeu, ce serait trop simple de continuer à développer le jeu en partant du principe
que cet objet fonctionne correctement. En effet, chaque fois que vous implémentez une
ressource créée en dehors de Unity, vous devez comprendre son fonctionnement. Dans le
cas contraire, vous aurez des dificultés pour ajuster cet élément ou corriger d’éventuelles
erreurs.
64 Développez des jeux 3D avec Unity

Nous allons aborder les points suivants ain que vous compreniez comment la combinaison
de quelques objets et de quelques composants peut créer un personnage à part entière :
∑ les tags, les calques et les éléments préfabriqués dans le panneau Inspector ;
∑ les relations parent-enfant dans les objets ;
∑ les bases du langage JavaScript ;
∑ l’écriture de script pour les mouvements du joueur ;
∑ le paramétrage de variables publiques dans le panneau Inspector ;
∑ l’utilisation de caméras pour créer le point de vue.

Le panneau Inspector
Comme c’est la première fois que vous disséquez un objet dans le panneau Inspector,
commençons par examiner les caractéristiques de ce panneau, communes à tous les objets.
Le nom de l’objet sélectionné s’afiche en haut du panneau Inspector, précédé d’une icône
d’élément préfabriqué (un cube rouge, vert et bleu) ou d’une icône d’objet de jeu (un cube
bleu clair) ainsi que d’une case à cocher permettant de le désactiver temporairement ou
déinitivement.
Pour l’objet de jeu Directional Light, qui n’est pas créé à partir d’un élément préfabriqué
existant, le haut du panneau Inspector se présente comme à la Figure 3.1.

Figure 3.1

Les faces rouges, vertes et bleues du cube de l’icône, indiquent qu’il s’agit d’un objet de
jeu standard. Vous pouvez renommer cet objet très simplement en cliquant sur le champ du
nom de l’objet, puis en entrant un nouveau nom.
Sous l’icône de l’objet et le champ indiquant son nom se trouvent la case à cocher d’acti-
vation de l’objet et les options Tag et Layer.
Chapitre 3 Personnages jouables 65

Les tags
Les tags sont tout simplement des mots clés qu’on peut assigner à un objet de jeu. Vous
pouvez ensuite utiliser ces mots ou une phrase de votre choix pour faire référence à l’objet
(ou aux objets) de jeu dans le script (un tag peut être utilisé plusieurs fois). Si vous connais-
sez Adobe Flash, vous pouvez comparer les tags aux noms d’occurrences dans Flash, au
sens où il s’agit dans les deux cas de mots clés utilisés pour représenter les objets dans une
scène.
L’attribution d’un tag à un objet de jeu se réalise en deux étapes : ajout du tag à la liste du
Tag Manager, puis application à l’objet.
Pour vous habituer à l’utilisation des tags, vous allez déinir et appliquer votre premier tag à
l’objet Directional Light. Sélectionnez-le dans le panneau Hierarchy, puis cliquez sur
le menu déroulant Tag qui indique pour le moment Untagged.
Ce menu contient la liste des tags existants. Vous pouvez soit choisir l’un d’eux ou en créer
un. Sélectionnez Add Tag au bas du menu ain d’ajouter un tag à la liste du Tag Manager.

Figure 3.2

Le panneau Inspector afiche alors le Tag Manager et non plus les composants de l’objet
sélectionné.
Le Tag Manager contient à la fois les Tags et les Layers. Pour ajouter un nouveau tag,
cliquez sur la lèche grise située à gauche de Tag, pour aficher les paramètres Size et
Element. Vous pouvez alors saisir le nom du tag dans le champ vierge situé à droite de
Element 0.
Entrez le nom Sunlight (vous pouvez nommer les tags comme cela vous convient), puis
appuyez sur Entrée pour valider. La valeur du paramètre Size s’incrémente d’une unité dès
que vous appuyez sur Entrée, et un nouveau champ Element devient disponible pour un
prochain tag.
66 Développez des jeux 3D avec Unity

Figure 3.3

Le paramètre Size correspond ici au nombre de tags actuellement déinis. Unity utilise les
noms Size et Element dans plusieurs menus différents du panneau Inspector, comme vous
le verrez par la suite.
Vous avez ajouté un tag à la liste, mais il n’est pas encore attaché à l’objet Directional
Light. Par conséquent, sélectionnez de nouveau cet objet dans le panneau Hierarchy,
puis cliquez sur le menu déroulant Tag en haut du panneau Inspector. Le tag Sunlight
que vous venez de créer apparaît maintenant sur la liste. Pour l’appliquer, il vous sufit de
le sélectionner dans le menu déroulant (voir Figure 3.4).

Figure 3.4

Les calques (layers)

Les calques sont un moyen supplémentaire de regrouper des objets ain de leur appliquer
des règles spéciiques, en particulier pour le rendu des lumières et des caméras. Toutefois,
Chapitre 3 Personnages jouables 67

ils peuvent aussi être utilisés avec une technique physique appelée raycasting (tracé de
rayon), ain d’isoler certains objets de façon sélective.
Après avoir placé des objets sur un calque, vous pouvez les désélectionner à partir du para-
mètre Culling Mask d’une lumière ain qu’ils ne soient pas affectés par celle-ci. Comme
les tags, les calques se créent dans le Tag Manager – ils apparaissent en dessous de la liste
des tags.

Les éléments préfabriqués dans le panneau Inspector

Si l’objet de jeu que vous sélectionnez dans le panneau Hierarchy provient d’un élément
préfabriqué, le panneau Inspector propose alors quelques paramètres supplémentaires
(voir Figure 3.5).

Figure 3.5

Trois boutons supplémentaires s’afichent sous les champs Tag et Layer et permettent
d’interagir avec l’objet créé à partir d’un élément préfabriqué.
∑ Select. Permet de localiser et de mettre en évidence l’élément préfabriqué auquel
appartient cet objet dans le panneau Project.
∑ Revert. Annule tous les paramètres des composants de l’objet actif et rétablit les para-
mètres utilisés par l’élément préfabriqué dans le panneau Project.
∑ Apply. Applique les valeurs utilisées dans l’occurrence sélectionnée aux paramètres de
l’élément préfabriqué. Toutes les copies de cet élément préfabriqué intégrées dans la
scène en cours sont également mises à jour.
Maintenant que vous connaissez les paramètres supplémentaires disponibles dans le
panneau Inspector, nous pouvons commencer à étudier le personnage du joueur.

L’objet First Person Controller en détail

Commençons par regarder les objets qui constituent l’objet First Person Controller
(FPC) avant de nous pencher sur les composants qui le font fonctionner.
68 Développez des jeux 3D avec Unity

Dans le panneau Hierarchy, cliquez sur la lèche grise à gauche de l’objet First Person
Controller, ain d’aficher les objets qui y sont imbriqués. Lorsque les objets sont imbri-
qués de cette manière, il s’agit d’une relation parent-enfant. Dans cet exemple, l’objet First
Person Controller est le parent, et les objets Graphics et Main Camera, ses enfants.
Les objets enfants s’afichent en retrait dans le panneau Hierarchy ain de montrer leurs
relations à l’objet parent (voir Figure 3.6).

Figure 3.6

Les relations parent-enfant

Vous devez retenir certaines règles essentielles concernant les objets imbriqués ou les
objets enfants.
Les valeurs de position et de rotation d’un objet enfant sont relatives à celles de ses parents.
On parle alors de position locale et de rotation locale. Par exemple, si les coordonnées d’un
objet sont (500, 35, 500), et que celles d’un de ses objets enfants sont (0, 0, 0), on remarque
que celui-ci semble avoir la même position que son parent. Il s’agit en effet de la position
relative de l’objet enfant : en plaçant un objet enfant à (0, 0, 0), vous le positionnez aux
coordonnées d’origine de son parent, autrement dit par rapport à la position du parent.
Cliquez sur l’objet Graphics situé sous l’objet parent FPC dans le panneau Hierarchy.
Comme vous pouvez le constater, l’objet FPC se trouve au centre de l’île et, pourtant, les
valeurs du composant Transform de l’objet Graphics sont de (0, 0, 0).
En conséquence, chaque fois que l’objet parent est déplacé, ses enfants l’accompagnent,
tout en conservant leur position et leur rotation locale selon la position et la rotation du
parent dans le monde du jeu.
Chapitre 3 Personnages jouables 69

Les objets de First Person Controller

Cet objet se compose des trois éléments suivants :
1. First Person Controller. L’objet FPC, ou parent du groupe, sur lequel sont appliqués
le script et le collider (composant de collision) principal pour contrôler son comporte-
ment. Le mouvement de cet objet est contrôlé par deux scripts : le premier permet de
le déplacer à l’aide du clavier et le second de le faire pivoter en déplaçant la souris à
gauche et à droite.
2. Graphics. Tout simplement la forme primitive Capsule (voir Figure  3.7), qui vous
permet en tant que développeur de voir où vous avez placé l’objet FPC.
3. Main Camera. Placé au niveau des yeux du joueur, cet objet fournit le point de vue.
Des scripts lui sont appliqués ain que le joueur puisse regarder vers le haut et vers le
bas.
En raison de la relation parent-enfant, lorsque l’objet FPC se déplace ou pivote, les objets
Graphics et Main Camera suivent.
Sélectionnez l’objet First Person Controller dans le panneau Hierarchy, placez le
curseur sur le panneau Scene, puis centrez la vue sur cet objet (touche F). L’objet FPC
devrait s’aficher comme à la Figure 3.7.

Figure 3.7
70 Développez des jeux 3D avec Unity

Cliquez maintenant sur le bouton Play, puis n’importe où dans le panneau Game et
commencez à déplacer le personnage tout en l’observant dans le panneau Scene. Vous
constatez que lorsque vous modiiez la position du personnage avec les touches du clavier
et que vous le faites tourner à l’aide de la souris, la position des objets enfants change
également.

Pour aficher les panneaux Game et Scene en même temps, cliquez sur WindoW >
Info layoutS > 2 by 3, puis déplacez les panneaux à votre convenance.

Objet 1. L’objet First Person Controller (parent)

L’objet First Person Controller étant toujours sélectionné dans le panneau Hierarchy,
observez ses composants dans le panneau Inspector.

Figure 3.8

L’objet FPC est formé de quatre composants  : Transform, FPSWalker (Script),

Character Controller et Mouse Look (Script) [voir Figure 3.8].
Chapitre 3 Personnages jouables 71

Le composant Transform
Comme tous les objets de jeu actifs, l’objet FPC possède un composant Transform qui
indique ses paramètres de position, de rotation et d’échelle et permet de les ajuster.

Le composant FPSWalker (Script)

Ce script, écrit en JavaScript, permet de contrôler le déplacement du personnage vers l’ar-
rière et vers l’avant avec les touches directionnelles Haut et Bas (ou W et S), sur le côté (le
straing dans le jargon des joueurs) à l’aide des touches directionnelles Gauche et Droite
(ou A et D), et de le faire sauter en utilisant la touche de saut, qui est, par défaut, la barre
d’espacement.
Ce script compte trois variables publiques Speed, JumpSpeed et Gravity, visibles dans le
panneau Inspector. Il est ainsi possible d’ajuster ces valeurs sans même ouvrir le script.
Le moteur physique de Unity peut contrôler les objets avec un composant Rigidbody,
mais notre personnage n’en possède pas. Sa propre gravité doit donc être indiquée dans
une partie du script. Cette variable permet d’augmenter l’effet de la gravité, ce qui a pour
conséquence d’entraîner une chute plus rapide du personnage.

Script est le premier paramètre (avant les variables publiques) de tous les com-
ce posants de type script. Il permet de sélectionner un autre script sans devoir
Astu
remplacer le composant.
C’est particulièrement utile lorsque vous améliorez progressivement les scripts
existants – vous pouvez alors simplement dupliquer les scripts, les modiier, puis
les utiliser à tour de rôle en les sélectionnant dans le menu déroulant situé
à  droite du nom du script. De cette manière, vous conservez les paramètres
existants des variables publiques dans le panneau inSPector.

Le composant Character Controller

Cet objet agit comme un collider (un composant de collision qui donne à l’objet la capacité
physique d’interagir avec d’autres objets) et il est spécialement conçu pour s’appliquer aux
mouvements du personnage et à leur contrôle dans le monde du jeu. Ses paramètres sont
les suivants :
∑ Height. La hauteur du personnage, qui déinit la taille du collider en forme de capsule
du personnage.
72 Développez des jeux 3D avec Unity

∑ Radius. La largeur du collider en forme de capsule. La valeur par défaut correspond

au rayon de l’objet enfant Graphics. Toutefois, si vous souhaitez agrandir la circonfé-
rence du personnage, soit pour restreindre ses mouvements soit pour augmenter l’es-
pace dans lequel les collisions sont détectées, vous pouvez augmenter la valeur de ce
paramètre.
∑ Slope Limit. Ce paramètre permet de déinir le degré d’une pente que le personnage
peut gravir. En l’incluant, le composant Character Controller empêche que le
joueur puisse gravir les parois verticales ou les zones les plus escarpées du terrain, ce
qui serait bien entendu peu réaliste.
∑ Step Offset. Dans un univers du jeu qui inclut des escaliers, ce paramètre sert à déinir
à quelle distance du sol le personnage peut s’élever – plus la valeur est importante, plus
le personnage peut s’éloigner du sol pour gravir un obstacle.
∑ Skin Width. Comme le personnage va entrer en collision avec d’autres objets de jeu
dans la scène, et souvent à grande vitesse, ce paramètre vous permet de préciser à quelle
profondeur les autres colliders peuvent croiser les colliders du personnage avant qu’une
réaction ne se produise. Cela aide à réduire les conlits qui peuvent notamment occasion-
ner une secousse légère mais constante du personnage ou bloquer le personnage dans
les murs. En effet, lorsque deux colliders entrent subitement en contact sans donner le
temps au moteur de jeu de réagir en conséquence, celui-ci les désactive ou les écarte
les uns des autres de manière imprévisible plutôt que de se bloquer. Unity Technologies
recommande de régler cette valeur à 10 % du paramètre Radius du personnage.
∑ Min Move Distance. La distance minimale à laquelle le personnage pourra se dépla-
cer. Elle est généralement déinie à 0 ; avec une valeur plus importante, le personnage
ne peut bouger que si son déplacement est supérieur à cette valeur (ce qui l’empêche
alors de se mouvoir dans un lieu trop coniné). Ce paramètre s’utilise uniquement pour
réduire les conlits, mais conserve la valeur 0 dans la plupart des cas.
∑ Center. Ce paramètre de type Vector3 (valeurs x, y, z) permet d’éloigner le collider du
personnage de son point central local. Sa valeur est généralement de 0 et ne se modiie
le plus souvent que pour les personnages vus à la troisième personne, qui ont une forme
plus complexe qu’une simple capsule. En modiiant la coordonnée Y par exemple, vous
pouvez tenir compte du point de contact entre les pieds du personnage et le sol – car
c’est l’objet Character Controller collider qui déinit où l’objet repose sur le sol
et non le maillage visible des pieds du personnage.
Le composant Character Controller collider est représenté dans le panneau Scene
par un contour vert en forme de capsule, de la même manière que les autres colliders dans
Unity. À la Figure 3.9, nous avons désactivé temporairement le rendu de l’objet Graphics,
Chapitre 3 Personnages jouables 73

ain de vous aider à mieux repérer le contour du composant Character Controller

collider.

Figure 3.9

Le composant Mouse Look (Script)

Écrit en C#, ce script permet de faire pivoter le personnage lorsqu’on déplace la souris, en
laissant les déplacements latéraux aux touches directionnelles Gauche et Droite. Ce script
compte un certain nombre de variables publiques qui peuvent être ajustées :
∑ Axes. Déinit sur MouseX dans ce cas. Vous pouvez choisir pour cette variable MouseX,
MouseY ou MouseXAndY. Pour l’objet FPC, vous avez besoin que cette instance du
script Mouse Look (l’autre occurrence étant un composant de l’objet enfant Main
Camera) soit déinie sur l’axe X uniquement pour faire pivoter le personnage entier à
gauche ou à droite à l’aide de la souris – et donc l’objet enfant Main Camera.
Vous vous demandez peut-être pourquoi ne pas choisir MouseXAndY pour le compo-
sant Mouse Look de l’objet Main Camera. Cela permettrait à la caméra de s’incliner
et de pivoter sur les deux axes, certes, mais alors le personnage ne ferait plus face à
l’endroit qu’il regarde, car la caméra pivoterait uniquement de façon locale. En consé-
quence, le personnage pourrait regarder autour de lui, mais lorsque vous le déplaceriez
avec les touches du clavier, il se dirigerait aléatoirement. Avec cette instance du script
Mouse Look sur l’objet parent (First Person Controller), vous faites pivoter le
personnage, ce qui entraîne une rotation de la caméra puisque celle-ci est un objet enfant
et suit donc la rotation de son parent.
74 Développez des jeux 3D avec Unity

∑ Sensitivity X et Sensitivity Y. Comme vous n’utilisez que l’axe X de ce script, cette

variable contrôle uniquement l’inluence des mouvements latéraux de la souris sur la
rotation de l’objet. Si la variable Axes était déinie pour agir également sur l’axe Y, on
pourrait alors ajuster la manière dont les mouvements de la souris vers le haut ou vers
le bas affecteraient l’inclinaison de la caméra. Vous remarquerez que l’option Sensiti-
vity Y est déinie à 0, puisque vous ne l’utilisez pas, tandis que l’option Sensitivity X
est réglée à 15 – plus cette valeur est importante et plus la rotation est rapide.
∑ Minimum X et Maximum X. Permet de déinir l’amplitude du panoramique, puisque
ce script se charge de faire pivoter le personnage. Ces valeurs sont déinies à –360 et
360 respectivement, ce qui permet au joueur de pivoter complètement autour d’un point.
∑ Minimum Y et Maximum Y. Là encore, vous n’utilisez pas l’axe Y, si bien que cette
variable est déinie à 0. Ce paramètre limite normalement le déplacement de la vision du
joueur vers le haut et vers le bas, comme le fait l’instance de ce script attaché à l’objet
enfant Main Camera.

Objet 2. L’objet Graphics

Comme ce personnage est, par nature, destiné à un jeu à la première personne, le joueur ne
pourra jamais voir son propre corps. La capsule qui le représente est simplement incluse
dans cet élément préfabriqué pour aider le développeur à repérer facilement l’objet dans
le panneau Scene lors du développement et des tests du jeu. Les développeurs désactivent
souvent le composant Mesh Renderer dans le panneau Inspector ain de s’assurer que
le maillage de la capsule ne soit pas rendu et donc qu’elle soit bien invisible, en particulier
dans les jeux où le personnage du joueur est vu sous un autre angle dans certaines scènes.
Sélectionnez l’objet enfant Graphics dans le panneau Hierarchy, puis observez ses
composants dans le panneau Inspector.

Figure 3.10
Chapitre 3 Personnages jouables 75

Vous pouvez constater que cet objet possède un composant Transform et que sa position
est (0, 0, 0), car il se situe au centre de l’objet parent First Person Controller. Cet objet
ayant pour seul but d’offrir une représentation visuelle du joueur, il ne dispose que des deux
composants nécessaires pour le rendre visible : Mesh Filter et Mesh Renderer. Mais
que font ces deux composants ?

Le composant Mesh Filter

Ce composant est nommé "Poly Surface  2" dans cette occurrence. Quel que soit le
maillage  3D, le nom du composant Mesh Filter correspond généralement au nom de
l’objet qu’il représente. Par conséquent, lorsque vous utilisez des modèles créés dans une
application externe, les composants Mesh Filter portent le nom des différentes parties du
modèle.
Ce composant est tout simplement celui qui contient le maillage, autrement dit la forme 3D
elle-même. Il permet au moteur de rendu de tracer une surface à partir de ce maillage.

Le composant Mesh Renderer

Un composant Mesh Renderer doit être présent ain de créer les surfaces sur le maillage
d’un objet  3D. Il gère également la réaction du maillage à la lumière et les matériaux
utilisés sur la surface pour aficher les couleurs ou les textures.
Ses paramètres sont les suivants :
∑ Cast Shadows. Déinit si la lumière sur cet objet projette une ombre sur les autres
surfaces (effectif uniquement dans la version Unity Pro ; les ombres sont désactivées
dans les lumières dans la version gratuite de Unity).
∑ Receive Shadows. Déinit si les ombres projetées par d’autres objets sont dessinées sur
cet objet (disponible uniquement dans la version Unity Pro ; les ombres sont désactivées
dans les lumières dans la version gratuite de Unity).
Dans cet exemple, aucune de ces deux options n’est activée. Tout d’abord, la capsule
n’étant jamais visible, il est inutile de projeter des ombres dessus. Ensuite, le joueur ne
pense pas que son personnage a un corps en forme de gélule, si bien qu’il lui semblerait
plutôt étrange de voir une ombre de cette forme le suivre.
∑ Materials. Ce paramètre utilise le système Size et Element que nous avons vu dans le
Tag Manager précédemment. Il permet de déinir un ou plusieurs matériaux et d’ajuster
leurs paramètres directement, sans avoir à chercher les matériaux utilisés, puis de les
paramétrer séparément dans le panneau Project.
76 Développez des jeux 3D avec Unity

Comme l’objet Graphics ne nécessite ni ne possède de paramètre de couleur ou de texture,

il n’existe pas de matériau à prévisualiser. Vous étudierez les paramètres des matériaux au
cours des prochains chapitres.

Objet 3. L’objet Main Camera

L’objet Main Camera permet de visualiser le monde virtuel dans le jeu. Dans l’élément
préfabriqué First Person Controller, il est positionné à la hauteur des yeux du person-
nage (en haut de la capsule Graphics). Grâce à des scripts, le joueur peut déplacer tout
l’objet parent mais aussi la caméra de façon indépendante pour regarder autour de lui tout
en se déplaçant.
En plus de l’élément Transform habituel, les objets de jeu caméra disposent habituel-
lement de trois composants clés  : Camera, GUILayer et Flare Layer ainsi que d’un
composant Audio Listener pour capter des sons, même si ce dernier est généralement
supprimé car Unity exige qu’un seul écouteur audio soit présent par scène.
Dans cet exemple, la caméra dispose également d’un composant de script unique appelé
Mouse Look (Script), qui gère la rotation et l’inclinaison de la caméra en fonction de la
position de la souris. Pour mieux comprendre les vues caméra, nous allons étudier le fonc-
tionnement de ces composants de base.

Le composant Camera
C’est l’élément principal de visualisation, même s’il est généralement accompagné des
composants GUILayer et Flare Layer. Ain de comprendre comment le composant
Camera afiche le monde du jeu, nous allons examiner ses paramètres.

Figure 3.11
Chapitre 3 Personnages jouables 77

∑ Clear Flags. Généralement déini sur sa valeur par défaut, Skybox, pour que la caméra
puisse effectuer le rendu de l’objet Skybox actuellement appliqué à la scène. Ce para-
mètre permet au développeur de déinir et de gérer plusieurs caméras spéciiques ainsi
que de procéder au rendu de certaines parties de l’univers du jeu, en particulier lors de
la conception du jeu. Toutefois, il est peu probable que vous commenciez à utiliser ces
techniques avant de connaître beaucoup mieux Unity.
∑ Back Ground Color. La couleur de fond est celle qui est rendue derrière tous les objets
du jeu si aucun matériau skybox n’est appliqué à la scène. Vous pouvez la modiier, soit
en cliquant sur le bloc de couleur puis en utilisant le sélecteur de couleur, soit en échan-
tillonnant une couleur sur l’écran avec l’outil Pipette située à droite du bloc de couleur.
∑ Normalized View Port Rect. Permet de déinir les dimensions et la position de la vue
Caméra. Généralement, il est déini pour occuper tout l’écran, ce qui est d’ailleurs le cas
de l’objet Main Camera attaché au joueur dans notre exemple.
Les coordonnées X et Y étant déinies à 0, la vision de la caméra commence dans le
coin inférieur gauche de l’écran. Étant donné que les options Width et Height ont
une valeur de 1, la vue de cette caméra emplit tout l’écran, car ces valeurs utilisent le
système de coordonnées de Unity, comprises entre 0 et 1.
Ce système est également utilisé dans d’autres éléments 2D dans Unity, notamment les
éléments de l’interface graphique (GUI).
Déinir la taille et la position de notre vue permet de pouvoir utiliser plus d’une caméra
dans un jeu. Dans un jeu de course automobile, par exemple, vous pourrez placer une
caméra dans le coin supérieur de l’écran pour aficher une vue située derrière la voiture
du joueur ain qu’il puisse repérer les véhicules qui s’approchent de lui.
∑ Near clip plane/Far clip plane. Les clip planes (plans de clipping) désignent la distance
des éléments du jeu dont le rendu doit être effectué ; l’option Near Plane désignant le
plan le plus proche et l’option Far Plane le plan le plus éloigné, ou plutôt la distance
où le rendu se termine.
Ain d’économiser de la mémoire dans la mémoire tampon de la carte graphique (une
partie de la mémoire utilisée pour stocker des informations sur les effets visuels du
monde du jeu), cette technique de clipping est souvent utilisée pour que le décor situé
loin du joueur ne soit pas calculé. Les développeurs recouraient à cette technique dans
les jeux 3D anciens, car les ordinateurs à l’époque avaient moins de mémoire RAM dans
laquelle écrire ; pour économiser la mémoire, seul le rendu des plans les plus proches de
la caméra était effectué ain que le jeu reste luide.
78 Développez des jeux 3D avec Unity

Figure 3.12

Plan proche Plan éloigné

∑ Field of view. Déinit la largeur du cône de vision de la caméra en degrés. Cet angle
est ixé à 60, car cette valeur reproduit de façon raisonnable la vision de l’œil humain.
∑ Orthographic et Orthographic Size. Transforment la vision de la caméra en vue
orthographique, par opposition à la vue en perspective 3D standard. Les caméras ortho-
graphiques sont le plus souvent utilisées dans les jeux en vue isométrique comme les
jeux de stratégie en temps réel (RTS) ou les jeux 2D.
∑ Depth. Lorsque vous utilisez plusieurs caméras et que vous passez de l’une à l’autre
à l’aide de scripts, le paramètre Depth permet de déinir un ordre de priorité. Ainsi,
le rendu de la caméra dont la valeur de profondeur est la plus élevée s’effectue avant
celui de la caméra possédant une valeur plus faible. Ce paramètre peut également être
utilisé en association avec le paramètre Normalized View Port Rect, ain de placer
des caméras au-dessus de l’écran principal. Pour le rétroviseur d’un jeu de course, par
exemple, la caméra de la vue arrière doit posséder une valeur Depth plus élevée que la
caméra principale pour que son rendu s’afiche en superposition de la vue principale
(vers l’avant) du jeu.
∑ Culling Mask. Fonctionne avec les calques de jeu de Unity, comme nous l’avons déjà
mentionné, ain que vous puissiez procéder à leur rendu de manière sélective. Si vous
placez certains éléments du jeu sur un calque, il vous sufira de désélectionner ce calque
dans le menu déroulant Culling Mask pour que la caméra ne réalise pas leur rendu.
Actuellement, notre objet Main Camera effectue le rendu de tous les éléments de la
scène, car il s’agit de la seule caméra dans le jeu.

Les composants GUILayer et Flare Layer

Ces deux composants ne possèdent aucun paramètre. Ils permettent simplement le rendu
des éléments visuels additionnels. GUILayer permet le rendu des éléments 2D, comme
les menus et l’afichage tête haute (HUD). Flare Layer permet à la caméra d’effectuer
le rendu des effets de lumière, comme celui que vous avez ajouté à l’objet Directional
Light au Chapitre 2, "Environnements".
Chapitre 3 Personnages jouables 79

Le composant Mouse Look (Script)

Il s’agit de la seconde occurrence du composant Mouse Look (Script) – la première se
trouvant sur l’objet parent First Person Controller. Cependant, son paramètre Axes a
cette fois pour valeur MouseY, car il gère le déplacement de la vue vers le haut ou vers le
bas en contrôlant la rotation de l’objet Main Camera autour de son axe X. Combiné au
script Mouse Look qui fait pivoter l’objet parent, il permet au joueur de tourner son regard
où il le souhaite à l’aide de la souris, puisque l’objet Main Camera pivote également de
gauche à droite lorsque l’objet parent tourne.

Le composant Audio Listener

Le composant Audio Listener fonctionne comme l’oreille humaine et permet au joueur
d’entendre toutes les sources audio du jeu. Si cet écouteur audio est placé sur la caméra
principale dans un jeu à la première personne, le joueur entendra de l’oreille gauche les
sons mono (canal unique) provenant de sa gauche. Vous pouvez ainsi créer un environ-
nement qui reproduise l’immersion auditive du monde réel en stéréo.
Maintenant que vous savez comment le composant First Person Controller est consti-
tué, vous allez vous familiariser avec le langage JavaScript dans Unity en étudiant le
fonctionnement du script FPSWalker.

Les bases de la programmation

L’écriture de script est un élément essentiel à maîtriser pour devenir un développeur de
jeux. Même si Unity permet de créer des jeux sans avoir vraiment besoin de connaître le
code source du moteur de jeu, vous devez cependant savoir écrire les scripts qui comman-
dent le moteur de Unity. Ces scripts utilisent un ensemble de classes prêtes à l’emploi,
que vous pouvez considérer comme des bibliothèques d’instructions ou de comportements.
En  écrivant des scripts, vous créerez vos propres classes en tirant parti des commandes
existantes dans le moteur de Unity.
Ce livre aborde principalement l’écriture de scripts JavaScript dans Unity, car il s’agit
du langage le plus simple pour débuter et celui sur lequel la documentation de référence
de Unity fournit le plus de renseignements. Bien que les bases de l’écriture de scripts
soient présentées, nous vous conseillons fortement de consulter en parallèle le manuel de
référence Scripting Manual de Unity fourni avec le programme et disponible en ligne à
l’adresse suivante :
http://unity3d.com/support/documentation/ScriptReference/
80 Développez des jeux 3D avec Unity

Les problèmes que vous rencontrerez lors de l’écriture de scripts trouvent souvent leur
solution dans ce manuel. Si ce n’est pas le cas, vous pouvez alors demander de l’aide sur
les forums consacrés à Unity ou sur le canal IRC (Internet Relay Chat) du logiciel. Pour
plus d’informations, visitez l’une des adresses suivantes :
http://unity3d.com/support/community (en anglais)
http://www.unity3d-france.com/ (en français)
Que vous rédigiez un nouveau script ou que vous utilisiez un script existant, celui-ci
devient opérationnel seulement après que vous l’avez attaché à un objet de jeu dans la scène
courante. Un script attaché à un objet de jeu en devient un composant et le comportement
écrit dans le script s’applique à cet objet. Cependant, les scripts ne se limitent pas à appeler
(activer ou exécuter en terme de programmation) un comportement de l’objet de jeu auquel
ils appartiennent, ils peuvent également donner des instructions aux autres objets en faisant
référence à leur nom ou à leur tag.
Ain de mieux comprendre, voyons tout d’abord quelques principes de base des scripts.

Les commandes
Les commandes sont des instructions données dans un script. Bien que vous puissiez les
disséminer à l’intérieur d’un script, vous contrôlerez mieux le moment où elles sont appe-
lées si vous les placez dans une fonction. Toutes les commandes en JavaScript doivent se
terminer par un point-virgule de la façon suivante :
vitesse = 5;

Les variables
Les variables sont de simples conteneurs d’informations. Elles sont déclarées (créées) avec
le mot var, suivi d’un ou de plusieurs mots sans espace entre eux. Vous pouvez les nommer
comme vous voulez, à condition de respecter les conditions suivantes :
∑ Le nom ne doit pas être celui d’un terme utilisé dans le code du moteur de Unity.
∑ Le nom doit uniquement contenir des caractères alphanumériques et des traits de souli-
gnement et ne pas commencer par un chiffre. Par exemple, le mot transform existe déjà
pour représenter le composant Transform d’un objet de jeu, si bien que nommer ainsi
une variable ou une fonction pourrait provoquer un conlit.
Chapitre 3 Personnages jouables 81

Les variables peuvent contenir du texte, des chiffres et des références à des objets, des
ressources ou des composants. Voici un exemple d’une déclaration de variable :
var vitesse = 9.0;

Notre variable commence par le mot var, suivi de son nom, vitesse. Sa valeur est ensuite
déinie à l’aide d’un seul symbole égal et se termine comme toute autre commande par un
point-virgule.

Dans l’interface de Unity, les valeurs décimales peuvent s’écrire avec une vir-
ntion gule ou un point (0,2 ou 0.2). Si on écrit 0.2, la valeur est automatiquement
Atte
convertie sous la forme avec une virgule (0,2). Mais dans le code, les valeurs
décimales doivent impérativement s’écrire 0.2. Avec 0,2, un message d’erreur
s’afiche.

Types de données des variables

Lors de la déclaration des variables, vous devez aussi indiquer le type d’information
qu’elles stockent en déinissant le type de données. Voici la même déclaration de variable
que l’exemple précédent, mais cette fois avec le type de données :
var vitesse : loat = 9.0;

Le nom de la variable est suivi de deux-points pour préciser le type de données. Dans cet
exemple, la valeur de la variable est un nombre à une décimale, et nous indiquons que
les données sont de type loat (abréviation de "loating point" pour "virgule lottante" –
autrement dit un nombre décimal).
Préciser le type de données de chaque variable que vous déclarez rend le script plus eficace
car le moteur du jeu n’a pas besoin de décider par lui-même du type de la variable lors de sa
lecture. De plus, cela facilite la détection d’erreur (débogage) et la relecture du code. Voici
quelques-uns des types de données les plus courants que vous utiliserez :
∑ string (chaîne de caractères). Combinaison de texte et de chiffes stockés entre guillemets,
"comme ceci".
∑ int (entier). Abréviation d’integer. S’utilise pour les chiffres entiers sans décimale.
∑ loat. Valeur numérique décimale.
∑ boolean (booléen). Une valeur vraie ou fausse utilisée couramment comme condition
à respecter.
∑ Vector3. Un ensemble de valeurs XYZ.
82 Développez des jeux 3D avec Unity

Utiliser les variables

Une fois que les variables sont déclarées, les informations qu’elles contiennent peuvent être
utilisées ou redéinies. Pour cela, on emploie simplement le nom de la variable. Pour régler
la variable vitesse, par exemple, il sufit d’écrire :
vitesse = 20;

var et le type de données s’indiquent seulement dans la déclaration de la variable et non

dans les commandes.
Il est également possible d’interroger ou d’utiliser la valeur d’une variable dans certaines
parties d’un script. Par exemple, pour stocker une valeur égale à la moitié de celle de la
variable vitesse actuelle, on peut déinir une nouvelle variable, comme dans l’exemple
suivant :
var vitesse : loat = 9.0;
var moitieVitesse : loat;
moitieVitesse = vitesse/2;

Notez également que la valeur de la variable moitieVitesse n’est pas déinie dans sa décla-
ration. Elle l’est, en fait, dans la commande suivante où la valeur de la variable vitesse est
divisée par deux.

Variables publiques et variables privées

Les variables déclarées à l’extérieur d’une fonction dans un script sont appelées variables
globales ou propriétés. Par défaut, en JavaScript, de telles variables sont dites variables
publiques, car elles s’afichent automatiquement en tant que paramètres du script (consi-
déré alors comme un composant) dans le panneau Inspector. Lorsque vous afichez le
script FPSWalker en tant que composant lié à l’objet First Person Controller par
exemple, ses variables publiques Speed, JumpSpeed et Gravity sont alors visibles.

Figure 3.13

La valeur de chacune de ces variables peut donc être ajustée dans le panneau Inspector.
Chapitre 3 Personnages jouables 83

Si vous ne souhaitez pas régler la valeur d’une variable dans le panneau Inspector, vous
devez alors utiliser le préixe private pour qu’elle ne s’afiche pas. Pour cacher la variable
JumpSpeed, par exemple, vous devriez modiier la déclaration de cette variable dans le script
de la façon suivante :
var speed = 6.0;
private var jumpSpeed = 8.0;
var gravity = 20.0;

Dans le panneau Inspector, le script s’aficherait alors comme à la Figure 3.14.

Figure 3.14

Si vous ajustez une valeur dans le panneau inSPector, celle-ci remplace la

ce valeur originale donnée à la variable lors de sa déclaration dans le script. En
Astu
fait, la valeur indiquée dans le script n’est pas réécrite mais elle est remplacée
par la nouvelle lors de l’exécution du jeu. Vous pouvez également restaurer les
valeurs déclarées dans le script en cliquant sur l’icône en forme d’engrenage
située à droite du nom du composant, puis en choisissant reSet dans le menu
déroulant qui s’afiche.

Les fonctions
Les fonctions sont des ensembles d’instructions qui peuvent être appelées à un moment
précis lors de l’exécution du jeu. Un script peut contenir de nombreuses fonctions et
chacune peut appeler une ou plusieurs autres fonctions au sein du même script. Les scripts
peuvent faire appel à de nombreuses fonctions prédéinies du moteur de Unity pour exécuter
des commandes à des moments précis ou selon les actions de l’utilisateur. Vous pouvez
également écrire vos propres fonctions et les appeler lorsque vous avez besoin de réaliser
des instructions spéciiques.
L’écriture d’une fonction commence par function suivi de son nom, puis d’accolades d’ou-
verture et de fermeture. Le développeur peut ensuite passer des paramètres supplémentaires
entre ces accolades. Voici quelques exemples de fonctions existantes.
84 Développez des jeux 3D avec Unity

Update()
Tout nouveau ichier JavaScript créé dans Unity commence par la fonction Update()
suivante :
function Update(){
}

Toutes les instructions ou les commandes d’une fonction doivent se trouver entre ses acco-
lades d’ouverture et de fermeture, comme dans l’exemple suivant :
function Update(){
speed = 5;
}

Tant que les commandes sont écrites entre les accolades de la fonction, elles se déclenchent
chaque fois que le moteur du jeu fait appel à cette fonction.
Les jeux s’exécutent à un certain nombre d’images par seconde (FPS), si bien que la fonc-
tion Update() est appelée une fois le rendu de chaque image effectué. En conséquence, elle
s’utilise principalement pour toutes les commandes qui doivent être exécutées en perma-
nence ou pour détecter les modiications qui se produisent en temps réel dans le monde du
jeu, comme les commandes en entrée – lorsque le joueur appuie sur des touches ou clique.
Lorsqu’il s’agit de commandes liées aux lois physiques, vous devez de préférence utiliser
la fonction FixedUpdate() car elle est synchronisée avec le moteur physique, tandis que le
déclenchement de la fonction Update() peut varier selon le nombre de FPS.

OnMouseDown()
OnMouseDown() est un exemple de fonction appelée à un moment précis  : uniquement
lorsque le joueur clique sur un objet de jeu ou sur un élément graphique dans le jeu.
Elle s’utilise le plus souvent pour les jeux contrôlés à la souris ou pour détecter les clics
dans les menus. Voici un exemple de fonction OnMouseDown() simple qui, lorsqu’elle est
attachée à un objet de jeu, permet de quitter le jeu en cliquant sur un objet :
function OnMouseDown(){
Application.Quit();
}

Écrire des fonctions

En écrivant vos propres fonctions, vous pouvez créer un ensemble d’instructions suscep-
tibles d’être appelées à tout moment dans vos scripts. Si vous devez déinir plusieurs
Chapitre 3 Personnages jouables 85

instructions pour déplacer un objet à un endroit précis dans le monde du jeu, vous pouvez
alors écrire une fonction personnalisée contenant toutes les instructions nécessaires, puis
appeler cette fonction à partir d’autres fonctions de votre script.
Imaginons par exemple que vous deviez replacer le personnage du joueur au début du
niveau, lorsqu’il tombe dans un piège et meurt. Plutôt que d’écrire les instructions néces-
saires sur chaque partie du jeu qui provoque sa mort, vous pouvez les regrouper dans une
seule fonction appelée plusieurs fois. Cette fonction pourrait ressembler à ceci :
function PlayerDeath(){
transform.position = Vector3(0,10,50);
score–=50;
vies--
}

Lorsque cette fonction PlayerDeath() est appelée, les trois commandes qu’elle contient
sont exécutées : la position du joueur est redéinie à X = 0, Y = 10 et Z = 50, une valeur
de 50 est soustraite de la note variable nommée score et une valeur de 1 soustraite d’une
variable nommée vies (les deux symboles de soustraction indiquent une soustraction d’une
unité ; de la même façon ++ dans un script signiie simplement l’ajout d’une valeur de 1).
Pour appeler cette fonction, il vous sufit d’écrire la ligne suivante dans la partie du script
qui provoque la mort du joueur :
PlayerDeath();

Les instructions if else

Une instruction if (si) permet de vériier des conditions dans les scripts. Si ces conditions
sont remplies, l’instruction if exécute une série d’instructions imbriquées. Dans le cas
contraire, ce sont les instructions par défaut, appelées par else (sinon), qui le seront. Dans
l’exemple suivant, l’instruction if vériie si la variable booléenne grounded est déinie sur
true (vraie) :

var grounded : boolean = false;

var speed : loat;
function Update(){
if(grounded == true){
speed = 5;
}
}
86 Développez des jeux 3D avec Unity

Si la condition énoncée entre les crochets de l’instruction if est atteinte, autrement dit si
la variable grounded devient true, alors la valeur de la variable speed est ixée à 5. Sinon,
aucune valeur ne lui est attribuée.

Vous ne devez pas confondre le symbole d’affectation (=), utilisé pour déinir la
ntion valeur de la variable, et le symbole de comparaison d’égalité (==), qui permet
Atte
de vériier si l’information stockée dans la variable correspond à une valeur.

Pour établir une condition alternative, vous pourriez ajouter une déclaration else après le
if ain d’indiquer ce qui doit se produire si les conditions ne sont pas remplies :

var grounded : boolean = false;

var speed : loat;
function Update(){
if(grounded == true){
speed = 5;
}
else{
speed = 0;
}
}

Ainsi, à moins que la variable grounded ne soit true, la variable speed est égale à 0.
Pour que la vériication des conditions entraîne davantage de conséquences possibles, vous
pouvez utiliser l’instruction else if avant le else facultatif. Si vous vériiez des valeurs, le
code peut alors s’écrire :
if(speed >= 6){
//faire quelque chose
}
else
if(speed >= 3){
//faire quelque chose d’autre
}
else{
//si aucune des conditions ci-dessus n’est vraie, faire ceci
}

Dans l’exemple précédent, les lignes qui commencent par le symbole // indiquent qu’il
s’agit de commentaires (du code non exécuté).
Chapitre 3 Personnages jouables 87

Les conditions multiples

Vous pouvez également vériier plus d’une seule condition dans une instruction if en utilisant
l’opérateur logique ET, qui s’écrit &&.
Si, par exemple, vous voulez vériier l’état de deux variables à la fois et exécuter les instruc-
tions qui suivent si les valeurs des deux variables sont celles énoncées, vous écrirez alors :
if(speed >= 3 && grounded == true){
//faire quelque chose
}

Pour vériier une condition ou une autre, vous pouvez alors utiliser l’opérateur logique OU,
qui s’écrit ||, de la façon suivante :
if(speed >= 3 || grounded == true){
//faire quelque chose
}

Les variables statiques et la syntaxe à point

À cette section, vous allez voir comment transmettre des informations entre plusieurs
scripts à l’aide d’une variable statique, et comment traiter l’information de manière hiérar-
chique en utilisant la technique d’écriture de script nommée syntaxe à point.
En programmation orientée objet (POO), les variables globales d’une classe (d’un script)
sont aussi appelées propriétés et les fonctions aussi appelées méthodes.

Déinir des variables statiques avec static

Le nom des scripts écrits en JavaScript correspond au nom de la classe. Cela signiie que,
pour vous adresser aux variables ou aux fonctions d’un autre script, vous pouvez faire
référence à cette classe en utilisant le nom de ce script suivi du nom de la variable ou de la
fonction en question à l’aide de la syntaxe à point.
En termes de programmation, une variable statique peut être déinie comme une valeur ou
une commande commune à toutes les instances de ce script. De plus, si elle est publique,
elle est accessible non seulement par les fonctions ou les variables situées dans le même
script mais aussi par n’importe quel script. Pour déclarer une variable globale dans un
ichier JavaScript de Unity, on utilise le préixe static de la manière suivante :
static var speed : loat = 9.0;
88 Développez des jeux 3D avec Unity

Si cette variable speed était celle du script FPSWalker, vous pourriez alors accéder à
sa valeur, ou la déinir, depuis un autre script. Pour cela, on utilise le nom du script suivi
d’un point, du nom de la variable, puis de la déinition de la valeur, comme dans l’exemple
suivant :
FPSWalker.speed = 15.0;

De la même manière, il existe des fonctions publiques statiques pouvant être appelées
depuis d’autres scripts. La fonction PlayerDeath(), par exemple, pourrait être une fonction
static, ce qui vous permettrait de l’appeler depuis n’importe quel autre script du jeu sans
même avoir de référence vers l’objet concerné.

La syntaxe à point
Dans l’exemple précédent, nous avons utilisé une technique de script appelé syntaxe à
point. Bien que ce terme semble désigner une forme d’écriture complexe, ce n’est pas
vraiment le cas. On utilise simplement un point pour séparer les éléments auxquels on fait
référence et indiquer leur hiérarchie, depuis l’élément situé le plus haut dans la hiérarchie
jusqu’au paramètre en particulier que l’on souhaite déinir.
Ainsi, pour régler la position verticale d’un objet de jeu, par exemple, vous devez modiier
sa coordonnée Y. Vous devez donc vous adresser aux paramètres de position du composant
Transform de cet objet. Pour cela, on écrit :
transform.position.y = 50;

La syntaxe à point permet donc de désigner n’importe quel paramètre en indiquant le

composant auquel il appartient.

Les commentaires
Dans beaucoup de scripts prédéinis, vous remarquerez que certaines lignes commencent
par deux barres obliques. Il s’agit simplement des commentaires écrits par l’auteur du
script. Nous vous conseillons d’écrire vos propres commentaires ain d’indiquer comment
fonctionnent vos scripts, en particulier lorsque vous débutez.

Lectures complémentaires
Il est essentiel que vous vous preniez l’habitude de vous référer au manuel de référence
Scripting Manual de Unity installé avec votre copie du programme et également disponible
sur le site web de Unity à l’adresse suivante :
http://unity3d.com/support/documentation/ScriptReference/
Chapitre 3 Personnages jouables 89

Ce manuel de référence permet notamment de vériier comment utiliser correctement les

classes du moteur de Unity. Maintenant que vous connaissez les rudiments de l’écriture de
scripts, nous allons étudier le script FPSWalker qui contrôle le déplacement de l’objet
First Person Controller, autrement dit le personnage du joueur.

Le script FPSWalker
Pour visualiser un script dans Unity, vous devez l’ouvrir dans l’éditeur de script. Pour cela,
sélectionnez le script dans le panneau Project puis double-cliquez sur son icône.
L’éditeur de script fourni par défaut s’appelle Unitron sous Mac  OS et Uniscite sous
Windows. Il s’agit, dans les deux cas, d’une application autonome permettant d’éditer
différents formats de ichier texte, comme les scripts JavaScript et C# par exemple.
Vous pouvez également déinir l’éditeur de texte de votre choix pour écrire vos scripts
destinés à Unity. Pour les besoins de cet ouvrage, nous utiliserons les éditeurs de script par
défaut Unitron et Uniscite.

Lancer le script
Sélectionnez l’objet First Person Controller dans le panneau Hierarchy, puis cliquez
sur le nom du ichier de script sous le composant FPSWalker (Script) dans le panneau
Inspector ain qu’il soit surligné en bleu (voir Figure 3.15).

Figure 3.15

L’emplacement du script s’afiche également en jaune dans le panneau Project (voir

Figure  3.16) ain de vous aider à le localiser. Une fois que vous avez repéré l’icône du
ichier, double-cliquez dessus pour le lancer dans l’éditeur de script par défaut. Vous pouvez
aussi double-cliquer directement sur le nom du script dans le composant.
90 Développez des jeux 3D avec Unity

Figure 3.16

Mac OS – FPSWalker dans Unitron

Sous Mac OS, le script FPSWalker s’ouvre dans l’éditeur de script par défaut Unitron
(voir Figure 3.17).

Figure 3.17
Chapitre 3 Personnages jouables 91

Windows PC – FPSWalker dans Uniscite

Sous Windows, le script FPSWalker s’ouvre dans l’éditeur de script par défaut Uniscite
(voir Figure 3.18).

Figure 3.18

Bien qu’il s’agisse du même script, vous voyez que les deux éditeurs utilisent des couleurs
différentes pour mettre en valeur la syntaxe. Cela est propre à l’éditeur lui-même et n’a
aucune incidence sur le fonctionnement du script.

Le script en détail
Nous allons voir le fonctionnement dans la pratique des différents éléments que nous
venons de décrire, en décomposant leur utilisation dans le script FPSWalker.
92 Développez des jeux 3D avec Unity

Déclarer une variable

Comme la plupart des scripts, FPSWalker commence par une série de déclarations de
variables des lignes 1 à 6 :
var speed = 6.0;
private var jumpSpeed = 8.0;
var gravity = 20.0;
private var moveDirection = Vector3.zero;
private var grounded : boolean = false;

Les variables publiques des lignes 1 et 3 sont utilisées plus tard dans le script comme coef-
icients de multiplication. Il s’agit de valeurs décimales, donc le type des données devrait
être déini à loat dans l’idéal (comme il s’agit d’un simple exemple de script de Unity
Technologies, le type de données de toutes les variables n’est pas indiqué). Les variables
des lignes 2, 5 et 6 sont des variables privées, car elles ne seront utilisées que dans ce script.
La variable privée moveDirection stocke la direction actuelle du joueur sous la forme d’une
valeur de type Vector3 (un ensemble de coordonnées X, Y, Z). Elle est déinie à (0,0,0) ain
d’éviter que le joueur soit tourné dans une direction aléatoire lorsque le jeu commence.
La variable privée grounded est de type booléen (true ou false). Cette variable est utilisée
plus loin dans le script pour savoir si le joueur est en contact avec le sol ou non. Le person-
nage peut se déplacer et sauter uniquement dans le premier cas, car dans le cas contraire,
cela signiie qu’il se trouve déjà en l’air.

Stocker les informations de mouvement

Le script se poursuit à la ligne 8, avec l’ouverture de la fonction FixedUpdate(). Elle fonc-
tionne de façon analogue à la fonction Update() : une mise à jour prédéinie est appelée à
une cadence prédéinie. Elle est plus appropriée à la gestion des règles physiques (comme
l’utilisation des corps rigides et les effets de gravité) que la fonction Update() standard,
car l’exécution de cette dernière varie selon le nombre d’images par seconde et donc de la
puissance matérielle dont dispose le joueur.
La fonction FixedUpdate() s’exécute des lignes 8 à 27.

Dans cet ouvrage, une seule ligne de code peut de temps à autre apparaître sur
Info deux lignes différentes en raison de l’indentation et des contraintes de mise en
page. Lorsque vous recopiez ces scripts, assurez-vous que l’extrait en question
se trouve bien sur une seule ligne dans votre script.
Chapitre 3 Personnages jouables 93

La première instruction if dans la fonction s’exécute sur les lignes 9 à 18 (le commentaire
du développeur a été supprimé dans l’extrait suivant) :
if (grounded) {
moveDirection = new Vector3(Input.GetAxis("Horizontal"), 0,
„ Input.GetAxis("Vertical"));
moveDirection = transform.TransformDirection(moveDirection);
moveDirection *= speed;
if (Input.GetButton ("Jump")) {
moveDirection.y = jumpSpeed;
}
}

Les commandes et l’instruction if imbriquée (ligne 15) s’exécutent seulement si la condi-

tion if (grounded) est respectée. Il s’agit d’une forme d’écriture raccourcie de la ligne
suivante :
if(grounded == true){

Quand grounded devient true, cette instruction if agit trois fois sur la variable
moveDirection.
Premièrement, elle lui assigne une nouvelle valeur Vector3 en donnant à sa coordonnée X
la valeur actuelle de Input.GetAxis ("horizontal") et à sa coordonnée Z la valeur de
Input.GetAxis ("vertical"), mais laisse la coordonnée Y déinie à 0 :

moveDirection = new Vector3(Input.GetAxis("Horizontal"), 0,

„ Input.GetAxis("Vertical");

Dans cet exemple, Unity Technologies utilise le mot new comme préixe du para-
Info mètre Vector3 utilisé pour déinir la variable moveDirection. Il s’agit d’une
convention du langage C# destinée à faciliter la conversion entre les langages
JavaScript et C#. Toutefois, ce terme n’est pas nécessaire en JavaScript, ce qui
explique pourquoi les autres exemples de ce livre n’utilisent pas ce préixe.

Mais que font les commandes Input.GetAxis  ? Elles représentent tout simplement les
valeurs comprises entre –1 et 1 obtenues en entrée à partir des touches directionnelles. Par
défaut, ces touches sont les suivantes :
∑ A (Gauche) et D (Droit) pour l’axe horizontal ;
∑ W (Haut) et S (Bas) pour l’axe vertical.
Lorsque aucune touche n’est utilisée, ces valeurs sont égales à 0, car Unity donne auto-
matiquement un état idle (inactif) aux entrées qui gèrent les axes. Par conséquent, si vous
94 Développez des jeux 3D avec Unity

appuyez par exemple sur la touche Gauche, la valeur de Input.GetAxis ("horizontal")

est égale à –1, tandis que si vous appuyez sur la touche Droit, elle est égale à 1. En relâchant
l’une ou l’autre de ces deux touches, la valeur redevient égale à 0.
En bref, la ligne :
moveDirection = new Vector3(Input.GetAxis("Horizontal"), 0,
„ Input.GetAxis("Vertical"));

assigne à la variable moveDirection une valeur Vector3 en fonction des valeurs X et Z des
touches pressées, tout en laissant la valeur Y déinie à 0.
La variable moveDirection est ensuite de nouveau modiiée à la ligne 12 :
moveDirection = transform.TransformDirection(moveDirection);

La variable moveDirection est ici déinie selon la valeur de TransformDirection du

composant Transform. La commande TransformDirection a pour effet de convertir les
valeurs locales XYZ en valeurs globales. Donc, la variable moveDirection déinie sur la
ligne précédente est ici passée en paramètre de la commande TransformDirection ain que
cette dernière modiie le format de ses coordonnées XYZ en un ensemble de coordonnées
globales.
Enin, moveDirection est multipliée par la variable speed à la ligne 13 :
moveDirection *= speed;

Puisque speed est une variable publique, multiplier les valeurs XYZ de moveDirection par
speed implique que vous pouvez augmenter la vitesse de déplacement du personnage sans
avoir à éditer le script. Il vous sufit en effet d’augmenter la valeur de speed dans le panneau
Inspector, puisque c’est la valeur de moveDirection ainsi obtenue qui est utilisée plus tard
dans le script pour déplacer le personnage.
L’instruction grounded contient enin une autre instruction if imbriquée aux lignes 15 à 17 :
if (Input.GetButton ("Jump")) {
moveDirection.y = jumpSpeed;
}

Cette instruction if se déclenche lorsque la touche nommé Jump est pressée. Par défaut, ce
bouton de saut est affecté à la barre d'espacement. Dès que cette touche est enfoncée, la valeur
de l’axe Y de la variable moveDirection est ixée à la valeur de la variable jumpSpeed. Par
conséquent, à moins que la variable jumpSpeed n’ait été modiiée dans le panneau Inspector,
moveDirection.y prend une valeur de 8.0.
Lors du déplacement du personnage plus loin dans le script, cette modiication soudaine
de la valeur sur l’axe Y (de 0 à 8.0) produira l’effet de saut. Mais comment le personnage
Chapitre 3 Personnages jouables 95

redescend-il ensuite  ? En effet, aucun composant Rigidbody n’est attaché à l’objet du

personnage, si bien qu’il n’est pas soumis au contrôle de la gravité dans le moteur physique.
C’est pourquoi la ligne 21 modiie la valeur moveDirection.y :
moveDirection.y –= gravity * Time.deltaTime;

Vous remarquerez que la soustraction ne porte pas uniquement sur la valeur de la gravité
ici, car cela ne produirait pas l’effet d’un saut mais déplacerait plutôt le personnage vers
le haut puis de nouveau vers le bas entre deux images. En fait, cette ligne soustrait de la
valeur de moveDirection.y le résultat obtenu en multipliant la variable gravity par une
commande appelée Time.deltaTime.
En multipliant une valeur à l’intérieur d’une fonction Update() ou FixedUpdate() par
Time.deltaTime, vous ne tenez pas compte de la nature de cette fonction basée sur la
cadence des images ou des appels et vous convertissez l’effet de la commande en secondes.
Autrement dit, en écrivant :
moveDirection.y –= gravity * Time.deltaTime;

la valeur de gravité est soustraite à chaque seconde plutôt qu’à chaque image ou appel.

Déplacer le personnage
Comme le commentaire de la ligne  23 l’indique, les lignes  24 à 26 sont chargées du
mouvement du personnage.
À la ligne  24, une nouvelle variable controller est déclarée avec le type de données
CharacterController. Elle est ensuite déinie pour représenter le composant Character-
Controller à l’aide de la commande GetComponent() :

var controller : CharacterController = GetComponent(CharacterController);

La commande GetComponent() permet d’accéder à tous les composants de l’objet auquel

un script est attaché. Il sufit d’indiquer son nom entre les parenthèses.
Ainsi, chaque fois que vous utilisez la référence de variable controller, vous pouvez accé-
der à tous les paramètres de ce composant et utiliser la fonction Move pour déplacer l’objet.
Ce qui est exactement ce que réalise la ligne 25, en plaçant ce mouvement dans une variable
lags :

var lags = controller.Move(moveDirection * Time.deltaTime);

La fonction CharacterController.Move s’attend à recevoir une valeur Vector3 ain de

déplacer un contrôleur de personnage dans les directions X, Y et Z. Donc le script utilise
les données stockées plus tôt dans la variable moveDirection et les multiplient par
96 Développez des jeux 3D avec Unity

Time.deltaTime ain que le déplacement soit en mètres par seconde plutôt qu’en mètres
par image.

Vériier grounded
Une valeur est attribuée à la variable moveDirection uniquement si la variable booléenne
grounded est déinie sur true. Alors, comment décider si le personnage est en contact avec
le sol ou non ?
Comme tous les autres colliders, le composant Character Controller (le contrôleur
de collision du personnage) peut détecter les collisions avec d’autres objets. Toutefois,
contrairement aux colliders standard, il dispose de quatre raccourcis de collision spéci-
iques, déinis dans l’ensemble CollisionFlags :
∑ None (aucun) ;
∑ Sides (sur les côtés) ;
∑ Above (au-dessus) ;
∑ Below (en dessous).
Ils sont chargés de vériier les collisions avec la partie spéciique du collider qu’ils décri-
vent – à l’exception de None, qui signiie tout simplement qu’aucune collision ne se produit.
Ces indicateurs (ou lags) sont utilisés pour déinir la variable grounded à la ligne 26 :
grounded = (lags & CollisionFlags.CollidedBelow) != 0;

Cette ligne peut sembler complexe en raison des nombreux symboles d’égalité qu’elle
contient, mais il s’agit simplement d’une forme d’écriture abrégée pour vériier une
condition et déinir une valeur sur une seule ligne.
Premièrement, la variable grounded est déinie à l’aide d’un symbole d’égalité. Puis, dans
la première série de parenthèses, une technique de masque de bits est appliquée ain de
déterminer si les collisions dans la variable lags (le mouvement du contrôleur) corres-
pondent à la valeur déinie en interne CollidedBelow :
(lags & CollisionFlags.CollidedBelow)

L’utilisation d’une seule esperluette (&) indique une opération qui s’effectue entre deux
valeurs sous forme binaire. Vous n’avez pas besoin de comprendre ce que cela signiie pour
le moment, car le système de classe de Unity offre un raccourci pour la plupart des calculs
de ce type.
Si le contrôleur entre en collision avec ce qui se trouve en dessous de lui (le terrain, logi-
quement), alors cette opération sera non nulle.
Chapitre 3 Personnages jouables 97

Cette opération est suivie de !=0. Un point d’exclamation devant un symbole d’égalité
signiie "est différent de". Cette comparaison renvoie donc true (vrai) si l’opération entre
parenthèses est non nulle. Par conséquent, grounded est déini comme true quand une
collision se produit entre le composant Character Controller et ce qui se trouve en
dessous de lui.

Les commandes @script

La fonction FixedUpdate() se termine à la ligne 27, suivie de la seule commande @script
suivante :
@script RequireComponent(CharacterController)

Les commandes @script s’utilisent pour réaliser des actions que vous devriez normalement
effectuer manuellement dans l’interface de Unity.
Dans cet exemple, une fonction RequireComponent() est exécutée, ce qui force Unity à
ajouter le composant indiqué entre parenthèses, au cas où l’objet sur lequel est attaché ce
script ne possède pas ce composant. De même, si vous essayez de supprimer ce composant,
Unity indique qu’un autre composant (le script) nécessite sa présence.
Comme ce script s’appuie sur CharacterController pour contrôler le personnage, il est
logique d’utiliser une commande @script pour s’assurer que le composant est présent et
que le script peut donc par conséquent s’adresser à lui. Il est également intéressant de noter
que les commandes @script sont les seuls exemples de commandes qui ne doivent pas se
terminer par un point-virgule.

En résumé
Au cours de ce chapitre, vous avez examiné le premier élément interactif de jeu pour le
moment : l’objet First Person Controller. Vous avez également découvert les bases des
scripts utilisés pour les jeux dans Unity, une première étape importante sur laquelle nous
nous appuierons tout au long de ce livre.
Au chapitre suivant, vous allez commencer à écrire vos propres scripts et vous en appren-
drez plus sur la détection de collision. Pour cela, vous utiliserez le modèle d’avant-poste
que vous avez importé au Chapitre 2, "Environnements", vous l’intégrerez à la scène du
jeu, puis vous le ferez interagir avec le personnage du joueur en combinant animations et
écriture de script.
 4
Interactions
Nous allons voir ici, plus en détail, d’autres interactions et nous plonger dans deux éléments
essentiels au développement d’un jeu : la détection de collision et le raycasting (tracé de
rayon).
Pour détecter les interactions physiques entre les objets de jeu, la méthode la plus courante
consiste à utiliser un collider – un ilet invisible tout autour d’un objet chargé de détecter
les collisions avec d’autres objets. La détection de collision regroupe à la fois la détection
et la récupération des informations provenant de ces collisions.
Il est non seulement possible de détecter que deux colliders (composants de collision)
interagissent, mais également d’anticiper une collision et d’effectuer de nombreuses autres
tâches à l’aide d’une technique appelée raycasting, qui dessine un rayon – une ligne vecto-
rielle invisible (non rendue) tracée entre deux points dans l’espace 3D – qui peut aussi être
utilisé pour détecter une intersection avec le collider d’un objet de jeu. Le raycasting permet
également de récupérer de nombreuses autres informations utiles comme la longueur du
rayon (et donc la distance entre deux objets) ou le point d’impact de la in de la ligne.
100 Développez des jeux 3D avec Unity

Figure 4.1 Fin du rayon

Y

Dans cet exemple, un rayon pointant vers l’avant part de notre personnage. On peut lui
donner une direction mais également une longueur spéciique, ou le projeter jusqu’à ce
qu’il trouve un objet.
Au cours de ce chapitre, vous travaillerez avec le modèle d’avant-poste que vous avez
importé au Chapitre 2, "Environnements". Nous avons créé pour vous l’animation d’ouver-
ture et de fermeture de la porte et vous allez voir comment les déclencher une fois le modèle
intégré dans la scène en implémentant la détection de collision et le raycasting.
Commençons par examiner la détection de collision et voir quand la remplacer ou la
compléter par le raycasting.

Les collisions
Lorsque des objets entrent en collision dans n’importe quel moteur de jeu, des informations
sur cet événement deviennent alors disponibles. En enregistrant différentes informations
au moment de l’impact, le moteur de jeu peut ensuite réagir de manière réaliste. Dans un
jeu tenant compte des lois physiques par exemple, si un objet tombe au sol d’une certaine
hauteur, le moteur a besoin de savoir quelle partie de cet objet touche le sol en premier pour
contrôler de façon correcte et réaliste la réaction de l’objet à cet impact.
Bien entendu, Unity gère ce type de collisions et stocke ces informations pour vous, si bien
que vous avez seulement à les récupérer ain de déinir la réaction qui doit se produire.
Dans le cas de l’ouverture d’une porte, vous avez besoin de détecter les collisions entre le
collider du personnage du joueur et celui situé sur – ou près de – la porte. Cela n’aurait
guère de sens de détecter les collisions ailleurs, puisque l’animation de la porte doit se
déclencher lorsque le joueur est assez proche pour espérer qu’elle s’ouvre ou pour franchir
le seuil.
Par conséquent, vous allez vériier les collisions entre le collider du personnage et celui de
la porte. Vous devez toutefois étendre la profondeur du collider de la porte ain que celui du
personnage du joueur n’ait pas besoin de s’appuyer contre la porte pour que la collision se
Chapitre 4 Interactions 101

déclenche (voir Figure 4.2). Cependant en étendant la profondeur du collider, son interaction

avec le jeu devient irréaliste.

Figure 4.2

X
------ les contours du collider

Dans notre exemple, si le collider de la porte dépassait de la surface visuelle de la porte, le

personnage entrerait en collision avec une surface invisible qui l’arrêterait net. En outre,
bien que vous puissiez utiliser cette collision pour déclencher l’animation d’ouverture de la
porte, l’impact initial dans le collider semblerait peu naturel pour le joueur, ce qui nuirait à
son immersion dans le jeu. Si la détection de collision fonctionne très bien entre le collider
du personnage et celui de la porte d’un point de vue technique, cette approche présente
donc trop d’inconvénients pour qu’un développeur de jeux créatif ne recherche pas une
approche plus intuitive. C’est là qu’intervient le raycasting.

Le raycasting
Bien qu’il soit possible de détecter les collisions entre le collider du personnage et un
collider qui s’adapte à l’objet porte, il semble plus judicieux que la porte s’ouvre lorsque le
joueur lui fait face et à une certaine distance, ce qui peut être réalisé en projetant un rayon
d’une longueur limitée depuis l’avant du personnage. Ainsi, le joueur n’a pas besoin de
s’avancer jusqu’à la porte ou d’entrer en collision avec un collider étendu pour que le rayon
soit détecté. Cette méthode garantit également que le joueur ne peut pas ouvrir la porte s’il
102 Développez des jeux 3D avec Unity

lui tourne le dos ; avec le raycasting, il doit faire face à l’objet pour l’utiliser, ce qui est plus
logique.
Cette méthode est couramment utilisée lorsque la détection de collision se montre trop
imprécise pour obtenir une réaction correcte, par exemple lorsque les réactions doivent se
produire à un niveau de détail très précis (image par image) car elles se produisent alors
trop rapidement. Dans notre exemple, vous avez besoin de détecter à l’avance si la collision
est susceptible de se produire plutôt que d’y réagir. Prenons un exemple pratique de ce
problème.

L’image manquante
Dans le cas d’un jeu de tir en 3D, le raycasting s’utilise pour prédire l’impact d’une balle
tirée. En raison de la vitesse d’une balle réelle, il est très dificile d’en représenter visuel-
lement le trajet vers la cible de façon satisfaisante pour le joueur, car cette vitesse est
largement supérieure à la cadence des images rendues dans les jeux.
Lors d’un tir au pistolet dans le monde réel, la balle met si peu de temps pour atteindre sa
cible que l’événement semble instantané à l’œil nu. On peut donc admettre que la balle
devrait atteindre son objectif en quelques images seulement dans le jeu, même avec un
rendu supérieur à 25 images par seconde.

Distance parcourue
0 15 3 4,5 6 7,5 9

Balle tirée

1 2 3 4 5 6 7
Images
Figure 4.3

À la Figure 4.3, une balle est tirée d’un pistolet. Pour que son parcours soit réaliste, elle
devrait se déplacer à une vitesse de 150 mètres par seconde. À une cadence de 25 images
par seconde, la balle se déplace donc de 6 mètres par image. Or la circonférence d’un corps
humain est environ de 1,50 mètre, si bien que la balle manquerait très probablement les
ennemis situés à 5 et 7,50 mètres. Voilà pourquoi on utilise la détection a priori.
Chapitre 4 Interactions 103

La détection de collision a priori

Au lieu de vériier la collision avec un objet Balle, il s’agit de découvrir si une balle attein-
dra sa cible. En projetant un rayon depuis l’objet Pistolet (en tenant donc compte de son
orientation) sur la même image que celle où le joueur appuie sur le bouton de tir, vous
pouvez immédiatement vériier quels objets coupent le rayon.
Cela est possible car les rayons sont tracés immédiatement. Vous pouvez comparer le rayon
à un pointeur laser : lorsqu’on allume un laser, l’œil humain ne perçoit pas le déplacement
de la lumière vers l’avant en raison de sa vitesse, si bien que le rayon laser semble tout
simplement apparaître.
Dans le raycasting, les rayons fonctionnent de la même façon. Chaque fois que le joueur
appuie sur le bouton de tir, un rayon est tracé dans la direction visée. Il est alors possible
de récupérer des informations sur le collider que ce rayon touche. Une fois le collider
identiié, un script peut alors désigner l’objet de jeu lui-même et scénariser son comporte-
ment en conséquence. Vous pouvez obtenir des informations très détaillées, comme le point
d’impact, et les utiliser pour déinir la réaction de la cible (faire reculer l’ennemi dans une
direction particulière par exemple).

Figure 4.4

Y
L'ennemi visé

X
------- Le rayon
Le point d'impact

Le joueur

Dans cet exemple de jeu de tir, vous utiliseriez sans doute des scripts pour tuer ou repousser
l’ennemi dont le collider touche le rayon. Comme le rayon est immédiat, cette réaction peut
s’effectuer sur l’image suivant celle sur laquelle le rayon croise le collider de l’ennemi.
La réaction étant enregistrée immédiatement, l’effet produit par le tir est réaliste.
104 Développez des jeux 3D avec Unity

Il est également intéressant de noter que les jeux de tir afichent souvent des rayons norma-
lement invisibles pour aider le joueur à viser. Ne confondez toutefois pas ces lignes avec
le raycasting car ces rayons sont simplement utilisés pour effectuer le rendu des lignes de
la visée.

L’ajout de l’avant-poste
Avant de commencer à utiliser à la fois la détection de collision et le raycasting pour ouvrir
la porte, vous devez intégrer à la scène l’avant-poste que vous avez déini au Chapitre 2,
"Environnements". Plus loin, vous écrirez le script qui contrôle les états d’animation de ce
modèle.
Faites glisser le modèle d’avant-poste depuis le panneau Project dans le panneau Scene.
Souvenez-vous que vous ne pouvez pas positionner le modèle lors du glisser-déposer, mais
seulement une fois que celui se trouve dans la scène (autrement dit, après avoir relâché le
bouton de la souris).

Figure 4.5
Chapitre 4 Interactions 105

Une fois l’avant-poste dans le panneau Scene, son nom apparaît dans le panneau Hierar-
chy et il est automatiquement sélectionné. Vous êtes maintenant prêt à déinir sa position
et à le redimensionner.

Positionner le modèle
Comme la conception de votre terrain peut être différente de la nôtre, sélectionnez l’outil
Transform, puis placez l’avant-poste dans une zone de terrain dégagée en faisant glisser
ses poignées d’axe dans la scène.

Soyez prudent lorsque vous utilisez les poignées d’axe pour déplacer un modèle.
ce Faire glisser le carré blanc où convergent les poignées modiie les trois axes à la
Astu
fois, ce qui est à éviter en vue Perspective. Assurez-vous de faire glisser chaque
poignée individuellement en gardant le curseur à l’extérieur du carré blanc.
Si vous souhaitez que l’objet reste plaqué sur la surface du terrain en vue
Perspective, appuyez sur Cmd/Ctrl et faites glisser le carré blanc.

Figure 4.6

Nous avons placé l’avant-poste à (500, 30.8, 505) mais vous devrez peut-être le déplacer
manuellement. Rappelez-vous qu’après avoir positionné l’objet à l’aide de ses poignées
d’axe dans le panneau Scene, vous pouvez saisir des valeurs spéciiques dans les champs
Position du composant Transform dans le panneau Inspector.
106 Développez des jeux 3D avec Unity

Redimensionner le modèle
Lorsque vous travaillez comme ici avec deux applications – le logiciel de modélisation
dans lequel la ressource outpost a été créée et Unity –, il est courant que la taille du modèle
importé ne corresponde pas aux unités métriques utilisées dans Unity et que vous deviez
modiier ses dimensions.
Bien qu’il soit possible de déinir les valeurs d’échelle dans les champs Scale du panneau
Inspector, il est généralement préférable d’utiliser le paramètre Scale Factor de la
ressource originale. Sélectionnez le modèle outpost dans le dossier Outpost du panneau
Project. Le composant FBXImporter s’afiche alors dans le panneau Inspector. Ses
paramètres d’importation affectent toutes les occurrences du modèle que vous placez dans
le panneau Scene. Dans ce cas précis, modiiez la valeur Scale Factor de 1 à 2, puis
cliquez sur le bouton Apply. Ainsi, la taille de l’avant-poste est sufisante pour que l’objet
Character Controller passe par la porte et la taille de la pièce sera réaliste lorsque le
personnage se trouvera à l’intérieur.

Colliders et tag de la porte

La porte doit être identiiée comme un objet particulier pour pouvoir s’ouvrir lorsqu’elle
entre en collision avec le joueur. Pour cela, l’objet doit posséder un composant Collider
et un tag spéciique qui désignera l’objet dans le script. Cliquez sur la lèche grise située
à gauche du nom de l’objet outpost dans le panneau Hierarchy pour aficher tous ses
objets enfants.
Sélectionnez l’objet door, puis placez le curseur sur le panneau Scene et centrez la vue
sur cet objet (touche F).

Figure 4.7
Chapitre 4 Interactions 107

La porte est maintenant visible dans le panneau Scene. Cet objet étant sélectionné, ses
composants apparaissent également dans le panneau Inspector, notamment Mesh Colli-
der (un composant de collision respectant le maillage de l’objet). Ce collider précis est
assigné à tous les maillages des objets enfants d’un modèle lorsque l’option Generate
Colliders est activée, ce que vous avez fait pour cette ressource outpost au Chapitre 2,
"Environnements".
Avec cette option, Unity attribue par défaut un composant Mesh Collider à chaque
élément enfant, car le programme ne sait pas quelle quantité de détails sont présents dans
les modèles importés. Chaque Mesh Collider adopte la forme du maillage de l’objet.
Ici, la porte étant une forme cubique simple, vous devez le remplacer par un collider plus
simple et plus eficace en forme de boîte.
Cliquez sur Component > Physics > Box Collider dans le menu principal.
Une première boîte de dialogue, Losing Prefab, signale que l’ajout d’un nouveau compo-
sant entraînera la in de la connexion entre cet objet et l’objet parent dans le panneau
Project. Autrement dit, la copie placée dans le panneau Scene ne sera plus identique à la
ressource d’origine et toute modiication apportée à la ressource dans le panneau Project ne
sera pas répercutée sur cette copie. Cliquez simplement sur le bouton Add pour conirmer.

Figure 4.8

Vous n’avez pas à vous inquiéter de ce message qui s’afiche chaque fois que vous commen-
cez à personnaliser les modèles importés dans Unity. Vous avez généralement besoin
d’ajouter des composants à un modèle, pour cela, vous pouvez créer vos propres éléments
préfabriqués.
Étant donné qu’un collider est déjà assigné à l’objet, une seconde boîte de dialogue appa-
raît dans laquelle vous indiquez si vous voulez ajouter ce collider à votre objet (Add),
le remplacer (Replace) ou annuler l’opération (Cancel). Le moteur physique de Unity
fonctionnant mieux avec un seul collider par objet, le programme vous demande si vous
souhaitez remplacer celui qui existe plutôt que d’en ajouter un nouveau.
Comme nous n’avons plus besoin du Mesh Collider, cliquez sur Replace.
108 Développez des jeux 3D avec Unity

Le composant Box Collider que vous venez d’ajouter apparaît alors autour de la porte,
iguré par un contour vert.

Figure 4.9

Un Box Collider (un composant de collision en forme de boîte) est un exemple de colli-
der primitif, car sa forme est constituée de primitives. Unity dispose de plusieurs colliders de
forme prédéinie de ce type, notamment Box, Sphere, Capsule et Wheel. Tous les compo-
sants colliders primitifs s’afichent sous la forme d’un tracé vert. Vous l’avez peut-être
remarqué lorsque vous avez étudié le collider du contrôleur de personnage, un collider de
type capsule, qui s’afiche donc aussi en vert.
Enin, vous avez besoin d’attribuer un tag à l’objet door, puisque vous y ferez référence
plus tard dans le script. L’objet enfant door étant toujours sélectionné, cliquez sur le menu
déroulant Tag situé en haut du panneau Inspector, puis choisissez Add Tag. Ajoutez le
tag outpostDoor dans le Tag Manager qui s’afiche dans le panneau Inspector (voir
Figure 4.10).

Figure 4.10
Chapitre 4 Interactions 109

Comme l’ajout de balises est un processus en deux étapes, vous aurez ensuite besoin de
sélectionner de nouveau l’objet enfant door dans le panneau Hierarchy pour choisir votre
nouveau tag outpostDoor dans le menu déroulant Tag et l’attribuer à cet objet.

Désactiver l’animation automatique

Par défaut, Unity suppose que toutes les animations des objets placés sur la scène doivent
être lues automatiquement. C’est pourquoi vous avez désactivé (idle) l’animation de cette
ressource. Si vous laissez Unity lancer automatiquement les animations des objets, ceux-
ci risquent de s’aficher dans un des états d’animation plutôt qu’avec leur apparence par
défaut. Pour corriger ce problème, il sufit de décocher la case Play automatically dans
le panneau Inspector pour l’objet parent du modèle. Vous n’auriez pas besoin de le faire
s’il s’agissait d’une animation en boucle se répétant constamment dans le jeu – un drapeau
claquant au vent ou la lumière tournante d’un phare par exemple – mais puisque l’anima-
tion de l’avant-poste ne doit pas se déclencher avant que le joueur n’ait atteint la porte, vous
devez éviter la lecture automatique d’une des animations que cet objet contient.
Pour cela, sélectionnez à nouveau l’objet parent outpost dans le panneau Hierarchy, puis
désactivez l’option Play automatically du composant Animations dans le panneau
Inspector.
Le panneau Inspector devrait présenter la même apparence qu’à la Figure 4.11.

Figure 4.11
110 Développez des jeux 3D avec Unity

Nous avons afiché les options du paramètre animationS ain de visualiser les
Info différents états de l’animation de cet objet.

L’objet outpost est maintenant prêt à interagir avec le personnage du joueur. Vous allez
donc commencer à écrire les scripts pour gérer les collisions avec la porte, en utilisant soit
la détection de collision soit le raycasting.

L’ouverture de la porte
Nous allons étudier les deux méthodes permettant de déclencher l’animation ain que vous
puissiez ensuite utiliser l’une ou l’autre lors du développement de vos jeux en fonction de
la situation. Dans un premier temps, vous utiliserez la détection de collision – une notion
essentielle à connaître lorsque vous commencez à travailler sur des jeux dans Unity. Puis
dans un second temps, vous implémenterez simplement une projection de rayon depuis le
personnage du joueur.

Méthode 1. La détection de collision

Pour commencer à écrire le script qui va déclencher l’animation d’ouverture de la porte et
ainsi permettre au joueur d’entrer dans l’avant-poste, vous devez choisir l’objet auquel le
script se destine.
Lors du développement de jeux, il est souvent plus eficace d’écrire un seul script pour un
objet qui interagira avec plusieurs autres objets, plutôt que d’écrire de nombreux scripts
pour chacun des objets ain de vériier que ceux-ci entrent en collision avec un objet en
particulier. Pour un jeu comme celui-ci, vous allez donc écrire un script à appliquer au
personnage du joueur et non un script pour chaque objet avec lequel le joueur peut interagir.

Créer de nouvelles ressources

Avant de créer un nouveau type de ressource dans un projet, il est conseillé de créer un
dossier qui contiendra toutes les ressources de ce type. Cliquez sur le bouton Create dans
le panneau Project, puis choisissez Folder dans le menu déroulant qui s’afiche.
Sélectionnez ce dossier, appuyez sur la touche Entrée (Mac  OS) ou F2 (Windows) et
renommez-le Scripts.
Le dossier Scripts toujours sélectionné, créez-y ensuite un ichier JavaScript. Pour cela,
cliquez de nouveau sur le bouton Create dans le panneau Project et choisissez cette fois
JavaScript.
Chapitre 4 Interactions 111

En sélectionnant le dossier, vous indiquez l’emplacement de la ressource que

ce vous allez créer. Vous n’aurez donc pas ensuite à le déplacer.
Astu

Modiiez le nom par défaut du script – NewBehaviourScript – en PlayerCollisions. Les

ichiers JavaScript portent l’extension de ichier .js mais celle-ci ne s’afiche pas dans le
panneau Project. Il n’est donc pas nécessaire d’essayer d’ajouter cette extension lorsque
vous renommez des ressources.

Vous pouvez également identiier le type de ichier d’un script grâce à son icône
Info dans le panneau Project. L’icône des ichiers JavaScript porte la mention "JS",
les ichiers C#, tout simplement "C#" et les ichiers Boo, une image d’un fantôme
Pacman.

Écrire le script pour la détection de collision du personnage

Double-cliquez sur l’icône du script dans le panneau Project pour lancer l’éditeur de
script – Unitron (Mac OS) ou Uniscite (Windows) – et commencer à l’éditer.

Utiliser OnControllerColliderHit
Par défaut, tous les nouveaux scripts JavaScript contiennent la fonction Update(), qui s’af-
iche lorsque vous les ouvrez pour la première fois. Pour commencer, vous allez déclarer
les variables que vous utiliserez.
Ce script doit commencer par la déinition de six variables, trois privées et trois publiques,
dont le but respectif est le suivant :
∑ doorIsOpen. Une variable privée true/false (booléenne) pour vériier si la porte est
ouverte.
∑ doorTimer. Une variable privée numérique décimale, utilisée pour décompter le temps
écoulé après l’ouverture de la porte et la refermer automatiquement une fois terminé le
délai déini.
∑ currentDoor. Une variable privée de type GameObject qui stocke l’état courant de la
porte. Elle évite, si vous ajoutez plus d’un avant-poste dans le jeu, que l’ouverture de
l’une des portes entraîne celle de toutes les autres, en gardant en mémoire la dernière
porte à avoir été touchée.
112 Développez des jeux 3D avec Unity

∑ doorOpenTime. Une variable publique numérique de type loat (éventuellement déci-

male) permettant de ixer dans le panneau Inspector le temps pendant lequel la porte
reste ouverte.
∑ doorOpenSound/doorShutSound. Deux variables publiques de type AudioClip, qui
servent à assigner un objet audio par glisser-déposer dans le panneau Inspector.
Pour déinir ces variables, ajoutez les lignes suivantes au tout début du script Player-
Collisions que vous modiiez :

private var doorIsOpen : boolean = false;

private var doorTimer : loat = 0.0;
private var currentDoor : GameObject;

var doorOpenTime : loat = 3.0;

var doorOpenSound : AudioClip;
var doorShutSound : AudioClip;

Avant d’aborder la fonction Update(), vous allez établir la fonction de détection de collision
elle-même. Insérez deux lignes après :
function Update(){

Et ajoutez la fonction suivante :

function OnControllerColliderHit(hit : ControllerColliderHit){
}

Cette fonction de détection de collision, appelée OnControllerColliderHit, est spécia-

lement destinée aux personnages jouables qui utilisent le composant Character-
Controller, comme c’est le cas ici. Son seul paramètre, hit, est une variable qui stocke
des informations lorsqu’une collision se produit, notamment l’objet de jeu avec lequel le
joueur est entré en collision.
Pour utiliser ces informations, vous allez ajouter une instruction if, entre les accolades de
la fonction :
function OnControllerColliderHit(hit: ControllerColliderHit){
if(hit.gameObject.tag == "outpostDoor" && doorIsOpen == false){
}
}
Chapitre 4 Interactions 113

Cette instruction if vériie deux conditions : tout d’abord, si l’objet avec lequel le person-
nage entre en contact a le tag outpostDoor, puis si la variable doorOpen est actuellement
déinie à false. Rappelez-vous que deux symboles d’égalité (==) indiquent une comparai-
son et que deux symboles esperluette (&&) signiient simplement "et". Autrement dit, si le
personnage entre en contact avec le collider de la porte que vous avez marqué d’un tag et
que la porte n’est pas déjà ouverte, une série d’instructions sera exécutée.
Ce script utilise la syntaxe à point pour faire référence à l’objet dont on vériie les colli-
sions, en descendant successivement la hiérarchie depuis hit (la variable qui contient les
informations sur les collisions) à gameObject (l’objet touché), puis au tag sur cet objet.
Si les conditions de cette instruction if se vériient, un ensemble d’instructions doit alors
se réaliser pour ouvrir la porte. Il s’agira de jouer un son, de lancer la lecture d’une des
animations sur le modèle et de déinir la variable booléenne doorOpen à true. Comme
vous allez appeler plusieurs instructions – et que vous aurez peut-être besoin d’utiliser leur
résultat dans une autre condition, par la suite lorsque vous implémenterez la technique du
raycasting –, vous allez les placer dans leur propre fonction personnalisée appelée OpenDoor.
Avant d’écrire cette nouvelle fonction, vous allez ajouter l’appel à cette fonction dans
l’instruction if que vous venez de créer. Pour cela, saisissez la ligne suivante :

OpenDoor();

La fonction de collision complète doit maintenant être semblable à celle-ci :

function OnControllerColliderHit(hit: ControllerColliderHit){
if(hit.gameObject.tag == "outpostDoor" && doorIsOpen == false){
OpenDoor();
}
}

Écrire des fonctions personnalisées

Vous pouvez écrire vos propres fonctions pour stocker des ensembles d’instructions à appe-
ler par la suite. De cette manière, vous pouvez simplement appeler une fonction à tout
moment pour exécuter de nouveau l’ensemble des instructions qu’elle contient au lieu de
devoir écrire plusieurs fois une série d’instructions ou de "commandes" dans un script.
Cela facilite également la localisation des erreurs dans le code – procédure connue sous
le nom de débogage –, car le nombre d’endroits où les erreurs peuvent se trouver est ainsi
réduit.
Vous venez d’écrire un appel à une fonction nommée OpenDoor dans la fonction de détec-
tion de collision. Les parenthèses qui suivent le nom de la fonction, OpenDoor, sont utilisées
114 Développez des jeux 3D avec Unity

pour stocker les paramètres éventuels que vous souhaitez passer à la fonction – vous pouvez
ainsi transmettre des comportements supplémentaires aux instructions situées à l’intérieur
de la fonction (voir la section "Des fonctions plus eficaces" de ce chapitre). Ici, les paren-
thèses sont vides, aucun comportement n’ayant encore été passé à la fonction.

Déclarer la fonction
Pour créer la fonction que vous appelez, écrivez tout simplement :
function OpenDoor(){
}

Vous pouvez ensuite écrire entre ses accolades toutes les instructions à effectuer lorsque
cette fonction est appelée, de la même manière que vous avez déini les conditions d’une
instruction if.

Lire les ichiers audio

La première instruction doit lancer la lecture de la séquence audio assignée à la variable
doorOpenSound. Pour cela, ajoutez la ligne suivante entre les accolades – après { et avant } :

audio.PlayOneShot(doorOpenSound);

La fonction doit maintenant être la suivante :

function OpenDoor(){
audio.PlayOneShot(doorOpenSound);
}

Cette ligne s’adresse au composant Audio Source attaché à l’objet de jeu auquel ce script
est appliqué (le personnage du joueur, autrement dit l’objet First Person Controller).
Vous aurez donc besoin plus tard de vous assurer que ce composant est bien lié à l’objet car
cette commande provoquerait une erreur si ce n’était pas le cas.
Le fait de désigner le composant Audio Source par le terme audio vous donne ensuite accès
à quatre fonctions  : Play(), Stop(), Pause() et PlayOneShot(). On utilise ici PlayOne-
Shot car cette option représente la meilleure façon de jouer une seule occurrence d’un
effet sonore, par opposition à la lecture de plusieurs séquences audio en continu, comme
de la musique. La variable doorOpenSound passée dans les parenthèses de la commande
PlayOneShot permet de déclencher la lecture du ichier audio assigné à cette variable dans
le panneau Inspector. Vous téléchargerez et assignerez ce ichier audio ainsi que celui de
la fermeture de la porte après avoir complété le script.
Chapitre 4 Interactions 115

Vériier l’état de la porte

Une condition de l’instruction if dans la fonction de détection de collision exige que la
variable booléenne doorIsOpen soit déinie à false. Par conséquent, la deuxième commande
de la fonction OpenDoor() a pour rôle de déinir cette variable à true.
En effet, le personnage du joueur peut entrer en collision avec la porte à plusieurs reprises
lors du contact. Sans cette variable booléenne, la fonction OpenDoor() pourrait se déclen-
cher plusieurs fois, ce qui entraînerait la répétition des sons et des animations à chaque
collision. Ainsi, la fonction OpenDoor() s’exécute lorsque la variable est déinie à false,
puis elle est immédiatement désactivée et la variable doorIsOpen déinie à true. On évite
ainsi que toute collision supplémentaire déclenche de nouveau la fonction OpenDoor().
Ajoutez la ligne suivante entre les accolades de la fonction OpenDoor() après la commande
que vous venez d’ajouter :
doorIsOpen = true;

Lancer l’animation
Au Chapitre 2, "Environnements", vous avez importé le paquet de ressources outpost et
étudié ses différents paramètres avant de l’intégrer dans le jeu au début de ce chapitre. Lors
du processus d’importation, vous avez déini les animations dans le panneau Inspector. En
sélectionnant cette ressource dans le panneau Project, vous avez précisé dans le panneau
Inspector qu’elle contenait les trois animations suivantes :
∑ idle (un état "inactif") ;
∑ dooropen (porte ouverte) ;
∑ doorshut (porte fermée).
Dans la fonction OpenDoor(), vous allez faire appel à une de ces animations à l’aide d’une
chaîne de caractères, ou string. Toutefois, vous devez au préalable indiquer quel objet de la
scène contient l’animation à lire. Comme le script que vous écrivez concerne le personnage
du joueur, vous devez faire référence à un autre objet avant de faire référence au composant
d’animation. Pour cela, ajoutez la ligne :
var myOutpost : GameObject = GameObject.Find("outpost");

Vous déclarez ici une nouvelle variable myOutpost de type GameObject puis vous sélec-
tionnez l’objet de jeu outpost par son nom à l’aide de la commande GameObject.Find. La
commande Find permet de sélectionner dans le panneau Hierarchy un objet présent dans
la scène actuelle par son nom. Elle peut donc s’utiliser comme une alternative aux tags.
116 Développez des jeux 3D avec Unity

À présent qu’une variable représente l’objet de jeu outpost, vous pouvez utiliser la syntaxe
à point ain de la désigner et appeler l’animation de la façon suivante :
myOutpost.animation.Play("dooropen");

Cette ligne désigne le composant d’animation attaché à l’objet outpost et lance la lecture
de l’animation dooropen. La commande Play() peut transmettre n’importe quelle chaîne
de caractères. Toutefois, cela fonctionne uniquement si les animations ont été déinies sur
l’objet en question.
Votre fonction personnalisée OpenDoor() complète doit maintenant être analogue à ceci :
function OpenDoor(){
audio.PlayOneShot(doorOpenSound);
doorIsOpen = true;
var myOutpost : GameObject = GameObject.Find("outpost");
myOutpost.animation.Play("dooropen");
}

Inverser la procédure
Maintenant que vous avez créé un ensemble d’instructions pour ouvrir la porte, comment
allez-vous la refermer ? Pour des raisons de jouabilité, vous n’obligerez pas le joueur à
fermer lui-même la porte. Vous allez donc écrire un script qui la referme après un certain
délai.
Pour cela, vous allez utiliser la variable doorTimer, vous lui ajouterez une valeur de temps
pour que le script commence à décompter dès l’ouverture de la porte, puis vous vériierez
si cette variable atteint une valeur particulière avec une instruction if.
Comme il s’agit d’un décompte dans le temps, vous devez utiliser une fonction constamment
mise à jour, comme la fonction Update() créée en même temps que le script.
Insérez des lignes vierges dans la fonction Update() pour décaler son accolade de ferme-
ture } de quelques lignes vers le bas.
Vous devez premièrement vériier si la porte a été ouverte, car il est évidemment inutile
d’incrémenter la variable de décompte du temps si la porte est fermée. Écrivez l’instruction
if suivante pour augmenter la valeur de la variable dans le temps lorsque la variable door-
IsOpen est déinie à true :

if(doorIsOpen){
doorTimer += Time.deltaTime;
}
Chapitre 4 Interactions 117

Ces lignes vériient si la porte est ouverte – la variable est par défaut déinie à false et
devient true uniquement à la suite d’une collision entre le personnage du joueur et la porte.
Si la variable doorIsOpen est true, on ajoute alors la valeur Time.deltaTime à la variable
doorTimer (écrire, comme ici, uniquement le nom de la variable dans la condition if
équivaut à écrire : doorIsOpen == true).

Time.deltaTime est une classe Time qui fonctionne indépendamment du nombre

Info d’images par seconde. C’est important car votre jeu peut être exécuté sur diffé-
rents ordinateurs, si bien qu’il serait étrange que le temps ralentisse ou accélère
en fonction de la puissance de l’ordinateur qui exécute le jeu. C’est pourquoi
on utilise Time.deltaTime pour calculer le temps nécessaire à l’afichage de la
dernière image. Avec cette information, vous pouvez automatiquement corriger
le décompte en temps réel.

Vous devez ensuite vériier si la variable doorTimer atteint une certaine valeur, autrement
dit qu’une certaine quantité de temps s’est écoulée. Pour cela, vous allez imbriquer une
instruction if dans celle que vous venez d’ajouter : elle sera seulement vériiée si la condition
doorIsOpen est valide.
Ajoutez les lignes de script suivantes sous la ligne qui incrémente la variable dans la décla-
ration if existante :
if(doorTimer > doorOpenTime){
shutDoor();
doorTimer = 0.0;
}

Cet ajout est constamment vériié dès que la variable doorIsOpen est égale à true puis il
attend que la valeur doorTimer dépasse celle de la variable doorOpenTime. Puisque vous
utilisez Time.deltaTime comme valeur d’incrémentation, trois secondes en temps réel
s’écouleront avant que cela ne se produise, à moins bien sûr que vous ne modiiiez la valeur
de cette variable ixée à 3 par défaut dans le panneau Inspector.
Une fois que la valeur doorTimer est supérieure à  3, une fonction appelée shutDoor()
est appelée et la variable doorTimer remise à 0 ain qu’elle puisse être de nouveau utilisée
la prochaine fois que l’ouverture de la porte sera déclenchée. Sans cette réinitialisation, la
valeur de doorTimer resterait supérieure à 3, si bien que la porte se refermait dès qu’elle
serait ouverte.
Votre fonction Update() complète doit maintenant être comme ceci :
118 Développez des jeux 3D avec Unity

function Update(){
if(doorIsOpen){
doorTimer += Time.deltaTime;

if(doorTimer > 3){

shutDoor();
doorTimer = 0.0;
}
}
}
Vous allez à présent ajouter la fonction shutDoor() au bas de votre script. Son rôle est
en grande partie le même que celui de la fonction openDoor(). Notez simplement qu’une
animation différente de l’objet outpost est appelée et que la variable doorIsOpen est redé-
inie à false ain que toute la procédure puisse être exécutée de nouveau :
function shutDoor(){
audio.PlayOneShot(doorShutSound);
doorIsOpen = false;

var myOutpost : GameObject = GameObject.Find("outpost");

myOutpost.animation.Play("doorshut");
}

Des fonctions plus eficaces

Maintenant que vous disposez d’un script qui contrôle l’ouverture et la fermeture de la
porte, vous allez voir comment améliorer ce script avec des fonctions sur mesure.
Pour le moment, vous disposez de deux fonctions personnalisées, OpenDoor() et shutDoor(),
qui effectuent les trois mêmes tâches  : elles lancent la lecture d’un son, déinissent une
variable booléenne et déclenchent une animation. Pourquoi ne pas alors créer une seule
fonction qui soit capable de jouer différents sons, de déinir si la variable booléenne est
true ou false et de lire les différentes animations ? Pour obtenir ce résultat, vous devez
passer ces trois tâches en tant que paramètres de la fonction. Pour déclarer des paramètres
dans une fonction, vous devez écrire chacun d’eux entre les parenthèses de la fonction en
les séparant par des virgules et en indiquant leur type de données.
Ajoutez la fonction suivante au bas de votre script :
function Door(aClip : AudioClip, openCheck : boolean, animName : String,
thisDoor : GameObject){
audio.PlayOneShot(aClip);
doorIsOpen = openCheck;

thisDoor.transform.parent.animation.Play(animName);
}
Chapitre 4 Interactions 119

Vous constatez que cette fonction est comparable aux fonctions OpenDoor() et shutDoor()
existantes, mais que sa déclaration compte quatre paramètres : aClip, openCheck, animName
et thisDoor. Il s’agit en fait de variables qui sont déinies lors de l’appel de la fonction et
dont la valeur est utilisée à l’intérieur de celle-ci. Pour ouvrir la porte, par exemple, vous
pourriez appeler cette fonction et déinir chaque paramètre de la façon suivante :
Door(doorOpenSound, true, "dooropen", currentDoor);

Ainsi, la valeur de la variable doorOpenSound est transmise au paramètre aClip, la valeur

true au paramètre openCheck, la chaîne de texte "dooropen" au paramètre animName et la
variable currentDoor au paramètre thisDoor.
Vous pouvez maintenant remplacer l’appel à la fonction OpenDoor() situé à l’intérieur
de la fonction de détection de collision. Cependant, vous devez encore déinir la variable
currentDoor. Pour cela, supprimez d’abord la ligne suivante qui appelle la fonction Open-
Door() dans la fonction OnControllerColliderHit() :

OpenDoor();

Et remplacez-la par les deux lignes suivantes :

currentDoor = hit.gameObject;
Door(doorOpenSound, true, "dooropen", currentDoor);

La variable currentDoor désigne ici le dernier objet à entrer en collision avec le personnage
du joueur. Vous pouvez ensuite passer cette information à votre fonction pour vous assurer
d’ouvrir uniquement la porte – autrement dit, déclencher l’animation – de l’avant-poste
avec lequel le joueur entre en collision, plutôt que celle d’un autre avant-poste possédant
une porte marquée d’un tag.
Dans la dernière ligne de la fonction Door, thisDoor.transform.parent.animation lance
la lecture de l’animation adéquate. La syntaxe à point permet de remonter dans la hiérarchie
jusqu’au composant d’animation sur lequel vous devez agir. La variable thisDoor reçoit
comme valeur l’objet le plus récemment touché – stocké dans la variable currentDoor –,
puis le script fait référence à l’objet parent de la porte, c’est-à-dire l’objet outpost lui-
même, puisque c’est à lui que le composant d’animation est attaché, et non à la porte. Vous
ne pourriez pas par exemple écrire :
thisDoor.animation.Play(animName);

Unity signalerait alors qu’il n’existe aucun élément d’animation. Vous devez donc dési-
gner le composant Transform du parent de l’objet enfant door – l’objet auquel il appar-
tient dans le panneau Hierarchy – pour sélectionner le composant d’animation depuis
ce point.
120 Développez des jeux 3D avec Unity

Enin, comme vous utilisez cette nouvelle méthode pour ouvrir et fermer les portes, vous
devez modiier le code de fermeture de la porte dans la fonction Update(). Dans l’instruc-
tion if qui vériie si la variable doorTimer dépasse la valeur de la variable doorOpenTime,
remplacez l’appel à la fonction shutDoor() par cette ligne :

Door(doorShutSound, false, "doorshut", currentDoor);

Vous pouvez maintenant supprimer les deux fonctions originales OpenDoor() et shutDoor(),
puisque la fonction personnalisée Door() les remplace toutes les deux. En créant des fonc-
tions de cette façon, vous évitez les répétitions dans vos scripts, ce qui les rend plus eficaces
et permet de réduire le temps nécessaire à l’écriture de plusieurs fonctions.

Finaliser le script
Pour compléter le script, vous allez vous assurer que l’objet qu’il ajoute possède un compo-
sant Audio Source, ce qui est nécessaire pour lire les extraits sonores puisque votre
fonction Door déclenche du son.
Ajoutez la ligne suivante tout en bas du script, en vous assurant que la ligne NE se termine
PAS par un point-virgule, contrairement à ce qu’on pourrait attendre. En fait, cette
commande est spéciique à Unity, et non d’une partie du code JavaScript.
@script RequireComponent(AudioSource)

Attacher le script à l’objet

Enregistrez votre script dans l’éditeur de script ain que Unity mette à jour les modiications
que vous avez effectuées – vous devez le faire pour tous les changements que vous apportez,
car sinon Unity ne peut pas recompiler le script.
Revenez ensuite à Unity. Regardez si la barre de message située au bas de l’interface
indique que le script contient des erreurs. Si c’est le cas, double-cliquez sur cette erreur et
assurez-vous que votre script correspond à celui indiqué dans les pages précédentes. Vous
prendrez l’habitude d’utiliser le rapport d’erreurs pour vous aider à corriger vos scripts.
Pour vous assurer que votre script ne contient pas d’erreur, commencez par vériier que
le nombre d’ouvertures et de fermetures des accolades est bien pair – autrement dit, que
toutes les fonctions et les instructions if sont correctement fermées.
Si le script ne contient aucune erreur, il vous sufit alors de sélectionner, dans le panneau
Hierarchy, l’objet sur lequel vous souhaitez l’appliquer : l’objet First Person Controller
ici.
Chapitre 4 Interactions 121

Il existe deux méthodes pour attacher un script à un objet dans Unity  : faire glisser le
script depuis le panneau Project sur l’objet dans les panneaux Hierarchy ou Scene,
ou tout simplement sélectionner l’objet puis cliquer sur Component > Scripts > Player
Collisions dans le menu principal de Unity. Le sous-menu Scripts du menu Component
contient la liste de tous les scripts disponibles dans le panneau Project : il afichera le
vôtre dès que vous l’aurez créé et sauvegardé.
Le panneau Inspector de l’objet First Person Controller devrait maintenant contenir
le composant Player Collisions (Script). Un composant Audio Source a également été
ajouté automatiquement en raison de l’utilisation de la commande RequireComponent à la
in du script.

Figure 4.12

Comme vous pouvez le constater, les variables publiques doorOpenTime, doorOpenSound et

doorShutSound s’afichent dans le panneau Inspector. Vous pouvez donc ajuster la valeur
de doorOpenTime et assigner des ichiers audio aux deux variables qui gèrent le son par
glisser-déposer depuis le panneau Project. Cela est vrai pour toutes les variables publiques
des scripts – le préixe private permet d’empêcher que les variables s’afichent de cette
manière, ce qui c’est le cas des trois autres variables utilisées dans le script. Gardez à
l’esprit que lors de l’utilisation de variables privées, vous devez leur assigner un type de
données ou une valeur dans le script pour éviter les erreurs. Dans le cas contraire, ces
variables sont "null" (n’ont aucune valeur).

Vous trouverez les ichiers audio Open Door et Door Close dans l’archive disponible sur
la page dédiée à cet ouvrage sur le site web Pearson (http://www.pearson.fr). Procédez si
nécessaire à l’extraction des ichiers, puis recherchez le paquet doorSounds.unitypackage.
Pour l’importer, revenez dans Unity, cliquez sur Assets  > Import Package, parcourez
votre disque dur jusqu’au dossier le contenant puis sélectionnez-le. Cliquez sur Ouvrir pour
aficher les deux ichiers que contient le paquet de ressources dans la boîte de dialogue
122 Développez des jeux 3D avec Unity

Importing package. Il vous sufit de cliquer sur le bouton Import pour conirmer l’impor-
tation des ichiers. Les éléments audio doorSlideOpen et doorSlideShut sont alors dispo-
nibles dans la liste des ressources du panneau Project (voir Figure 4.13).

Figure 4.13

À présent que ces ressources se trouvent dans le dossier de votre projet, faites glisser
chacune d’elles sur la variable publique appropriée du composant Player Collisions
(Script) dans le panneau Inspector (voir Figure 4.14).

Figure 4.14

Vous pouvez maintenant lancer le jeu et essayer d’ouvrir la porte. Pour cela, cliquez sur le
bouton Play en haut de l’interface, marchez jusqu’à la porte de l’avant-poste et entrez en
contact avec elle.
La collision entre le joueur et la porte est détectée, ce qui entraîne l’ouverture de la porte.
Puis celle-ci se referme automatiquement après 3  secondes. Cliquez de nouveau sur le
bouton Play pour terminer le test.
Pour que la porte s’ouvre sans que le joueur ait besoin de la toucher, vous allez agrandir
la taille du collider de la porte, comme nous l’avons évoqué au début du chapitre. Cliquez
sur la lèche grise située devant l’objet de jeu outpost dans le panneau Hierarchy pour
aficher ses objets enfants puis sélectionnez l’objet enfant door. Placez le curseur sur le
panneau Scene et appuyez sur la touche F pour centrer la vue sur cet objet.
Chapitre 4 Interactions 123

Figure 4.15

Dans le panneau Inspector, cliquez sur la lèche située devant le paramètre Size du
composant Box Collider pour aficher ses options et ainsi pouvoir ajuster la valeur Z (la
profondeur) du collider lui-même. Donnez-lui une valeur de 1,5 ain d’étendre le collider
(voir Figure 4.16).

Figure 4.16

Testez de nouveau le jeu. Vous pouvez constater que la porte s’ouvre plus tôt lorsque vous
vous en approchez, puisque la limite du collider dépasse davantage de la porte visible.
Cependant, une collision physique se produit dans le collider, entraînant une réaction de
repoussement. Vous pouvez contrer cet effet en utilisant le mode Trigger (déclencheur) du
collider, comme vous le verrez au chapitre suivant. Pour l’instant, vous allez implémenter
la seconde approche de détection  : le raytracing. En projetant un rayon vers l’avant du
personnage du joueur, il n’aura plus besoin de collider pour toucher le collider de la porte.
124 Développez des jeux 3D avec Unity

Méthode 2. Le raycasting
Bien que l’utilisation de la détection de collision ou de déclencheur soit une méthode tout
à fait valable, le raycasting vous permet de vous assurer que le joueur ouvre seulement la
porte de l’avant-poste s’il lui fait face. En effet, le rayon part toujours dans la direction vers
laquelle l’objet First Person Controller est tourné, si bien qu’il ne coupera pas la porte
si le joueur lui tourne le dos, par exemple.

Désactiver la détection de collision – utiliser les commentaires

Pour éviter d’avoir à écrire un script supplémentaire, vous allez simplement placer en
commentaires – c’est-à-dire désactiver temporairement – une partie du script qui contient
la fonction de détection de collision. Pour convertir le script de collision en commentaires
– ou le commenter –, vous devez ajouter certains caractères.
En programmation, les commentaires peuvent être conservés mais ne sont jamais exécutés.
Pour désactiver une partie du script, il vous sufit donc de la transformer en commentaires.
Revenez à votre éditeur de script (Unitron ou Uniscite), placez-vous au début de la ligne :
function OnControllerColliderHit(hit: ControllerColliderHit){

et insérez les caractères suivants :

/*

Dans un script, cette barre oblique (ou "slash") suivie d’un astérisque marque le début
d’un commentaire sur plusieurs lignes (par opposition aux deux barres obliques qui sont
utilisées pour les commentaires d’une seule ligne). Allez ensuite à la in de la fonction de
détection de collision et insérez un astérisque suivi d’une barre oblique. La couleur de
toute la fonction devrait avoir changé dans l’éditeur de script et se présenter de la façon
suivante :
/*
function OnControllerColliderHit(hit: ControllerColliderHit){
if(hit.gameObject.tag == "outpostDoor" && doorIsOpen == false){
currentDoor = hit.gameObject;
Door(doorOpenSound, true, "dooropen", currentDoor);
}
}
*/
Chapitre 4 Interactions 125

Réinitialiser le collider de la porte

Comme vous voulez éviter l’effet de repoussement qui survient lors du contact avec le
collider invisible de la porte, sélectionnez l’objet enfant door du composant Box Collider
dans le panneau Inspector, puis donnez au paramètre Size une valeur de 0,1 sur l’axe Z.
Cela correspond à la profondeur visuelle de la porte.

Ajouter le rayon
Revenez à l’éditeur de script et insérez quelques lignes après l’ouverture de la fonction
Update(). Le raycasting est placé dans la fonction Update() pour la simple raison que le
rayon doit être projeté vers l’avant à chaque image. Ajoutez les lignes suivantes avant la
condition if(doorIsOpen) :
var hit : RaycastHit;
if(Physics.Raycast (transform.position, transform.forward, hit, 5)) {
if(hit.collider.gameObject.tag=="outpostDoor" && doorIsOpen == false){
currentDoor = hit.collider.gameObject;
Door(doorOpenSound, true, "dooropen", currentDoor);
}
}

À la première ligne, on crée un rayon en déclarant une variable privée appelée hit, qui est
de type RaycastHit. Notez que cette variable n’a pas besoin du préixe private pour ne
pas s’aficher dans le panneau Inspector. En effet, il s’agit obligatoirement d’une variable
privée, car elle est déclarée dans une fonction. Elle sera utilisée pour stocker des informa-
tions sur le rayon lorsqu’il croisera des colliders. Nous utiliserons cette variable chaque fois
que nous ferons référence à ce rayon.
Suivent ensuite deux instructions. La première condition if est chargée de la projection du
rayon et utilise la variable créée à la ligne précédente. Comme la projection du rayon se
trouve dans une instruction if, l’appel à l’instruction if imbriquée se produira uniquement
si le rayon frappe un objet, ce qui rend le script plus eficace.
La commande Physics.Raycast de la première condition if projette le rayon. Elle possède
quatre paramètres indiqués entre parenthèses :
∑ Le point d’émission du rayon (transform.position). Indique la position de l’objet
sur lequel ce script s’applique, autrement dit l’objet First Person Controller.
126 Développez des jeux 3D avec Unity

∑ La direction du rayon (transform.forward). Le rayon est dirigé vers l’avant de l’objet

sur lequel s’applique ce script.
∑ La structure des données RaycastHit que nous avons déinies comme variable hit. Le
rayon est stocké sous la forme d’une variable.
∑ La longueur du rayon (5). La distance exprimée dans l’unité du jeu, le mètre.
Ensuite, l’instruction if imbriquée vériie tout d’abord que la variable hit entre en contact
avec des colliders dans le monde du jeu, en particulier le collider appartenant à un objet de
jeu portant le tag outpostDoor, avec :

hit.collider.gameObject.tag

Puis cette instruction if garantit, comme le faisait la fonction de détection de collision,

que la valeur de la variable booléenne doorIsOpen est false. Là encore, il s’agit de s’assu-
rer que le déclenchement de l’animation ne se répète pas plusieurs fois lorsque la porte a
commencé à s’ouvrir.
Une fois les deux conditions if réunies, la variable currentDoor est déinie sur l’objet
stocké dans la variable hit puis le script appelle la fonction Door() de la même manière
qu’il le faisait dans la fonction de détection de collision :

currentDoor = hit.collider.gameObject;
Door(doorOpenSound, true, "dooropen");

Testez la jouabilité du jeu une fois de plus et vous remarquerez que, lorsque vous appro-
chez de la porte, celle-ci s’ouvre non seulement avant que vous ne la percutiez, mais aussi
qu’elle s’ouvre uniquement lorsque vous lui faites face. En effet, le rayon qui détecte la
porte est projeté dans le même sens que celui où le personnage du joueur se dirige.

En résumé
Ce chapitre vous a permis d’explorer deux méthodes essentielles pour détecter les interac-
tions entre les objets dans les jeux 3D. Vous devez maîtriser le raycasting et la détection de
collision car vous aurez souvent à les réutiliser dans Unity pour vos futures créations.
Le chapitre suivant s’intéresse à une autre méthode de détection de collision, en utilisant
les colliders des objets comme des déclencheurs. Ce mode Trigger permet de détecter
les collisions sans qu’il y ait besoin qu’un objet soit présent physiquement – le joueur
peut ainsi collecter des objets sans les percuter, par exemple. Considérez les déclencheurs
comme des collisions sans aucun impact. Vous auriez pu adopter cette méthode pour la
Chapitre 4 Interactions 127

porte de l’avant-poste, cependant il est important que vous appreniez d’abord les principes
de base de la détection de collision. Voilà pourquoi nous les présentons dans cet ordre
particulier.
Vous allez créer un mini-jeu de collecte dans lequel le joueur devra trouver quatre piles ain
de recharger le mécanisme d’ouverture de la porte de l’avant-poste. Par conséquent, l’accès
à l’avant-poste lui sera interdit tant qu’il n’aura pas obtenu ces piles.
 5
Éléments préfabriqués,
collections et HUD
Au cours de ce chapitre, vous continuerez le travail du Chapitre 4. En utilisant une méthode
analogue à celle du chapitre précédent, vous allez en apprendre plus sur la détection des
collisions en utilisant les colliders (composants de collision) comme déclencheurs.
Les déclencheurs sont souvent considérés comme des composants. Pourtant, pour rester
simple, il s’agit de colliders qui possèdent un mode Déclencheur pouvant être activé avec
l’option Is Trigger dans le panneau Inspector (voir Figure 5.1).

Figure 5.1
130 Développez des jeux 3D avec Unity

Vous avez déjà un avant-poste dont la porte s’ouvre, mais vous allez maintenant forcer
le joueur à trouver certains objets pour qu’il puisse accéder à ce bâtiment. En afichant
des instructions à l’écran lorsque le joueur s’approche de la porte, vous lui ferez savoir
que l’ouverture de la porte nécessite une source d’alimentation. Pour l’inciter à rechercher
plusieurs exemplaires de cet objet disséminés à proximité ain de disposer de sufisamment
de puissance pour actionner le mécanisme d’ouverture de la porte, vous ferez ensuite appa-
raître une pile vide en 2D à l’écran.
En créant ce jeu simple, vous apprendrez à :
∑ travailler avec des objets 2D en utilisant des textures GUI ;
∑ contrôler l’afichage du texte à l’écran avec les éléments GUI Text ;
∑ utiliser des éléments préfabriqués pour créer plusieurs exemplaires d’un objet de jeu et
les stocker comme ressources.

La création de l’élément préfabriqué batterie

À cette section, vous importerez un modèle de pile que vous convertirez en élément préfa-
briqué de Unity (un modèle de données qui peut être utilisé pour créer plusieurs copies d’un
modèle possédant certains paramètres prédéinis). Si vous avez déjà utilisé Adobe Flash,
vous pouvez comparer cela à MovieClip, qui permet de créer plusieurs copies identiques et
de modiier chacune d’elles après leur création.

Télécharger, importer et positionner

Pour commencer à créer le jeu, vous aurez besoin du paquet de ressources de l’archive
fournie sur le site web de Pearson (http://www.pearson.fr). Procédez, si besoin, à l’extrac-
tion des ichiers, puis recherchez le package batteries.unitypackage. Revenez ensuite dans
Unity et cliquez sur Assets > Import Package. Parcourez le disque dur jusqu’au dossier
contenant le package et sélectionnez-le comme ichier à importer pour aficher la liste des
ressources dans la boîte de dialogue Importing package. Cliquez ensuite sur Import pour
importer les ressources suivantes :
∑ un modèle 3D de pile ;
∑ cinq ichiers image d’une batterie de remplissage avec charge ;
∑ un ichier audio qui sera lu lorsque le joueur collectera une pile.
Les ichiers doivent maintenant s’aficher dans le panneau Project (voir Figure 5.2).
Chapitre 5 Éléments préfabriqués, collections et HUD 131

Figure 5.2

Faites glisser le modèle battery depuis le dossier Other  Models du panneau Project
sur le panneau Scene. Placez ensuite le curseur sur le panneau Scene et appuyez sur la
touche F pour centrer la vue sur cet objet. La position de la pile est arbitraire, vous la repo-
sitionnerez une fois que vous aurez créé votre élément préfabriqué.

Ajouter un tag
Pour pouvoir détecter une collision avec l’objet battery, vous devez lui assigner un tag
pour l’identiier dans le script que vous allez bientôt écrire. Cliquez sur le menu déroulant
Tag, et sélectionnez Add Tag.
Le panneau Inspector afiche alors le Tag Manager. Ajoutez un tag battery dans le
premier élément disponible (voir Figure 5.3).

Figure 5.3
132 Développez des jeux 3D avec Unity

Appuyez sur Entrée pour valider la création de ce tag. Sélectionnez de nouveau l’objet
battery dans le panneau Hierarchy, puis choisissez le tag battery dans le menu dérou-
lant Tag du panneau Inspector.

Échelle, collider et rotation

Vous allez maintenant préparer la pile à devenir un élément préfabriqué en déinissant les
composants et les paramètres qui seront conservés sur chaque copie de la batterie.

Redimensionner la batterie
L’élément que vous créez devra avoir une taille sufisante pour que le joueur puisse le
repérer dans le jeu. Comme nous avons déjà vu comment modiier l’échelle des objets
dans le composant FBXImporter, vous allez ici simplement le redimensionner à l’aide du
composant Transform dans le panneau Inspector. L’objet battery étant toujours sélec-
tionné dans le panneau Hierarchy, donnez une valeur de 6 à tous les paramètres Scale du
composant Transform dans le panneau Inspector.

Ajouter un déclencheur de collision

Vous devez ensuite ajouter un collider à la pile pour que le joueur puisse interagir avec cet
objet. Cliquez sur Component  > Physics  > Capsule Collider. Nous avons choisi ce
type de collider car c’est celui dont la forme est la plus proche de celle de la pile. Le joueur
ne devant pas buter contre cet objet lors du contact, vous devez activer le mode Déclen-
cheur de son collider. Pour cela, choisissez l’option Is Trigger dans le nouveau composant
Capsule Collider.

Créer un effet de rotation

Vous allez maintenant écrire un script pour faire pivoter l’objet battery, de manière à ajou-
ter un effet visuel et à le rendre plus visible pour le joueur. Sélectionnez le dossier Scripts
dans le panneau Project pour vous assurer que ce script y sera bien créé. Cliquez sur
le bouton Create situé en haut du panneau Project et choisissez JavaScript. Appuyez
sur la touche Entrée/F2 et modiiez le nom du ichier (NewBehaviourScript par défaut)
en RotateObject. Double-cliquez ensuite sur son icône pour l’ouvrir dans l’éditeur de script.
Chapitre 5 Éléments préfabriqués, collections et HUD 133

Insérez une ligne au début de votre nouveau script, avant la fonction Update(), et créez-y
une variable publique à virgule lottante rotationAmount d’une valeur de 5.0 de la façon
suivante :
var rotationAmount : loat = 5.0;

Cette variable vous servira à déinir la vitesse de rotation de l’objet battery. Il s’agit d’une
variable publique (elle se trouve en dehors de toute fonction et n’est pas déclarée comme
private), vous pourrez donc également ajuster cette valeur dans le panneau Inspector une
fois le script attaché à l’objet battery.
Dans la fonction Update(), ajoutez la commande suivante pour faire pivoter l’objet battery
sur son axe Y avec une valeur égale à celle de la variable rotationAmount :
function Update () {
transform.Rotate(Vector3(0,rotationAmount,0));
}

La commande Rotate() attend une valeur de type Vector3 (X, Y, Z). Les valeurs X et Z sont
ici déinies à 0 tandis que la valeur Y est celle de la variable. Comme cette commande se
trouve dans la fonction Update(), elle s’exécutera à chaque image, si bien que la pile effec-
tuera une rotation de 5 degrés de chaque image. Cliquez sur File > Save dans l’éditeur de
script, puis revenez dans Unity.
Pour lier ce script à l’objet battery, assurez-vous que ce dernier est sélectionné dans le
panneau Hierarchy. Cliquez ensuite sur Component > Scripts > RotateObject. Vous
pouvez également simplement faire glisser le script depuis le panneau Project sur l’objet
dans le panneau Hierarchy.
Cliquez sur le bouton Play situé en haut de l’interface pour vous assurer que l’objet
battery tourne bien sur lui-même dans le jeu. Si cela ne fonctionne pas, vériiez que votre
script ne contient pas d’erreur et qu’il est attaché à l’objet adéquat. N’oubliez pas de cliquer
de nouveau sur Play pour terminer vos tests avant de poursuivre.

Enregistrer comme élément préfabriqué

À présent que l’objet battery est terminé, vous devez le cloner à trois reprises pour dispo-
ser d’un total de quatre piles. La meilleure méthode pour cela consiste à utiliser le système
d’élément préfabriqué de Unity. Un élément préfabriqué est simplement un modèle de
données qui stocke les paramètres d’un objet créé dans la scène. Il peut ensuite être cloné
lors de l’édition ou de l’instanciation (sa création à la volée) lors de l’exécution du jeu.
134 Développez des jeux 3D avec Unity

Créez un dossier dans le panneau Project pour stocker l’élément préfabriqué et ceux que
vous créerez plus tard. Pour cela, assurez-vous d’abord qu’aucun dossier existant n’est
sélectionné en cliquant dans l’espace gris sous les objets dans le panneau Project. Cliquez
ensuite sur le bouton Create et sélectionnez Folder, puis appuyez sur Entrée/F2 et
nommez ce nouveau dossier Prefabs.
Sélectionnez le dossier Prefabs, puis cliquez sur le bouton Create et choisissez Prefab
pour créer un nouvel élément préfabriqué vide dans ce dossier.

L’icône d’un élément préfabriqué vide est un cube gris, tandis que celle d’un
Info élément préfabriqué ayant un contenu est un cube bleu clair.

Renommez l’élément préfabriqué vide battery. Faites ensuite glisser l’objet battery sur
lequel vous avez travaillé depuis le panneau Hierarchy jusque sur l’élément préfabriqué
vide battery dans le panneau Project.
La pile devient alors un élément préfabriqué. Une copie de cet élément préfabriqué est
également créée dans la scène courante. Par conséquent, toute modiication apportée à
l’élément préfabriqué dans le panneau Project se répercute sur sa copie dans la scène. Le
nom des objets de la scène liés à des ressources du projet s’afiche en bleu dans le panneau
Hierarchy, tandis que le nom des objets existant uniquement dans la scène s’afiche en
noir.

Disperser les batteries

Comme l’objet battery est maintenant stocké sous la forme d’un élément préfabriqué,
la duplication de la copie dans la scène entraîne la création d’occurrences de cet élément
préfabriqué. Veillez à ce que l’objet battery soit toujours sélectionné dans le panneau
Hierarchy, puis cliquez sur Edit  > Duplicate ou utilisez le raccourci clavier Cmd/
Ctrl+D pour le dupliquer trois fois dans la scène.

Lorsque vous dupliquez des objets dans la scène, les copies sont créées dans
ce la même position, ce qui peut entraîner une certaine confusion. En effet, Unity
Astu
duplique chaque paramètre des objets, y compris leur position. Le plus simple
est de se souvenir que les copies se trouvent dans la même position que l’original
et doivent simplement être déplacées.
Chapitre 5 Éléments préfabriqués, collections et HUD 135

Sélectionnez chacune des quatre piles dans le panneau Hierarchy et utilisez l’outil Trans-
form pour les disposer autour de l’avant-poste. N’oubliez pas que vous pouvez utiliser
l’axe 3D situé dans le coin supérieur droit du panneau Scene pour passer de la vue Pers-
pective aux vues Haut, Bas et latérales. Placez les piles à une hauteur qui ne soit pas trop
élevée pour que le joueur puisse les atteindre.
Une fois que vous avez disposé les quatre piles autour de l’avant-poste, vous devriez obtenir
un résultat comparable à celui illustré à la Figure 5.4.

Figure 5.4

L’afichage d’une interface graphique pour la pile

Maintenant que les piles sont en place, vous devez indiquer au joueur ce qu’il doit collec-
ter grâce à une représentation visuelle de l’objet. Les textures importées avec le paquet
de ressources ont été conçues pour montrer clairement que le joueur devra collecter quatre
batteries ain de déverrouiller la porte. Pour créer l’illusion que cet élément d’interface est
dynamique, vous pouvez remplacer l’image de la pile vide par celle montrant la pile chargée
d’une unité lorsque le joueur collecte la première pile, puis par l’image de la pile chargée à
deux unités lorsqu’il obtient la deuxième, et ainsi de suite.
136 Développez des jeux 3D avec Unity

Créer l’objet GUI Texture

Un dossier de textures a été importé en même temps que le paquet de ressources contenant
les piles. Ce dossier contient cinq ichiers image : un pour la pile vide et quatre pour les
différentes étapes de chargement. Créées dans Adobe Photoshop, ces images au format
PNG (Portable Network Graphics) ont un fond transparent. Nous avons choisi ce format
car il prend en charge les couches alpha de haute qualité, bien que l’image soit compres-
sée. La couche alpha est celle qui crée la transparence dans une image en complément des
couches rouge, vert et bleu qui constituent l’image.
Pour créer l’interface graphique montrant le chargement progressif de la pile, vous allez
ajouter l’image de la pile vide dans la scène à l’aide du composant GUI Texture de Unity.
Afichez le contenu du dossier textures dans le panneau Project, puis sélectionnez le
ichier nommé battery_nocharge.
Vous ne pouvez pas déposer directement cette ressource dans le panneau Scene. Vous
devez créer un nouvel objet possédant un composant GUI Texture, puis utiliser l’image
battery_nocharge comme texture de ce composant.

Bien que cette procédure se déroule techniquement en trois étapes, elle peut être réalisée en
une seule. Pour cela, sélectionnez la texture à utiliser dans le panneau Project, puis cliquez
sur GameObject > Create Other > GUI Texture dans le menu principal.
Un nouvel objet auquel est attaché un composant GUI Texture est alors créé. Unity lit les
dimensions de la texture choisie à partir du ichier image, si bien que les valeurs du para-
mètre Pixel Inset sont déjà déinies dans le panneau Inspector (voir Figure 5.5).

Figure 5.5
Chapitre 5 Éléments préfabriqués, collections et HUD 137

Les valeurs du paramètre Pixel Inset déinissent les dimensions et la supericie d’afi-
chage d’un objet. Généralement, les paramètres Width et Height doivent être spéciiés
pour correspondre aux dimensions d’origine de votre ichier de texture, et les valeurs X
et Y être ixées à la moitié de ces dimensions. Lorsque vous créez l’objet après avoir sélec-
tionné la texture, Unity déinit ces valeurs pour vous.

Si vous sélectionnez l’image que vous souhaitez utiliser en premier, vous indi-
ce quez à Unity qu’en créant le nouvel objet, il doit utiliser ce ichier comme
Astu
texture et déinir les dimensions du composant Gui texture en fonction de
celle-ci.
De plus, lorsque vous sélectionnez une image et créez un objet Gui texture
à l’aide du menu principal, l’objet créé est nommé selon le nom de la texture,
ce qui est très utile pour trouver l’objet dans le panneau HierarcHy après sa
création.

Sélectionnez au besoin l’objet battery_nocharge que vous avez créé dans le panneau
Hierarchy, appuyez sur Entrée/F2 et renommez-le Battery GUI.

Positionner l’objet GUI Texture

Vous avez besoin d’utiliser les coordonnées relatives à l’écran lorsque vous travaillez avec
des éléments 2D car ils fonctionnent uniquement sur les axes X et Y – l’axe Z étant utilisé
pour déinir la priorité d’afichage des différents éléments GUI Texture.
Les coordonnées relatives à l’écran s’incrémentent de 0 à 1 avec des nombres décimaux.
Pour positionner l’objet Battery GUI où il doit apparaître (dans le coin inférieur gauche
de l’écran), vous avez besoin de déinir les valeurs X et Y de son composant Transform.
Donnez une valeur de 0,05 au paramètre X et une valeur de 0,2 au paramètre Y.
L’image doit maintenant s’aficher dans le panneau Game (voir Figure 5.6).
138 Développez des jeux 3D avec Unity

Figure 5.6

Vous pouvez également aficher les détails 2D dans le panneau Scene en cliquant sur le
bouton Game Overlay (voir Figure 5.7).

Figure 5.7
Chapitre 5 Éléments préfabriqués, collections et HUD 139

Modiier l’interface graphique à l’aide d’un script

La pile qui s’afiche dans le coin de l’écran est vide, or le joueur doit collecter plusieurs
piles. Vous devez donc écrire un script qui indique au composant GUI Texture de changer
de texture en fonction du nombre de piles que le joueur possède.
Sélectionnez le dossier Scripts dans le panneau Project, puis cliquez sur le bouton Create
et choisissez JavaScript. Renommez le script ainsi créé BatteryCollect (NewBehaviour-
Script par défaut), puis double-cliquez sur son icône pour l’ouvrir dans l’éditeur de script.
Le script servira à contrôler le composant GUI Texture de l’objet Battery GUI. Aussi,
il est préférable qu’il soit attaché à cet objet, ain que les scripts connexes soient joints aux
objets appropriés.
Avec ce script, la texture afichée à l’écran dépendra du nombre de piles qui ont été
collectées – ces informations seront stockées dans une variable numérique entière (de
type integer). Une fois l’écriture du script terminée, vous modiierez le script Player-
Collisions, en ajoutant une détection de déclencheur de collision pour les piles. Chaque
fois qu’une collision sera détectée entre le personnage et une pile, la variable numérique
sera incrémentée dans le script BatteryCollect, ce qui modiiera la texture utilisée par le
composant GUI Texture de l’objet Battery GUI.
Le script commence par la déclaration d’une variable de type static – une variable statique
accessible depuis d’autres scripts –, qui stocke l’état de chargement de la pile. Cette variable
est un entier, car il est impossible que sa valeur soit décimale. Ajoutez la ligne suivante
avant la première du script :
static var charge : int = 0;

Vous avez ensuite besoin de cinq variables pour stocker les textures qui représentent les
cinq états différents de l’objet Battery GUI – la pile vide et les quatre étapes de char-
gement. Pour cela, ajoutez les cinq variables suivantes de type Texture2D sans valeur
déinie :
var charge1tex : Texture2D;
var charge2tex : Texture2D;
var charge3tex : Texture2D;
var charge4tex : Texture2D;
var charge0tex : Texture2D;

Comme il s’agit de variables publiques, vous pourrez assigner chaque ichier image en
faisant glisser les textures du panneau Project sur les champs des variables dans le panneau
Inspector lorsque ce script sera sélectionné.
140 Développez des jeux 3D avec Unity

Pour conigurer les paramètres par défaut du composant GUI Texture, ajoutez la fonction
Start() suivante après les variables que vous venez de déclarer :

function Start(){
guiTexture.enabled = false;
charge = 0;
}

La fonction Start() s’exécutera une fois au début de ce niveau du jeu (ou de la scène, pour
reprendre le terme utilisé dans Unity). Avec la ligne :
guiTexture.enabled = false;

vous vous assurez que le composant n’est pas activé et donc que la pile n’est pas visible
lorsque le jeu commence. La variable charge est déinie également à 0 au début du jeu, ain
que le script considère qu’aucune pile n’a été collectée lorsque la scène commence.
Insérez ensuite quelques lignes avant l’accolade de fermeture de la fonction Update(), puis
ajoutez l’instruction if suivante :
if(charge == 1){
guiTexture.texture = charge1tex;
guiTexture.enabled = true;
}

Ici, le script vériie si la variable charge a une valeur de 1 puis il exécute deux commandes :
∑ guiTexture.texture = charge1tex;. Cette ligne déinit quelle est l’image assignée
à la variable charge1tex qui doit être utilisée comme texture par le composant GUI
Texture de l’objet sur lequel ce script est attaché.
∑ guiTexture.enabled = true;. Cette ligne active le composant lui-même. Vous avez
indiqué que l’objet Battery GUI n’est pas visible (c’est-à-dire inactivé) lorsque le jeu
démarre, ain d’éviter toute confusion pour le joueur et pour éviter d’encombrer l’écran.
La pile vide doit uniquement s’aficher après que le joueur a essayé d’ouvrir la porte.
L’instruction if de cette ligne du script permet donc d’activer l’interface graphique
lorsque le joueur a collecté une pile. Vous ajouterez plus tard quelques lignes de script
au raytracing qui détecte la collision avec la porte dans le script PlayerCollisions ain
d’aficher la pile vide si l’utilisateur essaie d’entrer dans l’avant-poste avant d’avoir
collecté sa première pile.
Vous allez ensuite ajouter trois instructions if supplémentaires dans la fonction Update()
pour vériier l’état de la variable charge. Comme il est impossible que la valeur de la
variable charge soit égale à la fois à 1 et à une autre valeur, vous utiliserez des conditions
Chapitre 5 Éléments préfabriqués, collections et HUD 141

else if, puisque celles-ci sont vériiées uniquement lorsque l’une ou l’autre des autres
instructions if s’exécute déjà.
Si vous deviez utiliser une instruction if pour chacune des conditions suivantes, elles
seraient toutes vériiées simultanément, ce qui rendrait le script ineficace. Ajoutez le code
suivant après l’accolade de fermeture de l’instruction if existante :
else if(charge == 2){
guiTexture.texture = charge2tex;
}
else if(charge == 3){
guiTexture.texture = charge3tex;
}
else if(charge >= 4){
guiTexture.texture = charge4tex;
}

Ces conditions else if indiquent à la texture afichée par le composant GUI  Texture
d’utiliser les différentes variables publiques déclarées au début du script (vous assignerez
plus tard les ichiers d’images à ces variables dans le panneau Inspector). Vous n’avez pas
besoin d’activer le composant dans ces conditions else if car il a déjà été activé lorsque le
joueur a ramassé la première pile.
Enin, il sufit d’ajouter une instruction else à la in de la suite de conditions if et else if
au cas où la variable charge aurait une valeur de 0, puisque la déclaration else signiie "si
aucune des conditions qui précèdent n’est vraie, alors procédez comme suit". Autrement
dit, puisque les déclarations if et else if recherchent une valeur de chargement allant
de 1 à 4, l’instruction else se chargera de l’afichage quand le jeu commencera (quand la
variable de charge sera égale à 0). Cela reprend pour l’essentiel la fonction Start() :
else{

guiTexture.texture = charge0tex;

Maintenant que le script est terminé, cliquez sur File > Save dans l’éditeur de script et
revenez à Unity.
Sélectionnez l’objet Battery GUI dans le panneau Hierarchy, puis cliquez sur Compo-
nent > Scripts > BatteryCollect dans le menu principal pour assigner le script à l’objet
Battery  GUI. Les cinq variables publiques en attente d’affectation devraient s’aficher
dans le panneau Inspector (voir Figure 5.8).
142 Développez des jeux 3D avec Unity

Figure 5.8

Faites glisser les cinq ichiers de texture depuis le dossier textures du panneau Project que
vous avez importé plus tôt sur les variables publiques appropriées (voir Figure 5.9).

Figure 5.9

À présent que l’interface graphique de la collecte des piles est prête, il vous reste à l’ajouter
au script PlayerCollisions attaché à l’objet First Person Controller, ain de détecter
si le personnage du joueur interagit avec les déclencheurs de collision des objets battery.

La collecte des piles avec des déclencheurs

Pour déclencher les différents états de l’objet Battery GUI, vous allez utiliser une fonc-
tion OnTriggerEnter() pour détecter l’interaction avec les objets qui disposent de colliders
en mode Déclencheur, c’est-à-dire les piles à collecter.
Avant d’écrire cette fonction dans le script PlayerCollisions, vous ajouterez une variable
publique pour stocker un élément audio. Ce son se déclenchera lorsque le joueur ramassera
une pile ain de compléter les indications visuelles sur le chargement de la pile.
Double-cliquez sur l’icône du script PlayerCollisions dans le dossier Scripts du panneau
Project pour l’ouvrir dans l’éditeur de script si nécessaire. Ajoutez la ligne suivante au
début du script pour créer une variable publique :

var batteryCollect : AudioClip;

Seul le type de données (AudioClip) de la variable est déclaré dans le script. Sa valeur n’est
pas déinie ; elle pourra l’être par la suite dans le panneau Inspector.
Chapitre 5 Éléments préfabriqués, collections et HUD 143

Insérez ensuite une ligne avant la dernière ligne du script :

@script RequireComponent(AudioSource)

et ajoutez la fonction suivante :

function OnTriggerEnter(collisionInfo : Collider){
}

Cette fonction est spéciiquement conçue pour détecter les collisions avec les colliders en
mode Déclencheur. Toute collision avec ce type de collider est placée dans le paramètre
collisionInfo, qui est de type Collider, si bien que pour effectuer une requête sur ces
informations, vous devez faire référence à l’objet attaché au collider qui a été touché.
Ajoutez l’instruction if suivante à l’intérieur de la fonction OnTriggerEnter() (c’est-à-
dire avant son accolade de fermeture) pour interroger tous les déclencheurs avec lesquels le
personnage du joueur entre en collision :
if(collisionInfo.gameObject.tag == "battery"){
BatteryCollect.charge++;
audio.PlayOneShot(batteryCollect);
Destroy(collisionInfo.gameObject);
}

Cette déclaration if effectue une requête sur le paramètre collisionInfo de la fonction

ain de vériier si le collider de la collision courante est attaché à un objet de jeu portant le
tag battery – s’il s’agit d’une pile. Si tel est le cas, le script :
∑ Incrémente la valeur de la variable statique (globale) charge du script BatteryCollect
à l’aide de la syntaxe à point et de l’opérateur ++. En augmentant la valeur de la variable
charge à chaque collision avec une pile, vous déclenchez le changement de texture dans
le script BatteryCollect pour représenter à l’écran le chargement de la pile, complétant
ainsi le lien entre les collisions et l’interface graphique.
∑ Lance une seule fois la lecture de la séquence audio assignée à la variable battery-
Collect dans le panneau Inspector.
∑ Retire de la scène, grâce à la commande Destroy(), l’objet avec lequel le personnage du
joueur est entré en collision. La syntaxe à point permet de préciser que l’objet à détruire
est celui qui est impliqué dans la collision. Cette opération est régie par une instruction
if et s’exécute donc uniquement en cas de collision avec un objet portant le tag battery.
Il est donc impossible qu’un autre objet soit détruit. Dans cet exemple, la commande
Destroy() prend un objet de jeu comme seul paramètre, mais elle peut également avoir
une valeur décimale comme second paramètre (séparé du premier par une virgule) pour
indiquer le temps après lequel un objet doit être supprimé.
144 Développez des jeux 3D avec Unity

Cliquez sur File > Save dans l’éditeur de script pour enregistrer le script, puis revenez
dans Unity. Sélectionnez l’objet First Person Controller dans le panneau Hierarchy.
Comme vous pouvez le constater, le composant PlayerCollisions (Script) dans le
panneau Inspector possède maintenant une nouvelle variable publique Battery Collect
qui attend que lui soit affectée une ressource Audio Clip (voir Figure 5.10).

Figure 5.10

Faites glisser la ressource audio battery_collect située dans le dossier Sounds du

panneau Project sur la variable Battery Collect, ou cliquez sur la lèche grise à droite
de None (Audio Clip) et sélectionnez battery_collect dans la liste déroulante qui
s’afiche.
Cliquez sur le bouton Play et testez le jeu. Chacune des piles doit disparaître lorsque le
personnage du joueur entre en contact avec elle ; l’image de la pile doit s’aficher puis sa
charge augmenter à chaque pile que vous obtenez. Vous devez également entendre l’effet
sonore jouer à chaque nouvelle pile, aussi assurez-vous que le volume sonore de votre ordi-
nateur n’est pas à zéro ! Cliquez de nouveau sur le bouton Play pour arrêter le test une fois
que vous avez vériié que vous pouvez recueillir toutes les piles.

Restreindre l’accès à l’avant-poste

Cet exercice a pour principal objectif de vous montrer comment contrôler certaines situa-
tions dans le jeu. Dans cet exemple, nous voulons que le joueur puisse uniquement ouvrir
la porte de l’avant-poste après avoir collecté quatre piles.
Du point de vue du développeur, cette énigme nécessite de résoudre deux questions
principales :
∑ Comment le joueur sait-il qu’il doit collecter des piles pour ouvrir la porte ?
∑ Comment écrire un script qui ouvre la porte uniquement lorsque le joueur est en
possession de toutes les piles ?
Considérons la première question : vous allez chercher à conserver une part de mystère
dans votre jeu. Vous proposerez au joueur un indice pour ouvrir la porte, uniquement s’il
cherche à entrer dans l’avant-poste. Pour cela, vous aurez besoin que des instructions s’afi-
chent à l’écran lorsqu’il s’approchera de la porte la première fois. Vous ajouterez également
Chapitre 5 Éléments préfabriqués, collections et HUD 145

de nouvelles instructions dans le cas où il s’approcherait de nouveau de la porte après avoir

rassemblé quelques piles mais pas toutes.
Ain de vériier si le joueur peut ouvrir la porte et, par conséquent, si des instructions
doivent s’aficher à l’écran, vous pouvez utiliser le script BatteryCollect existant. Comme
sa variable statique charge contient la quantité de piles collectées et stockées, vous saurez en
l’interrogeant si sa valeur est égale à 4 – autrement dit, si toutes les piles ont été collectées.

Restreindre l’accès
Avant de donner des instructions au joueur, vous allez modiier la partie du script Player-
Collisions qui gère l’ouverture de la porte ain qu’elle s’active uniquement lorsque le
joueur a collecté les quatre piles. Au chapitre précédent, vous avez écrit une fonction person-
nalisée Door() dans le script PlayerCollisions dont les paramètres géraient l’ouverture et
la fermeture des portes que le joueur rencontre de la manière suivante :
function Door(aClip : AudioClip, openCheck : boolean, animName : String,
thisDoor : GameObject){
audio.PlayOneShot(aClip);
doorIsOpen = openCheck;
thisDoor.transform.parent.animation.Play(animName);
}

Cette fonction lance la lecture d’une séquence sonore, garantit que la porte ne peut être
rouverte et déclenche l’animation d’ouverture de la porte. Elle est appelée au sein de la
fonction Update(), dans la partie du script consacrée au raycasting (la ligne vectorielle
projetée dans la même direction que le regard du joueur et qui vériie la collision avec la
porte). Ces lignes sont les suivantes :
var hit : RaycastHit;
if (Physics.Raycast (transform.position, transform.forward, hit, 5)) {
if(hit.collider.gameObject.tag=="outpostDoor" && doorIsOpen == false){
currentDoor = hit.collider.gameObject;
Door(doorOpenSound, true, "dooropen", currentDoor);
}
}
Double-cliquez sur le script PlayerCollisions dans le panneau Project pour l’ouvrir,
puis recherchez l’extrait de code de la fonction Update() dans lequel se trouve l’appel à la
fonction Door() qui ouvre la porte :
if(hit.collider.gameObject.tag=="outpostDoor" && doorIsOpen == false){
Door(doorOpenSound, true, "dooropen", currentDoor);
}
146 Développez des jeux 3D avec Unity

Pour que la porte reste fermée aussi longtemps que toutes les piles n’ont pas été collectées,
il sufit d’ajouter une troisième condition à l’instruction if existante, en utilisant une autre
paire d’esperluettes, && :
if(hit.collider.gameObject.tag=="outpostDoor" && doorIsOpen == false &&
„ BatteryCollect.charge >= 4){
Door(doorOpenSound, true, "dooropen", currentDoor);
}

En ajoutant la condition :
BatteryCollect.charge >= 4

vous vériiez si la valeur de la variable statique charge du script BatteryCollect est égale
ou supérieure à 4. Ainsi, la porte ne s’ouvrira pas tant que le joueur n’aura pas ramassé
toutes les piles dispersées dans l’île.

La commande GetComponent()
Une fois que le joueur peut entrer dans l’avant-poste, vous devez supprimer l’objet Battery
GUI de l’écran. Pour cela, vous avez besoin d’accéder à son composant GUI Texture. Le
déclenchement de la porte se trouvant dans le script PlayerCollisions dans lequel vous
travaillez actuellement, vous devez faire référence à un composant attaché à un objet diffé-
rent (Battery GUI) que celui sur lequel se trouve ce script (First Person Controller).
Dans le script BatteryCollect, vous pourriez écrire simplement :
guiTexture.enabled = false;

puisque ce script est attaché au même objet que le composant GUI Texture. Mais cela
n’est pas possible dans un script qui ne se trouve pas sur un objet possédant un composant
GUI Texture.
Vous devez donc utiliser la commande GetComponent(), à la suite de la référence à l’objet
sur lequel se trouve le composant auquel vous voulez vous adresser. En effet, vous pouvez
alors facilement ajuster les composants des objets externes.
Ajoutez la ligne suivante au-dessous de celle qui appelle la fonction Door() dans l’instruction
if que vous venez de modiier :

GameObject.Find("Battery GUI").GetComponent(GUITexture).enabled=false;

Cette ligne de script utilise la commande GameObject.Find, en indiquant le nom de l’objet

dans le panneau Hierarchy, puis passe le composant GUI Texture en paramètre de
GetComponent() à l’aide de la syntaxe à point, pour le désactiver enin de la manière habi-
tuelle, en déinissant sa valeur à false (enabled = false;).
Chapitre 5 Éléments préfabriqués, collections et HUD 147

Il ne s’agit pas de détruire cet objet, car vous avez encore besoin de ce script dans le
jeu pour référencer le nombre de piles déjà collectées. C’est pourquoi vous désactivez
simplement le composant visuel.
Cliquez sur File > Save dans l’éditeur de script, puis revenez à Unity.
Cliquez sur le bouton Play et testez le jeu. Assurez-vous que vous ne pouvez pas entrer
dans l’avant-poste sans avoir recueilli les quatre piles. Si ce n’est pas le cas, vériiez que
votre script correspond bien à celui que nous vous avons indiqué jusqu’à présent. N’oubliez
pas de cliquer de nouveau sur Play pour terminer le test.

Des indices pour le joueur

Que faire si le joueur, moins intrigué par les piles que par la porte de l’avant-poste, va
jusqu’à celle-ci et essaie d’entrer ? Dans l’idéal, vous devriez alors :
∑ Lui indiquer par du texte que le mécanisme de la porte doit être rechargé. Même s’il
est facile d’écrire : "Collectez quelques piles !", il est plus intéressant de lui fournir des
conseils, comme : "Le mécanisme de la porte semble manquer de puissance…"
∑ Aficher l’objet Battery GUI pour que le joueur comprenne qu’il doit charger une pile.
Le deuxième indice est beaucoup plus facile à implémenter, aussi allons-nous l’aborder en
premier.

L’indice Battery GUI

Revenez à l’éditeur de script dans lequel le script PlayerCollisions est toujours ouvert.
Si vous l’avez fermé pour une raison quelconque, vous pouvez le rouvrir depuis le panneau
Project.
Après l’accolade de fermeture de l’instruction if sur laquelle vous avez travaillé, ajoutez
une autre instruction else if. Elle vise les mêmes conditions que la précédente, mais elle
vériie cette fois si la valeur de la variable charge de BatteryCollect est inférieure à 4 :
else if(hit.collider.gameObject.tag=="outpostDoor" && doorIsOpen == false &&
„ BatteryCollect.charge < 4){

Dans cette instruction else if, vous utilisez la même ligne qui désactive le composant
GUITexture dans la première instruction if mais, cette fois, elle aura au contraire pour effet
de l’activer. Insérez la ligne suivante dans la déclaration else if :
GameObject.Find("Battery GUI").GetComponent(GUITexture).enabled=true;
148 Développez des jeux 3D avec Unity

Cliquez sur File > Save dans l’éditeur de script, puis revenez à Unity. Cliquez sur le bouton
Play et vériiez que si vous approchez de la porte sans aucune batterie, l’objet Battery
GUI s’afiche. Cliquez sur le bouton Play de nouveau pour arrêter l’essai.

L’indice textuel
Le moyen le plus simple pour écrire du texte en 2D qui doit s’aficher à l’écran consiste
à utiliser un composant GUIText. Vous allez donc créer un nouvel objet GUI Text qui
possède les deux composants Transform et GUIText. Cliquez sur GameObject > Create
Other > GUI Text. L’objet GUI Text s’afiche alors dans le panneau Hierarchy. Le texte
2D "Gui Text" apparaît également dans le panneau Scene (voir Figure 5.11).

Figure 5.11

Sélectionnez cet objet dans le panneau Hierarchy, appuyez sur Entrée/F2 et renommez-le
TextHint GUI.
Sélectionnez l’objet GUI Text dans le panneau Hierarchy pour aficher le composant
lui-même dans le panneau Inspector. Vous allez conserver la valeur par défaut (0,5) pour
les coordonnées X et Y du composant Transform. En effet, l’objet GUI Text utilisant
également les coordonnées relatives à l’écran, une valeur de 0,5 sur ces deux axes place le
texte au milieu de l’écran, ce qui est parfait pour attirer l’attention du joueur.
Chapitre 5 Éléments préfabriqués, collections et HUD 149

Le composant GUIText de l’objet possède également un paramètre Anchor qui permet

d’aligner le texte à gauche, à droite ou encore au centre, comme dans un logiciel de traitement
de texte. Cliquez sur la double lèche située à droite du paramètre Anchor et sélectionnez
middle center ain que le texte s’étire depuis et non vers le centre de l’écran.
Bien que le paramètre Text du panneau Inspector permette d’entrer le texte que doit afi-
cher le composant GUIText (voir Figure 5.12), vous allez contrôler ce texte dynamiquement
grâce à un script.

Figure 5.12

Sélectionnez le dossier Scripts dans le panneau Project, cliquez sur le bouton Create et
choisissez JavaScript dans le menu déroulant.
Renommez ce script TextHints, puis double-cliquez sur son icône pour l’ouvrir dans l’éditeur
de script.
Pour commencer, déclarez les trois variables suivantes au début du script :
static var textOn : boolean = false;
static var message : String;
private var timer : loat = 0.0;

La première variable statique, textOn, est de type booléen, car elle doit agir comme un
simple interrupteur. Nous reviendrons bientôt plus en détail sur ce point.
Ensuite, le script déclare une autre variable statique message de type string, que vous utili-
serez pour transmettre toutes les informations au paramètre Text du composant. Ces deux
variables sont statiques car nous aurons besoin de faire référence à elles depuis le script
PlayerCollisions.
La troisième variable, timer, est privée car elle n’a besoin ni d’être utilisée par d’autres
scripts ni de s’aficher dans le panneau Inspector. Elle servira à décompter le temps écoulé
à partir du moment où le message s’afiche à l’écran, ain de le faire disparaître après un
certain délai.
150 Développez des jeux 3D avec Unity

Ajoutez ensuite la fonction Start() suivante, ain de déinir certains états lorsque la scène
commence :
function Start(){
timer = 0.0;
textOn = false;
guiText.text = "";
}

Ces lignes s’assurent simplement que la variable timer est déinie à  0, que la variable
textOn est false (aucun texte ne doit s’aficher au début du jeu) et qu’aucun texte ne se
trouve actuellement dans le paramètre text du composant guiText. Pour cela, il sufit de
créer une chaîne de caractères vide à l’aide de deux guillemets sans aucun texte entre eux.
Ajoutez ensuite le code suivant à la fonction Update() du script :
function Update () {
if(textOn){
guiText.enabled = true;
guiText.text = message;
timer += Time.deltaTime;
}
if(timer >=5){
textOn = false;
guiText.enabled = false;
timer = 0.0;
}
}

En deux étapes, cette procédure simple :

∑ Vériie si la variable textOn devient true. Quand c’est le cas, elle :
– Active le composant GUIText.
– Donne au paramètre text la valeur de la variable message de type string.
– Commence à incrémenter la variable timer à l’aide de la commande Time.deltaTime.
∑ Contrôle si la variable timer a atteint une valeur de 5 secondes. Si cela est le cas, elle :
– Déinit la variable booléenne textOn à false (la première instruction if n’est alors
plus valide).
– Désactive le composant GUIText.
– Réinitialise la variable timer à 0.0.
Chapitre 5 Éléments préfabriqués, collections et HUD 151

Cliquez sur File > Save dans l’éditeur de script, puis revenez à Unity. Sélectionnez l’objet
TextHint GUI dans le panneau Hierarchy, puis cliquez sur Component > Scripts >
TextHints ain de lier le script que vous venez d’écrire à cet objet.
Maintenant que vous disposez d’un script qui contrôle l’objet TextHint GUI, il vous reste
à déclencher son afichage en appelant les variables statiques qu’il contient. Étant donné
que le moment où les messages doivent apparaître dépend de la collision du personnage
avec la porte, vous allez appeler ces variables statiques depuis le script PlayerCollisions.
Pour cela, commencez par l’ouvrir dans l’éditeur de script.
Trouvez les dernières déclarations else if que vous avez ajoutées à la fonction Update()
(elles accompagnent les lignes qui détectent la projection du rayon sur la porte), puis
écrivez les deux lignes suivantes :
TextHints.message = "le mécanisme de la porte semble manquer de puissance...";
TextHints.textOn = true;

Cette portion du script envoie un texte à la variable statique message du script TextHints et
déinit la valeur de la variable booléenne textOn du même script à true. Voici la déclaration
complète else if :
else if(hit.collider.gameObject.tag=="outpostDoor" && doorIsOpen == false &&
„ BatteryCollect.charge < 4){
GameObject.Find("Battery GUI").GetComponent(GUITexture). enabled=true;
TextHints.message = "le mécanisme de la porte semble manquer de puissance...";
TextHints.textOn = true;
}

Comme vous avez activé le composant en déinissant la variable textOn à true, le script
TextHints se charge du reste ! Cliquez sur File > Save dans l’éditeur de script puis reve-
nez à Unity. Cliquez sur le bouton Play pour tester le jeu. Marchez jusqu’à la porte sans
collecter les quatre piles nécessaires. Un indice textuel s’afiche pendant cinq secondes à
l’écran. Cliquez de nouveau sur Play pour arrêter le test du jeu.
Cliquez sur File > Save dans Unity pour sauvegarder votre travail.
Pour inir, vous allez modiier la police de caractères du texte de l’indice pour améliorer
son apparence.

Utiliser les polices

Pour utiliser des polices dans un projet Unity, vous devez les importer comme ressources,
comme pour tous les autres éléments. Pour cela, vous pouvez simplement ajouter un ichier
TTF (polices TrueType) ou OTF (polices OpenType) dans le dossier Assets depuis le Finder
152 Développez des jeux 3D avec Unity

(Mac OS) ou l’Explorateur (Windows) ou cliquer sur Assets > Import New Asset dans
Unity.
Pour cet exemple, vous emploierez une police libre de droits commerciaux, disponible sur
www.dafont.com (un site web proposant des polices libres de droits, très intéressantes
pour les travaux typographiques). L’utilisation des polices proposées sur certains sites web
peut être soumise à conditions.
Rendez-vous sur ce site et téléchargez une police dont vous aimez l’apparence et qui soit
lisible. N’oubliez pas qu’elle servira à donner des instructions au joueur : elle doit donc
être aisément lisible. Téléchargez la police Sugo si vous souhaitez avoir la même que nous,
décompressez-la, puis appliquez les méthodes mentionnées plus tôt pour ajouter le ichier
Sugo.ttf comme ressource à votre projet.
Une fois cette ressource importée dans votre projet, localisez et sélectionnez la police dans
le panneau Project. Pour la rendre plus lisible, vous allez augmenter sa taille chaque fois
qu’elle est utilisée. À la section True Type Font Importer du panneau Inspector, déi-
nissez une Font Size (taille de la police) de 24, puis cliquez sur le bouton Apply (voir
Figure 5.13). Si vous avez choisi une police différente, la taille à adopter peut être diffé-
rente, mais n’oubliez pas que vous pouvez modiier le paramètre Font Size à tout moment.

Figure 5.13

Pour que l’objet TextHint  GUI utilise cette police, sélectionnez-le dans le panneau
Hierarchy, puis choisissez la police dans le menu déroulant situé à droite du paramètre
Font du composant GUIText dans le panneau Inspector. Vous pouvez également faire
glisser la police du panneau Project sur ce paramètre dans le panneau Inspector.
Cliquez maintenant sur le bouton Play et testez votre jeu. Cette fois, si le joueur approche
de la porte en ayant moins de quatre batteries, le message s’afiche à l’écran. Puis il dispa-
raît cinq secondes après que le personnage du joueur n’entre plus en collision avec la porte,
comme vous l’avez déini plus tôt. Cliquez de nouveau sur le bouton Play pour arrêter le
test du jeu, puis cliquez sur File > Save pour sauvegarder vos modiications.
Chapitre 5 Éléments préfabriqués, collections et HUD 153

En résumé
Au long de ce chapitre, vous avez créé et résolu un scénario de jeu. En prévoyant ce que
le joueur s’attend à rencontrer dans le jeu que vous lui présentez – sans tenir compte de ce
que vous savez des événements préalables –, vous pouvez déinir au mieux la méthode à
adopter en tant que développeur.
Essayez de considérer chaque nouvel élément dans le jeu du point de vue du joueur. Pour
cela, entraînez-vous avec des jeux existants, pensez à des situations du monde réel et,
surtout, évitez tout a priori. Les jeux les plus intuitifs sont toujours ceux qui trouvent un
équilibre entre les dificultés des tâches à réaliser et qui informent correctement le joueur
sans le dérouter. Il est crucial que les informations visuelles ou sonores destinées au joueur
soient appropriées  ; quel que soit le jeu que vous concevez, vous devez toujours tenir
compte des informations dont le joueur dispose.
Maintenant que vous avez étudié un scénario de jeu de base et vu comment construire et
contrôler les éléments d’une interface graphique, vous allez découvrir un scénario de jeu
plus avancé. Au prochain chapitre, vous découvrirez deux concepts essentiels de plus  :
l’instanciation et la physique des corps rigides.
 6
Instanciation
et corps rigides
Vous allez étudier deux concepts essentiels à la conception d’un jeu 3D. Nous examinerons
dans la première moitié la notion d’instanciation – le processus de création d’objets au
cours de l’exécution du jeu. Puis vous la mettrez en pratique en utilisant la physique des
corps rigides (Rigid Body dans Unity).
Lorsque vous construisez différentes scènes de jeu, tous les objets nécessaires dans chacune
d’elles ne doivent pas être présents au début du jeu. C’est vrai pour une grande variété de
jeux, notamment les jeux de puzzle comme Tetris. Les pièces de formes aléatoires sont
créées – ou instanciées – en haut de l’écran à intervalles déinis, car toutes ne peuvent pas
y être stockées indéiniment.
Maintenant, prenons l’exemple de votre jeu d’exploration d’une île. Au cours de ce chapitre,
vous allez étudier la physique des corps rigides en créant une méthode qui permette au
personnage du joueur de lancer des noix de coco. Or, les noix de coco ne doivent pas être
présentes au chargement de la scène du jeu. C’est là que l’instanciation entre en scène.
156 Développez des jeux 3D avec Unity

En spéciiant une ressource (généralement un élément préfabriqué d’un objet), sa position

et sa rotation, vous pouvez créer des objets au cours de l’exécution du jeu et donc créer une
noix de coco à chaque pression du joueur sur le bouton de tir.
Ain de relier cette nouvelle partie au jeu tel qu’il se présente actuellement, vous allez
supprimer une des piles nécessaires pour entrer dans l’avant-poste. Pour l’obtenir, le
joueur devra participer à un jeu de massacre avec des noix de coco. À partir du modèle
de noix de coco fourni, vous devrez créer un élément préfabriqué et contrôler l’animation
des cibles dans le jeu à l’aide d’un script – en détectant la collision des noix de coco avec
les cibles.
Comme les cibles fournies sont animées (lorsqu’elles sont "touchées" puis "réinitialisées"),
vous allez également déinir à l’aide d’un script le temps qui s’écoulera entre le moment où
la cible est renversée et celui où elle se reprend sa position initiale. Le joueur pourra gagner
ce mini-jeu seulement si les trois cibles sont abaissées en même temps, ce qui requiert de
sa part une dose d’habileté supplémentaire.
Au cours de ce chapitre, vous apprendrez à :
∑ préparer des éléments préfabriqués pour l’instanciation ;
∑ utiliser la commande d’instanciation en pratique ;
∑ vériier une action du joueur en entrée ;
∑ utiliser les corps rigides pour qu’un objet soit régi par le moteur physique ;
∑ fournir des informations au joueur.

Présentation de l’instanciation
À cette section, vous apprendrez comment reproduire et dupliquer des objets en cours de
jeu. Ce concept est utilisé dans de nombreux jeux pour créer des projectiles, des objets à
collecter, voire certains personnages comme les ennemis.

Le concept
L’instanciation est tout simplement une méthode de création (ou de reproduction) d’objets
pendant l’exécution du jeu à partir d’un modèle (un élément préfabriqué dans Unity).
Elle sert également pour dupliquer des objets de jeu déjà présents dans la scène.
L’instanciation d’un objet se déroule généralement de la façon suivante :
∑ On crée l’objet à instancier dans la scène, puis on lui ajoute les composants nécessaires.
Chapitre 6 Instanciation et corps rigides 157

∑ On crée, dans le projet, un élément préfabriqué, sur lequel on fait glisser l’objet réalisé
auparavant.
∑ On supprime l’objet original de la scène ain de conserver uniquement la ressource
préfabriquée.
∑ On écrit un script contenant la commande Instantiate() qu’on attache à un objet de jeu
actif. On déinit ensuite l’élément préfabriqué comme l’objet créé par cette commande.

Le script
La commande Instantiate() compte trois paramètres et s’écrit de la façon suivante :
Instantiate (objet à créer, position où le créer, rotation à lui donner);

En comprenant comment déinir ces trois paramètres, vous serez ensuite capable d’utiliser
la commande Instantiate() dans toutes les situations.

Passer un objet
Pour transmettre un objet, il sufit d’indiquer le nom d’une variable publique pour le
premier paramètre de la commande Instantiate(). Quand une variable publique de type
GameObject est créée au début d’un script, vous pouvez ensuite, dans le panneau Inspector
de Unity, faire glisser dessus un élément préfabriqué puis utiliser cette variable comme
paramètre de l’objet, comme dans l’extrait de code suivant :
var myPrefab : GameObject;
Instantiate(myPrefab, position où le créer, rotation à lui donner);

Vous pouvez également vous assurer que seuls certains types d’éléments préfabriqués
peuvent être stockés dans la variable myPrefab en déinissant un type de données plus
précis. Vous pourriez ainsi écrire, par exemple :
var myPrefab : Rigidbody;
Instantiate(myPrefab, position où le créer, rotation à lui donner);

Ainsi, seuls les objets préfabriqués dotés d’un composant Rigidbody peuvent être utilisés.

Position et rotation
La position et la rotation des objets à créer doivent être indiquées sous la forme de valeurs
Vector3 (X, Y, Z). Elles peuvent être transmises directement comme suit :
Instantiate(myPrefab, Vector3(0, 12, 30), Vector3(0, 0, 90));
158 Développez des jeux 3D avec Unity

mais elles peuvent également être héritées d’un autre objet en utilisant ses valeurs de
position.
Lorsque vous déinissez la position d’un objet à instancier, vous devez tenir compte, d’une
part, de la position où il sera créé et, d’autre part, s’il doit l’être dans l’espace local ou dans
l’espace global.
Vous allez créer les éléments préfabriqués de noix de coco, par exemple, à un point dans
le monde du jeu déini par un objet de jeu vide, qui sera un enfant de l’objet représentant
le personnage du joueur. Par conséquent, on peut considérer qu’il sera créé dans l’espace
local – à un endroit différent chaque fois mais toujours à une position relative identique
par rapport à l’endroit où se tient le personnage du joueur et à la direction vers laquelle il
se tourne.
Cette décision vous permet de décider où écrire le code, autrement dit à quel objet attacher
le script. Si vous l’attachez à l’objet vide qui représente la position où les noix de coco
doivent être créées, vous pouvez simplement faire référence à la variable transform.posi-
tion à l’aide de la syntaxe à point pour indiquer la position de l’objet dans la commande
Instantiate(). De cette manière, l’objet créé hérite de la position du composant Trans-
form de l’objet vide, puisque c’est sur celui-ci que le script est attaché. Cette méthode peut
également servir pour la rotation de la nouvelle occurrence de l’objet ain qu’elle corres-
ponde à celle de l’objet parent vide.
La commande Instantiate() se présenterait alors de la façon suivante :

var myPrefab : GameObject;

Instantiate(myPrefab, transform.position, transform.rotation);

Vous mettrez tout cela en pratique plus loin, mais nous allons d’abord voir la physique des
corps rigides et son importance dans les jeux.

Présentation des corps rigides

Les moteurs physiques des jeux permettent de simuler le réalisme des lois physiques. Ils
sont donc une caractéristique commune à presque tous les moteurs de jeux, nativement ou
sous forme de plugin. Unity utilise PhysX de Nvidia, un moteur physique précis et récent
que l’on retrouve dans de nombreux jeux commerciaux. Le moteur physique permet non
seulement que les objets réagissent aux lois physiques, comme le poids et la gravité, mais
également de tenir compte de manière réaliste des effets de frictions, du couple mécanique
et des impacts.
Chapitre 6 Instanciation et corps rigides 159

Les forces
On appelle force l’inluence du moteur physique sur les objets. Ces forces peuvent être
appliquées de différentes façons à l’aide de composants ou de scripts. Pour être soumis aux
forces de la physique, un objet doit posséder un corps rigide, autrement dit un composant
Rigidbody.

Le composant Rigidbody
Pour qu’un objet puisse utiliser le moteur physique dans Unity, vous devez lui attribuer un
composant Rigidbody. Cela indique simplement au moteur qu’il doit utiliser le moteur
physique pour cet objet en particulier – vous n’avez pas besoin de l’appliquer à toute une
scène. Le moteur physique fonctionne tout simplement en arrière-plan.
Après qu’un composant Rigidbody a été ajouté à un objet, ses paramètres s’afichent dans
le panneau Inspector de la même manière que n’importe quel autre objet (voir Figure 6.1).

Figure 6.1

Les composants Rigidbody possèdent des paramètres que vous pouvez ajuster ou contrôler
à l’aide de scripts :
∑ Mass. Le poids de l’objet en kilogrammes. N’oubliez pas que le fait de déinir la masse
des différents corps rigides les conduit à se comporter de manière réaliste. Par exemple,
si un objet lourd heurte un objet plus léger, celui-ci sera repoussé plus loin.
∑ Drag. La résistance de l’air sur un objet en mouvement. Plus cette valeur est élevée, plus
le déplacement de l’objet dans les airs ralentira rapidement.
∑ Angular Drag. Ce paramètre est analogue au précédent, mais il affecte simplement la
vitesse de rotation. Il déinit à quel point l’air agit sur l’objet pour ralentir sa rotation.
∑ Use Gravity. Comme son nom l’indique, ce paramètre détermine si le corps rigide sera
affecté par la gravité ou non. Lorsque cette option est désactivée, l’objet est toujours
160 Développez des jeux 3D avec Unity

soumis aux forces et aux impacts du moteur physique et réagit en conséquence, mais
comme s’il se trouvait en apesanteur.

∑ Is Kinematic. Cette option permet de disposer d’un objet de corps rigide non soumis
aux lois physiques. Vous pouvez l’utiliser si vous souhaitez qu’un objet repousse un
corps rigide soumis à la gravité mais sans être affecté par le choc – c’est le cas, par
exemple, des lippers qui repoussent la balle d’un billard électrique.

∑ Interpolate. Ce paramètre peut être utilisé si le mouvement des objets de corps rigide
est saccadé. L’interpolation et l’extrapolation permettent de lisser le mouvement, soit en
se basant sur l’image précédente, soit en prévoyant l’image suivante.

∑ Freeze Rotation. Peut être utilisé pour verrouiller les objets ain que les forces appli-
quées par le moteur physique ne les fassent pas pivoter. C’est particulièrement utile pour
les objets qui doivent utiliser la gravité mais ne pas basculer, comme les personnages
de jeux.

Créer le mini-jeu
Pour mettre en pratique ce que vous venez d’apprendre, vous allez créer un jeu de lancer
de noix de coco qui permettra au joueur d’accéder à l’avant-poste. En récompense, le
joueur obtiendra la dernière pile nécessaire pour charger le mécanisme d’ouverture de la
porte.

Vous avez déjà disposé quatre piles dans le jeu, il vous sufit donc d’en enlever une de la
scène de manière que le joueur n’ait accès qu’à trois d’entre elles.

Sélectionnez un des objets battery dans le panneau Hierarchy, puis appuyez sur
Cmd+Retour arrière (Mac OS) ou Suppr (Windows) pour le supprimer.

Créer l’élément préfabriqué pour la noix de coco

Maintenant que vous connaissez les principes de l’instanciation, vous allez commencer la
conception du mini-jeu en créant le projectile, c’est-à-dire la noix de coco.
Cliquez sur Game Object > Create Other > Sphere.
Chapitre 6 Instanciation et corps rigides 161

Un objet sphérique (basé sur une forme primitive) est alors créé dans la scène. Il n’apparaît
pas directement au premier plan, mais vous pouvez facilement zoomer dessus. Pour cela,
placez le curseur sur le panneau Scene puis appuyez sur la touche F (pour focus). Sélec-
tionnez l’objet Sphere dans le panneau Hierarchy, appuyez sur Entrée/F2 et renommez-
le Coconut.
Vous allez modiier ses dimensions et sa forme pour qu’il ressemble davantage à une noix
de coco. Pour cela, vous réduirez sa taille et augmenterez légèrement la valeur sur l’axe Z.
Dans le composant Transform du panneau Inspector, donnez la valeur  0,5 aux para-
mètres Scale X et Z de l’objet Coconut et la valeur 0,6 au paramètre Y.
Les textures à utiliser sur la noix de coco se trouvent dans l’archive disponible sur la page
web consacrée à cet ouvrage (www.pearson.fr). Cliquez sur Assets > Import Package,
parcourez votre disque dur jusqu’au package CoconutGame.unitypackage, sélectionnez-le
puis cliquez sur Import.
Le dossier Coconut Game qui s’afiche dans le panneau Project contient les éléments
suivants :
∑ une image pour la texture de la noix de coco ;
∑ une texture en forme de cible ;
∑ quatre séquences audio ;
∑ deux modèles 3D, platform et target ;
∑ un dossier Materials pour les modèles 3D.

Créer la texture de la noix de coco

Pour appliquer la texture de la noix de coco, vous avez besoin de créer un nouveau matériau
à lui appliquer. Cliquez sur le bouton Create dans le panneau Project, puis sélectionnez
Material dans le menu déroulant. Appuyez sur Entrée/F2 et nommez ce nouveau matériau
Coconut Skin.
Pour appliquer la texture à ce matériel, faites simplement glisser la texture coconut du
panneau Project sur le rectangle vide situé à droite du paramètre Base (RGB) du matériau
dans le panneau Inspector. Un aperçu du matériau doit s’aficher dans la fenêtre au bas du
panneau Inspector (voir Figure 6.2).
162 Développez des jeux 3D avec Unity

Figure 6.2

Cet aperçu montre l’aspect du matériau sur une sphère. Il s’agit de l’aspect par défaut des
prévisualisations de matériaux dans Unity ; cela n’a rien à voir avec le fait que vous utilisez
ici un objet sphérique.
Ensuite, vous devez appliquer le matériau Coconut  Skin sur l’objet Coconut  Game
que vous avez placé dans la scène. Pour cela, il vous sufit de faire glisser le matériau du
panneau Project sur le nom de l’objet dans le panneau Hierarchy ou sur l’objet lui-
même dans le panneau Scene.

Ajouter des comportements physiques

Comme l’objet de jeu Coconut doit avoir un comportement réaliste, vous devez lui ajouter
un composant pour qu’il utilise le moteur physique. Sélectionnez cet objet dans le panneau
Hierarchy puis cliquez sur Component > Physics > Rigidbody.
Un composant Rigidbody est alors ajouté à l’objet pour gérer la gravité. Par conséquent,
lorsque le joueur lancera l’objet vers l’avant, celui-ci se rapprochera peu à peu du sol
comme dans le monde réel. Les paramètres par défaut du composant Rigidbody peuvent
être conservés pour le moment.
Chapitre 6 Instanciation et corps rigides 163

Cliquez sur le bouton Play pour tester le jeu. Vous constatez que la noix de coco tombe au
sol puis roule dans le panneau Game. Cliquez ensuite de nouveau sur le bouton Play pour
terminer le test.

Enregistrer comme élément préfabriqué

Maintenant que votre objet de jeu Coconut est terminé, vous devez le stocker comme
élément préfabriqué dans votre projet ain de pouvoir l’instancier autant de fois que néces-
saire à l’aide d’un script.
Sélectionnez le dossier Prefabs dans le panneau Project, puis cliquez sur le bouton Create
et sélectionnez Prefab. Nommez le nouvel élément préfabriqué Coconut Prefab. Faites
glisser l’objet de jeu Coconut du panneau Hierarchy sur l’élément préfabriqué dans le
panneau Project pour l’enregistrer. Enin, sélectionnez l’objet original dans le panneau
Hierarchy, puis appuyez sur Cmd+Retour arrière (Mac OS) ou Suppr (Windows) pour le
supprimer de la scène.

Créer l’objet Launcher

Pour permettre au joueur de lancer l’élément préfabriqué noix de coco que vous venez de
créer, vous avez besoin d’un script, pour gérer l’instanciation, et d’un objet de jeu vide,
pour déinir la position de référence où seront créés les objets dans le monde du jeu.
Dans le monde réel, lorsqu’on lance une balle à la manière d’un lanceur de base-ball, elle
entre dans notre champ de vision sur le côté, au fur et à mesure que notre bras se tend
pour la libérer. Par conséquent, il faut positionner un objet juste à l’extérieur du champ de
vision du joueur et s’assurer qu’il conserve la même position relative au personnage où que
celui-ci regarde. Le point de vue du joueur est géré par l’objet Main Camera, qui est un
enfant de l’objet First Person Controller. Par conséquent, si vous créez un objet vide
enfant de l’objet Main Camera, celui-ci suivra les mouvements de la caméra, puisque sa
position restera toujours la même par rapport à son parent.
Cliquez sur GameObject > Create Empty pour créer un objet de jeu vide dans la scène.
Sélectionnez ce nouvel objet dans le panneau Hierarchy (il se nomme GameObject par
défaut) et renommez-le Launcher. Cliquez ensuite sur la lèche grise à gauche de l’objet
First Person Controller dans le panneau Hierarchy pour aficher les éléments qui
le composent. Faites glisser l’objet Launcher sur l’objet Main Camera pour qu’il en
devienne un enfant. Si l’opération est correcte, une lèche grise apparaît devant le nom de
l’objet Main Camera pour indiquer qu’il possède des objets enfants. L’objet Launcher
s’afiche en retrait et en dessous (voir Figure 6.3).
164 Développez des jeux 3D avec Unity

Figure 6.3

Enfant de l’objet Main Camera, Launcher se déplace et tourne avec son parent. Mais il
doit être repositionné. Commencez par réinitialiser sa position dans le composant Trans-
form du panneau Inspector. Pour cela, vous pouvez soit remplacer toutes les valeurs du
paramètre Position par 0, soit, et cela est plus rapide, cliquer sur le bouton en forme d’en-
grenage et sélectionner Reset Position dans le menu déroulant (voir Figure 6.4).

Figure 6.4

Le bouton en forme d’engrenage est disponible pour chaque composant dans le

ce panneau inSPector et permet d’effectuer rapidement certaines opérations. Vous
Astu
pouvez également l’utiliser pour supprimer des composants dont vous n’avez
plus besoin ou qui ont été ajoutés par erreur.

Une fois la position de l’objet enfant Launcher réinitialisée à 0, celui-ci se place exacte-
ment au centre (position identique) de son parent. Bien sûr, ce n’est pas sa position déini-
tive, mais c’est un bon point de départ. Vous ne devez pas le laisser dans cette position pour
les deux raisons suivantes :
∑ Les noix de coco lancées sembleraient sortir de la tête du joueur, ce qui serait assez
bizarre.
∑ Lorsque vous instanciez des objets, vous devez vous assurer qu’ils sont créés à une posi-
tion où leur collider (composant de collision) n’en croise pas un autre, car cela forcerait
le moteur physique à écarter ces colliders, ce qui pourrait interrompre la force appliquée
lors du lancer de la noix de coco.
Chapitre 6 Instanciation et corps rigides 165

Pour éviter cela, vous avez simplement besoin de déplacer l’objet Launcher vers l’avant
et vers la droite de sa position actuelle. Donnez la valeur 1 aux options X et Y du paramètre
Position du composant Transform. Votre objet Launcher devrait maintenant être placé
à l’endroit où est censé se trouver le bras droit du personnage du joueur lorsqu’il lance un
objet (voir Figure 6.5).

Figure 6.5

Enin, pour que la trajectoire de la noix de coco aille vers le centre du champ de vision, vous
devez faire pivoter légèrement l’objet Launcher sur l’axe Y. Dans le paramètre Rotation
du composant Transform, donnez une valeur de 352 à l’axe Y pour que l’objet pivote de
8 degrés.
Vous devez maintenant écrire le script pour instancier la noix de coco et permettre au joueur
de la lancer lorsqu’il appuie sur le bouton de tir.

Le script du lancer de noix de coco

Comme les noix de coco sont lancées lorsque le joueur appuie sur le bouton de tir, vous
devez vériier, à chaque image, s’il appuie sur une touche – liée à une entrée dans Unity.
Les touches ainsi que les axes et les boutons de la souris sont liés par défaut aux entrées
nommées dans le gestionnaire Input Manager de Unity, mais vous pouvez les modiier
à votre guise. Cliquez sur Edit > Project Settings > Input, cliquez sur la lèche grise
située à gauche de Axes, puis sur la lèche grise avant Fire1.
Les trois principaux paramètres à observer ici sont Name, Positive et Alt Positive. Le
script fera référence à cet axe par son nom et écoutera les paramètres Positive et Alt
Positive, puisqu’il s’agit des touches et des boutons eux-mêmes. Vous pouvez ajouter de
166 Développez des jeux 3D avec Unity

nouveaux axes en augmentant simplement la valeur Size en haut du panneau Input Manager
– cela crée un axe que pouvez ensuite personnaliser.

Figure 6.6

Pour que le joueur lance des noix de coco vers les cibles – que vous disposerez dans la
scène plus tard –, le script doit implémenter deux étapes clés :
∑ l’instanciation de l’objet Coconut à lancer lorsque le joueur presse le bouton de tir ;
∑ l’attribution d’une vitesse au composant Rigidbody pour que la noix de coco soit
propulsée vers l’avant dès qu’elle a été créée.
Pour cela, commencez par créer un nouveau ichier JavaScript de la façon suivante :
1. Sélectionnez le dossier Scripts dans le panneau Project.
2. Cliquez sur le bouton Create et choisissez JavaScript dans le menu déroulant.
3. Appuyez sur Entrée/F2 et nommez le script CoconutThrow.
4. Double-cliquez sur l’icône du script pour l’ouvrir dans l’éditeur de script.

Vériier les actions du joueur en entrée

Vous devez écouter sur quelles touches le joueur appuie à chaque image. Pour cela, vous
avez besoin d’écrire le code du lanceur à l’intérieur de la fonction Update(). Insérez
quelques lignes avant l’accolade de fermeture de cette fonction (}), puis ajoutez l’instruction
if suivante pour écouter les pressions sur la touche Fire1 :
Chapitre 6 Instanciation et corps rigides 167

if(Input.GetButtonUp("Fire1")){
}

Cette instruction vériie la classe Input et attend que les boutons liés à l’entrée Fire1 (la
touche Ctrl gauche et le bouton gauche de la souris) soient relâchés. Vous devez ensuite
placer les actions à exécuter lorsque le joueur relâche l’un ou l’autre bouton dans cette
instruction if.
Pour commencer, un son doit se faire entendre pour indiquer le lancement. S’il s’agissait
d’un jeu de tir, on entendrait certainement la détonation d’une arme à feu. Ici, vous utiliserez
simplement un son de soufle pour représenter le lancement de la noix de coco.

Lancer la lecture du son

Une variable doit représenter la séquence sonore à jouer. Aussi, placez la variable publique
suivante au début du script :
var throwSound : AudioClip;

Cette variable est publique  ; vous pourrez donc lui assigner la séquence audio dans le
panneau Inspector après avoir écrit ce script.
Vous devez maintenant déinir l’action permettant de lire cette séquence audio. Pour cela,
ajoutez la ligne suivante après l’accolade d’ouverture de votre instruction if :
audio.PlayOneShot(throwSound);

Ainsi, la lecture du son se déclenchera lorsque le joueur relâchera le bouton Fire1.

Instancier la noix de coco

Vous devez ensuite créer la noix de coco proprement dite dans l’instruction if courante.
Étant donné que vous avez créé la noix de coco puis que vous l’avez enregistrée comme un
élément préfabriqué, vous devez ajouter une autre variable publique ain d’assigner par la
suite cet élément préfabriqué à une variable dans le panneau Inspector. Ajoutez la ligne
suivante au début du script, sous la déclaration de la variable throwSound :
var coconutObject : Rigidbody;

Une variable publique du type de données Rigidbody est alors créée. Bien que la noix de
coco soit stockée comme élément préfabriqué, son instanciation crée un objet de jeu possé-
dant un composant Rigidbody sur la scène. Il est donc important d’indiquer son type de
données pour interdire qu’un objet d’un type de données différent puisse être attribué à cette
variable dans le panneau Inspector. De plus, en limitant strictement le type de données à
168 Développez des jeux 3D avec Unity

Rigidbody, vous n’avez pas besoin de la commande GetComponent() pour sélectionner au

préalable le composant Rigidbody, vous pouvez écrire un script qui communique direc-
tement avec lui.
Insérez la ligne suivante sous la deuxième ligne de la condition if dans la fonction
Update() :

var newCoconut : Rigidbody = Instantiate(coconutObject, transform.position,

„ transform.rotation);

Ici, le script déclare une variable locale newCoconut. Cette variable est privée puisqu’elle
est déclarée dans la fonction Update(), si bien qu’il est impossible d’utiliser explicitement
le préixe private. Le script transmet la création (l’instanciation) d’un nouveau Game-
Object – et donc son type de données – dans cette variable.
N’oubliez pas que les trois paramètres de la commande Instantiate() sont le nom de
l’objet, sa position et sa rotation. Vous verrez que nous avons utilisé la variable publique
pour créer une occurrence de notre élément préfabriqué qui hérite des paramètres de posi-
tion et de rotation de l’objet sur lequel ce script est attaché, c’est-à-dire l’objet Launcher.

Nommer les occurrences

Chaque fois que vous créez des objets lors de l’exécution du jeu avec la commande Instan-
tiate(), Unity nomme les nouvelles occurrences à partir du nom de l’élément préfabri-
qué auquel il ajoute "(clone)". Comme il s’agit d’un nom assez peu pratique pour être
utilisé dans le script – vous y ferez référence plus tard lorsque vous déinirez les cibles
–, vous pouvez renommer les occurrences en ajoutant la ligne suivante sous la ligne de la
commande Instantiate() :
newCoconut.name = "coconut";

Ici, le script utilise simplement le nom de la variable, qui fait référence à la dernière occur-
rence créée de l’élément préfabriqué, pour désigner le paramètre name de la variable.

Déinir une vitesse

Bien que cette variable crée une occurrence de la noix de coco, le script n’est pas encore
terminé, car vous devez également lui assigner une vitesse. Sans ce paramètre, la noix de
coco tomberait au sol à sa création. Pour vous permettre de gérer la vitesse de la noix de coco
que le joueur lance, créez une autre variable publique au début du script. Ain que la préci-
sion soit correcte, cette variable sera de type loat et pourra prendre une valeur décimale :
var throwForce : loat;
Chapitre 6 Instanciation et corps rigides 169

Maintenant, ajoutez la ligne suivante sous la commande Instantiate() dans la déclaration

if :

newCoconut.rigidbody.velocity = transform.TransformDirection
„ (Vector3(0,0, throwForce));

Le script fait ici référence à la nouvelle instance de noix de coco par son nom de variable
(newCoconut) puis il utilise la syntaxe à point pour désigner le composant Rigidbody et
déinir sa vitesse.
La vitesse est ixée avec la commande transform.TransformDirection, qui crée une direc-
tion de l’espace local à l’espace global. Vous devez procéder ainsi car l’objet Launcher
sera constamment en mouvement et jamais orienté dans la même direction.
La direction de l’axe Z de l’espace global est toujours la même. Lorsqu’on déinit la vitesse
d’un objet, on peut alors prendre un axe local spéciique en lui attribuant une valeur de type
Vector3. C’est pourquoi les paramètres X et Y de la variable de type Vector3 ont ici une
valeur de 0.

S’assurer de la présence du composant

Pour éviter qu’une erreur se produise lorsque le script fait référence à un composant qui
ne serait pas attaché à un objet, vous pouvez vériier si ce composant existe et ajoutez-le si
ce n’est pas le cas. Dans notre exemple, vous pourriez vériier l’existence d’une nouvelle
occurrence newCoconut pour le composant Rigidbody de la façon suivante :
if(!newCoconut.rigidbody) {
newCoconut.AddComponent(Rigidbody);
}

Ainsi, si aucun composant Rigidbody n’est attaché à l’occurrence de la variable courante,

le script lui ajoute un élément de ce type. Pour écrire "il n’y a pas de rigidbody", on place
simplement un point d’exclamation au début de la condition if – une pratique courante
dans les scripts. Comme l’élément préfabriqué que vous avez préparé possède un composant
Rigidbody, vous n’avez pas besoin de le faire ici.

Éviter les collisions inutiles

Bien que vous ayez éloigné l’objet Launcher du collider du personnage du joueur (l’objet
Collider Controller), nous vous conseillons de toujours inclure ce dernier morceau
de script ain d’éviter d’instancier de nouvelles noix de coco qui risqueraient de croiser le
collider du joueur.
170 Développez des jeux 3D avec Unity

Pour cela, vous pouvez utiliser la commande IgnoreCollision() de la classe Physics.

Cette commande prend généralement trois arguments :
IgnoreCollision(Collider A, Collider B, doit être ignoré ou pas);

Vous avez donc besoin d’indiquer les deux colliders pour lesquels le moteur physique ne
doit pas réagir et déinir le troisième paramètre à true.
Ajoutez la ligne suivante sous la dernière ligne que vous avez écrite :
Physics.IgnoreCollision(transform.root.collider, newCoconut.collider, true);

Le premier paramètre de cette commande, transform.root, désigne le collider du person-

nage du joueur. Cette commande trouve tout simplement le premier objet parent de tous
les objets sur lesquels l’objet Launcher est attaché. Ici, cet objet est un enfant de l’objet
Main Camera mais celui-ci ne possède pas de collider. La commande transform.root
permet donc de trouver l’objet parent sur lequel la caméra est attachée, à savoir First
Person Controller.
Le script transmet ensuite le nom de la variable newCoconut, qui représente la dernière
occurrence créée de noix de coco. Pour ces deux paramètres, le script utilise la syntaxe à
point pour faire référence au composant Collider.

Ici, vous aviez besoin de trouver l’objet parent de tous ces objets, mais vous
ce pouvez utiliser la commande transform.parent si vous faites seulement réfé-
Astu
rence au parent direct d’un objet.

Inclure le composant Audio Source

Enin, comme le lancer de la noix de coco s’accompagne d’une séquence audio, vous
pouvez utiliser la commande @script ain que Unity intègre un composant Audio Source
lorsque ce script est ajouté à un objet.
Ajoutez la ligne suivante tout en bas du script, après la fermeture de la fonction Update() :
@script RequireComponent(AudioSource)

Cliquez sur File > Save pour enregistrer votre script et revenez dans Unity.

Assigner le script et les variables

Assurez-vous que l’objet Launcher est toujours sélectionné dans le panneau Hierarchy,
puis cliquez sur Component > Scripts > Coconut Throw dans le menu principal. Unity
Chapitre 6 Instanciation et corps rigides 171

ajoute le script que vous venez d’écrire en tant que composant, ainsi que le composant
Audio Source requis.
Les valeurs ou les ressources des variables publiques du script CoconutThrow doivent être
déinies puisque vous ne l’avez pas fait manuellement dans le script.

Figure 6.7

Des ressources doivent être attribuées aux deux variables publiques Throw Sound et Coco-
nut Object – vous pouvez facilement les identiier car leur type de données déini dans le
script est indiqué. La troisième variable publique, bien que son type de données déini dans
le script soit indiqué, prend simplement la valeur par défaut dans le format approprié : une
valeur numérique de 0.
Cliquez sur la lèche située à droite de None (Audio Clip) et sélectionnez la séquence
audio throw sur la liste des ressources audio disponibles. Faites glisser l’objet Coco-
nut Prefab du panneau Project sur le champ None (Rigidbody). Ainsi, cet élément préfa-
briqué est directement lié à cette variable, ce qui signiie que le script créera des instances
de cet objet. Enin, donnez une valeur de 25 à la variable Throw Force. Gardez à l’esprit
que le script ne change pas quand vous modiiez les valeurs dans le panneau Inspector ;
cela annule simplement les valeurs précédemment déinies dans le script. N’oubliez pas
non plus que ces variables publiques peuvent être modiiées sans que vous ayez besoin
de recompiler ou de modiier le code source. Pour des raisons de commodité et de gain
de temps, nous vous conseillons de prendre l’habitude d’ajuster les valeurs des variables
publiques dans le panneau Inspector.

Figure 6.8
172 Développez des jeux 3D avec Unity

Il est maintenant temps de tester le script du lancer dans le jeu. Cliquez sur le bouton Play,
puis cliquez du bouton gauche ou appuyez sur la touche Ctrl gauche du clavier pour lancer
une noix de coco. Après avoir vériié que tout fonctionne correctement, cliquez de nouveau
sur le bouton Play pour arrêter le test. Si ce n’est pas le cas, vériiez que votre script corres-
pond au script complet suivant :
var throwSound : AudioClip;
var coconutObject : Rigidbody;
var throwForce : loat;
function Update () {
if(Input.GetButtonUp("Fire1")){
audio.PlayOneShot(throwSound);
var newCoconut : Rigidbody = Instantiate(coconutObject, transform.position,
„ transform.rotation);
newCoconut.name = "coconut";
newCoconut.rigidbody.velocity = transform.TransformDirection
„ (Vector3(0,0, throwForce));
Physics.IgnoreCollision(transform.root.collider, newCoconut.collider, true);
}
}
@script RequireComponent(AudioSource)

Restrictions de l’instanciation
Cette méthode d’instanciation des objets est la mieux adaptée au système d’éléments préfa-
briqués de Unity, car elle permet de facilement créer un objet sur la scène et de le dupliquer
lors de l’exécution du jeu.
Toutefois, la création de nombreux clones d’un objet possédant un corps rigide peut être
coûteuse, car chacun de ces objets fait appel au moteur physique et interagit avec d’autres
objets dans le monde en 3D, ce qui utilise des cycles CPU (sollicite la puissance du proces-
seur). Imaginez que vous permettiez au joueur de créer une quantité ininie d’objets contrô-
lés par le moteur physique… vous comprendrez alors que votre jeu puisse ralentir après un
certain temps. Quand trop de cycles CPU et de mémoire sont utilisés, le nombre d’images
par seconde diminue. Votre jeu auparavant luide devient saccadé, ce qui est évidemment
désagréable pour le joueur et compromet l’avenir commercial de votre création.
Pour éviter qu’un trop grand nombre d’objets ralentissent le jeu, vous allez :
∑ permettre au joueur de lancer des noix de coco seulement dans une zone déinie de
l’univers du jeu ;
∑ écrire un script qui supprime les noix de coco instanciées dans le monde du jeu après
un certain temps.
Chapitre 6 Instanciation et corps rigides 173

Si l’instanciation se déroulait sur une plus grande échelle (lors de la création de balles de
pistolet, par exemple), vous devriez alors ajouter également un délai avant que le joueur ne
puisse "recharger" l’arme. Ce n’est pas nécessaire ici, puisque la commande GetButtonUp()
empêche le joueur de lancer un trop grand nombre de noix de coco à la fois : il doit relâcher
la touche de tir avant qu’une noix de coco ne soit lancée.

Activer le lancer de noix de coco

Pour ce premier point, vous allez utiliser une variable booléenne de commutation. Elle
doit avoir une valeur true ain que le joueur puisse lancer des noix de coco. Ce sera le cas
uniquement lorsque le personnage du joueur se tiendra dans une zone précise de la plate-
forme (qui constituera le pas de tir pour le lancer des noix de coco).
Indépendamment des considérations sur les performances, il est logique de limiter cette
action, puisque cela n’aurait pas vraiment de sens si le joueur pouvait lancer au hasard des
noix de coco dans tout le niveau.
Double-cliquez sur l’icône du script CoconutThrow dans le panneau Project si vous
l’avez fermé ou revenez dans l’éditeur de script pour continuer à l’éditer. Vous avez vu plus
tôt comment activer et désactiver des scripts à l’aide du paramètre d’activation d’un compo-
sant. Dans ce cas précis, vous pourriez également utiliser la commande GetComponent(),
sélectionner ce script et le désactiver lorsque vous ne voulez pas que le joueur puisse lancer
des noix de coco. Cependant, et c’est le cas pour tout ce qui concerne les scripts, il existe
de nombreuses solutions à un problème. C’est pourquoi vous allez voir ici de quelle façon
employer des variables statiques pour communiquer entre différents scripts. Ajoutez la
ligne suivante tout en haut du script CoconutThrow :
static var canThrow : boolean = false;

Ce préixe static placé avant la variable est le moyen employé par JavaScript dans Unity
pour créer une variable globale – une valeur à laquelle les autres scripts peuvent accéder.
Vous devez maintenant ajouter une autre condition à l’instruction if existante qui permette
le lancer. Pour cela, trouvez la ligne suivante dans la fonction Update() :
if(Input.GetButtonUp("Fire1")){

Pour ajouter une seconde condition, il sufit d’ajouter deux esperluettes && avant l’accolade
de fermeture de l’instruction if et d’indiquer le nom de la variable statique, comme suit :
if(Input.GetButtonUp("Fire1") && canThrow){

Souvenez-vous qu’écrire tout simplement le nom de la variable est l’équivalent abrégé de :
if(Input.GetButtonUp("Fire1") && canThrow==true){
174 Développez des jeux 3D avec Unity

Vous avez déini la variable canThrow à false lorsque vous l’avez déclarée. Comme il
s’agit d’une variable statique (ce n’est donc pas une variable publique), vous avez besoin
d’ajouter quelques lignes de script pour la déinir à true. Puisque le joueur doit se tenir à un
certain emplacement pour pouvoir lancer des noix de coco, la meilleure façon de procéder
consiste ici à utiliser la détection de collision ain de vériier si le joueur est en contact avec
un objet en particulier. Si c’est le cas, cette variable statique est alors déinie à true.
Ouvrez maintenant le script PlayerCollisions et recherchez la fonction OnController-
ColliderHit() suivante placée en commentaires :

/*
function OnControllerColliderHit(hit: ControllerColliderHit){
if(hit.gameObject.tag == "outpostDoor" && doorIsOpen == false){
Door(doorOpenSound, true, "dooropen");
}
}
*/

Supprimez les caractères /* et */ ain que cette fonction ne soit plus en commentaires et
redevienne active. Supprimez ensuite la condition if, puisque vous n’en avez plus besoin
pour gérer l’ouverture et la fermeture de la porte. Il ne devrait plus rester que la fonction
elle-même, comme ceci :
function OnControllerColliderHit(hit: ControllerColliderHit){

Une partie du modèle platform que vous avez téléchargé, appelée mat, constitue la zone
sur laquelle le joueur devra se trouver pour lancer les noix de coco. Vous allez donc vous
assurer que le personnage du joueur est en collision avec cet objet. Ajoutez l’instruction if
else suivante dans la fonction :

if(hit.collider == GameObject.Find("mat").collider){
CoconutThrow.canThrow=true;
}else{
CoconutThrow.canThrow=false;
}

Ici, le script vériie si le collider avec lequel le contact s’effectue est égal au collider de
l’objet de jeu qui porte le nom mat dans la scène (le signe de double égalité est un opérateur
de comparaison). Si cette condition est respectée, le script redéinit à true la valeur de la
variable statique canThrow déclarée dans le script CoconutThrow à l’aide de la syntaxe à
point, ce qui permet à la commande Instantiate() du script CoconutThrow de fonctionner.
Dans le cas contraire, le script s’assure que cette variable est déinie à false, ce qui signiie
Chapitre 6 Instanciation et corps rigides 175

que le joueur ne pourra pas lancer de noix de coco s’il ne se trouve pas sur le pas de tir de
la plate-forme.
Cliquez sur File > Save dans l’éditeur de script, puis revenez dans Unity.

Supprimer les noix de coco

Comme nous l’avons expliqué plus tôt, un nombre trop élevé d’objets contrôlés par le
moteur physique dans la scène peut sérieusement affecter les performances du jeu. Par
conséquent, lorsqu’il n’est pas utile de conserver les objets, comme c’est le cas ici, vous
pouvez écrire un script pour les supprimer automatiquement après un certain temps.
Sélectionnez le dossier Scripts dans le panneau Project, cliquez sur le bouton Create
et sélectionnez JavaScript pour créer un script. Appuyez sur Entrée/F2 et renommez ce
script CoconutTidy. Double-cliquez ensuite sur son icône pour l’ouvrir dans l’éditeur
de script.
Supprimez la fonction Update() par défaut car vous n’en avez pas besoin. Pour supprimer
un objet d’une scène, il sufit d’utiliser la commande Destroy() dont le second paramètre
permet de déinir un délai d’attente. Ajoutez la fonction et la commande suivantes à votre
script :
function Start(){
Destroy(gameObject, 5);
}

Avec la commande Start(), l’appel à la commande Destroy() s’effectue dès l’apparition

de l’objet dans le monde du jeu, lorsqu’il est instancié par le joueur qui appuie sur le bouton
de tir. La référence à gameObject signiie simplement : "l’objet sur lequel ce script est atta-
ché". Le second paramètre, après la virgule, déinit le délai en secondes avant l’exécution
de la commande.
Avec ce script, la noix de coco est supprimée du monde du jeu cinq secondes après son
lancement. Cliquez sur File  > Save dans l’éditeur de script, puis revenez dans Unity.
Jusqu’à présent, vous avez attaché tous vos scripts aux objets de la scène sur laquelle vous
travaillez. Toutefois, vous avez ini de travailler sur l’élément préfabriqué Coconut et il
n’existe plus de copies de noix de coco dans la scène.
Il existe deux méthodes pour appliquer le script que vous venez d’écrire à l’élément préfa-
briqué. La manière la plus simple consiste à sélectionner l’élément préfabriqué Coconut
dans le panneau Project puis à cliquer sur Component > Scripts > CoconutTidy.
176 Développez des jeux 3D avec Unity

Mais vous pouvez également procéder en plusieurs étapes, en modiiant l’élément préfa-
briqué dans le panneau Scene de la manière suivante :
1. Faites glisser l’élément préfabriqué Coconut dans le panneau Scene ou dans le
panneau Hierarchy.
2. Cliquez sur Component > Scripts > CoconutTidy, cliquez sur Add pour conirmer
que l’ajout du composant mettra un terme à la relation de l’objet à l’élément préfa-
briqué parent.
3. Cliquez sur GameObject > Apply Changes to prefab pour répercuter cette mise à
jour sur l’élément préfabriqué original.
4. Supprimez l’instance de l’objet dans la scène à l’aide du raccourci clavier Cmd+Retour
arrière (Mac OS) ou Suppr (Windows).
Nous vous conseillons d’utiliser la première méthode, en une seule étape. Cependant, dans
certains cas, il peut être utile de placer un élément préfabriqué dans la scène et de le modi-
ier avant d’appliquer les modiications à l’élément préfabriqué lui-même. Par exemple, si
vous travaillez sur un élément visuel, comme un système de particules, vous aurez alors
besoin de voir l’effet de vos modiications ou des nouveaux composants sur cet objet. Il
devient par conséquent indispensable de placer un objet issu de l’élément préfabriqué dans
la scène pour le modiier.
Une fois le script attaché à l’élément préfabriqué, cliquez sur File > Save Project dans
Unity pour sauvegarder votre travail.

Ajouter la plate-forme
Maintenant, vous êtes prêt à implémenter les ressources du mini-jeu que vous avez télé-
chargées plus tôt. Vous allez importer une plate-forme et trois cibles dans la scène. Vous
détecterez ensuite les collisions entre les noix de coco et les cibles et vériierez si les trois
cibles sont renversées à la fois – ce qui est l’objectif du mini-jeu – à l’aide d’un script.
Dans le panneau Project, ouvrez le dossier Coconut Game qui a été importé lorsque vous
avez téléchargé les ressources nécessaires à ce chapitre. Sélectionnez le modèle 3D plat-
form pour aficher ses propriétés dans le panneau Inspector.

Les paramètres d’importation

Avant de placer une plate-forme et les cibles dans la scène, assurez-vous que les dimen-
sions de ces objets sont correctes et, en créant des colliders pour chaque partie des modèles,
que le joueur peut interagir avec eux.
Chapitre 6 Instanciation et corps rigides 177

La plate-forme
Dans le composant FBXImporter du panneau Inspector, assurez-vous que le composant
FBXImporter a une valeur de 1,25 et que l’option Generate Colliders est activée pour
que Unity assigne un Mesh Collider (un composant de collision respectant le maillage
de l’objet) à chaque partie du modèle. Ainsi, le personnage du joueur pourra marcher sur
la plate-forme.
Pour conirmer ces modiications, cliquez sur le bouton Apply au bas du panneau Inspector.
Faites maintenant glisser le modèle depuis le panneau Project dans le panneau Scene
puis, avec l’outil Transform, positionnez-le à proximité de l’avant-poste, ain que le
joueur comprenne que les deux éléments sont liés. Assurez-vous que le modèle de plate-
forme touche le sol pour que le personnage du joueur puisse monter les marches situées à
l’avant du modèle (voir Figure 6.9).

Figure 6.9

Les cibles et les collisions des noix de coco

Sélectionnez le modèle target dans le dossier Coconut Game du panneau Project ain
d’aficher les paramètres d’importation de ses différents composants dans le panneau
Inspector.
Dans le composant FBXImporter du panneau Inspector, activez l’option Generate
Colliders pour vous assurer que la cible bascule lorsqu’une partie du modèle est touchée
– souvenez-vous que, sans collider, les objets 3D ne peuvent entrer en contact les uns avec
les autres. Donnez également la valeur 1 au paramètre Scale Factor.
178 Développez des jeux 3D avec Unity

Dans le composant Animations, vous devez déinir et nommer les images pour chaque état
de l’animation de ce modèle, de la même manière que vous l’avez fait pour les animations
de la porte de l’avant-poste. Vous pourrez ensuite les appeler dans vos scripts lorsqu’une
collision se produit entre une noix de coco et la bonne partie de la cible.
Pour ajouter trois états d’animation (voir Figure 6.10), cliquez sur l’icône plus (+) située à
droite dans le tableau Animations, puis indiquez le nom des états dans la colonne Name
ainsi que la première et la dernière image de chaque animation dans les colonnes Start
et End.

Figure 6.10

Une fois le tableau Animations complété, n’oubliez pas de cliquer sur le bouton Apply
au bas du panneau pour conirmer tous les changements que vous avez apportés aux para-
mètres de cette ressource.

Positionner les cibles

Pour placer les cibles facilement sur la plate-forme, vous allez les déinir comme des
enfants de l’objet platform déjà présent dans la scène. Pour cela, faites simplement glisser
le modèle target depuis le dossier Coconut Game du panneau Project sur l’objet parent
platform dans le panneau Hierarchy.
Chapitre 6 Instanciation et corps rigides 179

Une boîte de dialogue vous informe que l’ajout de cet objet enfant entraînera la perte de
sa connexion avec l’élément préfabriqué. Cliquez sur le bouton Continue. Ce message
indique simplement que les modiications apportées aux composants attachés au modèle
d’origine dans le panneau Project – les paramètres de script, par exemple – ne s’applique-
ront plus à cette copie dans la scène puisque le lien entre cette occurrence et la ressource
originale ou l’élément préfabriqué est rompu.
Une fois que la cible est un enfant de l’objet platform, tous les objets enfants de ce dernier
s’afichent dans le panneau Hierarchy, y compris celui que vous venez d’ajouter.
Comme la cible se place par défaut au centre de la plate-forme, modiiez les valeurs du
composant Transform dans le panneau Inspector pour lui donner une position appropriée.
Placez-la à (0, 1.7, 1.7).

Le script de détection des noix de coco

Vous avez besoin de détecter les collisions entre la cible du modèle target (par opposi-
tion à son support ou à son socle), vous devez donc écrire un script de détection de colli-
sion sur cette partie du modèle. Sélectionnez le dossier Scripts dans le panneau Project,
puis cliquez sur le bouton Create et sélectionnez JavaScript dans le menu déroulant.
Renommez ce script CoconutCollision, puis double-cliquez sur son icône pour l’ouvrir
dans l’éditeur de script.

Déclarer les variables

Vous devez d’abord déclarer cinq variables :
∑ une variable publique GameObject pour stocker l’objet target lui-même ;
∑ une variable booléenne beenHit pour vériier l’état de la cible ;
∑ une variable privée à virgule lottante timer pour déinir un délai avant la réinitialisation
de la cible ;
∑ une variable publique audio hitSound ;
∑ une variable publique audio resetSound.
Pour cela, ajoutez les lignes suivantes au début du script :
var targetRoot : GameObject;
private var beenHit : boolean = false;
private var timer : loat = 0.0;
var hitSound : AudioClip;
var resetSound : AudioClip;
180 Développez des jeux 3D avec Unity

beenHit et timer sont des variables privées. Leurs valeurs sont uniquement utilisées dans
le script et n’ont pas besoin d’être déinies dans le panneau Inspector. Le préixe private
permet de ne pas les y aficher, contrairement aux variables publiques.

La détection de collision
Insérez ensuite la fonction de détection de collision suivante avant la fonction Update()
existante :
function OnCollisionEnter(theObject : Collision) {
if(beenHit==false && theObject.gameObject.name=="coconut"){
audio.PlayOneShot(hitSound);
targetRoot.animation.Play("down");
beenHit=true;
}
}

La fonction OnCollisionEnter() est différente des fonctions OnControllerColliderHit()

et OnTriggerEnter() que vous avez déjà rencontrées. En effet, cette fonction gère les colli-
sions ordinaires entre les colliders classiques – ceux qui ne sont ni en mode Déclencheur,
ni intégrés à l’objet First Person Controller.
Dans cette fonction, le paramètre theObject est une instance de la classe Collision, qui
stocke des informations sur les vitesses, les corps rigides, les colliders, les transformations,
les objets GameObject et les points de contact impliqués dans une collision. Par consé-
quent, la condition if interroge simplement cette classe, ain de savoir si ce paramètre
stocke un objet gameObject nommé coconut. Pour s’assurer que la cible ne puisse pas
être frappée à plusieurs reprises, l’instruction if contient une condition supplémentaire qui
vériie si la variable beenHit est déinie à false, ce qui sera le cas au lancement du jeu.
Lorsque cette collision se produit, beenHit prend la valeur true pour qu’il soit impossible
de la déclencher accidentellement à deux reprises.
Cette fonction lance également la lecture du ichier audio attribué à la variable hitSound,
puis lit l’état d’animation nommé down de l’objet que vous attribuez par glisser-déposer
à la variable targetRoot. Vous assignerez l’objet parent target à cette variable dans le
panneau Inspector après avoir écrit le script.

Réinitialiser la cible
Dans la fonction Update(), vous avez besoin d’utiliser la variable beenHit pour que la
variable timer lance un décompte de trois secondes. Autrement dit, la variable timer
Chapitre 6 Instanciation et corps rigides 181

comptera jusqu’à 3 à partir de l’image où la cible est touchée avant de déclencher sa réini-
tialisation. Pour cela, vous avez besoin de deux instructions if  : une pour vériier si la
variable beenHit est true et incrémenter la valeur de la variable timer, l’autre pour vériier
si la variable timer a atteint 3  secondes. Ajoutez les quelques lignes suivantes dans la
fonction Update() :
if(beenHit){
timer += Time.deltaTime;
}
if(timer > 3){
audio.PlayOneShot(resetSound);
targetRoot.animation.Play("up");
beenHit=false;
timer=0.0;
}

La première instruction if attend que la variable beenHit ait la valeur true puis incrémente
la variable timer à l’aide du compteur Time.deltaTime. Ce compteur est indépendant du
nombre d’images par seconde, si bien que le décompte s’effectue en temps réel.
La seconde instruction if attend que la variable timer dépasse trois secondes puis lance la
lecture du son assigné à la variable resetSound, lit l’état d’animation du modèle attribué à
la variable targetRoot et réinitialise les variables beenHit et timer à leurs valeurs d’ori-
gine pour que la cible puisse être atteinte de nouveau.

Intégrer la source audio

Des sons étant lus, vous avez besoin d’ajouter la commande RequireComponent habituelle
au bas du script ain de vous assurer qu’une source audio est ajoutée à l’objet sur lequel ce
script est attaché. Placez la ligne suivante au bas du script après l’accolade de fermeture de
la fonction Update() :
@script RequireComponent(AudioSource)

Cliquez sur File > Save dans l’éditeur de script et revenez dans Unity.

Assigner le script
Dans le panneau Hierarchy, cliquez sur la lèche qui précède le modèle target que
vous avez ajouté à l’objet platform ain de voir les éléments qui le constituent. Afichez
ensuite le contenu du groupe enfant target_pivot pour voir la cible et ses supports (voir
Figure 6.11).
182 Développez des jeux 3D avec Unity

Figure 6.11

Dans cette igure, nous avons sélectionné la cible elle-même. Vous devez faire de même
pour vous assurer que le script que vous venez d’écrire est affecté à cet objet et non à l’objet
parent target. Vous devez vériier les collisions avec cet objet enfant ; en effet, la collision
ne doit pas se déclencher si le joueur lance une noix de coco sur les supports qui soutiennent
la cible, par exemple.
Une fois cet objet sélectionné, cliquez sur Component > Scripts > CoconutCollision
pour lui attacher le script que vous venez d’écrire et un composant Audio Source. Faites
ensuite glisser l’objet parent target du panneau Hierarchy sur la variable publique
Target Root et les ichiers audio targetHit et targetReset du panneau Project sur les
variables publiques adéquates dans le panneau Inspector (voir Figure 6.12).

Figure 6.12

Cliquez sur File > Save Scene dans Unity pour sauvegarder vos progrès. Cliquez ensuite
sur le bouton Play pour tester le jeu ; marchez sur la plate-forme, en veillant à vous placer
Chapitre 6 Instanciation et corps rigides 183

sur le pas de tir – vous devriez maintenant être en mesure de jeter des noix de coco et
d’abattre la cible. Cliquez de nouveau sur Play pour terminer le test.
Pour compléter le mini-jeu, vous allez ajouter trois cibles supplémentaires à l’aide du
système d’éléments préfabriqués.

Créer des cibles supplémentaires

Pour créer d’autres cibles, vous allez dupliquer la cible actuelle, après l’avoir transfor-
mée en élément préfabriqué. Pour cela, sélectionnez le dossier Prefabs dans le panneau
Project, cliquez sur le bouton Create et choisissez Prefab, puis renommez ce nouvel
élément préfabriqué Target Prefab. Faites ensuite glisser l’objet parent target du panneau
Hierarchy sur cet élément préfabriqué pour l’enregistrer.
Le nom de l’objet parent target dans le panneau Hierarchy doit devenir bleu, pour
indiquer qu’il est lié à un élément préfabriqué du projet.
Sélectionnez l’objet parent target dans le panneau Hierarchy puis appuyez sur Cmd/
Ctrl+D pour le dupliquer.
La copie étant sélectionnée, réglez sa position X à 1,8 dans le composant Transform du
panneau Inspector. Répétez cette duplication pour créer une troisième cible puis déinissez
sa position X à –1,8.

Gagner la partie
Pour terminer le mini-jeu – le joueur doit obtenir la dernière pile dont il a besoin pour char-
ger le mécanisme de la porte de l’avant-poste. Vous devez écrire un script qui vériie si les
trois cibles sont renversées à la fois.
Sélectionnez le dossier Scripts dans le panneau Project puis cliquez sur le bouton Create
pour créer un ichier JavaScript. Renommez ce script CoconutWin, puis double-cliquez
sur son icône pour l’ouvrir dans l’éditeur de script.

Déclarer les variables

Ajoutez les quatre variables suivantes au début du script :
static var targets : int = 0;
private var haveWon : boolean = false;
var win : AudioClip;
var battery : GameObject;
184 Développez des jeux 3D avec Unity

La première variable, targets, est un compteur qui stocke le nombre de cibles abattues.
Cette valeur proviendra d’une modiication que vous apporterez au script CoconutColli-
sion plus tard. La variable privée haveWon est ensuite déinie à true ain qu’il soit impos-
sible de rejouer à ce mini-jeu une fois le challenge remporté.
Les deux variables publiques suivantes stockent respectivement la séquence audio à lire en
cas de victoire et l’élément préfabriqué battery. Cela permet à ce script d’instancier ces
éléments lorsque le joueur abat les trois cibles.

Vériier la victoire du joueur

Ajoutez maintenant le code suivant dans la fonction Update() :
if(targets==3 && haveWon == false){
targets=0;
audio.PlayOneShot(win);
Instantiate(battery, Vector3(transform.position.x, transform.position.y+2,
transform.position.z), transform.rotation);
haveWon = true;
}

Cette déclaration if a deux conditions : elle garantit que la valeur de targets atteint la
valeur 3, autrement dit que toutes les cibles ont été abattues, et que la variable haveWon est
false, ce qui signiie ce qui signiie que le joueur n’a pas encore remporté ce challenge.
Lorsque ces conditions sont remplies, les commandes suivantes sont exécutées :
∑ Le script réinitialise la variable targets à 0 (ce qui est simplement un autre moyen de
s’assurer que l’instruction if ne se déclenche pas de nouveau).
∑ La séquence audio win est lue pour fournir un signal sonore au joueur.
∑ Une instance de l’objet que vous assignez à la variable battery est instanciée. Sa posi-
tion Vector3 est déinie en fonction des valeurs de position  X et  Z de la plate-forme
(puisque ce script sera appliqué à cet objet), en ajoutant 2 à la valeur Y.
∑ La variable est déinie à true ain que le joueur ne puisse plus gagner de nouveau à ce
jeu et générer davantage de piles.
Enin, comme vous allez utiliser du son, ajoutez la ligne suivante à la dernière ligne du
script :
@script RequireComponent(AudioSource)

Cliquez sur File > Save dans l’éditeur de script et revenez dans Unity.
Chapitre 6 Instanciation et corps rigides 185

Assigner le script
Sélectionnez l’objet parent platform dans le panneau Hierarchy, puis cliquez sur Compo-
nent > Scripts > Coconut Win.
Pour inir, assignez l’élément préfabriqué battery situé dans le dossier Prefabs du panneau
Project à la variable publique battery et l’effet sonore Win du dossier Coconut Game à la
variable publique Win. Le composant devrait être identique à la Figure 6.13.

Figure 6.13

Gérer le nombre de cibles abattues

Enin, pour que le jeu fonctionne, vous devez revenir au script CoconutCollision ain
d’augmenter de 1 la valeur de la variable statique targets du script CoconutWin lorsque le
joueur abat une cible, et diminuer de 1 cette valeur lorsque les cibles se réinitialisent.
C’est simple à réaliser, puisque le script qui gère ces deux événements existe déjà. Double-
cliquez sur l’icône du script CoconutCollision dans le dossier Scripts pour l’ouvrir dans
l’éditeur de script.

Augmenter la valeur
Dans la fonction de détection de collision OnCollisionEnter(), l’instruction if contient
une ligne déinissant la variable beenHit à true. Ajoutez la ligne :
CoconutWin.targets++;

sous la ligne :
beenHit=true;

Diminuer la valeur
Comme la réinitialisation de la cible est gérée par la seconde instruction if de la fonction
Update(), vous devez soustraire le nombre de cibles abattues ici. Ajoutez la ligne :
CoconutWin.targets--;

sous la ligne :
beenHit=false;
186 Développez des jeux 3D avec Unity

Dans les deux cas, vous passez par la syntaxe à point pour accéder au script CoconutWin
(qui est, en fait, une classe) puis vous indiquez le nom de la variable, targets.
Cliquez sur File > Save dans l’éditeur de script et revenez dans Unity.
Cliquez sur le bouton Play et testez le jeu. Lancez des noix de coco et abattez les trois
cibles à la fois. Une pile doit alors être instanciée. Appuyez sur la barre d’espacement ain
de sauter par-dessus la barrière et de collecter la pile. Cliquez de nouveau sur Play pour
terminer le test puis sur File > Save Scene dans Unity pour sauvegarder votre travail.

La touche inale
Pour améliorer ce mini-jeu, vous allez ajouter un viseur qui s’afichera lorsque le joueur se
tiendra sur le pas de tir, puis vous utiliserez l’objet TextHint GUI existant pour donner des
instructions au joueur sur le jeu de lancer de noix de coco.

Ajouter le viseur
Pour ajouter le viseur à l’écran, procédez de la façon suivante :
1. Ouvrez le dossier Coconut Game dans le panneau Project.
2. Sélectionnez le ichier de texture Crosshair.
3. Cliquez sur GameObject > Create Other > GUI Texture pour créer un objet GUI
Texture du même nom et aux mêmes dimensions que le ichier de texture Crosshair.
Cet objet est automatiquement sélectionné dans le panneau Hierarchy, si bien que son
composant GUI Texture s’afiche dans le panneau Inspector. L’image en forme de réticule
de visée doit être visible dans le panneau Game et dans le panneau Scene lorsque l’option
Game Overlay est activée. Comme elle est placée au centre de l’objet par défaut, cela
fonctionne parfaitement avec ce ichier de texture de petite taille (64 × 64). Lorsque nous
avons créé le ichier de texture de cet exemple, nous avons veillé à ce que les contours du
viseur soient bien contrastés ain qu’il soit parfaitement visible aussi bien sur un fond clair
que sombre.

Si vous créez un objet Gui texture sans sélectionner de ichier de texture,

Info il utilisera le logo de Unity. Vous devez alors échanger cette image par votre
texture dans le panneau inSPector et indiquer ses dimensions manuellement.
C’est pourquoi il est préférable de toujours choisir au préalable la texture à
utiliser pour l’objet Gui texture.
Chapitre 6 Instanciation et corps rigides 187

Aficher le viseur GUI Texture

Ouvrez le script PlayerCollisions situé dans le dossier Scripts du panneau Project. Vous
constatez que la fonction OnControllerColliderHit() contient déjà un script qui vériie si
le joueur se trouve sur le pas de tir. Le viseur ne doit être visible que si le joueur s’y trouve.
Vous allez donc ajouter quelques lignes à ces instructions if.
Placez-vous avant l’instruction if suivante :
if(hit.collider == GameObject.Find("mat").collider){
CoconutThrow.canThrow=true;
}

et ajoutez ces deux lignes :

var crosshairObj : GameObject = GameObject.Find("Crosshair");
var crosshair : GUITexture = crosshairObj.GetComponent(GUITexture);

La première variable retrouve l’objet en forme de viseur à l’aide de la commande Game-

Object.Find suivie du nom de l’objet, tandis que la seconde utilise la commande GetCompo-
nent() pour représenter la valeur précédente de la variable dans le composant GUITexture.
De cette manière, vous pouvez facilement activer et désactiver le réticule de visée à l’aide
des instructions if et else.
Ajoutez maintenant la ligne suivante dans l’instruction if indiquée précédemment :
crosshair.enabled = true;

Puis ajoutez la ligne suivante dans l’instruction else qui l’accompagne :

crosshair.enabled=false;

Informer le joueur
Vous allez utiliser l’objet TextHints GUI que vous avez créé au Chapitre 5, "Éléments
préfabriqués, collections et HUD", pour aficher un message à l’écran qui indiquera au
joueur ce qu’il doit faire lorsqu’il se trouve sur le pas de tir.
Ajoutez les lignes suivantes dans l’instruction if de la fonction OnControllerColliderHit()
du script PlayerCollisions :
TextHints.textOn=true;
TextHints.message = "Abattez 3 cibles pour obtenir une pile !";
GameObject.Find("TextHint GUI").transform.position.y = 0.2;
188 Développez des jeux 3D avec Unity

Le script afiche l’objet TextHint GUI en déinissant sa variable statique textOn à true
puis il envoie une chaîne de caractères à sa variable statique message. La minuterie du script
TextHints fera disparaître ce message lorsque le joueur quittera l’aire de lancement.
Le script utilise également la commande GameObject.Find pour s’adresser à l’objet
TextHint GUI lui-même et déinir sa position sur l’axe Y à 0,2. En effet, les messages de
l’objet TextHint GUI apparaissent au centre de l’écran, si bien qu’ils chevaucheraient
l’image du viseur. Pour éviter cela, la dernière des trois lignes de l’extrait de code précédent
décale le message vers le bas de l’écran.
Ajoutez maintenant le texte suivant dans l’instruction else de la fonction OnController
ColliderHit() :

GameObject.Find("TextHint GUI").transform.position.y = 0.5;

Cela réinitialise simplement l’objet TextHint GUI à sa position d’origine lorsque le joueur
a terminé le mini-jeu et quitte le pas de tir.
La fonction OnControllerColliderHit() complète doit être la suivante :
function OnControllerColliderHit(hit: ControllerColliderHit){
var crosshairObj : GameObject = GameObject.Find("Crosshair");
var crosshair : GUITexture = crosshairObj.GetComponent(GUITexture);
if(hit.collider == GameObject.Find("mat").collider){
CoconutThrow.canThrow=true;
crosshair.enabled = true;
TextHints.textOn=true;
TextHints.message = "Abattez 3 cibles pour obtenir une pile !";
GameObject.Find("TextHint GUI").transform.position.y = 0.2;
}
else{
CoconutThrow.canThrow=false;
crosshair.enabled = false;
GameObject.Find("TextHint GUI").transform.position.y = 0.5;
}
}

Cliquez sur File > Save dans l’éditeur de script pour sauvegarder vos modiications puis
revenez dans Unity.
Cliquez sur le bouton Play et testez le jeu. Quand vous vous placez sur le pas de tir, un
message vous indiquant le but du jeu doit apparaître. Quittez l’aire de lancement : le viseur
doit disparaître immédiatement de l’écran, puis le message devenir invisible quelques
secondes plus tard. Cliquez de nouveau sur Play pour terminer le test puis sur File > Save
Project pour sauvegarder votre travail.
Chapitre 6 Instanciation et corps rigides 189

En résumé
Au cours de ce chapitre, nous avons abordé divers sujets essentiels à la création d’un scéna-
rio de jeu. Vous avez vu comment implémenter les objets corps rigides qui utilisent le
moteur physique et vous avez étudié le concept de l’instanciation, qu’il est très important
d’apprendre à maîtriser. En effet, l’instanciation est un outil majeur pour le concepteur car
elle permet de créer ou de cloner n’importe quelle ressource préfabriquée ou n’importe
quel objet de jeu lors de l’exécution.
Vous avez également fourni au joueur des informations supplémentaires, en réutilisant
l’objet TextHint GUI que vous aviez créé au Chapitre 5. Vous avez vu comment envoyer
ces informations à cet objet dans le script.
Vous continuerez à vous servir de toutes ces notions au il des pages de cet ouvrage et dans
vos futurs projets. Au prochain chapitre, nous allons délaisser provisoirement l’écriture de
script pour étudier les effets visuels de Unity. Vous découvrirez les systèmes de particules
visant à créer un feu à proximité de l’avant-poste, ain de donner au joueur une récompense
visuelle après qu’il a gagné le mini-jeu et ouvert la porte.
 7
Systèmes de particules
Ce chapitre aborde certains effets de rendu que les développeurs peuvent employer dans
Unity. Pour créer des mondes  3D plus dynamiques, outre les matériaux et les textures
simples, on peut utiliser des effets pour reproduire les caractéristiques du monde réel,
souvent en les exagérant. De nombreux jeux 3D ont ainsi adopté les conventions visuelles
du cinéma, comme les effets de relet sur l’objectif ou les traînées de lumière que l’œil
humain ne perçoit pas dans la réalité.
Vous avez déjà vu l’effet de relet du soleil sur l’objectif au Chapitre 2, "Environnements",
avec lecomposant Light de l’objet Directional Light. Ici, vous allez découvrir comment
obtenir des effets plus polyvalents avec les systèmes de particules dans le monde 3D. Les
jeux utilisent les effets de particules pour de nombreux effets, du brouillard à la fumée en
passant par les étincelles et les lasers. Vous verrez aux sections suivantes comment simuler
l’effet d’un feu grâce à deux systèmes de particules.
Au cours de ce chapitre, vous apprendrez :
∑ de quoi est constitué un système de particules – ses composants et ses paramètres ;
∑ comment créer des systèmes de particules pour simuler le feu et la fumée ;
192 Développez des jeux 3D avec Unity

∑ à aficher de nouveau des instructions et des informations à l’écran pour le joueur ;

∑ utiliser des variables pour activer les systèmes de particules au cours de l’exécution du
jeu.

Qu’est-ce qu’un système de particules ?

Dans Unity, un système de particules est plus qu’un composant. En effet, un certain nombre
d’éléments doivent être combinés pour que l’effet escompté fonctionne correctement.
Avant de commencer à travailler avec les systèmes de particules, vous devez connaître
leurs différents composants et comprendre leurs rôles respectifs.

L’émetteur de particules
Dans tout système de particules, le composant émetteur est chargé de l’instanciation des
particules individuelles. Unity dispose d’un composant Ellipsoid Particle Emitter et
d’un composant Mesh Particle Emitter.
Le composant Ellipsoid Particle Emitter s’utilise généralement pour les effets de
fumée, la poussière et les autres éléments de l’environnement qui peuvent être créés dans
un espace fermé. Il est dit ellipsoïde car il crée des particules à l’intérieur d’une sphère
pouvant être étirée.
Le composant Mesh Particle Emitter crée des particules liées directement à un
maillage 3D et qui peuvent être soit animées le long des sommets du maillage soit émises
sur les points du maillage. Il sert principalement lorsqu’on doit contrôler directement la
position d’une particule. Le développeur, en ayant la possibilité de suivre les sommets d’un
maillage, peut ainsi concevoir des systèmes de particules extrêmement précis et de n’im-
porte quelle forme 3D.
En tant que composants, les deux émetteurs disposent des paramètres communs suivants :
∑ Size. La taille visible d’une particule.
∑ Energy. La durée de vie d’une particule dans le monde avant son autodestruction.
∑ Emission. Le nombre de particules émises à la fois.
∑ Velocity. La vitesse à laquelle les particules se déplacent.
Nous examinerons quelques-uns des réglages spéciiques de chaque type d’émetteur. Pour
créer un feu, vous choisirez Ellipsoid Particle Emitter qui permet d’obtenir un effet
plus aléatoire car il n’est pas lié à un maillage.
Chapitre 7 Systèmes de particules 193

Figure 7.1

L’animateur de particule
Le composant Particle Animator régit le comportement de chaque particule dans le
temps. Pour sembler dynamiques, les particules ont une durée de vie déinie puis elles s’auto-
détruisent. Dans l’exemple d’un feu, l’idéal serait que chaque particule soit animée et change
d’apparence au cours de sa vie dans le monde. Pour reproduire les variations de couleurs d’un
feu dans le monde réel, ce composant est intéressant pour faire varier la couleur et la visibilité
et pour appliquer des forces aux particules elles-mêmes.

Figure 7.2

Le rendu des particules

Le composant Particle Renderer déinit l’aspect visuel de chaque particule. Les particules
sont, en fait, des images carrées en 2D (des sprites). Leur rendu s’effectue généralement de
la même manière que celui de l’herbe que vous avez ajoutée au terrain au Chapitre 2 : la
194 Développez des jeux 3D avec Unity

technique du billboarding est appliquée ain que les particules semblent toujours faire face à
la caméra. Dans Unity, le composant Particle Renderer peut aficher les particules diffé-
remment, mais le billboarding est la méthode la mieux appropriée dans la plupart des cas.
Le composant Particle Renderer gère également les matériaux appliqués au système
de particules. Ces dernières étant rendues comme de simples sprites, si vous appliquez des
shaders de particules aux matériaux dans le composant, vous pouvez créer l’illusion que les
sprites ne sont pas carrés en plaçant tout autour des textures sur une couche alpha (trans-
parente). La Figure 7.3 illustre cette méthode que vous allez bientôt utiliser sur le matériau
feu (la zone sombre de l’image représente les zones transparentes).

Figure 7.3

Grâce à la transparence, les particules n’ont plus l’aspect carré que le rendu donne habituel-
lement aux sprites 2D. En combinant le rendu de la partie visible de cette texture avec des
valeurs d’émission plus élevées, vous pouvez obtenir un effet de densité.
Les moteurs de rendu des particules peuvent aussi animer celles-ci avec l’animation UV de
textures – plusieurs images sont alors utilisées pour modiier les textures d’une particule au
cours de sa durée de vie. Mais comme cette technique dépasse la portée de ce livre, nous
vous conseillons de vous reporter au manuel de Unity plus en savoir plus à ce sujet.

En résumé
Un système de particules fonctionne grâce à la collaboration de ses composants : l’émet-
teur, qui crée les particules  ; l’animateur, qui régit leur comportement et leur évolution
Chapitre 7 Systèmes de particules 195

dans le temps ; et le moteur de rendu, qui déinit leur aspect visuel en utilisant différents
matériaux et paramètres d’afichage.
Vous allez maintenant voir comment créer un élément inédit dans votre jeu : un feu composé
de deux systèmes de particules, un pour les lammes et un autre pour le panache de fumée.

Le but du jeu
Pour l’instant, votre jeu consiste à collecter quatre piles pour entrer dans l’avant-poste.
Depuis le chapitre précédent, une de ces piles s’obtient en abattant les trois cibles avec des
noix de coco.
Une fois dans l’avant-poste, le joueur risque d’être assez déçu, car le bâtiment est vide. Vous
allez donc ajouter une boîte d’allumettes au centre de la pièce. Vous créerez également un
feu à proximité de l’avant-poste qui pourra s’allumer uniquement si le joueur possède cette
boîte d’allumettes. En voyant le tas de bois attendant de prendre feu, le joueur sera incité à
trouver les allumettes et donc à remplir les tâches déinies (c’est-à-dire, à ouvrir la porte).
Pour créer ce jeu, vous devez :
∑ installer un paquet de ressources, puis ajouter un modèle de feu de bois à la scène près
de l’avant-poste ;
∑ créer des systèmes de particules pour les lammes et la fumée lorsque le feu est allumé,
puis empêcher qu’ils se déclenchent trop tôt à l’aide d’un script ;
∑ utiliser la détection de collision entre le personnage du joueur et l’objet feu de bois de
façon que l’allumage du feu déclenche le composant émetteur ;
∑ ajouter le modèle d’allumettes dans l’avant-poste et mettre en place une détection de
collision pour que le joueur puisse les collecter et soit ensuite capable d’allumer le feu ;
∑ utiliser l’objet TextHint GUI pour donner des indications au joueur lorsqu’il s’approche
du feu sans posséder les allumettes.

Télécharger les ressources

Pour obtenir les ressources nécessaires à la réalisation de cet exercice, recherchez le ichier
nommé irePack.unitypackage extrait de l’archive fournie. Cliquez ensuite dans Unity sur
Assets > Import Package, puis parcourez votre disque dur jusqu’au dossier où vous avez
extrait ce paquet de ressources et sélectionnez-le.
Les ichiers suivants requis pour créer cette partie du jeu sont alors importés :
∑ un modèle 3D d’un feu de camp ;
196 Développez des jeux 3D avec Unity

∑ une texture de lamme pour le système de particules du feu ;

∑ une texture de fumée pour le système de particules de la fumée ;
∑ une séquence sonore de feu qui crépite ;
∑ un dossier Material contenant les modèles 3D.
Tous ces ichiers sont regroupés dans le dossier Fire feature du panneau Project.

Ajouter le tas de bois

Sélectionnez le modèle campfire dans le dossier Fire feature du panneau Project, puis
donnez la valeur  0,5 au paramètre Scale Factor dans le composant FBXImporter du
panneau Inspector si elle n’est pas déjà déinie. Vous garantissez ainsi que le modèle est
importé dans la scène à une taille raisonnable par rapport aux autres objets déjà présents.
Cliquez sur le bouton Apply au bas du panneau Inspector pour valider.
Faites glisser ce modèle dans le panneau Scene, puis avec l’outil Transform placez-le
près de l’avant-poste et de la plate-forme de lancer des noix de coco déjà présents (voir
igure 7.4).

Figure 7.4

Ce modèle doit disposer d’un collider (composant de collision) ain que le joueur ne
puisse pas passer au travers. Pour des modèles aussi complexes, on utilise habituellement
le composant FBX Importer pour créer des Mesh Colliders (composants de collision
respectant le maillage de l’objet) sur chaque maillage du modèle. Toutefois, étant donné
Chapitre 7 Systèmes de particules 197

que vous devez seulement veiller à ce que cet objet constitue un obstacle pour le joueur,
vous pouvez simplement utiliser un collider de type capsule à la place. Cela fonctionnera
tout aussi bien et permettra d’économiser la puissance de calcul car le processeur n’aura
pas à construire un collider sur chaque partie du modèle.
Sélectionnez l’objet feu campfire dans le panneau Hierarchy, puis cliquez sur Compo-
nent > Physics > Capsule Collider. La boîte de dialogue Losing Prefab s’afiche alors
et vous demande de conirmer la suppression de la connexion entre ce modèle et l’original.
Cliquez sur le bouton Add comme d’habitude.
Un petit collider sphérique apparaît alors à la base du modèle de feu. Vous devez augmenter
sa taille ain qu’il recouvre tout le modèle. Dans le nouveau composant Capsule Collider
du panneau Inspector, donnez la valeur 2 au paramètre Radius et la valeur 5 au paramètre
Height. Afichez ensuite les valeurs du paramètre Center puis donnez la valeur 1,5 à Y
(voir Figure 7.5). Testez le jeu pour vériier que le joueur est bloqué par l’objet.

Figure 7.5

Créer les systèmes de particules pour le feu

À cette section, vous allez créer deux systèmes de particules différents, un pour le feu
et l’autre pour sa fumée. En utilisant deux systèmes distincts, vous contrôlerez mieux
l’animation des particules dans le temps car vous pourrez animer les lammes et la fumée
indépendamment.
198 Développez des jeux 3D avec Unity

Créer le feu
Pour commencer à construire le système de particules du feu, vous allez ajouter un objet
de jeu possédant les trois composants essentiels pour les particules. Pour cela, cliquez sur
GameObject > Create Other > Particle System. Un nouvel objet de jeu Particle
System apparaît alors dans les panneaux Scene et Hierarchy. Appuyez sur Entrée/F2
et renommez-le FireSystem, en vous assurant que le nom ne contient pas d’espace : c’est
essentiel pour le script que vous allez créer ensuite.
Vous n’avez pas besoin de positionner le feu avant d’avoir terminé sa création. Vous pouvez
tout à fait continuer sa conception là où Unity l’a placé de façon aléatoire dans le monde 3D.
Par défaut, les particules prennent l’apparence de petits points blancs aux contours lous et
ressemblent un peu à un nuage de lucioles. Il s’agit tout simplement des paramètres les plus
génériques de chaque composant. Pour le moment, l’émetteur de particules génère le plus
petit nombre possible de particules, l’animateur régit l’apparition et la disparition progres-
sive des particules, et le moteur de rendu n’utilise aucun matériau.
Vous allez maintenant déinir chaque composant individuellement. Lorsque vous réglez les
paramètres dans le panneau Inspector, vous pouvez visualiser un aperçu du système de
particules dans le panneau Scene.

Les paramètres du composant Ellipsoid Particle Emitter

Commencez par déinir la valeur de Min Size à 0,5 et celle de Max Size à 2. La taille des
lammes augmente alors considérablement par rapport aux paramètres par défaut. Comme
avec tous les paramètres Min et Max, la taille des particules créées par l’émetteur varie
entre ces deux valeurs.
Donnez maintenant la valeur 1 au paramètre Min Energy et la valeur 1,5 au paramètre
Max Energy. Ces paramètres déinissent la durée de vie des particules : elles s’autodétrui-
ront entre une seconde et une seconde et demie après leur création.
Donnez les valeurs 15 au paramètre Min Emission et 20 au paramètre Max Emission pour
déinir le nombre de particules présentes dans la scène à tout moment. Plus ces valeurs
sont élevées et plus les particules seront nombreuses à l’écran, rendant ainsi le feu plus
dense. Cependant, comme le coût pour le processeur peut être important, il est préférable
en général de conserver des valeurs aussi faibles que possible pour ces paramètres, à partir
du moment où le résultat visuel est acceptable.
Déinissez la valeur Y du paramètre World Velocity à 0,1 pour que les particules s’élè-
vent au cours de leur durée de vie, comme le font les lammes. Ce paramètre sert pour les
objets qui doivent toujours s’élever dans le monde du jeu. Si vous utilisiez le paramètre
Chapitre 7 Systèmes de particules 199

Local Velocity sur un objet pouvant être déplacé et si celui-ci pivotait au cours du jeu,
son axe Y local ne correspondrait alors plus à l’axe Y global.
Un baril enlammé régi par le moteur physique, par exemple, peut tomber, voire rouler au
sol. Pourtant, les lammes doivent toujours s’élever d’un point de vue global. Bien que le
feu de camp ne puisse pas être déplacé, vous devez comprendre la différence entre espace
local et espace global dans ce cas précis.
Déinissez ensuite la valeur Y de Rnd Velocity (Random, pour aléatoire) à 0,2 pour que
des lammes s’élèvent un peu plus haut que les autres, de temps à autre et de façon aléatoire.
Fixez le paramètre Tangent Velocity à 0,2 sur les axes X et Z, en laissant l’axe Y à 0. Ce
paramètre déinit la vitesse originale de chaque particule. Avec une valeur faible sur X et Z,
vous accélérez donc la vitesse des lammes sur le plan horizontal.
Le paramètre Emitter Velocity Scale sert uniquement à contrôler la vitesse à laquelle
les particules se déplacent lorsque l’objet parent du système de particules est en mouve-
ment. Il peut donc être déini à 0 ici, puisque la position de ce feu ne changera pas.
Le paramètre Simulate in Worldspace sera désactivé, puisque les particules doivent être
créées en fonction de la position du système et non selon une position dans l’espace global.
Le paramètre One Shot peut lui aussi rester désactivé, car l’émission des particules doit
être continue. Ce paramètre serait plus utile pour représenter la fumée sortant d’un canon,
par exemple.
Toutes les valeurs du paramètre Ellipsoid peuvent être déinies à 0,1. Cette valeur est
faible, mais l’échelle du système de particules est également réduite – cette valeur devra,
par exemple, être beaucoup plus élevée pour le système de particules du panache de fumée.

Les paramètres du composant Particle Animator

À présent, vous devez déinir les paramètres du composant Particle Animator, qui régit
le comportement des particules au cours de leur vie. Ici, vous avez besoin que les particules
apparaissent et disparaissent (Fade In et Fade Out). Vous les animerez à l’aide de couleurs
(tons de rouge et d’orange) et vous leur appliquerez des forces pour que les lammes aient
un comportement plus réaliste.
Commencez par vous assurer que le paramètre Does Animate Color est activé, ain que
les cinq paramètres Color Animation jouent un rôle. Cliquez ensuite sur chacun des
champs de couleur situés à droite. Dans la boîte de dialogue Color qui s’afiche, sélection-
nez la couleur blanche pour Color Animation[0], une couleur orange foncé pour Color
Animation[4] et des teintes intermédiaires pour les paramètres restants.
200 Développez des jeux 3D avec Unity

Modiiez également la valeur A (alpha) de chaque couleur au bas du sélecteur de couleurs

Color ain que les paramètres Color Animation[0] et Color Animation[4] aient une
valeur alpha de 0, et que les états intermédiaires forment un fondu. La ligne blanche et noire
sous chaque bloc de couleur dans le panneau Inspector représente la valeur alpha. Vous
pouvez utiliser la Figure 7.6 comme modèle pour vos couleurs.

Figure 7.6

Le système de particules dans le panneau Scene doit à présent se comporter de façon plus
naturelle grâce aux couleurs et aux valeurs alpha que vous avez déinies.

L’effet du système Color Animation peut être plus ou moins visible selon les
Info shaders spéciiques que les matériaux appliqués au système de particules uti-
lisent, car certains shaders révèlent un peu plus de couleur que d’autres. Ceux
avec de la transparence, par exemple, peuvent montrer les couleurs de manière
moins eficace.

Conservez toutes les valeurs par défaut de 0 sur tous les axes des paramètres World Rota-
tion Axis et Local Rotation Axis, puis donnez la valeur –0,3 au paramètre Size Grow.
Avec une valeur négative, les particules diminuent de taille au cours de leur durée de vie,
ce qui donne un aspect plus dynamique au feu.
Vous allez maintenant ajouter des forces pour rendre le mouvement du feu plus réaliste.
Elles sont différentes des vitesses ajoutées dans le paramètre Emitter, car elles sont appli-
quées lors de l’instanciation – ce qui entraîne une accélération puis une décélération des
particules. Cliquez sur la lèche grise située à gauche du paramètre Rnd Force pour afi-
cher ses options, puis donnez la valeur 1 aux axes X et Z. Afichez ensuite les options du
paramètre Force de la même manière et entrez la valeur 1 pour l’axe Y.
Déinissez la valeur du paramètre Damping à 0,8. Le damping (amortissement) déinit le
ralentissement des particules au cours de leur durée de vie. La valeur par défaut, 1, n’en-
traîne aucun amortissement et les valeurs comprises entre 0 et 1 provoquent un ralentisse-
ment (0 causant le ralentissement le plus important). On utilise ici une valeur de 0,8 ain
que les particules ne ralentissent pas de manière trop artiicielle.
Chapitre 7 Systèmes de particules 201

Vous pouvez laisser le dernier paramètre Autodestruct désactivé. Toutes les particules
s’autodétruisent naturellement à la in de leur durée de vie, mais ce paramètre porte sur l’ob-
jet de jeu parent lui-même. S’il est activé, toutes les particules s’autodétruisent, puis l’objet
de jeu est détruit. On l’utilise seulement lorsque le paramètre One Shot est activé dans le
composant émetteur. Pour un coup de canon, par exemple, l’objet de jeu serait détruit dès
que toutes les particules se seraient autodétruites, ce qui économiserait les ressources du
CPU, du GPU et de la RAM.

Les paramètres du composant Particle Renderer

Pour le système de particules du feu, vous avez simplement besoin d’appliquer un matériau
de type particle-shaded contenant l’image du feu que vous avez téléchargée et importée.
Mais avant cela, assurez-vous que le rendu des particules est correctement coniguré.
Comme les particules ou les lammes doivent techniquement émettre de la lumière, vous
allez désactiver les paramètres Cast Shadows et Receive Shadows ain qu’aucune
ombre ne soit projetée sur ou par le feu (cela est effectif seulement pour les utilisateurs
de la version Unity Pro, la version gratuite de Unity ne permet pas le contrôle des ombres
dynamiques).
Actuellement, aucun matériau n’est appliqué à ce système de particules, si bien que le para-
mètre Materials est vide (vous allez y remédier très bientôt). Assurez-vous que le paramètre
Camera Velocity Scale a une valeur de 0 – ce paramètre s’utilise uniquement lorsque le
rendu des particules s’effectue avec une autre technique que le billboarding (toujours face
à l’écran). Si vous aviez prévu de déformer les particules en fonction de l’angle de vue,
vous devriez utiliser ce paramètre pour déinir l’inluence du mouvement de la caméra sur
l’étirement des particules.
Le paramètre Stretch Particles doit être déini sur Billboard pour garantir que les
particules seront créées face au joueur, quel que soit l’angle à partir duquel celui-ci observe
le feu. Comme les paramètres Length Scale et Velocity Scale s’utilisent uniquement
avec les particules étirées en fonction de l’angle de vue, vous pouvez conserver leurs valeurs
à 0, les modiier n’aurait aucune inluence sur le rendu des particules par la technique du
billboarding.
Max Particle Size est le dernier paramètre à considérer, puisque nous n’utilisons pas
les options UV Animation. Ce paramètre contrôle la taille qu’une particule peut avoir par
rapport à la hauteur de l’écran. Si sa valeur est de 1, par exemple, la taille des particules
peut être égale à la hauteur de l’écran ; si elle est de 0,5, leur taille maximale est égale à la
moitié de la hauteur de l’écran, et ainsi de suite. Les particules de ce feu n’auront jamais
besoin d’une taille aussi importante que la hauteur de l’écran, vous pouvez donc conserver
la valeur par défaut de 0,25 pour ce paramètre.
202 Développez des jeux 3D avec Unity

Ajouter un matériau
Maintenant que le système de particules est déini, il ne vous reste plus qu’à créer un matériau
qui utilise la texture de feu. Sélectionnez le dossier Fire feature dans le panneau Project,
cliquez sur le bouton Create en haut du panneau et choisissez Material pour créer une
nouvelle ressource New Material dans le dossier. Renommez-la ensuite simplement
Flame, puis sélectionnez-la pour aficher ses propriétés dans le panneau Inspector.
Ouvrez le menu déroulant Shader et choisissez Particles > Additive (soft) pour obtenir
une particule basée sur la couche alpha avec un rendu de la texture que vous appliquez.
Faites glisser la texture appelée Fire 1 du dossier Fire feature dans le panneau Project, sur
la place vide à la droite du paramètre Particle Texture qui indique pour l’instant None
(Texture2D).
Pour appliquer ce matériau, faites-le simplement glisser du dossier Fire feature dans le
panneau Project sur l’objet FireSystem dans le panneau Hierarchy.

Positionner l’objet FireSystem

Ain de placer le système de particules du feu plus facilement, vous devez créer un objet
enfant de l’objet campfire déjà présent dans la scène. Dans le panneau Hierarchy,
faites glisser l’objet FireSystem sur l’objet campfire pour le premier devienne l’enfant
du second. Réinitialisez ensuite sa position en cliquant sur l’icône en forme d’engrenage
située à droite du composant Transform de l’objet FireSystem et choisissez Reset.

Figure 7.7

Le fait de réinitialiser sa position place le système de particules au centre de son objet

parent. Or, comme vous pouvez le constater, cette position est trop basse. Si vous ne
pouvez pas le voir, sélectionnez l’objet dans le panneau Hierarchy, placez le curseur sur le
panneau Scene et appuyez sur la touche F pour centrer la vue sur cet objet. Toujours dans
le composant Transform, déinissez une valeur de 0,8 sur l’axe Y pour décaler légèrement
le système de particules vers le haut.
Chapitre 7 Systèmes de particules 203

Il est temps de tester !

Cliquez sur le bouton Play pour tester le jeu et admirez votre travail ! N’oubliez pas de
cliquer de nouveau sur Play pour mettre un terme au test avant de passer à la section
suivante.

Créer la fumée
Comme le dit l’adage, "Il n’y a pas de fumée sans feu" et vice versa. C’est pourquoi vous
avez besoin qu’un panache de fumée s’échappe du sommet de votre feu de camp pour le
rendre plus réaliste.
Pour commencer, cliquez sur GameObject > Create Other > Particle System pour
ajouter un système de particules à la scène. Renommez-le SmokeSystem dans le panneau
Hierarchy (encore une fois, vous ne devez pas utiliser d’espace dans le nom de l’objet).

Les paramètres du composant Ellipsoid Particle Emitter

Nous avons déjà étudié les différents paramètres lors de l’exercice précédent, aussi vous
pouvez utiliser la liste suivante et observez les modiications que vous apportez au fur et à
mesure. Tous les paramètres qui ne igurent pas sur cette liste doivent conserver leur valeur
par défaut :
∑ Min Size : 0,8 ;
∑ Max Size : 2,5 ;
∑ Min Energy : 8 ;
∑ Max Energy : 10 ;
∑ Min Emission : 10 ;
∑ Max Emission : 15 ;
∑ World Velocity Y : 1,5 ;
∑ Rnd Velocity Y : 0,2 ;
∑ Emitter Velocity Scale : 0,1.

Les paramètres du composant Particle Animator

Conigurez le composant Particle Animator pour que l’animation des particules s’effectue
sur des nuances de gris (voir Figure 7.8).
204 Développez des jeux 3D avec Unity

Figure 7.8

Encore une fois, les particules doivent être animées entre deux valeurs alpha égales à 0 ain
qu’elles apparaissent et disparaissent de façon moins abrupte et plus naturelle.
Modiiez ensuite les paramètres suivants :
∑ Size Grow : 0,2 ;
∑ Rnd Force : (1.2, 0.8, 1.2) ;
∑ Force : (0.1, 0, 0.1) ;
∑ Autodestruct : non sélectionné.

Les paramètres du composant Particle Renderer

Avant de créer un matériau et de l’appliquer à la fumée, vériiez que les paramètres suivants
sont appliqués au composant Particle Renderer :
∑ Cast/Receive Shadows : désélectionnés tous les deux ;
∑ Stretch Particles : Billboard ;
∑ Camera Velocity Scale, Length Scale et Velocity Scale : 0 ;
∑ Max Particle Size : 0,25.
Reprenez maintenant les étapes de l’exercice "Ajouter un matériau" à la section "Créer le
feu" de ce chapitre. Cette fois, en revanche, nommez le matériau Smoke, assignez-lui la
texture smoke 1 et faites-le glisser sur l’objet de jeu SmokeSystem.

Positionnement
Répétez l’étape de positionnement du feu pour la fumée. Faites glisser l’objet Smoke-
System sur l’objet parent campfire dans le panneau Hierarchy. Cliquez ensuite sur
l’icône en forme d’engrenage dans le panneau Inspector et choisissez Reset, puis redé-
inissez la valeur de la position Y à 0,9. Cliquez sur le bouton Play. Le feu devrait main-
tenant s’allumer et le panache de fumée s’élever dans le ciel (voir Figure  7.9). Comme
toujours, n’oubliez pas de cliquer de nouveau sur Play pour arrêter le test.
Chapitre 7 Systèmes de particules 205

Figure 7.9

Ajouter du son au feu de camp

Maintenant que l’aspect visuel du feu est correct, vous devez ajouter un son qui reproduise
l’atmosphère du crépitement du feu. Le ichier audio ire_atmosphere fourni dans le paquet
de ressources que vous avez téléchargé est une séquence audio mono, conçue pour être
lue en boucle. Ce ichier étant monophonique, le volume sonore diminue lorsque le joueur
s’éloigne du feu de camp, ce qui semble logique.
Sélectionnez l’objet campfire dans le panneau Hierarchy, puis cliquez sur Component >
Audio > Audio Source pour ajouter un composant audio source à l’objet. Faites ensuite
simplement glisser la séquence audio fire_atmosphere depuis le dossier Fire feature du
panneau Project sur le paramètre Audio Source dans le panneau Inspector. Pour inir,
activez l’option Loop.
Cliquez sur le bouton Play et approchez-vous du feu de camp en écoutant le crépitement
des lammes. Éloignez-vous ensuite pour entendre le son décroître peu à peu.
206 Développez des jeux 3D avec Unity

Allumer le feu
Maintenant que la conception du feu est terminée, vous allez désactiver les systèmes de
particules et l’audio ain qu’il soit éteint au lancement du jeu.
∑ Sélectionnez l’objet campfire dans le panneau Hierarchy, puis désactivez le para-
mètre Play on Awake du composant Audio Source dans le panneau Inspector.
∑ Sélectionnez l’objet enfant FireSystem de l’objet campfire, puis désactivez le para-
mètre Emit dans le composant Ellipsoid Particle Emitter.
∑ Sélectionnez l’objet enfant SmokeSystem de l’objet campfire et désactivez le para-
mètre Emit dans le composant Ellipsoid Particle Emitter.
Il est temps maintenant d’ajouter la boîte d’allumettes à collecter et de créer l’interface qui
indiquera que le joueur possède les allumettes. Pour cela, vous devez :
∑ ajouter dans l’avant-poste le modèle matchbox que vous avez téléchargé plus tôt pour
donner au joueur une raison d’ouvrir la porte ;
∑ créer une interface graphique (Gui Texture) en utilisant une texture du dossier Fire
feature, puis l’enregistrer comme élément préfabriqué ;
∑ modiier le script PlayerCollisions existant et ajouter une détection de collision pour
la boîte d’allumettes ain que celle-ci puisse être détruite, puis instancier l’élément
préfabriqué matchbox GUI.

Ajouter la boîte d’allumettes

Sélectionnez le modèle matchbox dans le dossier Fire feature du panneau Project, puis
faites-le glisser sur l’objet outpost dans le panneau Hierarchy pour que la boîte d’allu-
mettes devienne un objet enfant de l’avant-poste. Elle sera ainsi plus facile à positionner.
L’objet matchbox étant toujours sélectionné, déinissez les valeurs Position à (0, 5.5, 0) et
toutes les valeurs Scale à 5 dans le composant Transform du panneau Inspector.
Pour que le joueur puisse collecter la boîte d’allumettes, cet objet doit posséder un colli-
der qui détecte les collisions avec lui. L’objet matchbox toujours sélectionné, cliquez sur
Component > Physics > Box Collider, puis cliquez sur Add dans la boîte de dialogue
Losing Prefab. Pour éviter que le contact entre le joueur et l’objet entraîne un heurt, vous
allez utiliser le mode Déclencheur pour ce collider. Pour cela, activez l’option Is Trigger
du composant Box Collider dans le panneau Inspector.
Pour montrer de façon plus évidente au joueur qu’il peut collecter cet objet, vous allez lui
attacher le script que vous avez déjà utilisé pour faire tourner les piles sur elles-mêmes.
Cliquez sur Component > Scripts > Rotate Object. Donnez ensuite la valeur 2 au para-
mètre Rotation Amount dans le nouveau composant Rotate Object (script) qui s’afiche
dans le panneau Inspector.
Chapitre 7 Systèmes de particules 207

Créer l’interface graphique Matches GUI

Sélectionnez le ichier de texture MatchGUI dans le dossier Fire feature du panneau
Project, puis cliquez sur GameObject > Create Other > GUI Texture. Vous n’avez
pas besoin de déinir la position de cette texture à l’écran, vous pourrez le faire lorsque vous
l’instancierez en tant qu’élément préfabriqué.
Sélectionnez le dossier Fire feature dans le panneau Project, cliquez sur le bouton Create
et sélectionnez Prefab. Renommez cet élément préfabriqué MatchGUIprefab puis faites
glisser l’objet MatchGUI du panneau Hierarchy sur cet élément préfabriqué vide dans
le panneau Project.
Enin, sélectionnez de nouveau l’objet original MatchGUI dans le panneau Hierarchy
puis appuyez sur Cmd+Retour arrière (Mac OS) ou Suppr (Windows) pour le supprimer
de la scène.

La collecte des allumettes

Ouvrez le script PlayerCollisions situé dans le dossier Scripts du panneau Project. Pour
que le joueur sache s’il a collecté les allumettes ou non, vous allez ajouter dans le script
une variable booléenne qui aura pour valeur true quand le joueur les aura en sa possession.
Ajoutez la ligne suivante au début du script :
private var haveMatches : boolean = false;

Vous avez également besoin d’une variable publique pour représenter l’élément préfabri-
qué Matches GUI Texture ain de pouvoir l’instancier lorsque le joueur collecte la boîte
d’allumettes. Ajoutez la variable suivante au début du script :
var matchGUI : GameObject;

Maintenant, faites déiler le script jusqu’à la fonction OnTriggerEnter(), puis ajoutez cette
instruction if à la suite de celle qui y est déjà :
if(collisionInfo.gameObject.name == "matchbox"){
Destroy(collisionInfo.gameObject);
haveMatches=true;
audio.PlayOneShot(batteryCollect);
var matchGUIobj : GameObject = Instantiate(matchGUI, Vector3(0.15,0.1,0),
„ transform.rotation);
matchGUIobj.name = "matchGUI";
}

Cette condition vériie le paramètre collisionInfo, qui enregistre chaque objet avec lequel
le joueur entre en collision. La commande gameObject.name vériie si collisionInfo
208 Développez des jeux 3D avec Unity

contient un objet nommé matchbox puis compare ce nom à la chaîne de caractères "Match-
box". Si ces conditions sont réunies, alors le script :
∑ Détruit l’objet matchbox, en faisant référence à l’objet gameObject courant stocké dans
collisionInfo.
∑ Déinit la variable haveMatches à true.
∑ Lance la lecture de la séquence audio assignée à la variable batteryCollect. Comme le
joueur est déjà habitué à ce son lorsqu’il collecte des objets, il est logique de le réutiliser.
∑ Instancie une occurrence de l’objet de jeu assigné à la variable publique matchGUI et la
positionne à (0.15, 0.1, 0). Souvenez-vous que, pour les objets 2D, l’axe Z permet tout
simplement de superposer plusieurs calques, d’où la valeur  0. La commande trans-
form.rotation permet d’hériter de la rotation de l’objet parent – il est inutile de déinir
un paramètre de rotation pour les objets 2D.
∑ Nomme la nouvelle instance de l’objet à l’aide de la variable matchGUIobj qui est créée
dans la ligne de l’instanciation. Elle sera utilisée plus tard pour supprimer l’interface
graphique de l’écran.
Cliquez sur File  > Save dans l’éditeur de script et revenez dans Unity. Cliquez sur le
bouton Play et assurez-vous que vous pouvez vous procurer les allumettes si vous entrez
en contact avec elles après être entré dans l’avant-poste. La texture de la boîte d’allumettes
doit également s’aficher dans le coin inférieur gauche de l’écran. Maintenant, vous allez
décider si le feu peut être allumé ou non avec la variable haveMatches.

Allumer le feu
Ain d’allumer le feu, vous devez vériier les collisions entre le joueur et l’objet campfire.
Pour cela, revenez dans l’éditeur de script pour modiier le script Player Collisions. Si
vous l’avez fermé, double-cliquez sur son nom dans le dossier Scripts du panneau Project.
Recherchez la première ligne de la fonction OnControllerColliderHit() :
function OnControllerColliderHit(hit: ControllerColliderHit){

puis ajoutez l’instruction if suivante sur la ligne en dessous :

if(hit.collider.gameObject == GameObject.Find("campire")){

Cette condition permettra de vériier si le joueur touche l’objet campfire. Toutefois, vous
devez également vériier que le joueur dispose des allumettes. Pour cela, ajoutez les lignes
suivantes à l’intérieur de cette instruction if :
Chapitre 7 Systèmes de particules 209

if(haveMatches){
haveMatches = false;
lightFire();
}else{
TextHints.textOn=true;
TextHints.message = "vous avez besoin d’allumettes pour allumer ce feu...";
}

Ici, le script vériie si la variable haveMatches est true. Si ce n’est pas le cas (else), il
utilise le script TextHints pour aficher l’interface graphique TextHint GUI qui indique au
joueur ce qu’il doit faire.
Si haveMatches est true, le script appelle une fonction lightire(), que vous allez écrire,
pour lancer la lecture de la séquence audio et déclencher les systèmes de particules. Placez-
vous à la in du script et ajoutez la fonction suivante avant la ligne @script :
function lightFire(){
var campire : GameObject = GameObject.Find("campire");
var campSound : AudioSource = campire.GetComponent(AudioSource);
campSound.Play();

var lames : GameObject = GameObject.Find("FireSystem");

var lameEmitter : ParticleEmitter = lames.GetComponent(ParticleEmitter);
lameEmitter.emit = true;

var smoke : GameObject = GameObject.Find("SmokeSystem");

var smokeEmitter : ParticleEmitter = smoke.GetComponent(ParticleEmitter);
smokeEmitter.emit = true;

Destroy(GameObject.Find("matchGUI"));
}

Cette fonction réalise quatre opérations :

∑ Elle lance la lecture de la boucle audio pour le feu.
∑ Elle déclenche le système de particules Fire.
∑ Elle déclenche le système de particules Smoke.
∑ Elle supprime l’interface graphique Matches GUI de l’écran pour indiquer que les
allumettes ont été utilisées.
Pour les trois premières opérations, le script doit créer une variable pour représenter l’objet
auquel il s’adresse, par exemple :
var campire : GameObject = GameObject.Find("campire");
210 Développez des jeux 3D avec Unity

Cette ligne nomme la variable, déclare son type de données sur GameObject et utilise la
commande Find pour la déinir comme égale à l’objet de jeu campire.
Puis il s’adresse à un composant spéciique de cet objet à l’aide de la variable qui vient
d’être établie et de la commande GetComponent :
var campSound : AudioSource = campire.GetComponent(AudioSource);

On déclare là encore une nouvelle variable pour représenter le composant, on ixe son type
de données sur AudioSource et on utilise cette variable pour appeler une commande :
campSound.Play();

Comme la commande Play est spéciique aux composants Audio Source, Unity sait exac-
tement quoi faire et lance simplement la lecture de la séquence audio assignée dans le
panneau Inspector.
La méthode est la même dans la deuxième et dans la troisième opération, sauf que le script
concerne le paramètre emit du composant Particle Emitter, comme à la ligne suivante :
lameEmitter.emit = true;

Enin, cette fonction exécute la commande Destroy(), qui trouve tout simplement l’objet
GUI qui afiche la boîte d’allumettes, autrement dit l’objet nommé matchGUI à l’instan-
ciation (reportez-vous à la section "La collecte des allumettes").
Cliquez sur File > Save dans l’éditeur de script et revenez dans Unity.
Comme vous avez créé une variable publique pour l’élément préfabriqué MatchGUIprefab
dans le script PlayerCollisions, vous devez maintenant lui assigner une valeur. Cliquez
sur les lèches grises qui précèdent tous les objets parents dans le panneau Hierarchy pour
que seuls ceux-ci restent afichés, puis sélectionnez l’objet First Person Controller ain
d’aficher ses composants dans le panneau Inspector.
Localisez le composant Player Collisions (script) puis faites glisser l’élément préfabri-
qué MatchGUIprefab à partir du dossier Fire feature du panneau Project sur la variable
publique Match GUI.
Félicitations ! Le feu est maintenant terminé. Cliquez sur File > Save Scene dans Unity
pour sauvegarder votre projet.

Tests et conirmation
Chaque fois que vous modiiez votre jeu, il est essentiel d’effectuer des tests. Au Chapitre 9,
vous verrez comment optimiser le jeu, comment vous assurer que les tests fonctionnent
comme ils sont censés le faire, ainsi que différentes options pour diffuser votre jeu.
Chapitre 7 Systèmes de particules 211

Pour l’instant, vous devez vous assurer que votre jeu fonctionne normalement. Même si
aucune erreur ne s’est afichée dans la console de Unity (pour l’aficher, appuyez sur Cmd/
Ctrl+Maj+C), vous devez toujours vous assurer qu’aucune erreur ne se produit pendant les
différentes étapes de la partie.
Cliquez sur le bouton Play puis collectez les piles, lancez les noix de coco, récupérez la
boîte d’allumettes et allumez le feu pour vous assurer que tous ces éléments fonctionnent.
Si une erreur se produit, vériiez que vos scripts correspondent bien à ceux indiqués dans
cet ouvrage.

En cas d’erreurs pendant les tests, le bouton PauSe situé en haut de l’interface
Info de Unity permet de mettre le jeu en pause, de regarder l’erreur indiquée dans
la console, puis de relancer le jeu. Lorsqu’une erreur s’afiche dans la console,
double-cliquez dessus pour aficher la ligne du script qui la contient ou, du
moins, l’emplacement où le script rencontre un problème.
De là, vous pouvez diagnostiquer l’erreur ou vériier le script à l’aide du manuel
de référence Scripting Manual de Unity pour vous assurer que votre approche
est la bonne. Si vous ne parvenez pas à résoudre les erreurs, demandez de l’aide
sur les forums de la communauté Unity ou sur le canal IRC. Pour de plus amples
renseignements, consultez la page suivante :
http://unity3d.com/support/community.

En résumé
Vous venez de voir comment intégrer les particules pour donner une touche plus dynamique
à votre jeu. Les particules s’utilisent dans de nombreuses situations de jeu différentes, qu’il
s’agisse de représenter la fumée qui s’échappe du pot d’échappement d’une voiture, des
tuyères des vaisseaux spatiaux, du canon des armes à feu, ou encore la vapeur des systèmes
de ventilation. La meilleure façon d’en apprendre plus sur ce sujet consiste à effectuer
des essais. Les paramètres sont nombreux, si bien qu’il vous faudra un certain temps pour
savoir ce que vous pouvez réaliser et pour obtenir les meilleurs résultats.
Au prochain chapitre, vous allez voir comment créer des menus pour votre jeu. Pour cela,
vous utiliserez la classe GUI de Unity dans vos scripts, les ressources GUI Skin et vous
créerez des comportements pour vos interfaces. La classe GUI est un élément particulier
du moteur de Unity utilisé spéciiquement pour créer des menus, des HUD (Heads Up
Displays, afichage tête haute). En combinant la classe GUI et les ressources GUI Skin,
vous pouvez créer des éléments totalement personnalisables et réutilisables. Les ressources
GUI Skin peuvent en effet être appliquées à autant de scripts de la classe GUI que vous le
souhaitez. Vous pouvez ainsi créer un style cohérent dans tous vos projets Unity.
 8
Conception de menus
Ain de créer un exemple de jeu complet, vous allez voir au long de ce chapitre comment
créer une scène distincte de la scène de l’île qui servira de menu. Plusieurs méthodes exis-
tent pour concevoir des menus dans Unity, qui combinent des comportements intégrés et
des textures 2D.
Les composants GUI Texture s’utilisent pour les écrans de démarrage incluant les logos
des développeurs ou les écrans de chargement. Par contre, pour les menus interactifs, deux
manières différentes sont possibles. La première repose sur l’utilisation des composants
GUI Texture – que vous avez étudiés au Chapitre  6, "Instanciation et corps rigides",
pour ajouter un viseur, et au chapitre précédent, pour aficher la boîte d’allumettes. L’autre
méthode se base sur les classes UnityGUI et sur les ressources GUI skin pour créer une
interface graphique personnalisée.
Au cours de ce chapitre, vous apprendrez à :
∑ concevoir une interface de deux manières différentes ;
∑ contrôler les composants GUI Texture avec des événements souris scriptés ;
∑ rédiger un script simple UnityGUI ;
214 Développez des jeux 3D avec Unity

∑ paramétrer les ressources GUI skin ;

∑ charger les scènes, les menus et le niveau de jeu.
Vous découvrirez deux méthodes pour ajouter des menus interactifs :
∑ Méthode 1 : composants GUI Texture et contrôle des événements souris par le script.
Cette méthode consiste à créer des objets GUI Texture puis à gérer l’afichage de
leurs textures à l’aide de scripts basés sur les événements souris – survol du menu, clic,
bouton relâché. Elle nécessite moins de code pour créer les boutons eux-mêmes, mais
toutes les actions doivent être contrôlées par des scripts.
∑ Méthode 2 : classe UnityGUI et ressources GUI skin. Avec cette méthode, la totalité du
menu est créée à l’aide de scripts, contrairement à la précédente dans laquelle on crée
des objets de jeu.
La création des éléments de menu demande donc plus de code au début, mais des
ressources GUI skin peuvent être créées pour déinir l’apparence et le comportement
des éléments dans le panneau Inspector.
Les développeurs préfèrent généralement la seconde méthode pour créer des menus de
jeu complet en raison de sa plus grande lexibilité. Les éléments du menu eux-mêmes
sont créés dans le script, mais leur aspect est déini à l’aide des composants GUI. Cela est
comparable à l’utilisation du code HTML et des CSS lors de la conception de pages web
– les CSS (Cascading Style Sheets, feuilles de styles en cascade) contrôlent l’apparence
tandis que le code HTML fournit le contenu.
Vous verrez que les composants GUI appliquent certaines conventions des CSS, pour les
marges, le padding et la justiication, ce qui vous sera utile si vous avez une expérience du
développement web. Cependant, ne vous inquiétez pas si ce n’est pas le cas ; à l’instar de la
plupart des fonctionnalités de Unity, les paramètres des composants GUI sont conçus pour
qu’un minimum de connaissances préalables soit nécessaire.

Les interfaces et les menus

Les menus servent le plus fréquemment pour déinir les contrôles et ajuster les paramètres
du jeu – les options graphiques et sonores – ou pour charger ou sauvegarder une partie.
Quel que soit le jeu, il est essentiel que le menu qui l’accompagne ne gêne pas l’accès au
jeu ou à l’un de ses paramètres. C’est avant tout du jeu lui-même dont on se souvient, à
moins que les menus ne soient particulièrement réussis ou mal conçus.
Les développeurs cherchent souvent à relier le menu du jeu au thème ou au principe du jeu.
Par exemple, dans l’excellent World of Goo de 2D Boy, le curseur prend l’apparence d’une
boule de Goo (les petites créatures rondes du jeu) suivie d’une traînée lumineuse dans les
Chapitre 8 Conception de menus 215

menus ain de créer un lien visuel entre le concept du jeu et son interface. Ainsi, la navi-
gation dans le menu d’ouverture permet déjà au joueur de s’amuser.
Dans LittleBigPlanet de Media Molecule, ce concept est poussé encore plus loin, puisque
le joueur doit apprendre à contrôler le personnage jouable pour pouvoir naviguer dans le
menu.
Comme pour toute création, l’important est de rester cohérent. Dans notre exemple, vous
devez veiller à utiliser des couleurs et une typographie en harmonie avec le contenu du jeu.
Vous avez peut-être déjà rencontré des jeux mal conçus et qui utilisent trop de polices de
caractères différentes ou trop de couleurs qui jurent. Or, le menu étant le premier élément
que le joueur découvre, ces erreurs créent d’emblée un sentiment peu agréable et nuisent à
la viabilité commerciale du jeu.
Les textures employées pour créer le menu de notre exemple de jeu sont disponibles sur
la page web consacrée à cet ouvrage (www.pearson.fr). Décompressez si nécessaire
le ichier nommé Menu.unitypackage puis revenez dans Unity. Cliquez sur Assets  >
Import package, parcourez votre disque dur jusqu’à l’emplacement de ces ressources et
importez-les.
Une fois l’importation terminée, un dossier Menu s’afiche dans le panneau Project.
Il contient les éléments suivants :
∑ des textures pour le menu principal du jeu et trois boutons  : Play, Instructions et
Quit ;
∑ une séquence audio (un bip pour les boutons de l’interface).

Créer le menu principal

À cette section, vous utiliserez l’île elle-même comme toile de fond de vos menus ain de
donner aux joueurs un avant-goût de l’environnement qu’ils exploreront et de ixer le cadre
visuel du jeu.
Vous allez dupliquer l’île existante, l’aficher en plaçant une caméra à une certaine distance,
puis vous superposerez des éléments d’interface  2D en utilisant les deux méthodes que
nous avons mentionnées au début de ce chapitre.

Créer la scène
Pour ces menus, l’environnement insulaire que vous avez créé va vous servir. En plaçant
l’île à l’arrière-plan dans le menu, vous éveillerez la curiosité du joueur en lui présentant
l’environnement qu’il pourra explorer lors du lancement de la partie. Ce type d’incitation
216 Développez des jeux 3D avec Unity

visuelle peut sembler anodin, mais cela encourage le joueur à tester le jeu de manière quasi
subliminale.

Un exemple visuel
La Figure 8.1 montre l’aspect qu’aura votre menu une fois terminé. Cet exemple est obtenu
en suivant la méthode 1 ; les éléments de menu créés avec la méthode 2 auront un aspect
différent.

Figure 8.1

Dupliquer l’île
Pour commencer, vous réutiliserez la scène Island Level que vous avez créée aux chapitres
précédents. Pour faciliter la gestion des éléments, vous regrouperez les ressources essen-
tielles de cet environnement ain de les distinguer des objets dont vous n’avez pas besoin,
comme l’avant-poste et les piles. De cette façon, il vous sufira ensuite de tout supprimer
à l’exception du groupe que vous allez créer dans la copie du niveau. Il est aussi facile de
regrouper des éléments dans Unity que d’imbriquer des objets enfants dans un objet parent
vide.
Chapitre 8 Conception de menus 217

Regrouper les objets de l’environnement

Cliquez sur Game Object > Create Empty.
Un nouvel objet nommé GameObject est alors créé. Renommez-le Environment.
Dans le panneau Hierarchy, faites glisser les objets Directional Light, Daylight
Simple Water et Terrain sur l’objet vide Environment. Vous êtes maintenant prêts à
dupliquer ce niveau pour créer le menu dans une scène distincte.

Dupliquer la scène
Suivez les étapes suivantes pour dupliquer la scène :
1. Cliquez sur File > Save Scene pour vous assurer que la scène Island Level est
enregistrée, puis sélectionnez la ressource Island Level dans le panneau Project.
2. Cliquez sur Edit > Duplicate ou utilisez les raccourcis clavier Cmd/Ctrl+D. Lors
de la duplication, Unity ajoute simplement un numéro au nom de l’objet ou de la
ressource, si bien que cette copie est baptisée Island Level 1. Assurez-vous qu’elle est
sélectionnée dans le panneau Project puis renommez-la Menu.
3. Double-cliquez sur cette scène dans le panneau Project pour la charger et commencer
à la modiier.
4. La scène Menu étant ouverte, vous pouvez maintenant supprimer tous les objets
inutiles. Appuyez sur Cmd/Ctrl puis cliquez sur tous les objets dans le panneau
Hierarchy à l’exception du groupe Environment pour les sélectionner.
5. Appuyez sur Cmd+Retour arrière (Mac  OS) ou Maj+Suppr (Windows) pour les
supprimer de cette scène.
Comme l’illustre la Figure  8.1, l’île apparaîtra vue de loin et dans le coin inférieur de
l’écran dans le menu, tandis que le titre du jeu et le menu s’aficheront en surimpression
du ciel et de la mer. Pour reproduire cela, vous devez ajouter une nouvelle caméra dans la
scène, car la seule caméra existante était celle attachée à l’objet First Person Control-
ler. Il n’y a donc aucune caméra dans la scène actuelle, rien qui permette de visualiser le
monde 3D, si bien que le point de vue dans le panneau Game est maintenant complètement
vide.
Pour créer une caméra, cliquez sur GameObject > Create Other > Camera. Assurez-
vous que ce nouvel objet Camera est sélectionné dans le panneau Hierarchy, puis entrez
les valeurs de Position suivantes dans le composant Transform du panneau Inspector :
(150, 250, –650).
218 Développez des jeux 3D avec Unity

Annuler le mip mapping

Le mip mapping est une technique permettant de générer de plus petites versions de textures
distantes dans un moteur de jeu, ce qui améliore les performances (jusqu’à 33  % dans
le moteur de Unity). Toutefois, il ne s’applique qu’aux textures intégrées dans le monde
en 3D et non aux textures 2D comme celles que vous allez utiliser pour le titre et les trois
boutons de menu. Vous devez donc désactiver cette fonction dans les paramètres d’impor-
tation de chaque ressource.
Commencez par sélectionner le ichier de texture MainTitle dans le dossier Menu du
panneau Project pour aficher les paramètres d’importation de cette texture dans le
panneau Inspector. Désactivez ensuite l’option Generate Mip Maps.
Répétez cette étape pour les textures suivantes dans le dossier Menu :
∑ InstructionsBtn
∑ InstructionsBtnOver
∑ PlayBtn
∑ PlayBtnOver
∑ QuitBtn
∑ QuitBtnOver

Ajouter le titre
Maintenant, vous avez besoin d’un logo pour le jeu. Le plus simple consiste à partir d’une
texture que vous avez conçue et à la déinir comme un objet GUI Texture dans Unity.

Les formats des objets GUI Textures

Sélectionnez la texture MainTitle dans le dossier Menu du panneau Project. Cette
texture créée dans Photoshop est enregistrée au format TIFF (Tagged Image File Format),
un format qui convient pour toutes les textures que vous comptez utiliser pour vos inter-
faces graphiques. Il prend en charge la transparence en haute qualité non compressée, ce
qui permet d’éviter certains problèmes avec les contours blancs que présentent les formats
GIF (Graphics Interchange Format) ou PNG (Portable Network Graphics) notamment.

Créer les objets

Cette texture toujours sélectionnée, cliquez sur GameObject  > Create Other  > GUI
Texture pour créer un nouvel objet GUI Texture basé sur cette texture. Nous l’avons
Chapitre 8 Conception de menus 219

déjà vu, les dimensions de la texture sélectionnée sont automatiquement déinies. Un

nouvel objet, MainTitle, s’afiche dans le panneau Hierarchy (l’objet prend le nom du
ichier sélectionné lors de sa création).

Positionnement
La plupart des ordinateurs actuels sont capables de gérer des résolutions égales ou supé-
rieures à 1 024 × 768 pixels. Vous allez donc utiliser cet objet comme une norme pour tester
votre menu. Vous déinirez sa position de façon dynamique avec la classe Screen, ain que
cela fonctionne dans d’autres résolutions. Le menu déroulant situé dans le coin supérieur
gauche du panneau Game (voir Figure 8.2) permet de spéciier différents ratios d’écran et
résolutions. Cliquez dessus et sélectionnez Standalone (1024  ×  768) pour aficher un
aperçu de cette résolution.

Figure 8.2

Gardez à l’esprit que si la résolution de votre propre ordinateur est proche de

ce celle que vous sélectionnez, le panneau Game n’afichera pas un aperçu exact
Astu
mais une version plus petite de l’image, car l’interface de Unity occupe une
petite partie de l’écran.
Pour aficher le panneau Game en mode plein écran (ainsi que tous les panneaux
de l’interface de Unity) et le réduire, placez le curseur dessus, puis appuyez
sur la barre d’espacement. Lorsque vous positionnez des éléments d’interface
graphique, cette méthode vous permet de prévisualiser l’apparence de cette
interface dans le jeu ini.

Par défaut, tous les objets GUI Texture se placent à (0.5, 0.5, 0), ce qui correspond au
milieu de l’écran. On se souvient que les éléments 2D utilisent les coordonnées de l’écran
comprises entre 0 et 1.
Déinissez la position de l’objet MainTitle à (0.5, 0.8, 0) dans le composant Transform
du panneau Inspector pour placer le logo du titre principal du jeu en haut et au centre
de l’écran. Maintenant, vous allez ajouter trois boutons à l’aide d’objets GUI Texture
supplémentaires.
220 Développez des jeux 3D avec Unity

La création du menu – méthode 1

Avec cette première méthode, vous créerez un menu avec une texture de fond transparente
comme GUI Texture, de la même manière que vous venez de le faire avec le logo du titre
principal.
Vous aurez ensuite besoin d’écrire un script ain que la texture puisse recevoir les événe-
ments souris (lorsque le curseur survole ou quitte le bouton et lorsque le joueur clique ou
relâche le bouton de la souris).

Ajouter le bouton Play/Jouer

Sélectionnez la texture PlayBtn dans le dossier Menu du panneau Project, puis cliquez
sur GameObject > Create Other > GUI Texture. Sélectionnez l’objet PlayBtn que
vous venez de créer dans le panneau Hierarchy et réglez sa position dans le composant
Transform du panneau Inspector à (0.5, 0.6, 0).

Le script du bouton GUI Texture

Comme il s’agit du premier des trois boutons que vous allez créer et qu’ils auront tous
des fonctions en commun, ce script pourra être utilisé pour les trois boutons. Pour cela,
vous choisirez des variables publiques pour déinir les différents paramètres. Ainsi, chaque
bouton doit :
∑ lancer la lecture d’un son lors du clic ;
∑ charger un autre niveau (ou une scène, selon la terminologie de Unity) lors du clic ;
∑ changer de texture lorsque la souris le survole pour être mis en évidence.
Sélectionnez le dossier Scripts dans le panneau Project, cliquez sur le bouton Create et
sélectionnez JavaScript dans le menu déroulant. Renommez le script MainMenuBtns, puis
double-cliquez sur son icône pour l’ouvrir dans l’éditeur de script.
Commencez par déclarer les quatre variables publiques suivantes au début du script :
var levelToLoad : String;
var normalTexture : Texture2D;
var rollOverTexture : Texture2D;
var beep : AudioClip;

La première variable stockera le nom du niveau à charger lorsque le joueur cliquera sur le
bouton sur lequel ce script est appliqué. Le fait de placer ces informations dans une variable
Chapitre 8 Conception de menus 221

permet d’appliquer ce script à tous les boutons, puisque le niveau à charger est déini par
le nom de la variable.
Les deuxième et troisième variables sont déclarées comme des variables de type Texture2D.
Aucune texture en particulier n’est déinie ain qu’elles puissent être assignées ensuite par
glisser-déposer dans le panneau Inspector.
Enin, la variable de type AudioClip permet de lancer la lecture d’un son au clic de la souris.
Ajoutez maintenant la fonction suivante pour déinir la texture utilisée par le composant
GUI Texture lorsque le curseur survole la zone que la texture occupe (on appelle généra-
lement cet état rollover ou survolé) :
function OnMouseEnter(){
guiTexture.texture = rollOverTexture;
}

Le paquet de ressources Menu que vous avez importé contient une texture pour l’état normal
et l’état survolé de chaque bouton. Cette fonction OnMouseEnter() déinit simplement que
la texture utilisée dans le composant correspond à la valeur attribuée à la variable publique
rollOverTexture dans le panneau Inspector. Ain de savoir quand le curseur s’éloigne ou
sort de la limite de cette texture, ajoutez la fonction suivante :
function OnMouseExit(){
guiTexture.texture = normalTexture;
}

Sans cette seconde fonction, la texture rollOverTexture resterait afichée. Le joueur verrait
alors cette option de menu toujours en surbrillance.
Pour gérer le son et le chargement de la scène appropriée, ajoutez la fonction suivante :
function OnMouseUp(){
audio.PlayOneShot(beep);
yield new WaitForSeconds(0.35);
Application.LoadLevel(levelToLoad);
}

La première commande concerne le son. Elle permet d’être sûr qu’il se lancera avant le
chargement de la scène suivante et qu’il ne sera pas coupé. La commande yield placée
entre le déclenchement du son et le chargement de la scène suivante indique au script de
faire une pause du nombre déini de secondes. Vous pouvez ainsi créer rapidement un délai
sans devoir utiliser une commande timer.
La commande yield sert ici à créer un retard, mais elle peut également servir à exécuter
tout un ensemble d’instructions avant la ligne de code suivante. En programmation, on
222 Développez des jeux 3D avec Unity

appelle cette unité de traitement une coroutine pour la distinguer des autres procédures –
les routines.
Ensuite, la commande Application.LoadLevel() charge la scène dans le jeu, en utilisant
la valeur de la variable publique levelToLoad indiquée dans le panneau Inspector pour
trouver le ichier approprié.

Pour les interfaces, il est généralement conseillé de déclencher les actions

ce lorsque le bouton de la souris est relâché (mouse up) plutôt qu’au moment du
Astu
clic (mouse down). Cela permet au joueur de déplacer le curseur sans valider
lorsqu’il s’est trompé et a sélectionné le mauvais élément.

Comme vous lancez la lecture d’un son, vous devez vous assurer que l’objet possède
un composant AudioSource en ajoutant la ligne RequireComponent suivante à la in du
script :
@script RequireComponent(AudioSource)

Cliquez sur File > Save dans l’éditeur de script puis revenez dans Unity. Sélectionnez
l’objet PlayBtn dans le panneau Hierarchy, puis cliquez sur Component > Scripts >
Main Menu Btns pour lui appliquer le script que vous venez d’écrire. Le script doit alors
apparaître sur la liste des composants de l’objet PlayBtn dans le panneau Inspector. En
raison de la ligne RequireComponent, l’objet dispose également d’un composant Audio
Source.

Assigner des variables publiques

Les variables publiques doivent être assignées avant que le script ne puisse fonctionner.
Entrez le nom Island Level dans le champ de la variable Level To Load, ain que ce niveau
se charge lorsqu’on clique sur le bouton. Faites ensuite glisser les textures PlayBtn et
PlayBtnOver depuis le dossier Menu du panneau Project sur les variables Normal
Texture et Roll Over Texture respectivement. Enin, faites glisser la séquence audio
menu_beep du même dossier sur la variable Beep. Une fois terminé, le composant doit être
identique à celui de la Figure 8.3.

Figure 8.3
Chapitre 8 Conception de menus 223

Tester le bouton
Cliquez sur le bouton Play pour tester la scène. Lorsque vous placez le curseur sur le
bouton Play Game, la texture PlayBtnOver doit s’aficher (le texte s’afiche en couleur
et s’accompagne d’un motif de lamme sur la droite). Lorsque vous éloignez le curseur du
bouton, la texture par défaut doit s’aficher de nouveau.
Cliquez maintenant sur le bouton. Le message suivant s’afiche alors dans la console
d’erreur au bas de l’écran :
Level Island Level couldn’t be loaded because it is not added to the build
settings (Le niveau Island Level n’a pas pu être chargé car il n’est pas ajouté aux
paramètres Build).
Unity cherche ainsi à s’assurer que vous n’oublierez pas d’ajouter tous les niveaux inclus
dans les paramètres Build Settings. Ces paramètres de compilation correspondent aux
paramètres d’exportation de votre jeu ini ou de la version de test. Ils doivent contenir
la liste de toutes les scènes incluses dans le jeu. Pour corriger cette erreur, cliquez sur le
bouton Play pour arrêter le test du jeu puis sur File > Build Settings.
À la section Scenes to build du panneau Build Settings, cliquez sur le bouton Add
Current pour ajouter la scène Menu sur laquelle vous travaillez actuellement. L’ordre
des scènes sur la liste, représenté par le nombre à droite du nom de la scène, indique l’ordre
dans lequel ces scènes apparaîtront dans le jeu. Vous devez vous assurer que la première
scène qui se chargera sera toujours en position 0.
Faites glisser la scène Island Level du panneau Project sur la liste actuelle des scènes
du panneau Build Settings ain qu’elle apparaisse sous la scène Menu.unity (voir
Figure 8.4).

Figure 8.4

Le panneau Build Settings n’afiche aucun message de conirmation ou de bouton

permettant de sauvegarder les paramètres. Fermez-le, cliquez sur le bouton Play puis sur
le bouton Play Game dans Unity pour tester le jeu. La scène Island Level doit se charger
224 Développez des jeux 3D avec Unity

après la lecture du son menu_beep. Cliquez de nouveau sur le bouton Play pour arrêter le
test et revenir à la scène Menu.

Ajouter le bouton des instructions

Pour ajouter le deuxième bouton, il vous sufit de sélectionner la texture InstructionsBtn
dans le dossier Menu du panneau Project puis de cliquer sur GameObject  > Create
Other > GUI Texture. Un deuxième objet nommé InstructionsBtn est créé dans le
panneau Hierarchy. Déinissez sa position à (0.5, 0.5, 0) dans le composant Transform
du panneau Inspector.
Comme vous avez déjà écrit le script nécessaire, cliquez simplement sur Component >
Scripts > Main Menu Btns pour l’ajouter à ce bouton, puis assignez les textures appro-
priées et la séquence audio menu_beep de la même manière que vous l’avez fait pour le
bouton précédent. La scène que ce bouton permettra de charger n’est pas encore créée,
aussi entrez Instructions pour la variable levelToLoad (vous veillerez à nommer ainsi cette
scène plus tard).

Ajouter le bouton Quit/Quitter

Ce bouton fonctionne de manière analogue aux deux premiers, mais il ne charge pas de
scène. Au contraire, il appelle la classe Application et utilise la commande Quit() pour
fermer le jeu, comme les boutons permettant de quitter une application sur un système
d’exploitation.
Vous devez par conséquent modiier le script MainMenuBtns pour tenir compte de cette
différence. Double-cliquez sur ce script dans le dossier Scripts du panneau Project pour
l’ouvrir dans l’éditeur de script.
Commencez par ajouter la variable booléenne publique suivante au début du script :
var QuitButton : boolean = false;

Lorsque cette variable sera déinie à true, le clic du bouton – la fonction OnMouseUp() –
exécutera la commande quit(). Lorsqu’elle sera déinie à false – son état par défaut – le
niveau assigné à la variable levelToLoad se chargera.
Pour cela, vous devez restructurer la fonction OnMouseUp() avec une instruction if else,
comme le montre l’extrait de code suivant :
function OnMouseUp(){
audio.PlayOneShot(beep);
yield new WaitForSeconds(0.35);
if(QuitButton){
Chapitre 8 Conception de menus 225

Application.Quit();
}
else{
Application.LoadLevel(levelToLoad);
}
}

La fonction ainsi modiiée lance la lecture du son et la commande yield (pause) quel
que soit le bouton sur lequel on a cliqué. Toutefois, il existe maintenant deux options  :
si quitButton est true, alors la commande Application.Quit() est appelée ; dans le cas
contraire (else), le niveau est chargé normalement.
Cliquez sur File > Save dans l’éditeur de script puis revenez dans Unity.
Sélectionnez la texture QuitBtn dans le dossier Menu du panneau Project puis cliquez
sur GameObject > Create Other > GUI Texture pour créer un objet nommé QuitBtn
dans le panneau Hierarchy. Déinissez ensuite sa position à (0.5, 0.4, 0) dans le composant
Transform du panneau Inspector.
L’objet QuitBtn étant toujours sélectionné dans le panneau Hierarchy, cliquez sur
Component > Scripts > Main Menu Btns pour lui attacher le script. Déinissez ensuite
les valeurs des variables publiques dans le panneau Inspector comme précédemment, en
laissant vide le champ de la variable level To Load, puis activez l’option de la nouvelle
variable Quit Button.
Voici le script dans son intégralité pour que vous puissiez vériier le vôtre :
var levelToLoad : String;
var normalTexture : Texture2D;
var rollOverTexture : Texture2D;
var beep : AudioClip;
var QuitButton : boolean = false;
function OnMouseEnter(){
guiTexture.texture = rollOverTexture;
}
function OnMouseExit(){
guiTexture.texture = normalTexture;
}
function OnMouseUp(){
audio.PlayOneShot(beep);
yield new WaitForSeconds(0.35);
if(QuitButton){
Application.Quit();
}
else{
226 Développez des jeux 3D avec Unity

Application.LoadLevel(levelToLoad);
}
}
@script RequireComponent(AudioSource)

Cliquez maintenant sur File > Save Scene, pour mettre à jour le projet, puis sur le bouton
Play pour tester le menu. La scène Island Level doit se charger lorsque vous cliquez sur
le bouton Play Game. Un clic sur le bouton Instructions entraîne l’afichage de l’erreur
"level could not be loaded" (le niveau ne peut pas être chargé), comme nous l’avons vu
précédemment, puisque cette scène n’a pas encore été créée. Le bouton Quit Game ne
provoque aucune erreur mais ne produit aucun effet dans Unity ; vous ne pourrez pas tester
son fonctionnement tant que vous n’aurez pas créé une version complète du jeu.
N’oubliez pas de cliquer de nouveau sur le bouton Play pour terminer le test. La création
d’un menu par la première méthode est terminée.

Utiliser les commandes de débogage pour vériier les scripts

Bien que la commande Application.Quit() ne produise aucun effet dans l’éditeur de
Unity, vous devez tout de même vous assurer que le bouton Quit fonctionne. Pour tester
une partie d’un script, il vous sufit de la placer dans une commande de débogage pour
envoyer un message à la console d’erreur de Unity qui s’afiche au bas de l’interface.
Revenez au script MainMenuBtns dans l’éditeur de script, puis localisez la partie du
script qui concerne le bouton quitButton :
if(QuitButton){
Application.Quit();
}

Une commande de débogage peut être enregistrée sur une liste pour aficher des messages
dans la console d’erreur. Elle se présente généralement comme suit :
Debug.Log("Cette partie fonctionne !");

En écrivant cette ligne de code à l’endroit où vous prévoyez que le script s’exécutera, vous
pouvez découvrir si certaines parties de celui-ci fonctionnent effectivement. Si vous la
placez après la commande Application.Quit() dans notre exemple, vous aurez alors la
preuve que la commande s’exécute sans problème. Ajoutez cette ligne à votre script comme
dans l’extrait de code suivant :
if(QuitButton){
Application.Quit();
Debug.Log("Cette partie fonctionne !");
}
Chapitre 8 Conception de menus 227

Cliquez sur File > Save dans l’éditeur de script pour enregistrer le script, puis revenez dans
Unity. Cliquez sur le bouton Play pour tester de nouveau le menu. Cliquez sur le bouton
Quit Game pour aficher le message de la commande de débogage au bas de l’interface
de Unity. Si nécessaire, appuyez sur Cmd/Ctrl+Maj+C pour ouvrir la console de Unity et
aficher le message (voir Figure 8.5).

Figure 8.5

Cette technique peut être très utile pour diagnostiquer des problèmes dans les scripts. Elle
l’est aussi lorsque vous concevez un script de façon théorique sans indiquer les véritables
commandes.
Vous allez maintenant voir comment créer un menu fonctionnel à l’aide de la fonction
OnGUI() (cette fonction est appelée GUI 2.0 system dans Unity car elle est apparue dans
la version 2.0 du programme).

La création du menu – méthode 2

Comme vous disposez déjà d’un menu fonctionnel, vous allez désactiver temporairement
les objets qui le composent plutôt que de le supprimer de la scène. De cette manière, vous
pourrez choisir le menu que vous préférez par la suite.

Désactiver les Game Objects

Sélectionnez l’objet PlayBtn dans le panneau Hierarchy, puis décochez la case située à
gauche de son nom dans le panneau Inspector pour le désactiver.
Répétez ensuite l’opération pour les objets InstructionsBtn et QuitBtn.
Assurez-vous que le nom de chacun de ces objets s’afiche en gris clair dans le panneau
Hierarchy et qu’ils ont disparu dans l’aperçu du panneau Game.
228 Développez des jeux 3D avec Unity

Rédiger un script OnGUI() pour un menu simple

Cliquez sur GameObject > Create Empty pour créer un objet vide GameObject dans le
panneau Hierarchy. Cet objet possède uniquement un composant Transform, que vous
utiliserez pour stocker le menu GUI 2.0. Puisque le script que vous allez écrire doit être
attaché à un composant pour fonctionner, il est plus pratique et logique de disposer d’un
objet spécialement pour cette tâche.
Comme la position des éléments OnGUI est gérée par un script, c’est inutile d’ajuster les
valeurs de position du composant. Renommez simplement l’objet Menu2.
Sélectionnez le dossier Scripts dans le panneau Project, cliquez sur le bouton Create puis
choisissez JavaScript. Renommez ce script MainMenuGUI2 puis double-cliquez sur son
icône pour l’ouvrir dans l’éditeur de script.

Les classes GUI et GUI Layout

Pour cet exemple, vous emploierez la classe GUI Layout de Unity, car elle dispose de plus
d’options de positionnement que la classe GUI, dont la position est ixe.
De nombreux développeurs préfèrent la classe GUI Layout car elle dispose automatique-
ment les éléments comme les formulaires et les boutons, les uns en dessous des autres.
Elle permet donc au développeur de consacrer plus de temps à déinir leur aspect à l’aide
la ressource GUI skin qui, lorsqu’elle est appliquée à un script OnGUI(), fonctionne d’une
manière analogue aux feuilles de styles utilisées pour la conception sur le Web.

Les variables publiques

Pour commencer le script, déclarez les quatre variables publiques suivantes :

var beep : AudioClip;
var menuSkin : GUISkin;
var areaWidth : loat;
var areaHeight : loat;

Ce script crée la même variable beep que dans la première méthode, puis une variable pour
la ressource GUI skin à appliquer et enin deux variables numériques permettant de déinir
la taille globale de la zone occupée par l’interface graphique.
Chapitre 8 Conception de menus 229

La fonction OnGUI()
Ajoutez ensuite la fonction suivante :
function OnGUI(){
GUI.skin = menuSkin;
}

Ainsi, l’aspect de tous les éléments GUI placés dans cette fonction OnGUI() (les boutons
et les formulaires, notamment) sera régi par le style de thème (skin) appliqué à la variable
menuSkin. Il est alors facile de permuter les skins et donc de modiier totalement l’appa-
rence de l’interface graphique en une seule opération.

Le positionnement lexible des interfaces graphiques

Vous devez maintenant déinir la zone qu’occuperont les boutons. Vous disposez déjà des
variables areaWidth et areaHeight, mais vous devez vous assurer que la zone rectangulaire
occupée par l’interface graphique tiendra compte de la résolution de l’écran sur lequel le
jeu s’exécutera.
Sans cela, l’interface graphique s’aficherait de façon différente selon la résolution, ce qui
semblerait assez peu professionnel. Vous allez donc créer quelques variables privées au
sein de la fonction OnGUI() qui stockeront le centre de l’écran. Vous n’avez pas besoin de
préixe private car vous déinissez ces variables à l’intérieur de la fonction  ; elles sont
implicitement privées.
Après la ligne GUI.skin que vous venez d’ajouter, déclarez les deux variables suivantes :
var ScreenX = ((Screen.width * 0.5) - (areaWidth * 0.5));
var ScreenY = ((Screen.height * 0.5) - (areaHeight * 0.5));

Leur valeur est égale au résultat d’une soustraction composée de deux parties :
((Screen.width * 0.5) - (areaWidth * 0.5));

Dans la ligne qui précède, (screen.width * 0.5) utilise le paramètre width (largeur) de la
classe Screen (écran) pour obtenir la largeur actuelle de l’écran. En divisant ensuite cette
valeur par deux, on obtient le centre de l’écran.

Notez que le script utilise * 0.5 plutôt que /2. En effet, une multiplication néces-
Info site environ cent cycles CPU de moins qu’une division pour obtenir des valeurs
dans Unity.
230 Développez des jeux 3D avec Unity

(areaWidth * 0.5) prend la largeur de la zone occupée par l’interface graphique et trouve
son centre en divisant cette valeur par deux. On soustrait ensuite celle-ci du centre de
l’écran car le point d’origine du tracé des zones GUI se trouve toujours à gauche. Cette
zone serait par conséquent décalée sur la droite si elle était tracée depuis le centre de l’écran
(voir Figure 8.6).

Figure 8.6 Centre de l'écran

Zone
GUI

Zone GUI
En soustrayant la moitié de la largeur de l’interface graphique, on obtient une position
centrale (voir Figure 8.7).

Figure 8.7
Centre de l'écran

Zone
GUI

Les deux parties de la somme sont placées entre parenthèses ain que la soustraction porte
sur leur résultat, qui devient la valeur de la variable. Ce processus se répète ensuite pour
une seconde variable, screenY, ain de déinir la position verticale de l’interface graphique.
Il est essentiel de déinir la zone occupée par l’interface graphique pour la classe GUILayout.
Sans cela, la fonction OnGUI() suppose que vous tracerez un menu sur toute la surface de
l’écran, depuis son coin supérieur gauche. Vous devez donc utiliser la commande Begin-
Area() et préciser quatre paramètres :
GUILayout.BeginArea(Rect(distance depuis la gauche de l’écran, distance depuis
le haut de l'écran, largeur, hauteur));

La commande Rect() déinit la zone rectangulaire qu’utilisera la commande BeginArea().

Vous pouvez indiquer la position de la zone rectangulaire à tracer avec les variables privées
ScreenX et ScreenY. Pour déinir sa largeur et sa hauteur, vous reprendrez les variables
publiques déclarées au début du script.
Chapitre 8 Conception de menus 231

Ajoutez la ligne suivante dans la fonction OnGUI() à la suite des deux variables privées que
vous venez de déclarer :
GUILayout.BeginArea (Rect (ScreenX,ScreenY, areaWidth, areaHeight));

Le dessin de la zone doit également être fermé à l’aide de la commande EndArea(). Cela
marquant la in du tracé de la zone, tout le code de l’interface graphique doit se trouver
avant cette ligne dans la fonction. Insérez plusieurs lignes après la commande BeginArea(),
puis ajoutez la ligne suivante pour terminer le tracé de l’interface graphique :
GUILayout.EndArea();

Ajouter des boutons UnityGUI

Pour créer le premier bouton, ajoutez les lignes suivantes avant la ligne EndArea() :
if(GUILayout.Button ("Play")){
OpenLevel("Island Level");
}

Un nouveau bouton GUILayout.Button est réalisé sur lequel est inscrit le mot Play. En
plaçant cette instruction dans une condition if, le script crée non seulement le bouton
mais indique également à Unity l’action à effectuer lorsqu’on clique dessus. Cette instruc-
tion appelle une fonction personnalisée nommée OpenLevel() possédant un seul paramètre
– le nom du niveau. Vous écrirez la fonction OpenLevel() une fois la fonction OnGUI()
complétée.
Ajoutez ensuite les deux conditions suivantes pour créer les deux autres boutons :
if(GUILayout.Button ("Instructions")){
OpenLevel("Instructions");
}
if(GUILayout.Button ("Quit")){
Application.Quit();
}

La deuxième condition if fait appel à la même fonction personnalisée OpenLevel() mais

transmet une chaîne de caractères différente à son seul paramètre – le nom du niveau
Instructions qui reste à créer.
Le bouton de la troisième condition if ne charge pas un niveau, mais appelle simplement la
commande Application.Quit(), comme dans la première méthode de création du menu.
232 Développez des jeux 3D avec Unity

Lancer des scènes à l’aide de fonctions personnalisées

Il vous faut maintenant écrire la fonction personnalisée qui sera appelée pour charger un
niveau en particulier. Placez-vous après l’accolade de fermeture de la fonction OnGUI(),
puis déclarez cette nouvelle fonction de la façon suivante :
function OpenLevel(level : String){
}

Cette fonction contient un paramètre nommé level de type String. Cela signiie que, tant
que l’on passe une chaîne de caractères pour appeler la fonction, on peut ensuite utiliser
le terme level pour désigner le texte transmis. Or, dans la fonction OnGUI(), vous venez
d’ajouter l’appel suivant :
OpenLevel("Island Level");

Dans cet exemple, les mots "Island Level" sont passés au paramètre level de la fonction
OpenLevel(). Notez qu’il est inutile d’écrire level = "Island Level" puisque le script
sait qu’il doit appliquer ce texte au paramètre de la fonction OpenLevel(). Une erreur
s’afiche si le type de données transmis n’est pas le bon (un chiffre ou un nom de variable,
par exemple), car seules les données de type String sont appropriées pour le paramètre
level.
Le script lira la chaîne de caractères transmise chaque fois que le paramètre level sera
utilisé.
Ajoutez maintenant les trois commandes suivantes dans cette fonction :
audio.PlayOneShot(beep);
yield new WaitForSeconds(0.35);
Application.LoadLevel(level);

Vous avez utilisé ces commandes dans la méthode 1. Vous pouvez vous y reporter, si néces-
saire, mais la différence essentielle à noter ici tient à l’utilisation du paramètre level pour
passer la chaîne de caractères dans la commande Application.LoadLevel(). Pour complé-
ter le script, assurez-vous que la séquence audio sera lancée en ajoutant la ligne Require-
Component habituelle à la in du script :

@script RequireComponent(AudioSource)

Cliquez sur File > Save dans l’éditeur de script et revenez dans Unity.
Voici le script en intégralité si vous souhaitez vériier que vous n’avez pas fait d’erreur :
var beep : AudioClip;
var menuSkin : GUISkin;
Chapitre 8 Conception de menus 233

var areaWidth : loat;

var areaHeight : loat;
function OnGUI(){
GUI.skin = menuSkin;
var ScreenX = ((Screen.width * 0.5) - (areaWidth * 0.5));
var ScreenY = ((Screen.height * 0.5) - (areaHeight * 0.5));
GUILayout.BeginArea (Rect (ScreenX,ScreenY, areaWidth, areaHeight));
if(GUILayout.Button ("Play")){
OpenLevel("Island Level");
}
if(GUILayout.Button ("Instructions")){
OpenLevel("Instructions");
}
if(GUILayout.Button ("Quit")){
Application.Quit();
}
GUILayout.EndArea();
}
function OpenLevel(level : String){
audio.PlayOneShot(beep);
yield new WaitForSeconds(0.35);
Application.LoadLevel(level);
}
@script RequireComponent(AudioSource)

Appliquer le script et modiier l’apparence du menu

De retour dans Unity, sélectionnez l’objet de jeu vide Menu2 dans le panneau Hierarchy,
puis cliquez sur Component > Scripts > Main Menu GUI2 pour ajouter ce script à cet
objet.
Faites glisser la séquence audio menu_beep depuis le dossier Menu dans le panneau
Project sur la variable publique Beep de ce script dans le panneau Inspector. Donnez
ensuite une valeur de 200 aux paramètres Area Width et Area Height.
Cliquez sur le bouton Play pour aficher le menu. Comme la classe GUI est compilée à
partir d’un script, son rendu s’effectue uniquement lorsque le jeu est testé. L’aspect du
menu que vous venez de créer avec le script est un peu terne (voir Figure 8.8).
234 Développez des jeux 3D avec Unity

Figure 8.8

Vous allez donc lui appliquer un style pour améliorer son apparence à l’aide des ressources
GUI skins.
Pour cela, une ressource GUI skin doit être assignée à la variable menuSkin. Sélectionnez
le dossier Menu dans le panneau Project, puis cliquez sur le bouton Create et sélection-
nez GUI Skin dans le menu déroulant. Renommez MainMenu la nouvelle ressource New
GUISkin.

Les paramètres de l’objet GUI Skin

Les objets GUI Skins possèdent des paramètres pour chaque élément de la classe GUI :
∑ Boxes (boîtes) ;
∑ Buttons (boutons) ;
∑ Toggles (boutons bascule) ;
∑ Labels (étiquettes) ;
∑ Text fields et Text areas (champs et zones de texte) ;
∑ Sliders (curseurs), scrollbars et scrollviews (barres de déilement et d’afichage).
Chapitre 8 Conception de menus 235

Le premier paramètre – Font (police) – est commun à tous les éléments régis par le thème
(skin). Pour commencer, sélectionnez la police utilisée dans le jeu (la police Sugo si vous
avez pris la même que nous) dans le panneau Project et déposez-la sur ce paramètre.
Ce thème (skin) va vous servir à déinir le style des éléments boutons. Cliquez sur la lèche
grise à gauche de l’élément Button du composant GUISkin dans le panneau Inspector
pour aficher ses paramètres (voir Figure 8.9).

Figure 8.9

Cliquez sur la lèche grise qui précède les paramètres Normal, Hover et Active ain
d’aficher les options Background et Text Color de chacun d’eux (voir Figure 8.10).
Le paramètre Background déinit la texture utilisée pour le fond du bouton – par défaut,
Unity utilise une image aux coins arrondis et légèrement différente pour les états Hover et
Active ain de les mettre en surbrillance. Conservez-les pour l’exemple de ce livre, mais
n’hésitez pas à essayer d’autres couleurs lorsque vous créerez les menus de vos propres
jeux. Pour le moment, cliquez sur chaque bloc de couleur de l’option Text Color puis,
avec la pipette, choisissez une couleur pour les états Normal, Hover (au survol) et Active
(au clic de la souris) du bouton.
236 Développez des jeux 3D avec Unity

Figure 8.10

Afichez ensuite les options du paramètre Padding et donnez la valeur 6 aux options Top et
Bottom pour augmenter l’espace entre les bords supérieur et inférieur du bouton et le texte
lui-même. Ce paramètre fonctionne de la même façon qu’avec les CSS.
Pour espacer davantage les boutons verticalement, vous devez augmenter la marge du bas.
Pour cela, afichez les options du paramètre Margin, puis donnez la valeur 10 à l’option
Bottom.
Maintenant que vous avez ajusté ces paramètres, vous êtes prêt à les appliquer au script
GUI. Sélectionnez l’objet Menu2 dans le panneau Hierarchy, puis faites glisser l’ob-
jet MainMenu depuis le panneau Project sur la variable publique Menu skin dans le
composant Main Menu GUI2.
Cliquez sur le bouton Play pour vériier que le skin a été appliqué et pour aficher le rendu
du script GUI (voir Figure 8.11).

Figure 8.11

Le menu a maintenant un aspect plus professionnel et il s’intègre mieux au logo du jeu car
sa police est la même que celle du jeu. Le menu complet doit maintenant ressembler à celui
de la Figure 8.12.
Chapitre 8 Conception de menus 237

Figure 8.12

Cliquez sur le bouton Play pour terminer le test du jeu puis sur File > Save Scene dans
Unity.

L’heure des décisions

C’est maintenant à votre tour de faire preuve de créativité ! Choisissez la méthode et le
résultat que vous préférez. À partir de ce que vous avez appris à la section "Désactiver les
Game Objects" de ce chapitre, vous pouvez choisir la deuxième méthode et laisser les trois
objets de jeu GUI Texture désactivés, ou désactiver Menu2 et réactiver ces objets en
cochant leurs cases dans le panneau Inspector.
Toutefois, nous vous conseillons de continuer avec la seconde méthode basée sur UnityGUI.
Elle permet de créer beaucoup plus que de simples menus : présenter des statistiques au
cours du test, par exemple, ou proposer des paramètres de compilation que le lecteur Unity
peut ensuite ajuster. Autant de techniques plus avancées que vous rencontrerez sans doute
lorsque vous connaîtrez mieux Unity.
238 Développez des jeux 3D avec Unity

En résumé
Nous venons d’étudier les deux principales méthodes de création des éléments d’interface
dans Unity : les scripts GUI et les GUI Texture. Vous devriez maintenant savoir comment
implémenter l’une ou l’autre méthode pour réaliser des interfaces. Nous n’avons abordé ici
que les notions essentielles dont vous aurez besoin chaque fois que vous écrirez un script
GUI, mais cette méthode offre beaucoup plus de possibilités.
Il vous reste encore à créer la scène Instructions contenant des informations destinées
au joueur. Ne vous inquiétez pas, vous allez le faire au prochain chapitre en découvrant de
nouvelles techniques d’animation, tout en apportant certaines retouches au jeu lui-même.
 9
Dernières retouches
Vous allez ici apporter les dernières retouches à l’île ain de transformer ce simple exemple
de jeu en un produit prêt à être déployé. Jusqu’à présent, nous vous avons présenté un seul
exemple à la fois ain que vous appreniez différentes compétences. Vous allez maintenant
revoir certaines des notions déjà abordées et voir en détail la façon d’ajouter certains effets
qui ne sont pas essentiels à la jouabilité, ce qui explique pourquoi il est préférable de les
réaliser à la in du cycle de développement.
Un jeu repose avant tout sur ses mécanismes de fonctionnement. Vous devez mettre en
place ses éléments physiques fonctionnels avant de pouvoir ajouter des illustrations et
améliorer l’aspect visuel de l’environnement. Dans la plupart des cas, vous serez contraint
par le temps pour créer votre jeu, que cela soit de votre fait ou imposé par l’éditeur pour
lequel vous travaillez. Vous devez consacrer tout votre temps à l’élément le plus important
du jeu – le gameplay (la jouabilité) – et procéder aux dernières retouches à la toute in du
cycle de développement seulement.
Pour les besoins de cet ouvrage, nous partons du principe que les mécanismes de votre jeu
sont terminés et fonctionnent comme prévu. Voyons maintenant ce que vous pouvez ajouter
à l’environnement de l’île et du jeu en général pour l’améliorer.
240 Développez des jeux 3D avec Unity

Au cours de ce chapitre, vous ajouterez les éléments suivants :

∑ un système de particules à l’intérieur du volcan ;
∑ le bruit du grondement de la lave que le joueur entendra lorsqu’il s’approchera du
volcan ;
∑ des traînées de lumière ain de montrer la trajectoire des noix de coco ;
∑ du brouillard, pour rendre l’horizon plus réaliste ;
∑ une scène animée Instructions pour expliquer le but du jeu au joueur ;
∑ un fondu en entrée lors du chargement du niveau Island Level à l’aide d’une interface
graphique constituée d’une texture et d’un script qui modiie sa transparence ;
∑ un message indiquant au joueur qu’il a terminé le jeu.
Pour inir, vous verrez comment déployer le jeu et comment procéder à des tests pour
rechercher les problèmes éventuels. Enin, vous aborderez la distribution du jeu via des
canaux indépendants.
Commençons tout d’abord par rendre le volcan plus dynamique.

Le volcan
Pour cette étape, vériiez que la scène Island Level est ouverte dans Unity. Si ce n’est
pas le cas, double-cliquez sur son ichier dans le panneau Project ou cliquez sur File >
Open Scene, puis sélectionnez-la dans le dossier Assets. Les ichiers de scène sont faciles
à repérer car ils utilisent le logo du programme Unity comme icône.
Au Chapitre 2, "Environnements", vous avez créé une île et le cratère d’un volcan avec
l’éditeur de terrain. Pour rendre ce volcan un peu plus réaliste, vous allez lui ajouter un
panache de fumée et une source audio mono, qui reproduit le bouillonnement de la lave en
fusion. Grâce à ces éléments sonores et visuels, l’environnement devient plus dynamique et
réaliste, ce qui devrait améliorer le sentiment d’immersion du joueur dans le jeu.
Cliquez sur GameObject > Create Other > Particle System pour créer un système
de particules dans Unity. Assurez-vous ensuite que ce système de particules, Particle
System, est sélectionné dans le panneau Hierarchy, puis renommez-le Volcano Smoke.

Positionner le système de particules

Pour positionner un objet de façon relative, on le déinit généralement comme l’enfant d’un
autre objet, puis on réinitialise sa position locale à (0, 0, 0). Mais comme le volcan est une
partie de l’objet terrain et non un objet indépendant, il n’est pas possible de déinir la position
relative des particules de cette manière.
Chapitre 9 Dernières retouches 241

Dans ce cas, vous devez utiliser l’axe 3D du panneau Scene. Commencez par cliquer sur
l’axe Y (vert) de l’axe 3D pour passer de la vue Perspective à une vue du dessus de l’île.
Le mot Top s’afiche alors sous l’axe 3D.

Figure 9.1

Pour voir où se trouve le système de particules, assurez-vous qu’il est sélectionné dans le
panneau Hierarchy, puis sélectionnez l’outil Transform (touche W) ain d’aficher ses
axes dans le panneau Scene.
Le système de particules a été créé au centre de la vue actuelle dans le panneau Scene,
aussi devez-vous le repositionner à l’intérieur du volcan dans cette vue du dessus (Top).
Vous devez voir à la fois les axes du système de particules et le volcan lui-même. Si vous
devez zoomer en arrière, activez l’outil Hand (touche  Q), appuyez sur Cmd/Ctrl puis
faites glisser la souris vers la gauche. Sélectionnez ensuite l’outil Transform (touche W) de
nouveau pour aficher les poignées d’axes de l’objet.
À l’aide de l’outil Transform, faites glisser l’une après l’autre les poignées des axes X
(rouge) et Z (bleu) pour placer le système de particules au centre du cratère (voir Figure 9.2).

Figure 9.2
242 Développez des jeux 3D avec Unity

Ne vous inquiétez pas si la poignée d’axe que vous sélectionnez s’afiche en jaune, il s’agit
toujours de la bonne poignée !
Cliquez ensuite sur la poignée de l’axe X (rouge) sur l’axe 3D en haut du panneau Scene
ain d’aficher une vue latérale de l’île. Avec l’outil Transform, faites glisser la poignée
d’axe Y (vert) du système de particules pour le placer au centre du volcan (voir Figure 9.3).

Figure 9.3

À la igure précédente, notez que la poignée d’axe verte est actuellement sélectionnée et
s’afiche donc en jaune. Enin, cliquez sur le cube blanc au centre de l’axe 3D en haut du
panneau Scene pour aficher de nouveau la vue en perspective.

Importer les ressources

Vous avez maintenant besoin d’ajouter certains éléments à votre projet pour compléter le
volcan. Vous trouverez ces ressources dans l’archive disponible sur la page web consacrée
à cet ouvrage (www.pearson.fr). Décompressez cette archive si nécessaire, localisez le
paquet de ressources volcanoPack.unitypackage, puis revenez à Unity.
Cliquez sur Assets > Import Package, parcourez votre disque dur jusqu’au paquet de
ressources volcanoPack.unitypackage, sélectionnez-le et cliquez sur Ouvrir. Cliquez
ensuite sur le bouton Import dans le panneau Importing package pour conirmer. Un
dossier Volcano est alors ajouté à votre projet. Il contient :
∑ la texture de fumée du volcan ;
Chapitre 9 Dernières retouches 243

∑ un ichier audio pour représenter le grondement de la lave ;

∑ un ichier de texture, nommé white, que vous utiliserez par la suite pour faire apparaître
le niveau en fondu enchaîné.

Créer un matériau pour la fumée

Maintenant que vous avez importé les ressources adéquates, vous devez créer un matériau
pour la texture de fumée du volcan. Ain que les éléments restent organisés, vous allez
le créer dans le dossier Volcano. Sélectionnez-le dans le panneau Project, cliquez sur le
bouton Create et choisissez Material dans le menu déroulant.
Renommez ce nouveau matériau Volcano Smoke Material, puis assurez-vous qu’il est
sélectionné dans le panneau Project et que ses paramètres s’afichent dans le panneau
Inspector. Choisissez ensuite Particles  > Multiply dans le menu déroulant Shader
ain que le style de rendu du matériau soit adapté à des particules – l’option Multiply
permet d’aficher le fond transparent des textures des particules et adoucit leurs contours.
Faites glisser le ichier de texture volcano_smoke du dossier Volcano sur l’emplacement
vide à droite du paramètre Particle Texture. Conservez les valeurs par défaut des para-
mètres Tiling et Offset.
Faites glisser le matériau Volcano Smoke Material du dossier Volcano dans le panneau
Project sur le système de particules Volcano Smoke dans le panneau Hierarchy pour
l’appliquer à cet objet.

Les paramètres du système de particules

Comme pour tout effet visuel, en particulier les systèmes de particules, de nombreux essais
sont nécessaires pour obtenir le résultat souhaité. C’est pourquoi nous vous conseillons
d’utiliser les paramètres indiqués ici comme guides, puis de prendre ensuite le temps de les
ajuster par vous-même ain d’obtenir un effet :
∑ dont vous aimez l’apparence ;
∑ qui fonctionne bien avec le style du cratère de volcan que vous avez créé sur votre
terrain.
Notez que seuls les paramètres dont la valeur par défaut a été modiiée sont indiqués ici.
244 Développez des jeux 3D avec Unity

Les paramètres du composant Ellipsoid Particle Emitter

∑ Min Size : 40 ;
∑ Max Size : 60 ;
∑ Min Energy : 10 ;
∑ Max Energy : 40 ;
∑ Min Emission : 2 ;
∑ Max Emission : 8 ;
∑ World Velocity Y axis : 30.

Les paramètres du composant Particle Animator

∑ Color Animation[0] : couleur orange, Alpha 5 % ;

∑ Color Animation[1] : couleur rouge, Alpha 25 % ;
∑ Color Animation[2] : couleur gris moyen, Alpha 40 % ;
∑ Color Animation[3] : couleur gris foncé, Alpha 25 % ;
∑ Color Animation[4] : couleur noire, Alpha 5 % ;
∑ Size Grow : 0,15 ;
∑ Rnd Force : (25, 0, 25) ;
∑ Force : (1, 0, 1).

Figure 9.4

Prenez maintenant le temps de régler ces paramètres ain que le système de particules s’in-
tègre au mieux à votre terrain.
Chapitre 9 Dernières retouches 245

Ajouter le son du volcan

Pour compléter le volcan et le rendre plus réaliste, vous allez lui ajouter une boucle sonore
comme source audio.
Nous l’avons déjà indiqué, le volcan n’est pas un objet de jeu proprement dit, si bien que
vous ne pouvez pas lui ajouter de composant. Cependant, vous disposez à présent d’un
objet au centre du volcan, le système de particules, que vous pouvez utiliser pour ajouter
le composant audio.
Assurez-vous que l’objet Volcano Smoke est sélectionné dans le panneau Hierarchy,
puis cliquez sur Component > Audio > Audio Source.
Un composant source audio s’ajoute alors au bas de la liste de composants dans le panneau
Inspector. Le système de particules ayant plusieurs composants, vous devrez peut-être
faire déiler le contenu du panneau Inspector vers le bas pour aficher le composant Audio
Source.
Assignez la séquence audio volcano_rumble du dossier Volcano au paramètre Audio
Clip, puis veillez à ce que l’option Play On Awake soit activée – la lecture du son se
déclenchera ainsi automatiquement dès le chargement de la scène. Réglez les paramètres
Volume et Max Volume à 200 ain que le son du volcan :
∑ Soit sufisamment élevé pour couvrir le son d’ambiance stéréo hillside appliqué au
terrain.
∑ Atteigne cette valeur lorsque le joueur est proche de la source audio – autrement dit,
lorsqu’il se tient près du volcan.
Laissez la valeur de Min Volume à 0 pour que ce son soit inaudible lorsque le joueur se
trouve loin du volcan.
Le paramètre Rolloff Factor (facteur d’éloignement) permet ensuite de déinir la distance
à laquelle doit se trouver le joueur pour que le volume diminue. Sur notre terrain, une valeur
de 0,025 convient – avec ce paramètre, plus la valeur est élevée, plus le joueur doit être près
de la source pour l’entendre. Par conséquent, quand la valeur est faible, comme ici, le son
s’entend de loin, comme un volcan qui gronde est censé le faire. Vous pouvez commencer
par cette valeur, puis en essayer d’autres lorsque vous testez le jeu. Enin, activez l’option
Loop pour que le son se répète indéiniment.
246 Développez des jeux 3D avec Unity

Tester le volcan
Maintenant que le volcan est terminé, vous devez tester l’eficacité des dernières modii-
cations apportées. Cliquez d’abord sur File > Save Scene, ain de vous assurer de ne pas
perdre votre travail, puis sur le bouton Play et marchez jusqu’au volcan. Les particules
devraient s’élever dans le ciel. Plus vous approchez du volcan et plus le volume sonore
devrait augmenter. S’il n’est pas assez fort à votre goût, modiiez simplement les valeurs
du paramètre Volume ; s’il ne porte pas assez loin, diminuez la valeur du paramètre Rolloff
Factor dans le composant Audio Source.

Souvenez-vous que toutes les modiications que vous apportez dans le panneau
ce inSPector lors du test du jeu sont annulées lorsque vous cliquez de nouveau sur
Astu
le bouton Play pour interrompre le test. Après les avoir testées, vous devez donc
de nouveau entrer ces valeurs dans le panneau inSPector lorsque vous avez
cessé de tester le jeu.

Pour les tests, vous souhaiterez peut-être augmenter la vitesse de déplacement de l’objet
First Person Controller ain d’atteindre les différentes parties de l’île plus rapidement.
Pour cela, sélectionnez cet objet dans le panneau Hierarchy pendant le test du jeu. Donnez
à la variable publique Speed du composant FPSWalker(script) la valeur souhaitée. Ce
paramètre est modiié uniquement pour la durée du test et reprend sa valeur précédente
lorsque vous cliquez de nouveau sur le bouton Play. Vous pouvez donc tout à fait déinir
une vitesse totalement irréaliste pour le test sans modiier la vitesse du personnage dans
le jeu.

Traînées de lumière
Vous allez maintenant améliorer l’aspect visuel du jeu en ajoutant des traînées de lumière
à l’élément préfabriqué coconut. Ainsi, lorsque le joueur lancera les noix de coco, une
traînée lumineuse suivra la trajectoire du projectile, ce qui devrait donner un effet visuel
intéressant.

Modiier l’élément préfabriqué

Pour effectuer cette modiication, vous devez revenir à l’élément préfabriqué Coconut
Prefab du Chapitre 6, car l’élément Trail Renderer que vous allez utiliser doit lui être
attaché. Faites glisser la ressource Coconut Prefab depuis le dossier Prefabs du panneau
Chapitre 9 Dernières retouches 247

Project dans le panneau Scene ain de la modiier. Vous pourriez éditer les ressources
directement dans le panneau Project, mais il est préférable de les placer dans la scène ain
de visualiser et de tester l’effet que vous créez. Souvenez-vous que vous pouvez zoomer
directement à l’emplacement de l’objet sélectionné en appuyant sur la touche F lorsque le
curseur se trouve sur le panneau Scene.

Le composant Trail Renderer

Pour ajouter ce composant, assurez-vous que l’élément préfabriqué Coconut Prefab
est toujours sélectionné dans le panneau Hierarchy, puis cliquez sur Component  >
Particles > Trail Renderer. Un message indique que la connexion entre cet objet et
l’élément préfabriqué est rompue. Ne vous inquiétez pas, vous mettrez à jour l’élément
préfabriqué une fois la traînée terminée.
Ce composant trace simplement une ligne vectorielle courbe en ajoutant une suite de points
derrière un objet lorsque celui-ci se déplace à travers le monde en  3D. En spéciiant la
longueur, le matériau et la largeur du début et de la in de la ligne, vous pouvez obtenir
l’effet recherché. Cliquez sur le bouton Play pour aficher la coniguration par défaut du
moteur de rendu et observez la chute de la noix de coco sur le sol. Comme vous pouvez le
constater, elle laisse une large trace de couleur sombre et assez laide derrière elle.
Premièrement, nous devons tenir compte des performances : comme vous n’avez pas besoin
que des ombres soient projetées sur ou par cette ligne, décochez ces deux paramètres du
composant Trail Renderer dans le panneau Inspector (les utilisateurs de la version Pro
de Unity peuvent utiliser des ombres dynamiques). Les ombres ont généralement un coût
élevé et le rendu de la traînée lumineuse elle-même sollicite davantage le processeur de
l’ordinateur du joueur. On doit faire tout ce qui est possible pour le soulager.
Cliquez sur la lèche qui précède le paramètre Materials pour aficher ses options Size
et Element 0. Vous pouvez déinir la texture de la traînée. Pour cela, vous allez réutiliser
le matériau Flame que vous avez créé car le type de shader qu’il utilise – Additive (soft) –
convient parfaitement pour une traînée lumineuse. Ouvrez le dossier Fire Feature dans le
panneau Project, puis faites glisser le matériau Flame sur le paramètre Element 0 dans
le composant Trail Renderer du panneau Inspector.
Pour vous assurer que la longueur de la traînée lumineuse ne sera pas excessive, donnez la
valeur 1 au paramètre Time : la traînée durera une seconde. Autrement dit, les points situés
à la in de la ligne seront supprimés après ce laps de temps.
Donnez la valeur 0,25 à Start Width et la valeur 0,15 à End Width. Ces options déinis-
sent la largeur du rendu du matériau à chaque extrémité de la ligne. En règle générale, il est
logique que la largeur de la traînée lumineuse aille en diminuant.
248 Développez des jeux 3D avec Unity

Afichez les options du paramètre Colors ain d’animer l’apparition de la traînée en modi-
iant sa couleur et sa visibilité (ses paramètres alpha). Vous conserverez les couleurs de la
texture de lamme et modiierez simplement la transparence de la traînée. Cliquez sur le
premier bloc de couleur, puis modiiez sa valeur A (alpha) à 80. Répétez la même opération
sur les autres blocs de couleur en réduisant chaque fois la valeur alpha de 20, jusqu’à ce
que la dernière soit égale à 0.

Figure 9.5

Vous devez obtenir un résultat analogue à celui de la Figure 9.6.

Figure 9.6

Les autres paramètres peuvent être laissés à leurs valeurs par défaut. Le paramètre Min
Vertex Distance déinit la distance la plus courte entre deux points de la ligne – plus le
nombre de points est important et plus la ligne est détaillée, mais plus son coût est élevé.
Le paramètre Autodestruct n’a pas besoin non plus d’être activé, car le script Coconut
Tidy que vous avez écrit au Chapitre 6, "Instanciation et corps rigides" est attaché à cet
objet et gère déjà la suppression de ces éléments préfabriqués.
Chapitre 9 Dernières retouches 249

Mettre à jour l’élément préfabriqué

Vous travaillez sur une instance de l’élément préfabriqué qui a perdu sa connexion avec la
ressource originale – d’où le message d’avertissement apparu lorsque vous avez ajouté le
composant Trail Renderer. Vous devez donc maintenant appliquer ces modiications à
la ressource d’origine ain que toutes les nouvelles occurrences de l’élément préfabriqué
disposent de la traînée lumineuse.
Pour cela, deux options s’offrent à vous : soit sélectionner l’objet Coconut Prefab dans
le panneau Hierarchy puis cliquer sur GameObject > Apply Changes to Prefab, soit
utiliser le bouton Apply situé en haut du panneau Inspector.

Figure 9.7

Une fois l’élément préfabriqué mis à jour, vous n’avez plus besoin de l’instance dans la
scène. Sélectionnez-la puis appuyez sur Cmd+Retour arrière (Mac  OS) ou Maj+Suppr
(Windows).
Pour visualiser l’effet, testez et essayez le mini-jeu de lancer de noix de coco. Vous devriez
voir une traînée lamboyante suivre chaque noix de coco que vous lancez.

L’amélioration des performances

À cette section, vous allez voir comment augmenter les performances de votre jeu inal.
Il est essentiel d’effectuer ce processus d’optimisation une fois que vous êtes sûr que votre
jeu fonctionne comme prévu.

Modiier la distance du rendu des objets et ajouter du brouillard

Pour donner un aspect visuel plus agréable à l’île, vous activerez le brouillard. Dans Unity,
il peut être activé très simplement et être utilisé en conjonction avec le paramètre Far Clip
Plane pour ajuster la distance d’afichage. Le rendu des objets situés au-delà d’une certaine
distance n’est pas effectué, ce qui permet d’améliorer les performances. Ce brouillard
permet de masquer la coupure entre les objets rendus et ceux qui ne le sont pas, ce qui
250 Développez des jeux 3D avec Unity

améliore le réalisme visuel du terrain. Vous avez déjà vu les paramètres Far Clip Plane
au Chapitre  3, "Personnages jouables", lorsque vous avez étudié l’objet First Person
Controller. Maintenant, vous allez ajuster cette valeur pour réduire la distance à laquelle
la caméra procède au rendu des objets et ainsi améliorer les performances du jeu.
∑ Cliquez sur la lèche grise à gauche de l’objet First Person Controller dans le
panneau Hierarchy pour aficher ses objets enfants.
∑ Sélectionnez l’objet enfant Main Camera.
∑ Donnez la valeur 600 au paramètre Far Clip Plane du composant Camera dans le
panneau Inspector. En réduisant cette distance, exprimée en mètres, vous diminuez la
portée de la vision du joueur, mais la brume masquera cette différence.
Cliquez sur Edit  > Render Settings pour remplacer le panneau Inspector par le
panneau Render Settings. Activez l’option Fog, puis cliquez sur le bloc de couleur à
droite du paramètre Fog Color pour déinir la couleur et la transparence du brouillard.
Déinissez une valeur Alpha (A) de 60 % environ et une valeur Fog Density de 0,004
(voir Figure 9.8).

Figure 9.8

Avec les valeurs par défaut ou des valeurs supérieures pour les paramètres alpha de Fog
Color et de Fog Density, le brouillard réduirait tant la portée de la vision du joueur que les
particules du volcan deviendraient invisibles, à moins qu’il ne se tienne tout près du volcan.

La lumière ambiante
Le panneau Render Settings dispose également d’un paramètre Ambient Light pour la
scène. Bien que l’objet Directional Light gère l’éclairage principal, en agissant comme
le soleil dans notre exemple, le paramètre Ambient Light permet de déinir la luminosité
générale et donc de simuler différentes heures du jour ou de la nuit. Cliquez sur le bloc de
couleur à droite de ce paramètre puis, avec la pipette de la boîte de dialogue Color, testez
différentes valeurs.
Chapitre 9 Dernières retouches 251

La scène Instructions
Pour inaliser le jeu, vous allez compléter le menu que vous avez réalisé au Chapitre 8, en
créant la scène Instructions que le joueur devra lire. Pour cela, vous implémenterez une
animation à l’aide de scripts et vous utiliserez une nouvelle commande appelée Linear
interpolation.
Pour que la scène Instructions imite le reste du menu, vous prendrez la scène Menu
comme point de départ. Avant cela, cliquez sur File > Save Scene pour vous assurer que la
scène Island Level est enregistrée. Sélectionnez ensuite la scène Menu dans le panneau
Project puis appuyez sur Cmd/Ctrl+D pour la dupliquer.
Renommez cette copie Instructions puis double-cliquez sur son icône pour l’ouvrir.

Ajouter du texte à l’écran

Comme les instructions destinées au joueur doivent s’aficher sur cet écran, vous allez
utiliser un objet GUI Text. Cliquez sur GameObject  > Create Other  > GUI Text,
puis sélectionnez ce nouvel objet GUI Text dans le panneau Hierarchy et renommez-le
Instruction Text.
Pour rester cohérent, vous devez utiliser la même police de caractères que dans les autres
scènes du jeu (la police libre de droit Sugo dans notre exemple). Pour cela, faites-la glisser
du panneau Project sur le champ du paramètre Font dans le composant GUI Text.
Écrivez ensuite un court paragraphe qui explique au joueur le but du jeu. Ici, il s’agit
d’allumer le feu de camp avec les allumettes pour survivre :
"Vous êtes bloqué sur une île déserte et risquez de périr de froid. Trouvez et allumez
le feu de camp avant que la nuit ne tombe…"
Ain que le texte se place sur plusieurs lignes dans le champ Text de ce composant, appuyez
sur Option+Entrée (Mac OS) pour passer à la ligne suivante. Sous Windows, créez le texte
sur le bloc-notes, puis copiez-le et collez-le dans le champ Text.
Enin, positionnez ce bloc de texte de la position en entrant les valeurs suivantes dans les
champs Position du composant Transform (0.5, 0.55, 0). Nous avons choisi de placer le
texte sur trois lignes pour l’aligner avec le logo en haut de l’écran (voir Figure 9.9).
252 Développez des jeux 3D avec Unity

Figure 9.9

Animer le texte avec l’interpolation linéaire

Vous allez maintenant animer ce texte à l’aide d’un script. Sélectionnez le dossier Menu dans
le panneau Project, cliquez sur Create et choisissez JavaScript dans le menu déroulant.
Renommez ce nouveau script Animator, puis double-cliquez sur son icône pour l’ouvrir
dans l’éditeur de script.
Vous commencerez par déclarer quelques variables publiques ain de contrôler le compor-
tement de l’animation de texte dans le panneau Inspector. Ajoutez les lignes suivantes au
début du script :
var startPosition : loat = -1.0;
var endPosition : loat = 0.5;
var speed : loat = 1.0;
private var StartTime : loat;

Le nom de ces variables indique leurs fonctions respectives – les variables startPosi-
tion et endPosition contrôlent la position du texte selon les coordonnées de l’écran (d’où
la valeur de –1 pour la position de départ, c’est-à-dire en dehors de l’écran). Il s’agit de
variables publiques que vous pourrez ajuster dans le panneau Inspector. La variable speed
servira à multiplier la vitesse de l’animation au cours du temps, donc sa valeur par défaut
est 1.
Chapitre 9 Dernières retouches 253

Enin, la variable StartTime de type loat est utilisée uniquement dans le script, aussi est-
elle déclarée comme privée. Elle stockera la valeur de temps déjà écoulée au moment où
la scène est chargée. Sans cela, les instructions seraient présentes à l’écran si le joueur
revenait à cette scène, car la valeur de temps que vous allez utiliser décompte à partir du
premier chargement du jeu.
Pour déinir la valeur de cette variable, vous enregistrerez la commande time de Unity lors
du chargement de la scène à l’aide de la fonction suivante :
function Start(){
StartTime = Time.time;
}

À présent, la variable StartTime utilise cette valeur au chargement de la scène. Elle va vous
servir à créer l’animation du texte.
Insérez quelques lignes avant l’accolade de fermeture de la fonction Update() puis ajoutez
la ligne suivante :
transform.position.x = Mathf.Lerp(startPosition, endPosition,
„ (Time.time-StartTime)*speed);

Le script commence par indiquer l’axe spéciique du paramètre Position du composant

Transform sur lequel il va agir :
transform.position.x

Puis il déinit cette valeur comme égale à une fonction mathématique – Mathf –, appelée
lerp (pour linear interpolation), qui effectue une interpolation linéaire entre deux valeurs.
Les valeurs transmises à cette fonction sont déinies par les variables startPosition et
endPosition, si bien que la fonction lerp fournit un chiffre compris entre ces deux nombres
pour la position du texte sur l’axe X.
Le troisième paramètre de la fonction lerp correspond à l’importance de l’interpolation ;
avec une valeur de 1, la valeur renvoyée passe complètement de la valeur de début à la
valeur de in, tandis qu’aucun changement ne se produit avec une valeur de 0. Comme cette
interpolation doit se dérouler dans le temps, le script n’utilise pas une seule valeur mais la
commande prédéinie time.time de Unity pour compter le temps écoulé et lui soustraire la
valeur de StartTime déinie plus tôt – une réinitialisation réelle de sa valeur ain de compter
à partir de 0. Enin, cette ligne modiie le temps en multipliant le résultat par la variable
speed. Actuellement, cette variable speed est déinie à 1, donc aucun changement ne sera
apporté, mais toute valeur supérieure à 1 aura pour effet d’augmenter la vitesse, et toute
valeur inférieure à 1 de la diminuer.
254 Développez des jeux 3D avec Unity

Cette commande doit être placée dans la fonction Update(), car les changements progres-
sifs produits par la fonction lerp doivent s’effectuer à chaque image. Cela ne fonctionnerait
pas si vous la placiez dans une fonction Start() par exemple.
Voici le script complet pour que vous puissiez le vériier :
var startPosition : loat = -1.0;
var endPosition : loat = 0.5;
var speed : loat = 1.0;
private var StartTime : loat;

function Start(){
StartTime = Time.time;
}

function Update () {
transform.position.x = Mathf.Lerp(startPosition, endPosition, (Time.time-
StartTime)*speed);
}

Cliquez sur File > Save dans l’éditeur de script puis revenez dans Unity.
Maintenant, vous allez appliquer le script et régler les paramètres des variables publiques
dans le panneau Inspector pour vous assurer qu’il réalise ce que vous souhaitez. Sélec-
tionnez l’objet Instructions Text dans le panneau Hierarchy puis cliquez sur Compo-
nent > Scripts > Animator pour ajouter ce script comme composant.
Les valeurs par défaut des variables publiques déinies dans le script s’afichent.

Figure 9.10

Pour voir cet effet en action, vous devez lancer la lecture de la scène. Mais avant, vous
devez supprimer le menu qui a été dupliqué depuis la scène Menu originale. Si vous avez
choisi le menu basé sur l’objet GUI Texture, vous devez alors désactiver les trois objets
boutons. Si vous utilisez le menu basé sur le script, désactivez l’objet sur lequel ce script
est attaché en tant que composant. Reportez-vous au chapitre précédent pour en savoir plus
sur la désactivation des éléments, si nécessaire.
Chapitre 9 Dernières retouches 255

Une fois le menu désactivé, revenez à l’objet Instructions Text. Déinissez le paramètre
Anchor sur Middle Center et le paramètre Alignment sur Left dans le composant
GUIText, puis cliquez sur le bouton Play pour visualiser l’animation. Votre texte doit se
déplacer sur l’axe X et apparaître depuis la gauche de l’écran pour se placer à une position
centrale de 0,5. Cliquez de nouveau sur Play pour terminer le test avant de poursuivre.
Pour que l’apparition du texte se produise de la droite vers la gauche, la valeur de la
variable publique Start Position doit être supérieure à 1,0 – puisque cela correspond aux
coordonnées du bord droit de l’écran. En revanche, pour que l’animation se déroule sur
l’axe Y, vous devriez modiier l’axe dans le script, en indiquant par exemple : transform.
position.y = Mathf (...).

Revenir au menu
La scène sur laquelle vous travaillez est distincte du menu principal et vous avez donc
besoin d’intégrer un bouton qui permettra au joueur de revenir à la scène Menu elle-même.
Sinon, il resterait coincé sur cet écran Instructions !
Pour cela, vous choisirez la technique d’écriture de scripts GUI abordée au chapitre précé-
dent et vous dupliquerez une partie des travaux existants, ce qui vous fera gagner du temps.
Sélectionnez le script MainMenuGUI2 dans le dossier Scripts du panneau Project, puis
dupliquez-le (Cmd/Ctrl+D). Unity numérote les objets et les ressources qu’il crée, cette
copie se nomme donc MainMenuGUI3. Renommez ce script BackButtonGUI, puis double-
cliquez sur son icône pour l’ouvrir dans l’éditeur de script.
Dans la première instruction if de la fonction OnGUI(), modiiez le texte sur le bouton pour
que le mot Back s’afiche au lieu de Play. Remplacez ensuite la chaîne de caractères Island
Level dans l’appel à la fonction OpenLevel() par Menu. La condition doit être :

if(GUILayout.Button ("Back")){
OpenLevel("Menu");
}

Ce script doit seulement générer un bouton ; vous devez supprimer les deux autres instruc-
tions if de la fonction pour ne conserver que celle qui concerne le retour à la scène Menu. Le
seul problème concerne ici le positionnement du bouton. Comme nous utilisons la variable
screenY du script MainMenuGUI2, la zone de l’interface graphique dans laquelle est
dessiné le bouton se trouve au centre de l’écran, si bien que ce dernier risque de chevaucher
le texte. Pour contourner ce problème et décaler le bouton vers le bas, modiiez la décla-
ration de la variable screenY pour qu’elle utilise une valeur légèrement inférieure :
var ScreenY = ((Screen.height / 1.7) - (areaHeight / 2));

Ainsi, le bouton sera placé plus bas que le texte contenant les instructions.
256 Développez des jeux 3D avec Unity

Le script terminé BackButtonGUI doit être le suivant :

var beep : AudioClip;
var menuSkin : GUISkin;
var areaWidth : loat;
var areaHeight : loat;

function OnGUI(){
GUI.skin = menuSkin;
var ScreenX = ((Screen.width / 2) - (areaWidth / 2));
var ScreenY = ((Screen.height / 1.7) - (areaHeight / 2));
GUILayout.BeginArea (Rect (ScreenX,ScreenY, areaWidth, areaHeight));
if(GUILayout.Button ("Back")){
OpenLevel("Menu");
}
GUILayout.EndArea();
}

function OpenLevel(level : String){

audio.PlayOneShot(beep);
yield new WaitForSeconds(0.35);
Application.LoadLevel(level);
}
@script RequireComponent(AudioSource)

Cliquez sur File > Save dans l’éditeur de script puis revenez à Unity.
Comme pour tous les éléments d’interface gérés par le script, vous devez attacher le script
à un objet pour que ce bouton s’afiche. Aussi, cliquez sur GameObject > Create Empty
pour créer un objet de jeu vide pour ce script. Renommez ensuite ce nouvel objet Back
Button dans le panneau Hierarchy, puis cliquez sur Component  > Scripts  > Back
Button GUI pour lui attacher le script que vous venez d’écrire. Les valeurs des variables
publiques du script doivent être déinies. Vous devez donc :
∑ faire glisser la séquence audio menu_beep depuis le dossier Menu du panneau Project
sur la variable Beep ;
∑ faire glisser la ressource MainMenu du dossier Menu sur la variable Menu Skin ;
∑ déinir la variable Area Width à 200 ;
∑ déinir la variable Area Width à 75, puisque l’écran ne compte qu’un seul bouton.
Le bouton Back est maintenant terminé. Avant de tester le menu entier, vous devez ajouter
la scène Instructions aux paramètres Build Settings du projet pour que Unity la charge
pendant les tests. Cliquez sur File > Build Settings puis sur le bouton Add Current.
Chapitre 9 Dernières retouches 257

La liste des niveaux dans les paramètres Build Settings doit maintenant correspondre à
celle de la Figure 9.11.

Figure 9.11

Fermez la boîte de dialogue Build Settings puis cliquez sur le bouton Play pour tester
la scène. Le bouton Back doit s’aficher et l’animation de l’apparition du texte se dérouler.
Cliquez sur le bouton Back pour aficher la scène Menu. Si rien de tout cela ne fonctionne,
vériiez que votre script correspond aux changements énumérés précédemment.
La Figure 9.12 illustre l’aspect que doit avoir l’écran présentant les instructions.

Figure 9.12

Terminez le test de la scène, puis cliquez sur File > Save Scene pour la sauvegarder.
258 Développez des jeux 3D avec Unity

L’apparition en fondu de la scène Island Level

Ain d’améliorer l’arrivée du joueur dans l’environnement du jeu, vous allez faire appa-
raître le niveau de l’île avec un fondu en entrée, à l’aide d’une texture GUI qui couvrira
tout l’écran avant de disparaître peu à peu. Pour cela, vous appliquerez la technique d’inter-
polation linéaire que vous venez d’apprendre.
Double-cliquez sur l’icône de la scène Island Level pour l’ouvrir. Le dossier Volcano que
vous avez importé plus tôt contient un ichier de texture nommé white. Cette texture est
une image de couleur blanche unie de 64 × 64 pixels créée dans Photoshop. Ces dimen-
sions peuvent sembler trop petites pour recouvrir tout l’écran, mais il n’est pas utile que le
ichier soit plus grand puisqu’il s’agit d’un aplat de couleur – vous allez donc simplement
l’agrandir à la taille de l’écran.
Sélectionnez la texture, puis décochez la case Generate Mip Maps dans le composant
Texture Importer du panneau Inspector pour que Unity ne crée pas de versions plus
petites de cette texture (cette option est utile pour les textures sur les objets 3D). Cliquez
ensuite sur le bouton Apply situé au bas du composant pour conirmer cette modiication.
Vous allez écrire un script pour que cette texture occupe la totalité de l’écran puis, à l’aide
d’une interpolation, qu’elle disparaisse en fondu lors du lancement de la scène. Le jeu
s’afichera depuis un fondu au blanc.
Sélectionnez le dossier Scripts, cliquez sur le bouton Create et sélectionnez JavaScript
dans le menu déroulant. Renommez ce script FadeTexture, puis double-cliquez sur son
icône pour l’ouvrir dans l’éditeur de script.
Commencez par déclarer les deux variables publique et privée suivantes :
var theTexture : Texture2D;
private var StartTime : loat;

La première variable stocke la texture blanche prête à être étirée sur toute la surface de
l’écran. La seconde est un nombre à virgule lottante que vous utiliserez pour stocker une
valeur de temps.
Pour transmettre la valeur Time.time à la variable StartTime lors du chargement du niveau,
ajoutez la fonction suivante à votre script, sous les deux variables :
function OnLevelWasLoaded(){
StartTime = Time.time;
}

Cette variable permet de saisir la durée écoulée car Time.time s’exécute au moment où la
première scène du jeu (le menu) est chargée. Ce menu est le premier élément du jeu que
voit le joueur, aussi Time.time n’est pas égal à 0 quand la scène Island Level se charge.
Chapitre 9 Dernières retouches 259

Vous soustrairez ensuite cette valeur de la variable qui stocke le temps courant ain d’obtenir
une valeur à partir de laquelle compter.
Insérez le script suivant dans la fonction Update() :
if(Time.time-StartTime >= 3){
Destroy(gameObject);
}

Cette instruction if contrôle la valeur actuelle de Time.time et lui soustrait le temps écoulé
au chargement de la scène courante, StartTime. Si cette valeur est supérieure ou égale à 3,
alors le script détruit l’objet de jeu sur lequel ce script est attaché après trois secondes. En
effet, une fois que l’effet fondu s’est produit, cet objet n’a plus aucune utilité dans la scène.

Le rendu de la texture UnityGUI

Créez la fonction OnGUI() suivante dans votre script :
function OnGUI(){
GUI.color = Color.white;
GUI.color.a = Mathf.Lerp(1.0, 0.0, (Time.time-StartTime));
GUI.DrawTexture(Rect(0, 0, Screen.width, Screen.height ), theTexture);
}

Ici, le script s’adresse directement à la classe GUI. La première ligne désigne le paramètre
color et le déinit comme égal à une constante prédéinie de la classe Color nommée white.
Une fois cette couleur déinie, le script utilise la commande GUI.color.a pour désigner
son paramètre alpha – sa visibilité. La même commande Mathf.Lerp que vous avez utilisée
pour animer l’objet GUI Text plus tôt crée ici une interpolation de la valeur alpha de 1.0
(entièrement visible) à 0.0 (invisible). Le troisième paramètre de la boucle déinit la durée
de cette interpolation. Comme celle-ci dépend du résultat de la soustraction Time.time-
StartTime, le décompte commence effectivement à 0.0, puis sa valeur augmente à mesure
que le temps passe. Ainsi, l’interpolation linéaire évolue dans le temps et produit un effet
de fondu.
La troisième ligne procède au rendu de la texture elle-même, à l’aide de la commande
DrawTexture de la classe GUI. Le paramètre Rect sert à tracer une zone rectangulaire à
partir de 0.0 – le coin supérieur gauche de l’écran – puis à s’assurer que cette texture s’étire
sur la totalité de l’écran à l’aide de screen.width et screen.height. En adaptant ainsi
automatiquement la taille de la texture à celle de l’écran, le fondu fonctionnera quelle que
soit la résolution.
Cliquez sur File > Save dans l’éditeur de script et revenez dans Unity.
260 Développez des jeux 3D avec Unity

Dans Unity, cliquez sur GameObject  > Create Empty pour créer un objet GameOb-
ject dans le panneau Hierarchy. Renommez-le Fader puis cliquez sur Component  >
Scripts > Fade Texture pour lui attacher le script que vous venez d’écrire. Ensuite, faites
glisser la texture white depuis le dossier Volcano du panneau Project sur la variable
publique theTexture dans le panneau Inspector.
Cliquez sur le bouton Play. L’écran doit s’aficher en blanc puis la scène apparaître
en fondu avant que l’objet white du panneau Hierarchy ne soit supprimé après trois
secondes. Terminez le test, puis cliquez sur File > Save Scene pour sauvegarder le projet.

Notiier la in du jeu
Pour inir, vous allez indiquer au joueur qu’il a terminé avec succès le jeu quand le feu est
allumé, le but à atteindre.
Ouvrez le script PlayerCollisions dans le dossier Scripts du panneau Project puis faites
déiler son contenu vers le bas. Vous allez ajouter quelques commandes supplémentaires
dans la dernière fonction du script, lightire(). Pour cela, insérez quelques lignes avant
son accolade de fermeture, à la suite de cette ligne :
Destroy(GameObject.Find("matchGUI"));

Insérez ensuite les commandes suivantes :

TextHints.textOn=true;
TextHints.message = "Vous avez allumé le feu et vous survivrez à cette épreuve,
„ félicitations !";
yield new WaitForSeconds(5);
Application.LoadLevel("Menu");

Ces lignes utilisent l’objet GUI TextHints pour aficher à l’écran la chaîne de caractères :
"Vous avez allumé le feu…". La commande yield met ensuite le script en pause pendant
cinq secondes, puis charge le niveau Menu du jeu, ain que le joueur puisse recommencer
la partie.
Cliquez sur le bouton Play et testez le jeu dans son intégralité. Vous devez pouvoir collecter
trois piles, gagner la quatrième en abattant les trois cibles à coups de noix de coco, entrer
dans l’avant-poste, ramasser les allumettes et enin allumer le feu. Le message du script
précédent doit alors s’aficher et vous devez revenir à l’écran du menu principal.
Après avoir vériié cela, arrêtez le test, puis cliquez sur File > Save Scene pour sauvegarder
votre projet.
Chapitre 9 Dernières retouches 261

En résumé
Nous venons de voir comment apporter différentes touches de inition aux jeux. Les effets
visuels, de lumière et les animations abordés ici ne font qu’efleurer la surface de ce qu’il
est possible de faire avec Unity. Cependant, même si Unity permet de polir l’aspect de
votre jeu ain qu’il se démarque vraiment, vous devez garder à l’esprit que ces opérations
s’effectuent uniquement une fois que le gameplay de votre projet est terminé. Comme leur
nom l’indique, les initions sont un excellent moyen de inaliser un projet, mais la jouabilité
doit toujours primer.
À présent que le jeu est terminé, vous verrez au prochain chapitre comment le compiler
et tester différentes versions et vous apprendrez ce que recouvre ce processus de déploie-
ment. Vous découvrirez également certaines optimisations supplémentaires et la manière de
publier votre jeu en tant que développeur indépendant.
 10
Compilation et partage
Ain de transformer ce simple exemple de jeu en une version de test, vous devez tenir
compte des différentes plates-formes sur lesquelles il sera déployé et l’adapter à une diffu-
sion sur le Web. La meilleure méthode pour un développeur consiste à partager son travail.
Unity permet de créer différentes versions d’un jeu, à différentes tailles et avec plusieurs
niveaux de compression des textures et des ressources. Vous devez également implémenter
une méthode de détection de la plate-forme pour les jeux destinés au Web. En effet, certains
paramètres devront être ajustés lors du déploiement en ligne, ce qui est inutile pour une
application autonome.
Les versions standard et Pro de Unity permettent de créer des applications autonomes pour
Mac OS et Windows, des widgets pour le Dashboard (Tableau de bord) de Mac OS X ou
des jeux destinés aux navigateurs web (le joueur doit télécharger un plugin).
Au cours de ce chapitre, vous découvrirez de quelle manière personnaliser les ressources
selon que vous créez un jeu destiné au Web ou une application autonome. Vous verrez
comment :
∑ ajuster les paramètres Build Settings ain d’exporter le jeu ;
∑ concevoir une version web et une version autonome du jeu ;
264 Développez des jeux 3D avec Unity

∑ détecter la plate-forme client pour supprimer des éléments dans le jeu destiné au Web ;
∑ partager les jeux avec d’autres personnes et en savoir plus sur le développement dans
Unity.

Les paramètres Build Settings

Dans Unity, cliquez sur File > Build Settings, et observez les options disponibles. Vous
devriez voir les différentes options mentionnées précédemment (voir Figure 10.1).

Figure 10.1

Dans la boîte de dialogue Build Settings, les créations destinées à une utilisation sous
Mac OS sont marquées par le préixe OS X, la génération actuelle de ce système d’exploi-
tation. Plusieurs options sont disponibles car il existe différentes générations de Mac dont
vous devez tenir compte : la génération précédente utilisait le processeur PowerPC tandis
que la génération actuelle s’articule autour des processeurs Intel. Le paramètre Universal
Binary crée un ichier binaire OS X qui peut s’exécuter aussi bien sur les anciens systèmes
PowerPC que sur les nouveaux systèmes Intel. Le ichier est alors plus volumineux, puisque
l’application contient dans les faits deux copies de votre jeu.
Chapitre 10 Compilation et partage 265

Dans notre exemple, la boîte de dialogue Build Settings contient la liste des scènes que
vous avez ajoutées au projet jusqu’à présent, à commencer par la scène Menu. Il est impor-
tant que la première scène vue par le joueur soit le premier élément de la liste Scenes to
build. Si votre menu ou la première scène n’est pas en tête de cette liste, faites glisser le
nom des scènes vers le haut ou vers le bas pour modiier leur ordre d’apparition dans le jeu.
Commençons par examiner les différentes options et voir ce que chacune d’elles permet
d’obtenir.

L’option Web Player

Pour diffuser sur le Web du contenu nécessitant un plugin, vous devez intégrer ce contenu
en tant qu’objet qui appelle le plugin installé. Les joueurs devront télécharger le plugin
pour leur navigateur web ain d’aficher les créations effectuées dans Unity, de la même
manière que le contenu Adobe Flash oblige les utilisateurs à télécharger le lecteur Flash
Player. L’option Web Player crée un ichier de jeu qui porte l’extension .unity3D et
appelle le plugin Web Player, ainsi qu’un ichier HTML qui contient le code d’intégration
nécessaire. Ce code HTML peut ensuite être intégré dans une page web de votre propre
conception.

Les paramètres du lecteur web

Les lecteurs web utilisent le navigateur pour charger le code HTML contenant l’appel au
plugin. Par conséquent, le navigateur sollicite déjà le processeur de l’ordinateur sur lequel
le jeu s’exécute. Il est donc conseillé de réduire la résolution du jeu par rapport à celle que
vous utiliseriez pour une application autonome. Le jeu de notre exemple a été conçu avec
une résolution d’entrée de gamme de 1 024 × 768 pixels. Toutefois, lors du déploiement sur
un site web, la taille de l’écran doit être réduite (640 × 480 par exemple). Cela permet de
diminuer la charge sur le processeur car les images qu’il doit créer sont plus petites, ce qui
améliore les performances.
Pour régler ces paramètres, vous devez étudier les paramètres Player Settings. Cliquez
sur Edit  > Project Settings  > Player pour aficher les paramètres du projet dans le
panneau Inspector. Lors de la inalisation du jeu, votre projet se place effectivement dans
un lecteur – qui appelle lui-même le plugin une fois sur le Web. Les paramètres Player
Settings vous permettent de déinir certains éléments que le joueur utilisera, comme la
résolution de l’écran.
266 Développez des jeux 3D avec Unity

Figure 10.2

Vous devez commencer par indiquer certains détails sur votre projet. Ajoutez le nom de
l’entreprise dans le champ Company Name et le nom du produit dans le champ Product
Name (rien de très oficiel dans notre exemple). Indiquez ensuite la largeur et la hauteur de
l’écran par défaut dans les champs Default Screen Width et Default Screen height,
en entrant 1024 × 768, soit la résolution à laquelle le jeu a été conçu.
Donnez aux paramètres Default Web Screen Width et Default Web Screen Heigth
les valeurs 640 et 480 respectivement (voir Figure 10.2). Le seul autre paramètre important
pour le déploiement du lecteur web, First Streamed Level With Resources, permet
de choisir le premier niveau sur votre liste pour lequel un ensemble de ressources doit
être chargé. Vous pouvez ainsi créer des écrans de chargement dans votre jeu. Si tel est le
cas, vous devez alors utiliser ce paramètre pour choisir le premier niveau qui contient les
ressources à charger en indiquant son numéro sur la liste de la boîte de dialogue Build
Settings.
Dans notre exemple, le premier écran (le menu) contient les ressources de l’île, si bien que
vous pouvez conserver la valeur par défaut, 0, pour ce paramètre. Nous étudierons bientôt
plus en détail les paramètres du lecteur lorsque vous verrez comment créer une application
autonome.

L’option Web Player Streamed

Les utilisateurs sont généralement impatients, et il est important que vous limitiez autant
que possible le temps d’attente lorsque vous créez des jeux destinés au Web. Avec l’option
Web Player Streamed (lecteur web en continu), le joueur peut commencer à jouer avant
que la totalité des ressources ne soit chargée – le chargement se poursuit pendant que le
joueur interagit avec la première scène.
Chapitre 10 Compilation et partage 267

Ce facteur est absolument essentiel lorsque vous présentez votre création sur un portail
de jeux comme www.shockwave.com, www.wooglie.com ou www.blurst.com. Pour ces
sites, votre jeu doit être jouable dès que 1  Mo de données environ a été téléchargé. En
acceptant ces directives, vous augmentez vos chances de voir ces sites présenter votre jeu,
ce qui vous permet de toucher une plus large audience. Pour plus d’informations à ce sujet,
visitez le site web de Unity.

L’option OS X Dashboard Widget

Sur les systèmes d’exploitation Mac OS (version 10.4 et suivantes), le Dashboard regroupe
un ensemble d’outils et d’applications simples, les widgets, qui peuvent être afichés à
tout moment en superposition sur l’écran. Unity peut publier votre jeu sous la forme d’un
widget, vous offrant ainsi un autre moyen pour le diffuser. Ce type de déploiement peut être
adapté pour un puzzle ou un jeu de passe-temps simple. Toutefois, cette méthode est moins
adaptée à notre jeu de randonnée à la première personne.
La Figure 10.3 illustre l’aspect de notre jeu publié pour le Dashboard de Mac OS :

Figure 10.3
268 Développez des jeux 3D avec Unity

Dans l’idéal, les jeux déployés en tant que widgets doivent rester simples. Il est en effet
préférable d’éviter le chargement de nombreuses données dans un widget car ce dernier
reste en mémoire et le jeu se poursuit lorsque le Dashboard est activé et désactivé.

Les options OS X/Windows Standalone

Les applications autonomes sont des programmes à part entière qui peuvent être distribués
de la même manière qu’un jeu commercial.
En créant une application autonome pour Mac  OS  X, vous obtenez un seul ichier
applicatif qui regroupe toutes les ressources nécessaires. Sous Windows, cette option
crée un dossier contenant un ichier .exe. (exécutable) et les ressources nécessaires au
fonctionnement.
Une application autonome est la meilleure façon de garantir que les performances du jeu
seront les meilleures, d’une part parce que les ichiers sont stockés en local et non en ligne
mais aussi parce que la puissance du processeur n’est pas partiellement sollicitée par un
navigateur ou par le Dashboard de Mac OS X.

Générer le jeu
Maintenant que vous êtes prêt à générer le jeu, vous devez examiner ces différentes
méthodes de déploiement et adapter votre projet pour le diffuser sur le Web et en tant que
jeu autonome.

Adapter les paramètres pour le Web

Dans Unity, le moteur redimensionne le monde 3D sur lequel vous travaillez en fonction de
la résolution que vous déinissez dans les paramètres Player Settings. Vous avez également
conçu les menus de ce projet pour qu’ils s’adaptent à différentes résolutions, en utilisant la
classe Screen, pour que les éléments de l’interface graphique se placent en fonction de la
résolution en cours. Toutefois, ain d’en apprendre davantage sur la détection de la plate-
forme, vous allez supprimer un élément qui ne doit pas apparaître dans la version en ligne :
le bouton Quit. Double-cliquez sur l’icône du script MainMenuGUI2 situé dans le dossier
Scripts du panneau Project, pour l’ouvrir dans l’éditeur de script.
Chapitre 10 Compilation et partage 269

Ajouter ou supprimer automatiquement le bouton Quit

Comme il s’agit d’une version du jeu destinée au Web, le bouton Quit du menu n’est pas
utile. En effet, la commande Application.Quit() ne fonctionne pas lorsqu’un jeu Unity est
exécuté dans un navigateur web. Les joueurs ferment tout simplement la page sur laquelle
se trouve le jeu ou se rendent à une autre adresse lorsqu’ils ont ini de jouer. Vous devez
donc retirer ce bouton du menu pour la version destinée au Web, mais sans le supprimer de
votre script, puisqu’il doit être présent dans la version autonome du jeu.
Pour résoudre ce problème, vous allez utiliser une autre partie de la classe Application
appelée platform, qui permet de détecter le type de déploiement (application autonome,
Web ou widget du Dashboard) choisi pour le jeu.
Pour cela, vous devez ajouter la ligne suivante après l’instruction if :

if(Application.platform == RuntimePlatform.OSXWebPlayer ||
„ Application.platform == RuntimePlatform.WindowsWebPlayer)

Cette ligne vériie le paramètre platform de la classe Application ain de savoir si le jeu
est en cours d’exécution sous Mac  OS (OSXWebPlayer) ou sous Windows (WindowsWeb-
Player) – le symbole || signiie simplement "OU". Autrement dit, si le jeu est en cours
d’exécution sur un lecteur web, le script doit réaliser une opération. Vous devez en outre
combiner cette condition avec une instruction else car le rendu du bouton Quit doit être
effectué si le jeu n’est pas déployé pour le Web.
Localisez l’instruction if chargée de créer le bouton Quit dans la fonction OnGUI() :

if(GUILayout.Button ("Quit")){
Application.Quit();
}

Ajoutez la structure if else suivante, en plaçant l’instruction if du bouton Quit dans la

section else. Le script doit maintenant ressembler à ceci :
if(Application.platform == RuntimePlatform.OSXWebPlayer || Application.platform
== RuntimePlatform.WindowsWebPlayer){
}
else{
if(GUILayout.Button ("Quit")){
Application.Quit();
}
}
270 Développez des jeux 3D avec Unity

Nous avons laissé une ligne vide lorsque la condition if est satisfaite et placé le code du
bouton Quit dans la partie else, ain qu’il soit créé uniquement si le script détecte que le
jeu ne s’exécute pas sur le Web.
Maintenant localisez les deux instructions if qui procèdent au rendu des boutons Play et
Instructions :
if(GUILayout.Button ("Play")){
OpenLevel("Island Level");
}
if(GUILayout.Button ("Instructions")){
OpenLevel("Instructions");
}

et placez-les dans la partie de l’instruction if que vous venez d’ajouter, ain que le script
soit le suivant :
if (Application.platform == RuntimePlatform.OSXWebPlayer ||
„ Application.platform == RuntimePlatform.WindowsWebPlayer){
if(GUILayout.Button ("Play")){
OpenLevel("Island Level");
}
if(GUILayout.Button ("Instructions")){
OpenLevel("Instructions");
}
}
else{
if(GUILayout.Button ("Quit")){
Application.Quit();
}
}

Ainsi, le script effectue le rendu des boutons Play et Instructions si la détection initiale
découvre que le jeu s’exécute en ligne et le rendu du bouton Quit si le jeu n’est pas en
ligne.
Mais vous avez également besoin des boutons Play et Instructions pour l’application
autonome. Pour cela, copiez et collez la partie du code de ces boutons dans l’instruction
else également. L’instruction de détection terminée doit être la suivante :

if (Application.platform == RuntimePlatform.OSXWebPlayer ||
„ Application.platform == RuntimePlatform.WindowsWebPlayer){
if(GUILayout.Button ("Play")){
OpenLevel("Island Level");
}
Chapitre 10 Compilation et partage 271

if(GUILayout.Button ("Instructions")){
OpenLevel("Instructions");
}
}
else{
if(GUILayout.Button ("Play")){
OpenLevel("Island Level");
}
if(GUILayout.Button ("Instructions")){
OpenLevel("Instructions");
}
if(GUILayout.Button ("Quit")){
Application.Quit();
}
}

Comme vous pouvez le constater, seuls les boutons Play et Instructions sont concer-
nés dans la condition if, tandis que la condition else agit sur le rendu des boutons Play,
Instructions et Quit. Cliquez sur File > Save dans l’éditeur de script puis revenez dans
Unity. Le rendu du bouton Quit s’effectue automatiquement si le jeu n’est pas diffusé sur
le Web.
Vous disposez maintenant d’un ensemble de ressources de scène qui peuvent être placées
sur la liste des paramètres Build Settings avec le niveau Island Level pour le lecteur web
Player ou Web Player Streamed.
Maintenant, voyons comment créer à la fois les versions Web et autonome du jeu.

La compression des textures et le débogage

Lorsque vous sélectionnez un système d’exploitation, Unity compresse pour vous les
textures utilisées dans le jeu en fonction de leurs paramètres d’importation. Dans la plupart
des cas, vous devez également désactiver l’option Development build lorsque votre jeu
est prêt à être généré ain de supprimer tout le code superlu de la classe Debug de vos
scripts – comme la commande Debug.Log que vous avez utilisée au Chapitre 8.

Créer une version autonome

Les versions autonomes du jeu s’ouvrent par défaut sur un écran de démarrage, la boîte de
dialogue Resolution Dialog, qui permet aux utilisateurs de personnaliser la résolution
du jeu, voire les paramètres d’entrée et d’afichage. En tant que développeur, vous pouvez
ajouter une image dans cet écran.
272 Développez des jeux 3D avec Unity

La Figure 10.4 illustre l’aspect la boîte de dialogue Resolution Dialog par défaut
(version Mac OS) :

Figure 10.4

La plupart des développeurs préfèrent garder cet écran activé, car il permet au joueur de
choisir la résolution et la qualité d’afichage qui correspondent le mieux à son ordinateur.
Cependant, vous pouvez le désactiver si vous souhaitez forcer les utilisateurs à jouer dans
une résolution en particulier.
Pour désactiver cet écran, cliquez sur Edit > Project Settings > Player et sélectionnez
Disabled pour le paramètre Display Resolution Dialog. Enin, vous pouvez activer l’op-
tion Default is Full Screen pour que le jeu s’exécute obligatoirement en mode plein
écran, si vous ne voulez que le jeu s’ouvre dans une fenêtre, comme c’est le cas par défaut.
Néanmoins, les joueurs peuvent toujours aficher la boîte de dialogue Resolution Dialog
en appuyant sur la touche Alt (aussi appelée Option sous Mac OS) lors du lancement de
l’application (ce raccourci peut être très utile pour les versions de test).

Pour intégrer une bannière graphique qui s’afiche dans la partie supérieure de
ce la boîte de dialogue reSolution dialoG, vous devez enregistrer une image de
Astu
432 × 163 pixels dans votre projet, puis la sélectionner dans le menu déroulant
reSolution dialoG banner du panneau Player SettinGS.
Chapitre 10 Compilation et partage 273

Cliquez sur File > Build Settings et veillez à ce que les trois scènes suivantes s’afichent
sur la liste Scenes to build :
∑ Menu.unity
∑ Island Level.unity
∑ Instructions.unity

Si une scène ne igure pas sur la liste, vous pouvez toujours la faire glisser
Info depuis le panneau Project sur la liste build SettinGS.

Il est important que la scène Menu soit en première position sur la liste car elle doit se
charger en premier. Aussi, assurez-vous qu’elle est en position 0.
La compression des textures permet au jeu de se charger plus rapidement mais la première
compilation du jeu peut prendre plus de temps, car les textures sont compressées pour la
première fois.
Sélectionnez le format à utiliser : Windows, pour créer une application pour Windows XP,
Vista 7 et les versions suivantes, ou Mac OS – en tenant compte des processeurs PowerPC,
Intel ou des deux (universal binary).
Cliquez sur le bouton Build au bas de la fenêtre de dialogue pour indiquer où vous souhai-
tez sauvegarder votre jeu. Parcourez ensuite le disque dur jusqu’à l’emplacement de votre
choix, indiquez le nom du jeu dans le champ Nom du fichier ou Enregistrer sous, puis
cliquez sur Enregistrer pour valider.
Attendez ensuite que Unity crée votre jeu. Différentes barres de progression indiquent que
les ressources sont compressées, puis l’avancement de la compilation de chaque niveau.
Une fois le processus terminé, le jeu inalisé, prêt à être utilisé, s’ouvre dans une fenêtre du
système d’exploitation.
Pour lancer le jeu, double-cliquez sur l’application (Mac OS) ou ouvrez le dossier conte-
nant le jeu, puis double-cliquez sur le ichier .exe (Windows). Gardez à l’esprit que, si vous
construisez une version Windows sous Mac OS, ou vice versa, vous ne pouvez pas la tester
en mode natif.

Unity et Unity Pro

Lorsque vous compilez un jeu avec la version gratuite de Unity, un écran portant le message
Powered by Unity s’afiche avant le chargement du jeu (voir Figure 10.5). Ce n’est pas le
cas avec la version Pro de Unity.
274 Développez des jeux 3D avec Unity

Figure 10.5

Les différences entre les deux versions, comme le manque d’ombres dynamiques dans la
version gratuite, sont énumérées à l’adresse suivante :
http://unity3d.com/unity/licenses.html.

Compiler pour le Web

Dans Unity, cliquez sur File > Build Settings pour ouvrir la boîte de dialogue Build
Settings, puis sur le bouton radio Web Player et, enin, sur Build. Unity se charge des
conversions et des compressions nécessaires pour créer un jeu luide sur le Web. Et ce n’est
que l’un de ses nombreux charmes !
Indiquez le nom du jeu et l’emplacement où enregistrer le ichier puis cliquez sur Enre-
gistrer pour conirmer.
Une fois le processus terminé, le système d’exploitation afiche le dossier dans lequel le
jeu est enregistré. Deux ichiers sont nécessaires pour que la compilation fonctionne : le jeu
lui-même (un ichier portant l’extension .unityweb) et un ichier HTML contenant le script
nécessaire (HTML et JavaScript) pour charger le jeu ou inviter l’utilisateur à télécharger le
plugin Unity Web Player.
Chapitre 10 Compilation et partage 275

Pour lancer le jeu, ouvrez le ichier HTML dans le navigateur web de votre choix.

Adapter le jeu destiné au Web

Unity fournit par défaut le code HTML/JavaScript nécessaire pour intégrer le ichier
.unityweb dans une page web. Aussi, il vous sufit de copier le script situé entre les balises
<head> et <body> et de le coller dans une page web HTML/CSS de votre conception.

Le script de détection – balise <HEAD>

Ouvrez la page HTML qui accompagne le jeu compilé dans l’éditeur de script fourni avec
Unity ou votre éditeur HTML favori, comme Dreamweaver, SciTE, TextMate ou Text-
Wrangler. Sélectionnez tout le code de la partie <head> – de la balise d’ouverture <script>
à la balise de fermeture </script> – puis copiez-le dans un nouveau document JavaScript.
Enregistrez ensuite ce ichier sous le nom UnityDetect.js.
Vous pouvez ensuite sauvegarder ce ichier dans le même dossier que vos pages web et
appeler ce code JavaScript dans la section d’en-tête (entre les balises <head>) de votre page
web à l’aide de la ligne de code HTML suivante :
<script type="text/JavaScript" src="UnityDetect.js"></script>

Intégrer l’objet – balise <BODY>

Pour intégrer l’objet lui-même dans une page, copiez tout le code de la section <body> – de
la balise d’ouverture <script> jusqu’à la balise de fermeture </noscript> puis collez cet
extrait de code HTML qui appelle le lecteur de Unity dans votre propre page web.
Pour que cela fonctionne, souvenez-vous que le ichier .unityweb doit être dans le même
dossier que la page contenant le code HTML qui l’appelle.

Les paramètres de qualité

Lors de l’exportation depuis Unity, vous pouvez contrôler la qualité de votre production.
Cliquez sur Edit  > Project Settings  > Quality pour aficher les paramètres Quality
Settings dans le panneau Inspector.
Vous pouvez choisir parmi six réglages de qualité prédéinis : Fastest, Fast, Simple, Good,
Beautiful et Fantastic. Vous pouvez également modiier ces préréglages pour obtenir
des résultats plus précis. Comme vous débutez avec Unity, nous allons voir et comparer le
réglage privilégiant la luidité, Fastest, à celui qui privilégie la qualité, Fantastic.
276 Développez des jeux 3D avec Unity

Figure 10.6

Comme vous pouvez le constater (voir Figure 10.6), les paramètres de chaque option sont
déinis de manière très différente :
∑ Pixel Light Count. Le nombre de lumières au pixel qui peut être utilisé dans une scène.
Le rendu des lumières dans Unity s’effectue sous la forme d’un pixel ou d’un sommet,
un processus qui améliore l’aspect des pixels mais qui est plus coûteux pour le proces-
seur. Ce paramètre Pixel Light Count permet de déinir le nombre de lumières au
pixel (les autres lumières étant rendues comme des lumières au sommet). C’est pour-
quoi il est déini sur 0 dans le réglage prédéini Fastest, avec lequel la qualité est la
moins élevée.
∑ Shadows. Cette fonctionnalité est seulement effective dans la version Pro de Unity.
Elle permet d’indiquer que le jeu ne doit pas utiliser les ombres dynamiques mais les
ombres aux contours durs seulement ou les ombres aux contours durs et adoucis (les
deux niveaux de qualité de l’ombre).
Chapitre 10 Compilation et partage 277

∑ Shadow Resolution. Ce paramètre, effectif, lui aussi, uniquement dans Unity Pro,
permet de déinir la qualité du rendu des ombres. Cela peut être utile pour améliorer les
performances lorsque plusieurs objets ont des ombres dynamiques dans la scène – choi-
sir une basse résolution permet d’optimiser les ombres sans les désactiver entièrement.
∑ Shadow Cascades. Unity Pro proite de Cascade Shadow Maps pour améliorer l’aspect
des ombres sur les lumières directionnelles dans la scène en utilisant la même carte pour
les ombres sur des zones plus importantes en fonction de la distance. Les zones les plus
proches de la caméra du joueur ont une carte d’ombres plus détaillée, ce qui améliore
la qualité.
∑ Shadow Distance. Analogue au paramètre Far Clip Plane, qui limite la distance de
rendu de la caméra, ce paramètre est un autre niveau de réglage des détails. Il peut être
utilisé pour déinir la distance après laquelle le rendu des ombres n’est pas effectué.
∑ Blend Weights. Sert lorsque des personnages disposent d’une ossature d’animation, en
contrôlant son niveau de complexité. Unity Technologies conseille d’utiliser l’option
2 Bones pour obtenir un bon compromis entre performance et qualité visuelle.
∑ Texture Quality. Comme son nom l’indique, ce paramètre déinit l’importance de la
compression des textures.
∑ Anisotropic Textures. Le iltrage anisotropique peut contribuer à améliorer l’apparence
des textures vues sous un angle prononcé, comme les collines, mais le coût en termes de
performances est important. Gardez à l’esprit que vous pouvez également conigurer le
iltrage de chaque texture dans les paramètres Import Settings des ressources.
∑ Anti Aliasing. Pour adoucir les contours des éléments en 3D, ce qui améliore considé-
rablement l’aspect du jeu. Comme pour les autres iltres cependant, le coût est élevé.
∑ Soft Vegetation. Permet aux éléments de terrain de Unity, comme la végétation et les
arbres, d’utiliser le paramètre alpha blending. Cela donne un meilleur aspect aux
zones transparentes des textures utilisées pour représenter la végétation.
∑ Sync to VBL. Ce paramètre force le jeu à se synchroniser avec le taux de rafraîchis-
sement du moniteur du joueur. En général, cela entraîne une dégradation des perfor-
mances mais permet d’éviter l’effet de "déchirure" entre les éléments dans le jeu : les
sommets semblent mal alignés si bien que les textures s’afichent décalées et séparées
par une coupure horizontale.
278 Développez des jeux 3D avec Unity

Vous pouvez modiier ces réglages prédéinis si cela apporte un avantage pour le joueur,
puisque ce dernier aura la possibilité de les redéinir dans la boîte de dialogue Résolution
Dialog (voir la section "Créer une version autonome" de ce chapitre) lors du lancement du
jeu, à moins que vous n’ayez désactivé cette option. Toutefois, nous vous conseillons, dans
la plupart des cas, d’utiliser les réglages prédéinis de Unity comme guides et de simple-
ment ajuster certains paramètres en particulier, si cela est nécessaire.

Les paramètres d’entrée du lecteur

Bien que le joueur puisse ajuster les contrôles d’entrée de votre jeu sous l’onglet Input de
la boîte de dialogue Résolution Dialog (voir Figure 10.7) lorsqu’il s’agit d’une applica-
tion autonome, sachez que vous pouvez déinir vos propres valeurs de contrôle par défaut
dans les paramètres Player Input Settings. C’est particulièrement utile pour les jeux desti-
nés au Web, car le joueur ne peut alors pas modiier ces paramètres lors du chargement du
jeu. Il est donc préférable que vous les déinissiez et les indiquiez au joueur dans l’interface
graphique du jeu.

Figure 10.7

Dans Unity, cliquez sur Edit  > Project Settings  > Input pour aficher les axes de
contrôle disponibles dans le panneau Inspector. La valeur Size indique simplement le
nombre de contrôles existants. En augmentant cette valeur, vous pouvez créer vos propres
contrôles. Vous pouvez également cliquer sur la lèche grise à gauche de chaque paramètre
d’entrée pour aficher les axes disponibles et ajuster leurs valeurs.
Chapitre 10 Compilation et partage 279

Figure 10.8

Vous pouvez voir comment lier ces axes dans le script CoconutThrow que vous avez écrit
plus tôt :
if(Input.GetButtonUp("Fire1")

Ici, l’axe Fire1 est référencé par son nom. En changeant la valeur du paramètre Name dans
les paramètres d’entrée, vous pouvez déinir ce qui doit être écrit dans le script. Pour plus
d’informations sur les touches que vous pouvez lier à ces paramètres, reportez-vous à la
page Input du manuel de référence de Unity disponible à l’adresse suivante :
http://unity3d.com/support/documentation/Manual/Input.html.
280 Développez des jeux 3D avec Unity

Diffuser votre création

Vous pouvez non seulement intégrer votre lecteur web dans votre propre site, mais aussi
passer par différents portails de jeux indépendants qui permettent aux développeurs de
partager leurs travaux.
Voici quelques sites que nous vous recommandons de visiter au moins une fois lorsque
vous serez prêt à partager votre création avec la communauté en ligne :
∑ www.shockwave.com
∑ www.wooglie.com
∑ www.blurst.com
∑ www.tigsource.com (The Independent Gaming source)
∑ www.thegameslist.com
∑ http://forum.unity3d.com (section Showcase)
∑ www.todaysfreegame.com
∑ www.learnUnity3d.com
Il est important que vous partagiez votre travail avec d’autres personnes, non seulement
pour démontrer vos talents de développeur, mais aussi pour avoir leur avis sur votre jeu et
permettre à ceux qui ne connaissent pas votre projet de tester son fonctionnement.
Ce retour impartial est crucial car il vous permet d’éliminer les bogues et de corriger les
parties de votre jeu dont le fonctionnement ou le but, évidents pour vous, se révèlent peu
intuitifs pour le joueur ordinaire.
Sachez également que certains sites ne pourront pas héberger votre jeu au format .unityweb
mais seront prêts à indiquer un lien vers votre propre blog qui intègre le jeu ou sur lequel
une version autonome peut être téléchargée.

En résumé
Vous avez vu comment exporter votre jeu sur le Web et en tant qu’application autonome.
En conclusion, nous allons revoir tout ce que nous avons abordé au cours de ce livre et nous
vous indiquerons comment améliorer vos compétences et où chercher de l’aide pour vos
futurs développements dans Unity.
 11
Procédures de tests et
lectures complémentaires
Nous avons abordé tout au long de cet ouvrage les sujets essentiels pour vous aider à déve-
lopper avec le moteur de jeu Unity. Vous découvrirez que chaque nouvel élément de jeu
que vous développerez dans Unity vous offrira de nouvelles possibilités d’améliorer vos
connaissances. Mieux vous connaîtrez le fonctionnement des scripts et plus vous aurez des
idées et des concepts de jeux. Au cours de ce chapitre, nous allons voir :
∑ comment tester et inaliser votre travail ;
∑ comment mesurer le nombre d’images par seconde pour les testeurs ;
∑ où trouver de l’aide sur Unity et ce que vous devez étudier ensuite.
Pour améliorer vos compétences, vous devriez prendre le temps d’approfondir vos connais-
sances dans les domaines suivants :
∑ le script ;
∑ le script ;
∑ le script.
282 Développez des jeux 3D avec Unity

Ce n’est pas de l’humour ! Unity s’enorgueillit d’offrir une interface graphique et des outils
intuitifs permettant de créer des scènes et des objets de jeu et de développer des jeux d’une
manière visuelle, mais vous devez absolument apprendre les classes et les commandes qui
constituent le moteur de Unity lui-même.
En lisant le manuel de Unity, ainsi que les guides de référence Component Reference et
Script Reference, qui s’installent avec le programme Unity et sont également disponibles en
ligne, vous verrez quelles sont les meilleures méthodes pour créer tous les types d’éléments
de jeu. Elles peuvent ne pas s’appliquer à votre projet en cours mais elles devraient vous
aider à travailler plus eficacement sur le long terme :
∑ le manuel de référence des composants (http://www.unity3d.com/support/
documentation/Components/) ;
∑ le manuel de référence des scripts (http://www.unity3d.com/support/documentation/
ScriptReference/) ;
∑ le manuel de Unity (http://www.unity3d.com/support/documentation/Manual/).

Les tests et la inalisation

Pour le développement d’un jeu, il est particulièrement important de le faire tester par des
utilisateurs qui n’ont aucune idée préconçue. Quel que soit votre projet, vous devez rester
objectif, être ouvert aux critiques et considérer les tests comme une nécessité technique.
En tant que développeur, vous connaissez les principes et les mécanismes de votre jeu, si
bien que vous êtes souvent incapable de voir "l’arbre qui cache la forêt" et d’envisager les
réactions des joueurs.

Les tests publics

Lorsque vous voulez faire tester votre jeu, envoyez des versions de test à différentes
personnes capables de vous fournir en retour les informations suivantes :
∑ La coniguration de leur ordinateur : veillez à ce que votre jeu soit testé sur des machines
différentes ain d’en savoir plus sur les performances du jeu.
∑ Le format : essayez d’envoyer une version de test pour Mac OS et Windows chaque fois
que c’est possible.
∑ La langue : vos testeurs parlent-ils tous la même langue que vous ? Peuvent-ils vous dire
si vous expliquez convenablement les éléments du jeu dans les interfaces ?
Chapitre 11 Procédures de tests et lectures complémentaires 283

On appelle version bêta la version publique du jeu proposée à plusieurs testeurs – la version
alpha étant la version de test que d’autres développeurs et vous-même testez. En forma-
lisant ce processus, vous pouvez obtenir des retours très utiles. Pour cela, établissez un
questionnaire commun pour tous les testeurs ain de connaître leur avis sur le jeu mais
également ain de recueillir des informations sur chacun d’eux en tant que joueur. De cette
façon, vous pouvez tirer certaines conclusions sur votre jeu. Par exemple :
"Les joueurs de 18 à 24 ans comprennent le but du jeu et aiment ses méca-
nismes mais les joueurs de plus de 45 ans ne comprennent pas ce qu’ils doivent
faire sans lire les instructions."
en plus des informations techniques suivantes :
"Les joueurs dont le processeur a une fréquence inférieure à 2,4 GHz trouvent
que le jeu réagit lentement."

Le nombre d’images par seconde

Ain que les testeurs de votre jeu puissent vous fournir des informations précises sur
les aspects techniques, comme le nombre d’images par seconde (la vitesse à laquelle les
images du jeu s’afichent pendant l’exécution), vous pouvez ajouter un élément d’interface
graphique indiquant cette valeur.
Nous ajouterons cette indication dans une scène à travers un exemple concret. Ouvrez
la scène pour laquelle vous souhaitez aficher le nombre d’images en superposition, puis
cliquez sur GameObject > Create Other > GUI Text pour créer un nouvel objet GUI
Text qui afiche ces informations. Renommez cet objet FPS Displayer, puis déinissez
le paramètre Anchor sur upper center et le paramètre Alignment sur center dans le
composant GUIText du panneau Inspector.
Sélectionnez le dossier Scripts dans le panneau Project, cliquez sur le bouton Create et
sélectionnez JavaScript dans le menu déroulant. Renommez ce script FPSdisplay puis
double-cliquez sur son icône pour l’ouvrir dans l’éditeur de script.
Comme le nombre d’images par seconde du jeu varie selon la coniguration matérielle et
logicielle, vous devez effectuer une somme qui tienne compte du nombre d’images qui sont
rendues dans le jeu à chaque seconde. Pour commencer, déclarez les variables suivantes au
début du script :
private var updatePeriod = 0.5;
private var nextUpdate : loat = 0;
private var frames : loat = 0;
private var fps : loat = 0;
284 Développez des jeux 3D avec Unity

Ces quatre variables sont déclarées pour les raisons suivantes :

∑ updatePeriod. Le nombre de fois par seconde où le texte de l’interface graphique doit
être mis à jour, et donc la période pendant laquelle le script évalue le nombre d’images
rendues. Avec une valeur de  0.5, le texte est actualisé chaque demi-seconde, ce qui
permet au testeur de le lire facilement – avec une valeur inférieure, le chiffre serait mis
à jour trop souvent pour être lu aisément. Avec une valeur supérieure, une seconde par
exemple, le résultat serait moins précis, car la fréquence des images peut varier considé-
rablement en une seule seconde.
∑ nextUpdate. Cette valeur stocke le moment où vous devez vériier et mettre à jour le
nombre d’images par seconde.
∑ frames. Un numéro incrémenté à chaque image qui stocke la quantité d’images qui ont
été rendues.
∑ fps. Stocke le nombre d’images par seconde. Cette valeur correspond au nombre
d’images courant et s’obtient en divisant la valeur de la variable frames par la variable
updatePeriod.
Insérez ensuite le code suivant dans la fonction Update() :
frames++;
if(Time.time > nextUpdate){
fps = Mathf.Round(frames / updatePeriod);
guiText.text = "Images par seconde : " + fps;
nextUpdate = Time.time + updatePeriod;
frames = 0;
}

Ce script effectue les opérations suivantes :

∑ La variable frames s’incrémente de 1 chaque fois que la fonction Update() s’exécute
(après chaque image).
∑ L’instruction if attend que la valeur de Time.time – qui décompte en réel le temps
écoulé depuis le début du jeu – soit supérieure à la valeur de la variable nextUpdate.
Comme nextUpdate a une valeur de 0 au lancement du jeu, cela se produit immédia-
tement après le chargement de la scène dans laquelle ce script se trouve.
∑ Cette instruction if déinit ensuite si la variable fps est égale à une valeur arrondie du
décompte des images divisée par la valeur de updatePeriod, ain d’obtenir un chiffre
entier du nombre d’images par seconde et non par demi-seconde – la valeur de 0.5 de la
variable updatePeriod.
∑ Le script s’adresse au paramètre text du composant guiText et lui donne comme valeur
la chaîne de caractères "Images par seconde :" suivie de la valeur de la variable fps.
Chapitre 11 Procédures de tests et lectures complémentaires 285

∑ La valeur de la variable nextUpdate est déinie comme égale à la somme de la valeur

actuelle de time et de la variable updatePeriod. C’est essentiel pour que l’instruction if
s’exécute de nouveau une demi-seconde plus tard.
∑ Enin, la variable frames est réinitialisée pour que l’évaluation puisse recommencer à
partir de zéro.
Insérez maintenant la ligne suivante après la fermeture de la fonction Update(), ain de
vous assurer que vous attachez ce script à un objet disposant d’un composant GUIText :
@script RequireComponent(GUIText)

Cliquez sur File > Save dans l’éditeur de script puis revenez dans Unity. Assurez-vous que
l’objet FPS Displayer est toujours sélectionné dans le panneau Hierarchy, puis donnez la
valeur 0,9 ou 1 à son paramètre Position Y. Cliquez ensuite sur Component > Scripts >
FPS display. Testez ensuite votre scène. L’objet GUI Text indiquant le nombre d’images
par seconde s’afiche en haut de l’écran.
Votre jeu se comporte différemment en dehors de l’éditeur de Unity. Par conséquent, vous
devez tenir compte uniquement des mesures qu’afiche l’objet FPS Displayer après avoir
compilé le jeu, qu’il s’agisse d’une version destinée au Web ou d’une application auto-
nome. Demandez ensuite aux testeurs de noter les valeurs maximales et minimales ain
de disposer de données utilisables. Demandez également si certaines parties de votre jeu,
comme les animations complexes de particules, ne sont pas particulièrement exigeantes.
Demander des relevés distincts peut être intéressant lorsque ces éléments sont actifs.
Comme le jeu fonctionne différemment à l’intérieur et en dehors de l’éditeur de Unity, les
valeurs afichées dans le jeu seront différentes de celles données dans l’onglet Stats du
panneau Game (voir Figure 11.1).

Figure 11.1
286 Développez des jeux 3D avec Unity

L’amélioration des performances

L’amélioration des performances de votre jeu en fonction des tests est un domaine d’étude
à part entière. Cependant, nous vous conseillons de tenir compte des points suivants pour
vos développements futurs :
∑ Le nombre de polygones. Les modèles 3D que vous importez doivent être conçus avec
un nombre restreint de polygones (appelés aussi modèles low poly). Vous devez donc
essayer de simpliier vos modèles autant que possible pour améliorer les performances.
∑ La distance d’afichage. Pensez à réduire la distance du paramètre Far Clip Plane
pour vos caméras ain que le jeu effectue le rendu d’une quantité moindre de terrain.
∑ La taille des textures. Intégrer des textures en haute résolution peut améliorer la clarté
visuelle, mais elles sollicitent également davantage le moteur du jeu. Essayez de réduire
leur taille autant que possible, en utilisant votre logiciel de retouche d’image et en
ajustant les paramètres d’importation de vos ressources.
∑ Des scripts eficaces. Il existe plusieurs façons différentes d’écrire un script, aussi
vous devez adopter la méthode la plus eficace. Commencez par lire le guide en ligne
d’optimisation des scripts dans Unity (http://unity3d.com/support/documentation/
ScriptReference/index.Performance_Optimization.html).
∑ La présentation vidéo. Regardez cette présentation sur l’optimisation des performances
de Joachim Ante, le programmeur en chef de Unity Technologies (http://unity3d.com/
support/resources/unite-presentations/performance-optimization).

Les méthodes d’apprentissage

Au fur et à mesure que vous progresserez, vous aurez besoin de développer une méthode
d’étude. Sachez quand persévérer dans vos recherches pour trouver la solution par vous-
même et quand demander de l’aide aux développeurs plus expérimentés. Si vous suivez les
conseils présentés ci-après, vous devriez pouvoir aider les autres membres de la commu-
nauté au fur et à mesure que vous améliorez vos connaissances.

Couvrir le plus de bases possible

Il est fréquent de devoir apprendre un nouveau logiciel ou un nouveau langage de program-
mation dans un certain délai, que cela soit dans le cadre de votre travail ou en indépendant.
Cela peut souvent conduire à une approche qui consiste uniquement à apprendre le strict
Chapitre 11 Procédures de tests et lectures complémentaires 287

nécessaire. Mais cette méthode se révèle souvent nuisible à long terme, car elle crée de
mauvaises habitudes que l’on conserve ensuite – à tel point qu’on en arrive à utiliser des
méthodes ineficaces.
C’est pourquoi nous vous conseillons de prendre le temps de lire la documentation ofi-
cielle chaque fois que vous le pouvez. Même si vous êtes bloqué sur un problème de déve-
loppement en particulier, elle peut souvent vous aider à le considérer sous un jour différent.

Ne pas hésiter à demander de l’aide

Il est également utile d’observer la manière dont les autres développeurs procèdent pour
créer un élément de jeu. Vous découvrirez qu’il existe souvent plusieurs méthodes pour
aborder le même problème (voir l’ouverture de la porte de l’avant-poste au Chapitre  5,
"Éléments préfabriqués, collections et HUD"). Il est souvent tentant de recycler les compé-
tences acquises pour résoudre un problème précédent, mais nous vous conseillons toujours
de vériier plusieurs fois que la méthode choisie est la plus eficace.
En demandant des informations sur le forum ou sur le canal IRC (Internet Relay Chat) de
Unity, vous pourrez dégager un consensus sur la manière la plus eficace d’effectuer une
tâche de développement en particulier – le plus souvent pour découvrir que votre première
approche du problème était beaucoup plus complexe que nécessaire.
Lorsque vous sollicitez de l’aide, n’oubliez pas d’indiquer chaque fois que possible :
∑ Ce que vous essayez d’obtenir.
∑ Quelle approche vous semble la meilleure.
∑ Ce que vous avez essayé jusqu’à présent.
Ces informations permettront aux autres de vous aider le mieux possible. Pour que les
réponses soient adaptées à votre problème, dévoilez autant d’informations que possible,
même si vous pensez qu’elles n’ont pas d’importance.
La communauté Unity encourage l’apprentissage par l’exemple. Les sites tiers basés sur
des wikis (www.unifycommunity.com/wiki) contiennent de très nombreux exemples de
scripts et de plugins, de didacticiels, et bien plus encore. Vous trouverez des extraits de code
utiles, libres de droits, pour compléter les exemples de scripts dans le manuel de référence
et même des informations sur la façon d’implémenter ce code grâce à des didacticiels.
288 Développez des jeux 3D avec Unity

En résumé
Vous avez vu comment dépasser le cadre de cet ouvrage et comment recueillir des infor-
mations auprès des testeurs pour améliorer votre jeu.
Il ne nous reste plus qu’à vous souhaiter bonne chance pour vos développements futurs
dans Unity. Toutes les personnes qui ont contribué à la création de cet ouvrage vous remer-
cient de l’avoir lu et espèrent que vous l’avez apprécié – ce n’est que le commencement !
 Index

Symboles A
@script (commandes) 97 Animations
3D déclencher par script 115
caméras 9 désactiver 109
coordonnées 8 Application.LoadLevel() (commande) 222
éléments Assets (menu) 22
corps rigides 11 Audio
détection de collision 12 composant Audio Source 51
polygones 10 formats 49
shader 10 paramètres 51
textures 10 Rolloff Factor 51
espace local et espace global 8 stéréo et mono 49
matériaux 10 Axe Z 8
modèles 60
ajouter dans la scène 196, 206
B
animations 58 Boîtes de dialogue
format de ichier 57 Create Lightmap 26
importer 176 Project Wizard 23
matériaux 58 Resolution Dialog 271
paramètres communs 57 Build Settings (paramètres)
rotation 206 OS X Dashboard Widget 267
programmes de modélisation externe 22 OS X/Windows Standalone 268
vecteurs 9 Web Player Streamed 266
290 Développez des jeux 3D avec Unity

C E
Caméras Éditeur de terrain
FOV 9 composant Terrain (Script) 28
Main Camera (objet) 76 Terrain Settings 33
Collisions, détection conigurer le terrain 35
a priori 103 arbres 44
audio 48
collecte d’objets 144
contour 35
Composants
détails 45
Animation 18
lumières 47
Collider 12, 99 textures 40
Ellipsoid Particle Emitter 192 fonctionnalités, Mass Place Trees 27
FBX Importer 57 outils
Meshes 57 Paint Details 33
GUI Texture 136 Paint Height 30
Importer 58 Paint Texture 31
Mesh Collider 12 Place Trees 32
Mesh Particle Emitter 192 Raise/Lower Terrain 29
Particle Animator, Color Animation 200 Smooth Height 30
références 282 Éléments préfabriqués
réinitialiser 164, 202 corps rigides 162
Rigidbody 12 créer 160
supprimer 164 dans le panneau Inspector 67
Trail Renderer 247 enregistrer 163
Transform 18 mettre à jour 249
vériier la présence (script) 169 modiier 246
Coordonnées cartésiennes 8 rupture du lien 179, 197
Corps rigides 160 texture 161
composant Rigidbody 159 Enregistrer, scripts 133
paramètres 159 Espaces 3D, de l’objet 8
forces 159
F
CSS (Cascading Style Sheets ou feuilles de
styles en cascade) 214 First Person Controller 53, 79
Audio Listener 79
D Camera 76
Character Controller 71
Destroy() (commande) 175, 210 contrôle au clavier 54
Détection de collision 127 FPSWalker (Script) 71
cibles 179 Graphics 74
composant Capsule Collider 197 GUILayer 78
désactiver 124 Mesh Filter 75
mode Déclencheur 129, 132 Mesh Renderer 75
supprimer les collisions inutiles 169 Mouse Look (Script) 73, 79
DrawTexture (commande) 259 Transform 71
 Index 291

G pour le Web
bouton quitter 269
Game Object 13 intégration HTML 275
gameObject.name (commande) 207 résolution 19
Game (panneau) 19 tester
GetButtonUp() (commande) 173 dans Unity 54, 211
GIF (Graphics Interchange Format) 218 tests publics 285
GUI.color.a (commande) 259
L
H
Lightmap 26
Heightmaps 25 Lumières
ambiante 250
I directionnelle 47, 54
point 47
IgnoreCollision() (commande) 170
spot 47
Instanciation 158
élément préfabriqué 167 M
nommer les occurrences 168
Mathf.Lerp (commande) 259
restreindre 172
Menus 238
script 157
boutons 257
supprimer des objets 175 choix de la méthode 237
vitesse 168 créer 215, 218
Instantiate() (commande) 157, 168 une scène 215
Interfaces graphiques 142 et interfaces 214
aficher un objet 207 GUI skin 214, 237
classe GUI (script) 259 boutons 231
GUI Text 148, 152, 251 lancer des scènes 232
interpolation linéaire 252 modiier l’apparence 233
indices pour le joueur 152 script 233
animations 147 GUI Texture 214, 227
informer le joueur 187 bouton
positionner 229 Instructions 224
textures Play 220
GUI Texture 138 quitter 224
résolution 219
viseur 186
Terrain
J heightmaps
importer et exporter 25
Jeu résolution 25
collecte d’objets 144, 207 Moteur physique 11
paramètres, Build Settings 268 propriétés 12
292 Développez des jeux 3D avec Unity

O d’entrée 279
qualité 278
Objets pour le Web 271, 275
collecter dans le jeu 144 résolution 265
de jeu (GO) 13
désactiver 227 R
dupliquer 183
Raycasting 104, 126
effet de rotation 132
RequireComponent() (commande) 181, 222
éléments préfabriqués
Ressources, importer 23, 195, 215, 242
créer 134
dupliquer 134 S
enregistrer 133
importer 130 Scènes
tags 131 apparition en fondu 259
relations parent-enfant 8, 68 dupliquer 217
Outils enregistrer 55
Hand 17 Instructions 255
Scale 17 placer un modèle 3D 105
Translate 17 redimensionner un modèle 3D 106
regrouper les objets 217
P Scripts
attacher à un objet 123, 170, 182, 185
Panneaux bases 89
aficher en plein écran 219 cibles
Game 19 réinitialiser 180
Hierarchy 17 vériier le nombre de cibles abattues 185
Inspector 18, 67 classes
calques 66 Collision 180
tags 65 Input 167
Project 19 Physics 170
bouton Create 19 collecte d’objets 207
Scene 17 commandes 80
outils 17 Application.LoadLevel() 222
Performances, améliorer 250, 286 Destroy() 143, 210
distance d’afichage 249 DrawTexture 259
PNG (Portable Network Graphics) 136, 218 GameObject.Find() 146
Programmation 79 gameObject.name 207
Projet 23 GetComponent() 146
application autonome 273 GUI.color.a 259
diffusion 280 Instantiate() 157, 168
dossiers 19 Mathf.Lerp 259
générer 280 RequireComponent 222
lecteur web 268 @script 97
paramètres time() 253
 Index 293

Time.deltaTime() 150 Particle Renderer 193, 201, 204

time.time 253 créer 198, 203
transform.rotation 208 feu 203
yield 260 fumée 204
commentaires 88, 174 déinition 192
conditions 87 désactiver 206
if else 85 émetteur de particules 192
multiples 87 matériau 202, 243
contrôler, audio 167 ombres 201
créer 139 paramètres 243
débogage 120, 211, 223, 226 positionner 202, 204, 240
éditeurs Uniscite et Unitron 15 rendu 193
enregistrer 133 tester 203, 246
fonctions 85
traînées de lumière 249
améliorer 118
transparence 202
écrire 84, 113
volcan 244
Update() 84, 111
FPS Walker 97 T
inclure composant 170
lancer des objets 172 Tags, Tag Manager 65
contrôles en entrée 166 Terrain
mettre en pause 260 mer 52
références 282 textures
restreindre l’accès à des objets 146 Splats 31
syntaxe à point 88 Tester le jeu 54, 211
transmettre en paramètres 157 Textures
variables 83 compresser 271
publiques 222 désactiver le mip mapping 218
publiques et privées 82 rendu de UnityGUI 259
statiques 87 résolution 11, 26
types de données 81 TIFF (Tagged Image File Format) 218
utilisation 82 time (commande) 253
victoire du joueur 183 time.time (commande) 253
Start() (commande) 175 transform.parent (commande) 170
Systèmes de particules 211
transform.root (commande) 170
animation 193
transform.rotation (commande) 208
audio 205, 245
composants U
Ellipsoid Particle Emitter 192, 198, 203,
244 Unitron et Uniscite 15
Mesh Particle Emitter 192 Unity
paramètres 192 différences entre les versions 273
Particle Animator 193, 199, 203, 244 éditeurs de scripts Uniscite et Unitron 15
294 Développez des jeux 3D avec Unity

Unity (suite) projet 23

fonctionnalités 27 application autonome 273
interface 20 diffusion 280
menus dossiers 19
Assets 22 générer 280
Edit 18 paramètres
méthodes d’apprentissage 286 d’entrée 279
de qualité 278
outils 34
pour le Web 271, 275
paramètres Build Settings 224
résolution 265
principes de fonctionnement 15 références 282
Composants 14 ressources 22
éléments préfabriqués 15 dépendances 22
Objets de jeu 14 tester le jeu 54, 211
ressources 13
scènes 14 Y
scripts 14 yield (commande) 260
jeux 3D
Développez des TABLE DES MATIÈRES

• Bienvenue dans la troisième

dimension

Unity
• Environnements
avec
• Personnages jouables

• Interactions

• Éléments préfabriqués, collections

et HUD
Unity est une petite révolution : outil de développement
• Instanciation et corps rigides
3D et moteur de jeux, il permet de produire simplement,
• Systèmes de particules
grâce à une interface d’intégration d’objets et de scripts
très intuitive, des jeux de standard professionnel pour • Conception de menus
Mac, PC et le Web. Une version du moteur existant éga- • Dernières retouches
lement pour la Wii, l’iPhone et l’Android, il offre un accès
• Compilation et partage
aux consoles et aux mobiles une fois que vous en maîtri-
sez les bases. • Procédures de tests et lectures
complémentaires
Ce livre vous explique tout ce qu’il faut savoir pour
prendre en main Unity et être en mesure de développer
ses propres jeux. Il propose un ensemble d’exemples fa-
ciles qui vous conduiront à la réalisation d’un jeu de tir à
la première personne (FPS) en 3D sur une île – un environ-
nement avec lequel le joueur pourra interagir. Partant des
concepts communs aux jeux et à la production 3D , vous
verrez comment utiliser Unity pour créer un personnage Á propos de l’auteur…
jouable et comment réaliser des énigmes que le joueur Will Goldstone est concepteur et formateur dans le
devra résoudre pour terminer la partie. domaine de l’interactivité. Ayant découvert Unity dans
sa première version, il s’emploie depuis à promouvoir le
À la fin de ce livre, vous disposerez d’un jeu en 3D en- développement de jeux accessible à tous.
tièrement fonctionnel et de toutes les compétences re-
quises pour en poursuivre le développement et proposer
à l’utilisateur final, le joueur, la meilleure expérience vidéo-
ludique possible.
Niveau : Tous niveaux
Les codes sources du livre sont disponibles sur Catégorie : Développement de jeux
www.pearson.fr. Configuration : PC / Mac

ISBN : 978-2-7440-4141-9
Pearson Education France
47 bis, rue des Vinaigriers 75010 Paris
Tél. : 01 72 74 90 00
Fax : 01 42 05 22 17
www.pearson.fr