Developper Des Jeux 3D Avec Unity

http://www.free-livres.
com/
jeux 3D Unity
avec
Dveloppez des
Codes sources
Will Goldstone
LE P R O G RAM M E U R
Dveloppez des jeux 3D avec Unity

Will Goldstone
Traduit par Philippe Beaudran, avec la contribution technique de Nicolas Colliot, responsable dveloppement chez Yamago
Pearson Education France a apport le plus grand soin la ralisation de ce livre afin de vous fournir une information complte et fiable. Cependant, Pearson Education France nassume de responsabilits, ni pour son utilisation, ni pour les contrefaons de brevets ou atteintes aux droits de tierces personnes qui pourraient rsulter de cette utilisation. Les exemples ou les programmes prsents dans cet ouvrage sont fournis pour illustrer les descriptions thoriques. Ils ne sont en aucun cas destins une utilisation commerciale ou professionnelle. Pearson Education France ne pourra en aucun cas tre tenu pour responsable des prjudices ou dommages de quelque nature que ce soit pouvant rsulter de lutilisation de ces exemples ou programmes. Tous les noms de produits ou marques cits dans ce livre sont des marques dposes par leurs propritaires respectifs.
Publi par Pearson Education France 47 bis, rue des Vinaigriers 75010 PARIS Tl. : 01 72 74 90 00 www.pearson.fr Mise en pages : TyPAO Copyright 2010 Pearson Education France Tous droits rservs
Titre original: Unity Game Development Essentials Traduit de langlais par Philippe Beaudran avec la contribution technique de Nicolas Colliot ISBN original: 978-1-847198-18-1 Copyright original: 2009 Packt Publishing All rights reserved dition originale publie par Packt Publishing Ltd 32 Lincoln Road, Olton Birmingham, B27 6PA, UK www.packtpub.com
ISBN : 978-2-7440-4141-9
Aucune reprsentation ou reproduction, mme partielle, autre que celles prvues larticle L. 122-5 2 et 3 a) du code de la proprit intellectuelle ne peut tre faite sans lautorisation expresse de Pearson Education France ou, le cas chant, sans le respect des modalits prvues larticle 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 matires
Prface. ............................................................... 1 1. Bienvenue dans la troisime dimension....... 7 Comprendre la 3D. .......................................... 7 Les coordonnes. .............................................. 8 Lespace local et lespace global. .................... 8 Les vecteurs. ..................................................... 9 Les camras...................................................... 9 Les polygones, les artes, les sommets et les maillages. ................................................ 10 Les matriaux, les textures et les shaders......... 10 La physique des corps rigides. ......................... 11 La dtection de collision................................... 12 Les concepts essentiels de Unity.................... 12 Le fonctionnement de Unity.............................. 13 Linterface....................................................... 16 Les panneaux Scene et Hierarchy..................... 17 Le panneau Inspector........................................ 18 Le panneau Project........................................... 19 Le panneau Game............................................. 19 En rsum....................................................... 20
2. Environnements............................................. 21 Les logiciels de modlisation externes. ............ 22 Les ressources................................................... 22 Votre premier projet Unity.............................. 23 Lditeur de terrain.......................................... 24 Les fonctionnalits du menu Terrain................. 24 Les outils de terrain.......................................... 28 Soleil, mer et sable: la cration de lle........... 35 Importer des modles. ...................................... 55 Le paramtrage du modle davant-poste........ 59 En rsum....................................................... 61 3. Personnages jouables..................................... 63 Le panneau Inspector...................................... 64 Les tags............................................................. 65 Les calques (layers).......................................... 66 Les lments prfabriqus dans le panneau Inspector............................................................ 67 Lobjet First Person Controller en dtail......... 67 Les relations parent-enfant .............................. 68 Les objets de First Person Controller ............... 69 Objet 1. Lobjet First Person Controller (parent)70 Objet 2. Lobjet Graphics.................................. 74 Objet 3. Lobjet Main Camera.......................... 76
IV
...................... 79 Les bases de la programmation. Le script FPSWalker....................................... 89 Lancer le script................................................. 89 Le script en dtail............................................. 91 En rsum....................................................... 97 4. Interactions. ................................................... 99 Les collisions.................................................. 100 Le raycasting................................................... 101 Limage manquante. .........................................102 La dtection de collision a priori......................103 Lajout de lavant-poste. .................................. 104 Positionner le modle. ......................................105 Redimensionner le modle................................106 Colliders et tag de la porte...............................106 Dsactiver lanimation automatique................109 Louverture de la porte.................................... 110 Mthode 1. La dtection de collision................110 Mthode 2. Le raycasting. ................................124 En rsum....................................................... 126 5. lments prfabriqus, collections et HUD................................................................ 129 La cration de llment prfabriqu batterie......................................... 130 Tlcharger, importer et positionner.................130 Ajouter un tag...................................................131 chelle, collider et rotation. .............................132 Enregistrer comme lment prfabriqu...........133 Disperser les batteries..................................... 134 Laffichage dune interface graphique pour la pile...................................................... 135 Crer lobjet GUI Texture.................................136 Positionner lobjet GUI Texture........................137 Modifier linterface graphique laide dun script. ..........................................139 La collecte des piles avec des dclencheurs. ... 142
Restreindre laccs lavant-poste................. 144 Restreindre laccs. ..........................................145 La commande GetComponent()........................146 Des indices pour le joueur................................147 En rsum....................................................... 153 6. Instanciation et corps rigides........................ 155 Prsentation de linstanciation........................ 156 Le concept.........................................................156 Le script............................................................157 Prsentation des corps rigides......................... 158 Les forces..........................................................159 Le composant Rigidbody..................................159 Crer le mini-jeu............................................. 160 Crer llment prfabriqu pour la noix de coco. ........................................160 Crer lobjet Launcher......................................163 Le script du lancer de noix de coco..................165 Assigner le script et les variables.....................170 Restrictions de linstanciation..........................172 Ajouter la plate-forme. .....................................176 Gagner la partie. ..............................................183 La touche finale. ...............................................186 En rsum....................................................... 189 7. Systmes de particules................................... 191 Quest-ce quun systme de particules?. ........ 192 Lmetteur de particules...................................192 Lanimateur de particule..................................193 Le rendu des particules.....................................193 Le but du jeu................................................... 195 Tlcharger les ressources................................195 Ajouter le tas de bois........................................196 Crer les systmes de particules pour le feu. ...197 Allumer le feu. ..................................................206 Tests et confirmation....................................... 210 En rsum....................................................... 211

8. Conception de menus. ................................... 213 Les interfaces et les menus............................. 214 Crer le menu principal....................................215 La cration du menu mthode1. .................. 220 Ajouter le bouton Play/Jouer............................220 Ajouter le bouton des instructions....................224 Ajouter le bouton Quit/Quitter. ........................224 Utiliser les commandes de dbogage pour vrifier les scripts.....................................226 La cration du menu mthode 2. .................. 227 Dsactiver les Game Objects............................227 Rdiger un script OnGUI() pour un menu simple. .......................................228 Lheure des dcisions........................................237 En rsum....................................................... 238 9. Dernires retouches....................................... 239 Le volcan. ........................................................ 240 Positionner le systme de particules.................240 Importer les ressources.....................................242 Crer un matriau pour la fume. ....................243 Les paramtres du systme de particules . .......243 Ajouter le son du volcan...................................245 Tester le volcan.................................................246 Tranes de lumire......................................... 246 Modifier llment prfabriqu.........................246 Le composant Trail Renderer............................247 Mettre jour llment prfabriqu. ................249 Lamlioration des performances.................... 249 Modifier la distance du rendu des objets et ajouter du brouillard.....................................249 La lumire ambiante.........................................250 La scne Instructions...................................... 251 Ajouter du texte lcran. ................................251
Table des matires
Animer le texte avec linterpolation linaire....252 Revenir au menu...............................................255 Lapparition en fondu de la scne Island Level.................................. 258 Le rendu de la texture UnityGUI......................259 Notifier la fin du jeu........................................ 260 En rsum....................................................... 261 10. Compilation et partage................................ 263 Les paramtres Build Settings........................ 264 .........................................265 Loption Web Player. Loption Web Player Streamed.........................266 Loption OS X Dashboard Widget . ..................267 Les options OSX/Windows Standalone. ............268 Gnrer le jeu.................................................. 268 Adapter les paramtres pour le Web.................268 La compression des textures et le dbogage.....271 Crer une version autonome.............................271 Compiler pour le Web.......................................274 Les paramtres de qualit............................... 275 Les paramtres dentre du lecteur................. 278 Diffuser votre cration.................................... 280 En rsum....................................................... 280 11. Procdures de tests et lectures complmentaires.............................. 281 Les tests et la finalisation................................ 282 Les tests publics................................................282 Les mthodes dapprentissage........................ 286 Couvrir le plus de bases possible.....................286 Ne pas hsiter demander de laide................287 En rsum....................................................... 288 Index. .................................................................. 289
propos de lauteur
Will Goldstone est concepteur et formateur dans le domaine de linteractivit et vit dans le Sud-Ouest de lAngleterre. Il passe beaucoup de temps en ligne concevoir des sites web et dvelopper des jeux, mais galement proposer des formations en ligne dans de nombreuses disciplines lies linteractivit. Ayant dcouvert Unity dans sa premire version, il semploie depuis promouvoir le concept de dveloppement de jeux accessible tous. Il utilise Unity pour crer des jeux destins au web et liPhone dApple. Vous pouvez contacter Will Goldstone par le biais de son blog www.willgoldstone.com , sur lequel vous en apprendrez plus sur ces diffrentes activits 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 ralisation de cet ouvrage, qui nexisterait pas sans eux. Je remercie galement les membres de lquipe Unity Technologies et les participants au canal IRC Unity pour leur patience lorsque jai commenc mintresser au dveloppement 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 joublie.
Prface
Unity est un outil de cration 3D pour Mac OS et Windows. Les moteurs de jeux sont lesmca nismes qui fonctionnent en coulisse de tous les jeux vido. Ce "moteur" prend les dcisions, quil sagisse des graphismes ou des mathmatiques qui rgissent chaque image lcran. partir du rendu laffichage des graphismes lcran, lintgration dune mthode de contrle et dun ensemble de rgles suivre pour le jeu , les dveloppeurs sappuient sur le moteur pour "construire" le jeu. Les moteurs de jeu3D actuels reposent sur une quantit impressionnante de code mticuleusement crit. Cest pourquoi ils sont souvent revendus, modifis et rutiliss, une fois que le jeu pour lequel ils ont t crs est termin. Le moteur Unreal Engine dEpic Games en est un bon exemple. Dvelopp lorigine, la fin des annes90 pour Unreal un jeu de tir la premire personne (FPS) , il a ensuite t rutilis sous licence par dautres dveloppeurs et a connu un norme succs dans des centaines de simulations et de jeux commerciaux plus rcents. En raison du niveau de complexit et du cot que reprsente la cration de tels moteurs de jeu commerciaux, il est trs difficile de se lancer dans lindustrie du jeu vido 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 sagit du langage le plus efficace 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 bibliothque C++ Mono (libre de droits et daccs au code source). Grce la compilation JIT, le code crit pour Unity est compil par Mono juste avant son excution. Cest essentiel pour les jeux qui doivent excuter du code des moments prcis. En plus de la bibliothque Mono, les fonctionnalits Unity tirent galement parti dautres bibliothques logicielles, comme le moteur physique PhysX de Nvidia, OpenGL et DirectX pour le rendu3D et OpenAL pour laudio. Toutes ces bibliothques sont intgres lapplication, si bien que vous naurez pas besoin dapprendre utiliser chacune dentre elles; il vous suffit dapprcier ce quelles vous permettent de raliser en toute transparence dans Unity. Les dveloppeurs de moteurs de jeux construisent galement des outils pour commander les fonctions de code quils ont cres. Par exemple, un ensemble dinstructions dfinit la forme (ou topographie) d'un terrain, son aspect visuel, et mme la faon dont sont gres ses dformations dans le jeu. Mais cet ensemble dinstructions serait inefficace en tant qulment du moteur de jeu sil ntait pas reli un outil visuel permettant de contrler ces proprits. Souvent, les dveloppeurs de moteur de jeu crent donc une interface
graphique (GUI, Graphical User Interface) afin que les membres de lquipe de dveloppement du jeu puissent plus facilement manipuler les lments du moteur. Ces outils facilitent non seulement le processus de cration du jeu mais rendent galement le moteur accessible aux acheteurs potentiels et aux quipes de postproduction. Cela est galement vrai pour Unity, et une trs importante communaut dutilisateurs partage ses outils sous forme de plugins. Pour en savoir plus, visitez le wiki de la communaut Unify ladresse: http://www.unifycommunity.com/wiki. Beaucoup de personnes tentes par le dveloppement se heurtent la difficult dapprendre les langages de programmation comme C++ et les moteurs qui lutilisent. Si on na pas suivi des tudes de programmation ou danimation par ordinateur, il est en effet difficile de se lancer dans lapprentissage des concepts, des mthodes et des principes de conception ncessaires la production de jeux vido. Unity Technologies est une des entreprises qui a dcid de rectifier cette situation. Aprs avoir cr son propre moteur de jeu en 2001, cette socit de dveloppement de jeux danoise a cherch rendre ses outils abordables en offrant une solution simple axe sur lutilisateur que tout le monde puisse utiliser. Lquipe a choisi de conserver le code source qui alimente le moteur dans les coulisses et de fournir une interface graphique complte afin que lutilisateur puisse contrler le code source de ce puissant moteur sans jamais avoir crer lui-mme de nouveaux lments dans celui-ci. Ce facteur a rendu Unity trs populaire auprs des nouveaux dveloppeurs et explique probablement pourquoi vous lisez cet ouvrage. En dfinissant des concepts logiques et en regroupant par catgorie les mthodes communes utilises pour produire des jeux, Unity met la puissance de son moteur au service de lutilisateur, lui permettant dobtenir un maximum de rsultats avec un minimum defforts, afin quil se concentre sur le facteur le plus crucial de tous: le gameplay (la jouabilit). En attirant de nombreux dveloppeurs de jeux, Unity a combl un vide sur le march du dveloppement des jeux vido, ce que peu dditeurs peuvent prtendre. Unity est en effet lun des moteurs de jeux les plus dynamiques de son secteur car il permet de produire des jeux3D professionnels aussi bien sur Mac, sur PC ou sur le Web. Comme le moteur existe galement dans des versions destines la Nintendo Wii et liPhone dApple, il offre un accs au march des ordinateurs mais aussi celui des consoles et des mobiles une fois que vous matrisez les bases. Lvolution rapide de lindustrie du divertissement et du marketing ncessite que les jeux soient produits rapidement. Aussi, de nombreuses entreprises se tournent vers des solutions intgres comme Unity pour que leurs crateurs sortent de meilleurs produits le plus facilement possible. Depuis la sortie en 2009 de la version2.5 et ses premiers pas sous Windows, Unity est de plus en plus utilis. Mais quest-ce que Unity? Comment fonctionne-t-il? Que peut-il raliser? Et surtout, comment ce programme permet-il de dvelopper des jeux3D en seulement quelques semaines?
Prface
Le contenu de cet ouvrage

Ce livre est conu pour couvrir un ensemble dexemples faciles suivre, qui culminent dans la production dun jeu de tir la premire personne (FPS) en 3D dans un environ nement interactif (une le). En abordant les concepts communs aux jeux et la production3D, vous allez voir comment utiliser Unity pour crer un personnage jouable qui interagit avec le monde du jeu et comment raliser des nigmes que le joueur devra rsoudre pour terminer la partie. Voici un aperu, chapitre par chapitre, des thmes abords:
Chapitre1. Bienvenue dans la troisime dimension. Ce chapitre couvre les concepts cls que vous aurez besoin de comprendre pour complter lexercice de ce livre. Ilprsente rapidement les concepts3D et les processus utiliss par Unity pour crer des jeux. Chapitre2. Environnements. Votre monde virtuel est, lorigine, totalement vide! Vous allez donc commencer par tudier les diffrentes manires dintgrer des terrains, dimporter des modles 3D crs en dehors de Unity. Vous dcouvrirez galement comment utiliser dautres fonctionnalits du moteur Unity comme le son et les lumires afin de dfinir lenvironnement du jeu et de le rendre fonctionnel. Chapitre3. Personnages jouables. Chaque jeu a besoin dun hros, nest-ce pas? Au cours de ce chapitre, vous tudierez chacun des lments qui constituent le personnage incarn par le joueur, depuis les contrles dentre en passant par les camras et la gestion des collisions. Une fois que vous aurez appris de quoi est form le personnage du joueur, vous lintgrerez dans lenvironnement du jeu et vous effectuerez une petite promenade sur votre le. Chapitre4. Interactions. Les jeux vido reposent avant tout sur les interactions dans le monde virtuel. Que serait un personnage jouable sil ne pouvait effectuer aucune action? Nous prsenterons donc ici la dtection de collision et le raycasting. Vous verrez comment combiner ces techniques avec du code et des animations pour transformer votre cration statique en lments qui ragissent aux actions du joueur. Chapitre5. lments prfabriqus, collections et HUD. Il est essentiel de donner au joueur un sentiment daccomplissement dans le jeu. Pour cela, vous aurez besoin de lui rappeler les actions quil a effectues et de lui donner un but atteindre. Pour cela, vous crerez un systme daffichage tte haute ou HUD (Heads Up Display). Autrement dit, vous apprendrez comment afficher du texte et des illustrations qui changent dynamiquement au cours du jeu.
Vous raliserez ensuite un mini-jeu de collecte dobjets, dans lequel le personnage du joueur devra ramasser des piles pour pouvoir entrer dans un btiment de lle.
Chapitre6. Instanciation et corps rigides. Presque tous les scnarios de jeu que vous pouvez imaginer imposent de crer ou de "reproduire" des objets dans lenvironnement. Il est essentiel pour tous les dveloppeurs dbutants de connatre et de savoir utiliser cette notion, appele instanciation en programmation, qui consiste crer des objets lors de lexcution du jeu.
Vous verrez comment amliorer linteractivit de votre jeu en crant un jeu de tir simple; en lanant des objets sur des cibles, le joueur pourra dbloquer une partie de lenvironnement. Vous dcouvrirez ainsi non seulement linstanciation, mais aussi comment utiliser les corps rigides.
Chapitre7. Systmes de particules. De nos jours, un jeu en 3D doit imprativement proposer quelques effets visuels intressants pour attirer le joueur. Dans ce dessein, vous crerez un feu de bois pour que le personnage du jeu se rchauffe. Pour cela, vous utiliserez deux systmes de particules, lun pour les flammes et lautre pour la fume.
Vous verrez comment les systmes de particules permettent dimiter le comportement dun feu et comment rendre chaque particule raliste en utilisant des images. Enfin, vous teindrez ce feu afin de donner un objectif au joueur: lallumer pour ne pas prir de froid!
Chapitre8. Conception de menus. Pour quun jeu soit agrable, ses menus doivent avoir un aspect professionnel et tre faciles utiliser. Qui voudrait dun jeu dont le bouton Dmarrer est impossible trouver? Ce chapitre abordera les diffrentes faons de crer des menus et dautres interfaces utilisateur avec lesquelles le joueur pourra interagir.
Vous laborerez des menus en utilisant la fois les textures GUI et la classe GUI afin de crer des interfaces redimensionnables qui puissent tre utilises aussi bien dans les jeux destins au Web que dans les applications autonomes.
Chapitre 9. Dernires retouches. Lorsque vous ralisez un jeu, en particulier dans Unity, il arrive un moment o vous crez un lment interactif dont vous tes si fier que vous souhaitez lui ajouter une touche supplmentaire pour le mettre en valeur.
Au fil de ce chapitre, nous dtaillerons lutilisation du son, les effets de lumire, le rendu des tranes lumineuses et dautres effets dynamiques simples implmenter, afin de transformer votre simple jeu fonctionnel en produit fini.
Chapitre10. Compilation et partage. Vous verrez comment exporter votre jeu pour le Web et en tant que projet autonome. Nous tudierons les diffrents rglages dont vous devez tenir compte lorsque vous prparez le produit fini, comme la qualit graphique, les commandes de contrles, et plus encore.
Prface
Chapitre11. Procdures de tests et lectures complmentaires. Vous verrez comment continuer votre apprentissage au-del de cet ouvrage et comment recueillir des informations auprs des testeurs pour amliorer votre jeu. Nous vous aiderons prparer votre projet pour quil soit test par un large public afin de recueillir des avis et des commentaires et produire des jeux encore meilleurs!
Ce dont vous avez besoin

Pour raliser les exercices de cet ouvrage, il vous faut:
Une copie installe du logiciel Unity (une version dessai est disponible sur le site Unity3D.com). Une connexion Internet afin de tlcharger des modles 3D et des ressources depuis la page ddie cet ouvrage sur le site de Pearson (http://www.pearson.fr). Un ou plusieurs logiciels de modlisation 3D, bien que cela ne soit pas obligatoire. Tous les matriaux utiliss sont fournis. Si vous dbutez dans le domaine de la modlisation, vous pouvez tlcharger une application gratuite compatible avec Unity comme Blender sur le site Blender.org.
qui sadresse cet ouvrage

Formateur sur Unity depuis plusieurs annes, jai dcouvert que le principal grief de ses utilisateurs ne portait pas sur le logiciel lui-mme, mais plutt sur le manque de didacticiels destins aux novices ne possdant pas une formation en programmation. Dans le contexte actuel, cette situation est rare, bien sr, mais un outil comme Unity, qui facilite autant la production, accrot lurgence dun tel guide didacticiel. Si vous tes un concepteur ou un animateur qui souhaite faire ses premiers pas dans le dveloppement de jeux vido, ou si vous avez tout simplement pass de nombreuses heures assis devant des jeux vido et que vous fourmilliez dides, Unity et ce livre pourraient constituer le point de dpart idal. Nous supposons que vous navez aucune connaissance en production de jeux vido et nous vous expliquons tout depuis le commencement. Nous vous demandons simplement dtre passionn et de vouloir raliser de grands jeux.
Conventions typographiques
Cet ouvrage utilise plusieurs styles de texte afin dtablir une distinction entre les diffrents types dinformations. En voici quelques exemples ainsi quune explication de leur signification. Le code qui apparat dans le corps du texte est prsent de la manire suivante: "Nous pouvons inclure dautres contextes, par lutilisation 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 affichs lcran, dans les menus ou les botes de dialogue, par exemple, seront en petites capitales comme ceci: "Cliquez sur le bouton Suivant pour passer lcran suivant." Dans la notation des raccourcis clavier, la premire variante est toujours pour MacOS, la seconde pour Windows. Appuyez sur Entre/F2 signifie donc Entre sur MacOS et F2 sur Windows.
Codes sources en ligne

Les fichiers 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 consacre cet ouvrage.
1
Bienvenue dans la troisime dimension
Avant de commencer utiliser un programme 3D, vous devez imprativement comprendre lenvironnement dans lequel vous allez travailler. Comme Unity est avant tout un outil de dveloppement3D, beaucoup de notions dveloppes dans ce livre demandent que vous compreniez en quoi consistent le dveloppement3D et les moteurs de jeux. Il est essentiel de cerner ces notions avant daborder les questions pratiques des chapitres suivants.
Comprendre la 3D
tudions les principaux lments des mondes 3D et la faon dont Unity permet de dvelopper des jeux en trois dimensions.
Les coordonnes
Si vous avez dj travaill avec un programme dillustration 3D auparavant, la notion daxeZ vous est probablement familire. LaxeZ reprsente la profondeur et sajoute aux axesX, pour le plan horizontal, etY, pour le plan vertical. Dans les applications3D, les informations sur les objets sont indiques selon un systme de coordonnes cartsiennes, autrement dit au format X,Y,Z. Les dimensions, les valeurs de rotation et les positions dans le monde3D peuvent toutes tre dcrites de cette faon. Dans ce livre, comme dans dautres documents concernant la 3D, ces informations sont crites entre parenthses, de la manire suivante: (10, 15, 10) Cette criture sexplique principalement pour des raisons de clart, mais aussi parce que ces valeurs doivent tre crites de cette faon dans le code. Indpendamment de leur prsentation, vous pouvez partir du principe que tout ensemble de trois valeurs spares par des virgules est prsent dans lordre X,Y,Z.
Lespace local et lespace global

La diffrence entre lespace local et lespace global est une notion essentielle. Dans tout logiciel 3D, le monde virtuel est techniquement infini, si bien que cela peut tre difficile de garder une trace de lemplacement des objets quil contient. Dans tous les univers3D, il existe un point dorigine, aussi dnomm zro, et reprsent par les coordonnes (0, 0, 0). Toutes les coordonnes des objets 3D sont relatives lorigine globale. Cependant, pour rendre les choses plus simples, on utilise galement lespace local (galement appel espace de lobjet) pour dfinir la position des objets les uns par rapport aux autres (voir Figure 1.1). Lespace local suppose que chaque objet possde sa propre origine, qui correspond celle de ses poignes daxes il sagit gnralement du centre de lobjet. En crant des relations entre les objets, on peut alors comparer leurs positions les uns par rapport aux autres. Ces relations, appeles relations parent-enfant, permettent de calculer les distances entre les objets en utilisant lespace local, la position de lobjet parent devenant la nouvelle origine pour chacun de ses objets enfants. Pour en savoir plus sur les relations parent-enfant, reportezvous au Chapitre3, "Personnages jouables".
Chapitre 1
Figure 1.1
Y
Y Z X L'espace local (de l'objet) Z
L'espace global
Les vecteurs
Vous verrez galement des vecteurs 3D dcrits en coordonnes cartsiennes. Comme leurs homologues2D, ce sont simplement des lignes traces dans le monde en3D qui possdent une direction et une longueur. Les vecteurs peuvent tre dplacs dans lespace global mais restent inchangs. Ils sont utiles dans le contexte dun moteur de jeu, car ils permettent de calculer la direction des objets ainsi que les distances et les angles relatifs entre les objets.
Les camras
Les camras sont essentielles dans le monde3D, car elles offrent un point de vue sur ce qui saffiche lcran. Leur champ de vision ayant une forme de pyramide, elles peuvent tre disposes nimporte quel point dans le monde, tre animes ou attaches des personnages ou des objets comme lments du scnario dun jeu. Les camras 3D ont un champ de vision (FOV, Field of Vision) rglable et offrent un point de vue sur le monde 3D. Dans les moteurs de jeu, vous remarquerez que les effets de lumire, les flous de mouvement et les autres effets sont appliqus la camra pour simuler la vision de lil humain sur le monde du jeu vous pouvez mme ajouter quelques effets cinmatographiques, comme les effets de rflexion du soleil sur lobjectif. La plupart des jeux 3D modernes utilisent plusieurs camras pour montrer certaines parties du monde du jeu que la camra attache au personnage nest pas en train dexaminer comme un "cut", pour reprendre un terme cinmatographique. Dans Unity, il est possible dutiliser plusieurs camras dans une seule scne et de les contrler laide du code, pour que chacune delles devienne tout moment la camra principale lors de lexcution du jeu.
10
Plusieurs camras peuvent aussi tre utilises dans un jeu pour contrler sparment le rendu de certains lments2D et 3D lors du processus doptimisation. Vous pouvez, par exemple, regrouper des objets sur des calques puis paramtrer les camras afin quelles procdent uniquement au rendu des objets sur certains calques. Vous contrlez mieux ainsi les rendus individuels de certains lments dans le jeu.
Les polygones, les artes, les sommets et les maillages

Tous les objets 3D se composent de formes 2D interconnectes appeles polygones. Lorsque vous importez des modles crs dans un programme de modlisation, Unity convertit tous les polygones en polygones triangles (appels galement faces), qui sont, leur tour, forms de trois artes connectes. Les points de jonction des artes sont appels points ou sommets. Quand les moteurs de jeux connaissent ces sommets, ils peuvent effectuer des calculs sur les points dimpact, connus sous le nom de collisions, en utilisant une dtection de collision complexe grce aux Mesh Colliders (selon le maillage mme de lobjet), comme dans les jeux de tir pour dtecter lemplacement exact o une balle a touch un autre objet. En combinant beaucoup de polygones relis entre eux, les applications de modlisation3D permettent de construire des formes complexes, les maillages. Outre la construction de formes en 3D, les donnes stockes dans les maillages ont de nombreuses autres utilisations, par exemple tre utilises comme surfaces sur lesquelles les objets peuvent se dplacer, en suivant les sommets. Il est crucial que le dveloppeur dun projet de jeu comprenne limportance du dcompte de polygones. Cette quantit de polygones indique le nombre total de polygones utiliss par un modle mais aussi dans un niveau de jeu entier. Plus ce nombre est lev et plus lordinateur est sollicit pour procder au rendu des objets lcran. Cela explique pourquoi le niveau de dtail a augment au cours des dix dernires annes, depuis les premiers jeux en 3D ceux daujourdhui il suffit pour sen convaincre de comparer visuellement les jeux Quake dId Software (1996) de Gears Of War dEpic Games (2006). Grce lamlioration des technologies, les dveloppeurs de jeux peuvent maintenant utiliser un nombre beaucoup plus lev de polygones pour les personnages et les mondes3D de leurs jeux. Etil nexiste aucune raison que cette tendance sinverse.
Les matriaux, les textures et les shaders

Les matriaux sont un concept commun toutes les applications 3D. Ils fournissent le moyen de dfinir lapparence visuelle dun modle3D. Ils grent tout, des couleurs de base aux surfaces rflchissantes constitues dimages. partir dune simple couleur et de la possibilit dutiliser une ou plusieurs images connues sous le nom de textures dans un seul matriau, celui-ci fonctionne avec le shader, qui est
Chapitre 1
11
un script charg du style de rendu. Avec un shader de rflexion, par exemple, le rendu du matriau rflchira les objets environnants tout en conservant sa couleur ou lapparence de limage qui lui est applique comme texture. Dans Unity, les matriaux sont simples utiliser. Tous les matriaux crs dans votre logiciel de modlisation 3D seront imports et recrs automatiquement par le moteur de Unity, en tant que ressources que vous pouvez ensuite utiliser. Vous pouvez galement crer vos propres matriaux partir de zro, en dfinissant des images comme fichiers de texture et en slectionnant un shader dans une grande bibliothque intgre. Vous pouvez aussi rdiger vos propres scripts de shader ou implmenter ceux crits par des membres de la communaut Unity, ce qui vous offre une plus grande libert par rapport aux lments fournis. Fondamentalement, lors de la cration de textures pour un jeu dans un logiciel graphique comme Photoshop, vous devez tre conscient de la rsolution. Les textures dun jeu doivent tre de forme carre et leurs dimensions des puissances de 2. Autrement dit, elles doiventavoir les dimensions suivantes:
128128 256256 512512 10241024
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 fichier de texture, car ses dimensions ont un impact direct sur la puissance de traitement exige par lordinateur du joueur. Par consquent, pensez toujours donner vos illustrations la plus petite taille2D possible, sans trop sacrifier la qualit.
La physique des corps rigides

Pour les dveloppeurs de moteurs de jeux, le moteur physique constitue un moyen de simuler les conditions du monde rel pour les objets dans les jeux. Dans Unity, le moteur du jeu utilise PhysX de Nvidia, un moteur physique commercial trs employ et trs prcis. Dans les moteurs de jeux, un objet nest pas soumis aux lois de la physique par dfaut. La raison en est que cela exigerait beaucoup de puissance de calcul, mais aussi parce quil est inutile dutiliser le moteur physique sur tous les objets. Dans un jeu de voitures en 3D, par exemple, il est logique que les voitures soient soumises linfluence du moteur physique, mais il ny a aucune raison que cela soit le cas de la piste ou des objets environnants, comme les arbres, les murs, etc. Cest pourquoi vous devez assigner un composant
12
RigidBody (corps rigide) chaque objet que le moteur physique doit contrler lors de la cration du jeu. Les moteurs physiques des jeux utilisent le systme dynamique des corps rigides pour crer un mouvement raliste. Ainsi, au lieu dtre de simples objets statiques dans le monde en 3D, ils peuvent possder les proprits suivantes:
Masse Gravit Vlocit Friction
Comme la puissance du matriel et des logiciels augmente, la physique des corps rigides, qui permet des simulations varies et ralistes, est de plus en plus largement utilise dans les jeux (voir Chapitre6, "Linstanciation et les corps rigides").
La dtection de collision
Plus cruciale dans les moteurs de jeu que dans lanimation3D, la dtection de collision est la faon danalyser le monde3D pour les collisions entre objets. En donnant un composant Collider (composant de collision) un objet, on place effectivement un filet invisible autour de ce dernier. Ce filet imite la forme de lobjet et il est charg de signaler toute collision avec dautres colliders afin que le moteur de jeu ragisse en consquence. Dans un jeu de bowling, par exemple, un simple collider sphrique 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 lobjet) pour une collision plus raliste. Au moment de limpact, les colliders de tous les objets touchs envoient un rapport au moteur physique qui leur dicte leur raction en fonction de lorientation de limpact, de la vitesse et dautres facteurs. Dans cet exemple, si on emploie un Mesh Collider qui suit exactement la forme de la quille, le rsultat est plus prcis mais aussi plus coteux en termes de calcul. Autrement dit, la puissance de calcul demande lordinateur est plus importante, ce qui se traduit par une baisse des performances do le terme coteux.
Les concepts essentiels de Unity

Unity simplifie le processus de production dun jeu en proposant une srie dtapes logiques pour construire tous les scnarios de jeu que vous pouvez imaginer. Unity nest pas spcifique dun type de jeu ; le programme offre un canevas vierge et un ensemble
Chapitre 1
13
de procdures cohrentes afin que votre imagination soit la seule limite votre crativit. Grce au concept de Game Object (GO), vous pouvez scinder les lments du jeu en objets faciles grer, constitus 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 dtendre votre jeu linfini dune manire progressive et logique. Les composants possdent des variables pour lessentiel des paramtres permettant de les contrler. En ajustant ces variables, vous contrlez totalement leffet que ce composant a sur votre objet. Prenons un exemple simple.
Le fonctionnement de Unity
Pour intgrer une balle qui rebondit dans le cadre dun jeu, par exemple, on commence par crer une sphre, ce qui peut rapidement tre ralis partir des menus de Unity. On obtient alors un nouveau Game Object possdant un maillage en forme de sphre (un filet de forme3D) et un composant Renderer (de rendu) pour quil soit visible. On peut ensuite ajouter un corps rigide (composant Rigidbody) pour indiquer Unity que lobjet doit utiliser le moteur physique. Ce composant intgre les proprits physiques de masse et de gravit ainsi que la capacit dappliquer des forces lobjet, soit lorsque le joueur agit dessus, soit lorsquil entre en collision avec un autre objet. La sphre va maintenant tomber sur le sol lors de lexcution du jeu, mais comment la faire rebondir? Cest simple! Le composant Collider possde une variable Physic Material un paramtre du composant Rigidbody qui dfinit la raction de celui-ci au contact des surfaces des autres objets. Ilsuffit donc de slectionner le paramtre prdfini Bouncy pour obtenir une balle qui rebondit en seulement quelques clics. Cette approche simplifie pour les tches les plus lmentaires, comme dans lexemple prcdent, semble prosaque au premier abord. Toutefois, vous dcouvrirez bientt quelle permet de raliser trs simplement des tches plus complexes. tudions rapidement les concepts cls de Unity.
Les ressources
Ce sont les composants de base de tous les projets Unity. Des lments graphiques sous forme de fichiers image, aux modles 3D en passant par les fichiers son, Unity dsigne tous les fichiers utiliss pour crer un jeu comme des ressources (assets). Cest pourquoi tous les fichiers utiliss dans le dossier dun projet Unity sont stocks dans un dossier enfant nomm Assets.
14

Info
Ce livre saccompagne de fichiers de ressources disponibles sur la page ddie cet ouvrage sur le site Pearson (http://www.pearson.fr). Tlchargez et dcompressez cette archive pour profiter de son contenu. Ce processus fait partie intgrante du dveloppement dun jeu dans Unity.
Les scnes
Considrez les scnes comme des niveaux de jeu individuels ou des zones de contenu (les menus, par exemple). En construisant votre jeu avec de nombreuses scnes, vous pourrez rpartir les temps de chargement et tester les diffrentes parties une par une.
Les objets de jeu (Game Objects)

Lorsquune ressource est utilise dans une scne de jeu, elle devient un nouvel objet de jeu, ou Game Object, que Unity dsigne 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 lchelle dun objet tous dcrits en coordonnes X,Y,Z (ou en dimensions dans le cas de lchelle). La position, la rotation ou lchelle dun objet peut galement tre dfinie dans les scripts. partir de ce premier composant, vous allez construire dautres objets de jeu possdant dautres composants afin dajouter les fonctionnalits ncessaires la construction de toutes les parties du jeu.
Les composants
Les composants se prsentent de diffrentes manires. Ils peuvent tre utiliss pour crer un comportement, dfinir lapparence ou exercer une influence sur la fonction dun objet dans le jeu. En "attachant" les composants un objet, vous pouvez appliquer immdiatement de nouveaux lments du moteur de jeu votre objet. Les composants les plus courants pour crer des jeux sont fournis avec Unity, depuis le composant Rigidbody, mentionn plus tt, jusquaux lments plus simples comme les lumires, les camras, les metteurs de particules, etc. Pour crer des lments plus interactifs dans le jeu, vous crirez des scripts, qui sont considrs comme des composants dans Unity.
Les scripts
Tout en tant considrs comme des composants par Unity, les scripts sont un lment essentiel de la cration de jeux et mritent, ce titre, dtre vus comme une notion cl.Dans ce livre, vous crirez vos scripts en JavaScript, mais Unity offre galement la possibilit
Chapitre 1
15
utiliser les langages C# et Boo (un driv du langage Python). Nous avons choisi de d prsenter Unity avec du code JavaScript car il sagit dun langage de programmation fonctionnel dont la syntaxe est simple. En outre, certains dentre vous ont peut-tre dj rencontr JavaScript dans dautres logiciels, comme son driv ActionScript dans Adobe Flash, ou lont utilis pour le dveloppement web. Unity ne ncessite pas dapprendre le fonctionnement du code de son propre moteur ni de savoir comment le modifier, mais vous utiliserez des scripts dans presque tous les scnarios de jeu que vous dvelopperez. Ces scripts sont assez simples et aisment comprhensibles aprs quelques exemples, car Unity possde sa propre classe prdfinie de comportement un ensemble dinstructions auxquelles vous ferez appel. Les scripts peuvent tre intimidants, en particulier pour les nouveaux utilisateurs de Unity qui ne connaissent que la phase de conception et dcouvrent le dveloppement. Nous allons les prsenter tape par tape, afin de vous en montrer limportance et les possibilits quils offrent. Pour crire des scripts, vous pourrez utiliser lditeur de script autonome de Unity. Sous MacOS, cette application sappelle Unitron, et sous Windows, Uniscite. Ces applications distinctes se trouvent dans le dossier de Unity sur votre ordinateur. Elles souvrent chaque fois que vous crez ou modifiez un script. Lorsque vous modifiez les scripts et que vous les enregistrez dans lditeur de script, celui-ci est immdiatement mis jour dans Unity. Vous pouvez galement choisir votre propre diteur de script dans les Prfrences de Unity si vous le souhaitez.
Les lments prfabriqus

Lapproche du dveloppement dans Unity repose principalement sur la notion de Game Object, mais le programme propose galement une faon astucieuse de stocker les objets comme ressources afin de pouvoir les rutiliser dans diffrentes parties dun jeu, en les "reproduisant" ou les "clonant" tout moment. En crant des objets complexes constitus de diffrents composants et paramtres, vous construisez de fait un modle que vous pouvez rutiliser plusieurs fois, chaque instance pouvant tre modifie individuellement. Prenons lexemple dune caisse: vous pouvez dfinir la masse de cet objet dans le jeu et crire des comportements scripts pour sa destruction. Vous utiliserez probablement cet objet plus dune fois dans le mme jeu, voire peut-tre dans dautres jeux que celui pour lequel il a t conu. Les lments prfabriqus permettent de stocker lobjet complet, ses composants et sa configuration actuelle. Considrez simplement les lments prfabriqus comme des conteneurs vides dans lesquels vous stockerez des objets pour former un modle de donnes rutilisable, comparable la notion de MovieClip dans Adobe Flash.
16
Linterface
Les diffrents panneaux qui composent linterface de Unity peuvent tre ancrs et dplacs. Comme dans de nombreux autres environnements de travail, vous pouvez donc personnaliser lapparence de linterface. tudions la disposition par dfaut:
Figure1.2
Comme le montre la Figure 1.2 (version Windows), linterface se compose de cinq panneaux:
Scene [1]. Le panneau o le jeu est cr. Hierarchy [2]. Contient la liste des GameObjects prsents dans la scne. Inspector [3]. Les paramtres de lobjet ou de la ressource actuellement slectionn. Game [4]. Le panneau de prvisualisation, actif uniquement en mode Lecture. Project [5]. Contient la liste des ressources de votre projet et agit comme une bibliothque.
Chapitre 1
17
Les panneaux Scene et Hierarchy

Le panneau Scene est celui dans lequel se construit la totalit dun projet de jeu dans Unity. Il offre par dfaut une vue en perspective (entirement en3D) mais il peut prsenter une vue de haut, du bas, de ct ou de face. Il sagit du rendu complet et modifiable de lunivers du jeu que vous crez. Faites glisser une ressource dans ce panneau pour quelle devienne un objet de jeu. La vue du panneau Scene est lie au panneau Hierarchy, qui rpertorie tous les objets actifs dans la scne actuellement ouverte par ordre alpha btique croissant.
Figure1.3
Le panneau Scene saccompagne de quatre boutons de contrle trs utiles (voir Figure1.3). Ces contrles, accessibles laide des raccourcis clavier Q, W, E et R, permettent dexcuter les oprations suivantes:
Hand (Main) [Q]. Permet de naviguer dans le panneau Scene afin de visualiser diffrentes parties du monde ou depuis diffrents angles. Maintenez la touche Alt enfonce pour faire pivoter la vue et la touche Cmd (MacOS) ou Ctrl (Windows) pour zoomer. Appuyez galement sur la touche Maj pour effectuer ces changements de perspective plus rapidement. Translate (Translation) [W]. Cest loutil de slection. Vous pouvez totalement interagir avec le panneau Scene et repositionner un objet laide de ses poignes daxe dans ce panneau aprs lavoir slectionn dans les panneaux Hierarchy ou Scene. Rotate (Rotation) [E]. Il fonctionne de la mme manire que loutil Translate, les poignes daxe permettant de faire tourner lobjet slectionn autour de chacun de ses axes. Scale (chelle) [R]. L encore, le fonctionnement est identique celui des outils Translate et Rotate. Cet outil permet dajuster la taille ou lchelle dun objet laide de ses poignes.
Lorsque vous slectionnez un objet dans le panneau Scene ou Hierarchy, il est immdiatement slectionn dans les deux panneaux et ses proprits saffichent dans le panneau Inspector. Toutefois il peut arriver que vous ne voyiez pas dans le panneau Scene un objet slectionn dans le panneau Hierarchy: la toucheF vous permet alors de centrer la vue sur lobjet en question. Il suffit de le slectionner dans le panneau Hierarchy, de placer le curseur sur le panneau Scene et dappuyer sur la toucheF.
18
Le panneau Inspector
Le panneau Inspector est le principal outil pour ajuster chaque lment des objets de jeu et des ressources de votre projet. Tout comme lInspecteur de proprits dans Adobe Flash et Dreamweaver, le contenu de ce panneau est sensible au contexte. Autrement dit, il affiche les proprits correspondant lobjet slectionn il est donc sensible au contexte dans lequel vous travaillez. Le panneau Inspector affiche tous les composants de llment slectionn ce qui permet den ajuster les variables laide dlments simples comme des zones de saisie de texte, des curseurs, des boutons et des menus droulants. Beaucoup de ces variables utilisent galement le systme de glisser-dposer de Unity, ce qui signifie quavec cette mthode vous pouvez dfinir des paramtres plutt que de slectionner une valeur dans un menu droulant, si cela est plus pratique. Ce panneau na pas uniquement pour rle dafficher les lments qui composent les objets. Il peut galement afficher les prfrences de votre projet selon loption que vous slectionnez dans le menu Edit (dition). Les proprits des composants saffichent ds que vous slectionnez de nouveau un objet ou une ressource.
Figure1.4
la Figure1.4, le panneau Inspector affiche les proprits dun objet cible dans le jeu. Lobjet lui-mme possde deux composants Transform et Animation , dont vous pouvez modifier les paramtres dans le panneau Inspector. Notez galement que vous pouvez dsactiver temporairement un composant tout moment, ce qui est trs utile pour effectuer
Chapitre 1
19
des tests et exprimenter diffrentes possibilits. Pour cela, il suffit de dcocher la case situe gauche du nom du composant. De mme, pour dsactiver un objet entier, dcochez 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 dun dossier parent, qui contient trois sous-dossiers: Assets, Library (bibliothque) et Temp lorsque lditeur de Unity est ouvert. Les ressources places dans le dossier Assets sont immdiatement visibles dans le panneau Project et sont importes automatiquement dans le projet Unity. De mme, si vous modifiez et enregistrez une ressource du dossier Assets dans une application tierce comme Photoshop, Unity la rimportera, si bien que les modifications effectues safficheront immdiatement dans le projet et dans toutes les scnes qui utilisent cette ressource en particulier. Lemplacement et le nom des ressources doivent tre uniquement modifis dans le panneau PROJECT. Lutilisation du Finder (MacOS) ou de lExplorateur Windows (Windows) risque en effet de rompre les connexions dans le projet Unity. Pour dplacer ou renommer les objets du dossier Assets, utilisez le panneau PROJECT.
ce Astu
Le panneau Project saccompagne dun bouton Create (crer). Celui-ci permet la cration de tous les types de ressources disponibles dans Unity scripts, lments prfabriqus et matriaux, par exemple.
Le panneau Game
Le panneau Game (jeu), qui saffiche lorsquon clique sur Play, propose un aperu raliste du jeu. Il dispose galement de paramtres de rsolution de lcran, 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 lments de la scne de jeu ne sont que temporaires. Ce mode est uniquement un mode de test, si bien que, lorsque vous cliquez de nouveau sur PLAY pour arrter le jeu, toutes les modifications apportes en cours de lecture seront annules. Cest souvent trs droutant pour les nouveaux utilisateurs, alors noubliez pas!
ntion Atte
20
Le panneau Game peut galement tre paramtr laide de loption Maximize. On obtient alors un aperu proche du plein cran en mode de lecture la taille du panneau recouvre la totalit de linterface. Notez que vous pouvez galement agrandir nimporte quel panneau de linterface. Il suffit pour cela de placer le curseur sur le panneau agrandir puis dappuyer sur la barre despacement.
En rsum
Nous avons dcouvert au cours de ce chapitre les concepts cls que vous avez besoin de comprendre pour complter les exercices de ce livre. En raison de contraintes despace, nous ne pouvons pas tout prsenter en dtail, car le dveloppement3D est un domaine dtude trs vaste. Cest pourquoi nous vous conseillons de chercher des informations supplmentaires sur les sujets abords, afin de complter vos connaissances. Chaque logiciel dispose de ses propres didacticiels et ressources consacrs son apprentissage. Si vous dsirez apprendre crer des modles 3D pour les utiliser dans Unity, nous vous recommandons de choisir et de vous familiariser avec le programme qui vous convient le mieux. Vous trouverez une liste des programmes compatibles avec Unity au Chapitre2, "Environnements". prsent que nous avons vu rapidement les concepts 3D et les processus utiliss par Unity pour crer des jeux, vous allez commencer utiliser le logiciel pour crer lenvironnement de votre jeu. Au chapitre suivant, nous aborderons lditeur de terrain, un outil simple utiliser pour commencer la cration dun jeu situ dans un environnement extrieur. Avec lui, vous construirez une le laquelle vous ajouterez des fonctionnalits au fil des chapitres suivants afin de crer un mini-jeu dans lequel le joueur devra allumer un feu de camp aprs avoir rcupr des allumettes dans un avant-poste dont la porte est verrouille.
2
Environnements
Pour construire votre monde en 3D, vous utiliserez deux types diffrents denvironnement: les btiments et les lments de dcor crs dans une application de modlisation 3D tierce mais aussi des terrains crs laide de lditeur de terrain de Unity. Vous verrez rapidement ici comment dfinir les paramtres ncessaires limportation des modles crs en dehors de Unity, mais vous utiliserez principalement les outils propres Unity pour crer des terrains. Vous verrez en particulier comment:
crer votre premier projet Unity; crer et configurer des terrains; utiliser les outils de terrain pour construire une le; clairer les scnes; utiliser le son; importer des paquets de ressources; importer des modles 3D externes.
22
Les logiciels de modlisation externes

tant donn que la conception 3D est une discipline part entire, nous vous recommandons de vous pencher sur un didacticiel analogue celui-ci pour lapplication de votre choix. Si vous dbutez, voici une liste des logiciels de modlisation3D actuellement pris en charge par Unity:
Maya 3D Studio Max Cheetah 3D Cinema 4D Blender Carrara Lightwave XSI
Ce sont les huit applications de modlisation recommandes par Unity Technologies: elles sont capables dexporter les modles dans un format qui peut tre automatiquement lu et import par Unity, une fois quils sont enregistrs dans le dossier Assets du projet. Les formats de ces huit applications conservent lensemble des maillages, des textures, des animations et des squelettes (une forme dossature) dans Unity, alors que le systme danimation par squelette utilis par des programmes moins connus peut ne pas tre pris en charge lors de limportation dans Unity. Pour une liste exhaustive de compatibilit, consultez le site: http://unity3d.com/unity/features/asset-importing.
Les ressources
Les modles utiliss dans ce livre sont disponibles en ligne au format .fbx (format natif pour Unity qui est commun la plupart des applications de modlisation3D). Lors du tlchargement du contenu ncessaire pour les exercices de ce livre, vous aurez besoin du systme de paquets de ressources de Unity. Limportation et lexportation de paquets de ressources dans Unity laide du menu Assets permettent de transfrer des ressources dun projet un autre en conservant les dpendances. Une dpendance est tout simplement une autre ressource lie celles que vous importez ou exportez. Lors de lexportation dun modle3D dans le cadre dun paquet de ressources Unity par exemple ( destination dun collaborateur, ou simplement entre vos propres projets Unity), vous devrez
Chapitre 2
Environnements
23
transfrer les matriaux adquats et les textures associes avec les modles; ces ressources connexes sont alors appeles dpendances du modle. Dans ce livre, nous vous indiquerons quand tlcharger des paquets Unity et les ajouter vos ressources. Pour cela, il vous suffira de cliquer sur Assets> Import Package.
Votre premier projet Unity

Unity existe sous deux formes diffrentes: une version gratuite et une version professionnelle1. Nous nous en tiendrons ici aux fonctionnalits accessibles aux dbutants, autrement dit aux options de la version gratuite. Lors du premier lancement, le programme souvre sur le projet de dmonstration Island Demo. Comme son nom lindique, il sagit effectivement dun projet destin prsenter les capacits de Unity et permettre aux nouveaux utilisateurs de dcouvrir certaines fonctionnalits du programme en tudiant les crations de ses dveloppeurs. Vous allez commencer avec un projet vierge. Pour cela, cliquez sur File> New Project afin de fermer le projet actuellement ouvert et douvrir la bote de dialogue Project Wizard (assistant de projet). Vous pouvez slectionner un projet existant ou en crer un en choisissant parmi plusieurs Asset Packages (paquets de ressources) avec lesquels commencer. Si vous souhaitez lancer Unity en ouvrant directement le PROJECT WIZARD, appuyez simplement sur la touche Alt (Mac Os et Windows) tout en lanant lditeur de Unity.
Info
Choisissez lemplacement o votre projet sera enregistr. Slectionnez un chemin de fichier dans le champ Project Location (emplacement du projet) ou cliquez sur Browse (parcourir) et choisissez un emplacement dans la bote de dialogue qui saffiche. Notre projet sappelle Projet1, mais vous pouvez choisir un autre nom. Cochez ensuite la case en regard de Standard Assets afin de disposer des ressources fournies par Unity Technologies. Cliquez enfin sur le bouton Create2.
1. Il existe galement des versions spcifiquement ddies la Wii ou liPhone. 2. Sur certaines versions, Project Location, Browse et Create sintitulent Project Directory, Set et Create Project.
24
Figure2.1
Lditeur de terrain
Un diteur de terrain est indispensable pour tout dveloppeur qui souhaite crer un jeu se droulant en extrieur. Unity en intgre un depuis sa version2.0, ce qui facilite et acclre la construction des environnements. Pour Unity, un terrain est simplement un objet de jeu sur lequel on applique certains composants en particulier. Le terrain que vous allez bientt crer est, lorigine, une surface plane, une forme3D une seule face, mais il peut tre transform en un ensemble gomtrique complet et raliste et inclure des dtails supplmentaires arbres, rochers, feuilles et mme des effets atmosphriques, comme le vent.
Les fonctionnalits du menu Terrain

Pour dcouvrir les fonctionnalits suivantes, un terrain est ncessaire. Pour cela, commencez par crer un objet Terrain dans le jeu. Vous pouvez le faire dans Unity en cliquant simplement sur Terrain> Create Terrain. Avant de pouvoir modifier le terrain, vous devez configurer diffrents paramtres, notamment ses dimensions et le niveau de dtail. Le menu principal Terrain permet non seulement de crer un terrain pour le jeu, mais aussi deffectuer les oprations suivantes.
Chapitre 2
Environnements
25
Importer et exporter des heightmaps

Les heightmaps (cartes dlvation) sont des graphismes en 2D, dont les zones claires et fonces reprsentent la topographie du terrain. Elles peuvent tre importes et reprsenter une alternative aux outils permettant de dfinir les lvations de terrain au pinceau dans Unity. Cres dans un logiciel dillustration comme Photoshop et enregistres dans un format .RAW, les heightmaps sont souvent utilises dans le dveloppement des jeux, car elles sont facilement exportes et transfres entre les applications de dessin et les environnements de dveloppement comme Unity. Comme nous allons crer notre environnement avec les outils de terrain de Unity, nous nutiliserons pas de heightmaps externes dans le cadre de ce livre.
Dfinir la rsolution dune heightmap

Figure2.2
La bote de dialogue Set Heightmap resolution permet de dfinir un certain nombre de proprits du terrain que vous venez de crer. Vous devez toujours ajuster ces paramtres avant de crer la topographie du terrain, sinon le terrain risque dtre partiellement rinitialis si vous les redfinissez par la suite.
Terrain Width, Height and Length (largeur, hauteur et longueur). Ces valeurs sont exprimes en mtres. Notez que Height dfinit ici la hauteur maximale que la topo graphie du terrain peut avoir. Heightmap Resolution. Cest la rsolution, exprime en pixels, de la texture que Unity stocke pour reprsenter la topographie. Bien que les dimensions des textures dansUnity doivent gnralement tre une puissance de deux dimensions (128, 256, 512,
26
etc.), les rsolutions heightmap comptent toujours un pixel supplmentaire car chaque pixel dfinit un sommet. Ainsi, dans lexemple dun terrain de 44, quatre sommets seraient prsents le long de chaque section de la grille, mais les points o ces sommets se rencontrent y compris leurs extrmits seraient au nombre de cinq.
Detail Resolution. Connue sous le nom de Detail resolution map, cest la rsolution de la surface stocke par Unity. Celle-ci dfinit prcisment la manire dont vous pouvez placer des dtails sur le terrain. Les dtails regroupent les caractristiques supplmentaires du terrain comme les plantes, les rochers et les arbustes. Plus cette valeur est leve et plus vous pouvez positionner les dtails avec prcision sur le terrain. Control Texture Resolution. Cest la rsolution des textures (appeles Splatmap dans Unity) lorsquelles sont peintes sur le terrain. La valeur de Control Texture Resolution correspond la taille et, par consquent, au dtail de toutes les textures sur lesquelles vous allez peindre. Comme pour toutes les rsolutions de texture, il est prfrable de conserver une valeur assez basse pour obtenir de bonnes performances. Il est gnra lement conseill de la laisser sa valeur par dfaut (512). Base Texture Resolution. La rsolution de la texture utilise par Unity pour faire le rendu des zones de terrain loignes de la camra dans le jeu, ou de toutes les textures sur un ordinateur ancien et peu performant.
Crer la lightmap (la liste des lumires)

Figure2.3
La bote de dialogue Create Lightmap est utilise pour gnrer un rendu semi-permanent de lclairage sur les textures qui donnent lapparence la topographie. Si vous crez 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 lombre projete sur le terrain par cette montagne, vous devez recrer la lightmap afin de faire le rendu des zones sombres sur les textures situes dans la zone prsent ombrage.
Chapitre 2
Environnements
27
La section Lights de cette bote de dialogue permet daugmenter le nombre de lumires utilises pour le rendu de la lightmap. Par exemple, la scne peut tre claire principalement par une Directional Light (lumire directionnelle), qui agit comme la lumire du soleil partir dune certaine direction. Vous pouvez galement intgrer certaines Point Lights (lumire en un point) pour des lampes dextrieur ou des feux. Lorsque vous crez une topographie laide des outils de terrain, vous risquez de devoir modifier les paramtres de cration de la lightmap au fur et mesure que le paysage volue. En crant une lightmap pour les zones claires et les zones sombres sur le terrain, vous rduisez galement la puissance de calcul ncessaire lors de lexcution du jeu, car une partie de lclairage est dj calcule. linverse, lclairage dynamique du terrain est plus coteux en termes de calcul.
La fonction Mass Place Trees

Cette fonction ralise exactement ce que son nom indique : disposer un certain nombre darbres sur le terrain. Les paramtres associs un arbre en particulier sont dfinis la section Place Trees du composant Terrain (Script) du panneau Inspector. Cette fonction nest pas recommande pour une utilisation gnrale, car elle noffre aucun contrle sur la position des arbres. Employez plutt Place Trees (placement darbres) du composant Terrain (Script) afin de peindre les arbres manuellement et ainsi obtenir une disposition plus raliste.
La fonction Flatten Heightmap

La fonction Flatten Heightmap (aplatir la carte dlvation) permet de donner tout le terrain la mme lvation. Par dfaut, la hauteur du terrain vaut0. Si vous souhaitez que llvation par dfaut soit suprieure, comme nous le faisons pour lle, vous pouvez alors utiliser cette fonction pour dfinir la valeur Height.
La fonction Refresh Tree and Detail Prototypes

Si vous modifiez les ressources qui composent des arbres et des dtails dj peints sur le terrain, vous avez alors besoin dutiliser Refresh Tree and Detail Prototypes (rafrachir les prototypes darbres et des dtails) pour les mettre jour.
28
Les outils de terrain

Nous allons tudier les outils de terrain afin que vous puissiez vous familiariser avec leurs fonctions avant de commencer construire lle. Comme vous venez de crer le terrain, il doit tre slectionn dans le panneau Hierarchy. Si ce nest pas le cas, slectionnez-le ds maintenant afin dafficher ses proprits dans le panneau Inspector.
Le composant Terrain (Script)

Dans le panneau Inspector, les outils de terrain sont indiqus sous le nom Terrain (Script). Le composant Terrain (Script) met disposition les diffrents outils et paramtres spcifiques du terrain en plus des fonctions disponibles dans le menu Terrain. la Figure 2.4, vous voyez quil sagit du deuxime de trois lments en rapport avec lobjet de jeu Terrain (les autres composants tant Transform et Terrain Collider).
Figure2.4
Chapitre 2
Environnements
29
Le composant Terrain (Script) comprend sept sections, qui sont facilement accessibles laide des boutons situs en haut du composant. Voici un rapide aperu de leurs capacits respectives.
Loutil Raise/Lower Terrain (lever/abaisser le terrain)

Il permet dlever certaines zones sur lesquelles vous peignez laide de loutil Transform (toucheW).
Figure2.5
Vous pouvez galement dfinir le style de brosse, la taille et lopacit (efficacit) de la dformation que vous effectuez. Pour obtenir leffet contraire, savoir un abaissement de la hauteur, appuyez en mme temps sur la touche Maj.
Figure2.6
30
Loutil Paint Height (peindre jusqu hauteur)

Il fonctionne de manire analogue loutil Raise/Lower Terrain mais il possde un paramtre supplmentaire: Height.
Figure2.7
Cela signifie que vous pouvez dfinir la hauteur que vous allez peindre. Lorsque la zone de terrain dont vous modifiez llvation atteint la hauteur spcifie, elle saplatit, vous permettant de crer des plateaux (voir Figure2.8).
Figure2.8
Loutil Smooth Height (adoucir les dnivels)

Il sert principalement en complment dautres outils, comme Paint Height, pour adoucir les dnivels abrupts de la topographie.
Figure2.9
Chapitre 2
Environnements
31
Le plateau de la Figure2.9 prsente, par exemple, une pente trs abrupte. Pour adoucir les contours de cette lvation, nous nous servirions de cet outil afin darrondir les angles (voir Figure2.10).
Figure2.10
Loutil Paint Texture (peindre des textures)

Il sutilise pour peindre les textures sur la surface du terrain (nommes Splats) dans Unity.
Figure2.11
Avant de peindre avec des textures, vous devez dabord les ajouter la palette dans la zone Textures de cet outil. Pour cela, cliquez sur le bouton Edit Textures, slectionnez Add Textures puis, dans le menu droulant Splat, choisissez un des fichiers de texture actuellement dans votre projet et dfinissez les paramtres de taille de la texture choisie.
32
La Figure2.12 montre trois textures ajoutes dans la palette. La premire sera peinte sur tout le terrain par dfaut. En combinant ensuite plusieurs textures de diffrentes opacits et en peignant la main sur le terrain, vous pouvez donner un aspect raliste tous les types de surface. Pour choisir la texture avec laquelle peindre, cliquez simplement sur son aperu dans la palette: un contour bleu lencadre alors.
Figure2.12
Loutil Place Trees (disposer des arbres)

Comme son nom lindique, cet outil permet de placer, la souris (en peignant ou par de simples clics), des arbres sur le terrain, aprs que les ressources utiliser ont t dfinies.
Figure2.13
Comme pour les textures de loutil Paint Texture, cet outil dispose dun bouton Edit Trees pour ajouter, modifier et supprimer des ressources de la palette.
Chapitre 2
Environnements
33
La section Settings dispose des options suivantes:
Brush Size. Dfinit la quantit darbres peindre chaque clic. Tree Density. Dfinit la distance entre les arbres que vous peignez. Color Variation. Applique une variation de couleur alatoire aux arbres lorsque vous en peignez plusieurs la fois. Tree Width/Height. Dfinit la taille de la ressource arbre que vous peignez. Tree Width/Height Variation. Permet grce la variation alatoire de la taille des arbres de crer des zones boises de manire plus raliste.
Appuyer en mme temps sur la touche Maj inverse galement ses effets: les arbres dj peints sont effacs. Appuyer simultanment sur les touches Maj+Ctrl permet deffacer uniquement le type darbres slectionn dans la palette.
Loutil Paint Details (peindre des dtails)

Il fonctionne dune manire analogue loutil Place Trees, mais il est conu pour travailler avec des objets de dtails comme les fleurs, les plantes, les rochers et le feuillage de petite taille.
Figure2.14
Terrain Settings (les paramtres de terrain)

La section Terrain Settings du composant Terrain (Script) contient diffrents paramtres pour le dessin du terrain par le GPU (processeur graphique) de lordinateur.
Figure2.15
34
Vous pouvez dfinir ici diffrents paramtres qui influent sur le niveau de dtail (LOD, Level of Detail). Dans le domaine du dveloppement de jeux, le LOD correspond la quantit de dtails reprsents une certaine distance du joueur. Dans notre exemple un terrain , nous devons pouvoir rgler les paramtres comme la distance daffichage (Draw Distance). Cette notion, courante dans les jeux3D, permet de procder au rendu des lments de faon moins dtaille lorsquils se trouvent une certaine distance du joueur afin damliorer les performances. La section Terrain Settings vous permet par exemple dajuster loption Base Map Distance (distance de base) afin de prciser quelle distance doivent se situer les objets avant que les graphismes en haute rsolution ne soient remplacs par des graphismes en plus basse rsolution, afin de rduire le cot du rendu des objets les plus lointains. La Figure2.16 montre un exemple de terrain avec une valeur Base Map Distance faible (environ 10 mtres). Comme vous pouvez le constater, le niveau de dtail des textures situes au-del de la distance spcifie est bien infrieur celui du premier plan.
Figure2.16
Vous allez tudier plus en dtail les paramtres de la section Terrain (script) en commenant sculpter le terrain.
Chapitre 2
Environnements
35
Soleil, mer et sable: la cration de lle

tape 1. La configuration du terrain
Maintenant que vous connaissez les outils disponibles, vous pouvez commencer crer le terrain partir du menu principal Terrain. Assurez-vous que le terrain est toujours slectionn dans le panneau Hierarchy, puis cliquez sur Terrain> Set Resolution (changer la rsolution). Comme il sagit de votre premier projet, vous nallez pas crer une le trop grande. Aussi, donnez la valeur 1000 aux deux paramtres Terrain Width et Terrain Length. Appuyez sur la touche Entre aprs avoir saisi ces valeurs pour les valider puis cliquez sur Set Resolution. La hauteur minimale de lle doit ensuite tre celle du niveau du sol et non tre gale 0 (la valeur par dfaut pour les nouveaux terrains). En effet, laltitude0 correspond au fond de la mer, si bien que la hauteur minimale du sol doit tre augmente pour correspondre la partie merge de lle. Cliquez sur Terrain> Flatten Heightmap. Dans le champ Height, entrez 30mtres. Appuyez sur la touche Entre pour confirmer, puis cliquez sur le bouton Flatten. Le changement est trs rapide et il est possible que vous ne voyiez pas la diffrence dans le panneau Scene, puisque vous avez augment lgrement la hauteur de tout le terrain. Toutefois, cette opration permet de gagner normment de temps, car vous pouvez prsent aplanir les bords du terrain laide de loutil Raise/Lower Terrain afin que seule la partie centrale reste surleve. Partir dune le plate et lever sa partie centrale demanderait beaucoup plus de temps.
tape 2. Le contour de lle

Dans le composant Terrain (Script) du panneau Inspector, slectionnez loutil Raise Height le premier des sept boutons. Slectionnez la premire brosse dans la palette et donnez les valeurs 75 au paramtre Brush Size et50 Opacity. Cliquez sur laxeY (le cne vert) de laxe 3D situ dans le coin suprieur droit du panneau Scene pour passer en vue de dessus.
Figure2.17
36
Maintenez la touche Maj enfonce pour que loutil rduise la hauteur du terrain, puis peignez sur les contours du terrain pour crer un rivage en pente jusqu laltitude0 vous savez que vous atteignez laltitude0 car le terrain sera aplati cette hauteur minimale. Bien quil ne soit pas ncessaire que le contour de votre le soit identique au ntre, essayez de crer une forme assez semblable, car vous aurez besoin dune tendue de terre plate par la suite. Une fois que vous avez peint tout autour du contour, vous devriez obtenir un rsultat semblable celui de la Figure2.18.
Figure2.18
Cliquez sur le cube au centre de laxe 3D situ dans le coin suprieur droit du panneau Scene pour revenir une vue en perspective (3D) et admirez votre travail. Si vous ntes pas sr davoir obtenu le bon rsultat, comparez votre le avec celle de la Figure2.19.
Chapitre 2
Environnements
37
Figure2.19
Continuez avec loutil Raise/Lower Terrain sur lle pour amliorer la topographie du terrain, en augmentant voire en diminuant (avec la touche Maj) llvation 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 lle pour ajouter un volcan.
tape 3. Le volcan
Vous allez maintenant crer un volcan! Pour cela, les outils Paint Height, Raise/Lower Terrain et Smooth Height seront adapts. Slectionnez loutil Paint Height pour commencer. Choisissez la premire brosse dans la palette, donnez les valeurs75 Brush Size, 50 Opacity et 200 Height. Slectionnez de nouveau la vue Haut en cliquant sur laxeY de laxe3D dans le panneau Scene, puis peignez un plateau dans le coin du terrain que vous avez laiss libre. Rappelez-vous que cet outil arrte de modifier le terrain une fois que la hauteur spcifie (200) est atteinte. Votre le devrait maintenant ressembler celle de la Figure2.20 dans la vue Perspective.
38
Figure2.20
Ce plateau a un aspect assez peu raliste. Vous allez remdier cela, mais vous devez dabord crer la bouche du volcan. Loutil Paint Height toujours slectionn, donnez la valeur20 Height et la valeur30 Brush Size. Cliquez et maintenez et commencez peindre du centre du plateau vers lextrieur dans toutes les directions, jusqu ce que vous ayez effectivement creus le plateau et laiss une crte troite autour de sa circonfrence (voir Figure2.21). Si vous repassez dans la vue en perspective, vous voyez que laspect du bord du volcan est toujours trop abrupt et assez peu raliste. Vous allez corriger cela: slectionnez loutil Smooth Height, puis donnez les valeurs30 Brush Size et1 Opacity. Peignez ensuite avec cet outil sur le pourtour de la crte pour ladoucir jusqu ce que larte soit suffisamment arrondie (voir Figure2.22). Maintenant que vous avez donn sa forme au volcan, vous pouvez ajouter une texture lle pour rendre le terrain plus raliste.
Chapitre 2
Environnements
39
Figure2.21
Figure2.22
40
tape 4. Lajout de textures

Lorsque vous texturez un terrain, gardez lesprit que la premire texture ajoute le recouvrira entirement. Cest pourquoi vous devez vous assurer que cest bien la premire 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 cration contient plusieurs ressources possdant diffrentes caractristiques. Ces ressources sont regroupes dans le dossier Standard Assets du panneau Project. Cliquez sur la flche grise situe gauche du nom de ce dossier pour afficher son contenu, puis affichez le contenu du sous-dossier Terrain Textures.
Figure2.23
Ces quatre textures vous serviront peindre le terrain de lle. Vous devez donc commencer par les ajouter votre palette. Assurez-vous que lobjet de jeu Terrain est toujours slectionn dans le panneau Hierarchy, puis slectionnez loutil Paint Texture dans le composant Terrain (Script) du panneau Inspector. La procdure de peinture Cliquez sur le bouton Edit Textures, puis slectionnez Add Textures dans le menu qui saffiche. La bote de dialogue Add Textures souvre alors pour vous permettre de slectionner toutes les textures actuellement dans votre projet. Cliquez sur la flche pointant vers le bas droite du paramtre Splat pour choisir une texture sur la liste. Slectionnez la texture Grass (Hill).
Chapitre 2
Environnements
41
Figure2.24
Conservez la valeur 15 pour les paramtres Tile Size X et Tile Size Y. Cette texture recouvrira toute la carte et cette petite valeur permettra dobtenir une herbe plus dtaille. Cliquez sur le bouton Add pour terminer. La texture dherbe recouvre le terrain : cest normal puisquil sagit de la premire texture que vous ajoutez. Celles que vous ajouterez ensuite la palette devront tre peintes la main. Rptez ltape prcdente pour ajouter les trois textures Grass&Rock, Cliff (Layered Rock) et GoodDirt dans la palette. Conservez les paramtres Tile Size, sauf pour Cliff (Layered Rock), dont les paramtres Tile SizeX et Tile SizeY doivent avoir une valeur de 70. En effet, comme cette texture va tre applique sur une zone tire du terrain, elle serait dforme avec une taille de carreau (unit de terrain ou tile) plus petite.
Figure2.25
42
Les rgions sablonneuses Les quatre textures devraient maintenant tre disponibles dans votre palette. Cliquez sur la dernire texture ajoute GoodDirt, si vous avez respect lordre. Un trait bleu saffiche sous sa vignette pour indiquer quelle est slectionne. Donnez les valeurs 60 Brush Size, 50 Opacity et1 Target Strength. Vous pouvez peindre autour de la cte de lle en utilisant soit la vue Haut soit la vue Perspective. En vue Perspective, slectionnez loutil 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 rsultat proche de celui illustr la Figure2.26.
Figure2.26
Si vous faites une erreur pendant que vous peignez, vous pouvez soit annuler le dernier coup de pinceau, cest--dire le dernier clic, avec la commande Edit> Undo, soit slectionner dans la palette la texture qui doit recouvrir cette zone et repeindre avec celle-ci.
Chapitre 2
Environnements
43
Lherbe et les rochers Cliquez ensuite sur la deuxime vignette que vous avez ajoute la texture Grass&Rock pour la slectionner. Donnez les valeurs25 Brush Size, 30 Opacity et 0,5 Target Strength. Peignez toutes les collines du terrain et la moiti suprieure du volcan (voir Figure2.27).
Figure2.27
Les rochers du volcan Vous devez maintenant rendre le volcan plus raliste laide de la texture Cliff (Layered Rock). Slectionnez-la dans la palette, puis donnez les valeurs25 Brush Size et 100 Opacity et Target Strength. Peignez le sommet et lintrieur du volcan avec ces paramtres, puis diminuez peu peu les valeurs de Brush Size et dOpacity au fur et mesure que vous descendez le long des pentes extrieures du volcan, afin que cette texture soit applique de faon plus subtile vers le sol. Vous pouvez galement peindre les cimes de certaines des collines les plus leves avec une opacit plus faible.
44
Aprs de nombreux essais, sans doute, votre volcan termin devrait ressembler celui de la Figure2.28.
Figure2.28
tape 5. Les arbres

Maintenant que lle est entirement texture, vous devez lembellir quelque peu en ajoutant des arbres. Larbre utiliser avec lditeur de terrain que contient le paquet de ressources Standard Assets convient parfaitement puisquil sagit dun palmier. Cliquez sur le bouton Place Trees du composant Terrain (Script), puis sur le bouton Edit Trees. Choisissez Add Tree dans le menu qui apparat. La bote de dialogue Add Tree saffiche alors. Vous pouvez y choisir, comme pour certains des autres outils de terrain, nimporte 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 modliser vos propres arbres, les enregistrer dans le dossier Assets de votre projet afin de les utiliser ensuite. Cependant, ici, le palmier du paquet de ressources Standard Assets est tout fait adquat. Cliquez sur la flche pointant vers le bas droite du paramtre Tree et slectionnez Palm.
Chapitre 2
Environnements
45
Avec le paramtre Bend Factor, les arbres semblent se balancer dans le vent. Le cot du calcul de cet effet tant lev, nous allons utiliser une valeur faible. Entrez2 puis validez (touche Entre). Si vous remarquez, par la suite, que ce paramtre a un impact ngatif sur les performances du jeu, vous pourrez toujours le redfinir en lui donnant la valeur0. Cliquez sur le bouton Add. Un petit aperu du palmier devrait apparatre dans la palette, encadr de bleu pour indiquer quil sagit de larbre slectionn placer. Donnez les valeurs suivantes : 15 Brush Size (pour peindre quinze arbres la fois), 10 Tree Density (afin que les arbres soient assez disperss sur la carte), 0,4 Color Variation (pour obtenir un ensemble darbres vari). Enfin, 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 lle, proximit des zones de sable o ce type darbres est cens se trouver. Puis, pour complter le relief de lle, placez dautres palmiers des emplacements alatoires lintrieur des terres. Vous pouvez tout moment effacer des arbres mal placs: pour cela, appuyez sur la touche Maj et cliquez ou peignez sur ces arbres.
tape 6. Ajouter des touffes dherbe

prsent que vous avez plac quelques arbres sur lle, vous allez ajouter des touffes dherbe pour complter la texture avec laquelle vous avez recouvert la plus grande partie du terrain. Slectionnez la section Paint Details du composant Terrain (Script), cliquez sur le bouton Edit Details puis slectionnez Add Grass Texture dans le menu contextuel. Ouvrez le menu droulant situ droite du paramtre Detail Texture et slectionnez la texture Grass, la texture dherbe du paquet de ressources Standard Assets. Conservez pour cette texture les valeurs par dfaut des proprits Width et Height et assurez-vous que loption Billboard, au bas de la bote de dialogue, est active. Comme la texture dherbe est en 2D, la technique du billboard (panneau daffichage) est applicable. Elle consiste faire pivoter la texture dherbe face la camra pendant le jeu afin de lui donner un aspect moins bidimensionnel. Utilisez les pipettes des options Healthy Color et Dry Color, pour obtenir les mmes teintes vertes que celles des textures que vous avez peintes sur le terrain. En effet, les touffes dherbe sembleraient artificielles si vous conserviez la couleur vert clair par dfaut.
46
Figure2.29
Cliquez sur le bouton Add au bas de la bote de dialogue pour confirmer lajout de cette texture votre palette. Vous pouvez peindre lherbe sur la carte avec la souris de la mme faon quavec les autres outils de terrain. Vous devez dabord choisir une brosse et dfinir ses paramtres afin de crer des touffes dherbe espaces et disparates sur la carte. Le rendu de lherbe tant galement coteux pour lordinateur, donnez des valeurs trs faibles : 100 pour Brush Size mais seulement 0,05 pour Opacity et 0,6 pour Target Force de faon que les touffes dherbe soient clairsemes. En choisissant en outre une forme de brosse irrgulire (voir Figure2.30), vous pouvez peindre des zones dherbe ingales. Slectionnez loutil 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 suffisant, vous pouvez cliquer sur le terrain pour peindre les zones dherbe. Dplacez-vous sur lle mais ne peignez que quelques zones dherbe 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 dtails. Afin dconomiser de la mmoire, le rendu des dtails nest, en effet, pas visible dans le panneau SCENE avec un facteur de zoom rduit. Lorsque vous zoomez en arrire, les dtails semblent ainsi souvent disparatre mais, ne vous inquitez pas, cela nest pas le cas.
ce Astu
Chapitre 2
Environnements
47
Figure2.30
tape 7. Que les lumires soient!

Maintenant que votre le est prte tre explore, vous devez clairer la scne. Pour cela, trois types de lumire sont disponibles:
Directional Light (lumire directionnelle). La principale source de lumire, souvent la lumire du soleil. Elle nmane pas dun seul point mais elle claire dans une seule direction. Point Light (lumire point). Ces lumires proviennent dun seul point dans le monde3D et sont utilisespour toutes les autres source de lumire, comme lclairage lintrieur des btiments, le feu, les objets incandescents,etc. Spot Light (lumire spot). Comme son nom lindique, cette lumire claire dans une direction unique, mais son rayon peut tre dfini, tout comme sil sagissait dune lampe torche.
Crer la lumire du soleil Vous allez placer une lumire directionnelle comme source de lumire principale. Cliquez sur GameObject> Create Other> Directional Light pour ajouter la lumire comme un objet dans la scne. Vous constatez quelle est dsormais rpertorie dans le panneau Hierarchy.
48
Comme la lumire directionnelle nmane pas dun point en particulier, sa position na gnralement aucune importance car elle ne peut pas tre vue par le joueur il ne peroit que la lueur quelle projette. Toutefois, pour ce didacticiel, vous utiliserez une lumire directionnelle pour reprsenter le soleil, en appliquant le paramtre Flare. Vous allez positionner la lumire une grande distance au-dessus de lle puis vous lloignerez sur laxe Z afin 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 lumire (appuyez sur Entre pour confirmer chaque valeur). Donnez la valeur8 la proprit Xrotation afin que la lumire soriente vers le bas sur laxeX et quelle projette davantage de clart sur le terrain. Enfin, vous devez rendre cette lumire visible. Pour cela, cliquez sur la flche pointant vers le bas, situe droite du paramtre Flare dans le composant Light (il indique actuellement None), puis slectionnez Sun dans le menu.
Figure2.31
tape 8. Quel est ce bruit?

Le son est souvent un lment nglig dans le dveloppement dun jeu. Or, pour que lexprience vidoludique soit vraiment immersive, le joueur a non seulement besoin de dcouvrir lenvironnement avec ses yeux, mais aussi avec ses oreilles. Le son dans Unity est gr 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 loreille du joueur. Par dfaut, les objets de jeu Camra de Unity possdent un composant Audio Listener. Et comme vous disposez toujours dune camra dans votre jeu, il est fort probable que vous naurez que les sources sonores dfinir. Il est galement intressant de noter que le composant Audio Listener na pas de proprits ajustables il fonctionne, tout simplement , et que Unity affiche un message derreur si vous supprimez par inadvertance le dernier couteur dans une scne.
Stro et mono Unity gre le comportement du son en stro (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 dmission et lauditeur dans lunivers3D. Prenons deux exemples:
La musique dans le jeu. Le son stro est prfrable, le volume tant constant, o que se trouve le joueur dans le jeu. Les effets sonores dune chane hi-fi lintrieur dun btiment. Le son mono est le mieux adapt. Bien que vous puissiez choisir de la musique comme effet sonore, lutilisation de fichiers audio mono permet daugmenter le volume de la source sonore mesure que le joueur sen approche.
Les formats audio Unity accepte la plupart des formats audio courants WAV, MP3, AIFF et OGG. Dans le cas dun format compress comme le MP3, il convertit les fichiers audio au format Ogg Vorbis mais il ne convertit pas les sons non compresss (les sons au format WAV, par exemple). Comme les autres ressources que vous importez, les fichiers audio sont convertis ds que vous passez dun autre programme Unity, ce dernier scannant le contenu du dossier Assets la recherche de nouveaux fichiers chaque fois que vous basculez vers le programme. Les collines sont pleines de vie! Pour rendre lle plus raliste, vous allez ajouter une source sonore dambiance en utilisant un son stro. Commencez par slectionner lobjet 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 stro demeure constant, la position na pas dimportance,
50
si bien que cette source sonore pourrait se situer sur nimporte quel objet. Il est cependant logique que lambiance sonore de lle soit lie cet objet de jeu. Un composant Audio Source est prsent disponible dans le panneau Inspector du terrain. Vous pouvez soit choisir le fichier qui doit tre lu soit ne rien indiquer si vous avez dcid de dclencher les sons laide dun script. Importer le premier paquet de ressources Pour cette tape, vous aurez besoin dutiliser le premier paquet de ressources de larchive que vous avez tlcharge sur le site Pearson (http://www.pearson.fr). Dcompressez cette archive, localisez le fichier nomm Sound1.unitypackage dans le dossier 8181_02_code, puis revenez Unity et cliquez sur Assets> Import Package. Dans la bote de dialogue Import Package qui souvre alors, parcourez votre disque dur jusqu lemplacement o vous avez enregistr larchive dcompresse. Slectionnez ce dossier, puis cliquez sur Ouvrir. La liste des ressources disponibles saffiche par dfaut, Unity part du principe que lutilisateur souhaite importer toutes les ressources, mais il vaut mieux importer seulement certaines ressources lors de lutilisation de plus gros paquets de ressources. Le paquet sound1 ne contient quun fichier audio au format MP3 fichier appel hillside. mp3 plac dans un dossier Sound, si bien que seuls ces deux lments saffichent. Cliquez sur Import pour confirmer lajout de ces fichiers dans votre projet. Aprs leur conversion, ils devraient apparatre dans le panneau Project vous devez cliquer sur la flche grise gauche du dossier Sound pour afficher le fichier hillside quil contient. Les fichiers audio saccompagnent dune icne en forme de haut-parleur dans le panneau Project (voir Figure2.32).
Figure2.32
Le fichier hillside peut maintenant tre appliqu au composant Audio Source du terrain.
Chapitre 2
Environnements
51
Cliquez sur la flche pointant vers le bas, situe droite du paramtre Audio Clip dans le composant Audio Source de lobjet de jeu Terrain, afin dafficher la liste de tous les fichiers audio disponibles dans le projet. Comme celui-ci ne contient que le fichier audio hillside, seul ce dernier saffiche dans le menu contextuel. Slectionnez-le maintenant. Les autres paramtres audio Le composant Audio Source dispose de diffrents contrles sur la lecture des sons. Pour le son dambiance hillside, assurez-vous simplement que les options Play On Awake (lecture lactivation) et Loop (boucle) sont slectionnes. La lecture se dclenchera lors de lentre du joueur dans la scne (ou dans le niveau) et continuera en boucle jusqu ce que la scne se termine. Les paramtres de votre composant Audio Source devraient tre les mmes qu la Figure2.33.
Figure2.33
Les paramtres Min/Max Volume et Rolloff Factor (facteur dloignement) nont aucun effet sur ce son car il est en stro le volume est indpendant de la distance entre le joueur et la source sonore. Pour des sons mono, en revanche, ces options donnent les rsultats suivants:
Min/Max Volume. Le volume le plus faible/lev que le son peut avoir, indpendamment de la proximit de lcouteur audio. Rolloff Factor. La rapidit avec laquelle le volume sonore crot ou dcrot lorsque lauditeur se rapproche ou sloigne de la source.
tape 9. Regardez le ciel (la skybox)

Dans les environnements 3D, vous reprsentez lhorizon ou le lointain en ajoutant une skybox. Une skybox est un cubemap (une vue cubique aplatie), cest--dire une srie de six
52
textures places lintrieur dun cube dont le rendu simule le ciel et lhorizon. Ce cubemap recouvre le monde en3D tout moment et, tout comme lhorizon rel, il ne peut pas tre atteint par un joueur. Pour appliquer une skybox la scne, cliquez sur Edit> Render Settings. Le contenu du panneau Inspector affiche alors les prfrences de rendu de cette scne. Cliquez sur la flche droulante situe droite du paramtre Skybox Material, puis slectionnez Sunset pour lappliquer la skybox. Il est crucial que vous compreniez que chaque skybox ajoute sera uniquement visible dans le panneau Game par dfaut. La skybox Sunset du paquet de ressources Standard, comme de nombreuses autres, dispose dun soleil prdfini. Cependant, votre scne en a dj un, reprsent visuellement par le reflet de la lumire directionnelle. Vous devez donc repositionner celle-ci pour quelle corresponde au soleil de la skybox. Afin que vous puissiez juger de ce problme par vous-mme, vous ajouterez dabord le personnage du joueur (First Person Controller).
tape 10. La mer

Vous avez cr une le, celle-ci doit donc tre entoure deau. Leau, dans Unity, est ralise partir dun matriau anim appliqu une surface. Bien quil soit possible de crer dautres effets dynamiques pour leau laide des particules, la meilleure faon den ajouter une grande tendue consiste utiliser un des matriaux fournis avec Unity. Le paquet de ressources Standard Assets contient deux surfaces prtes lemploi sur lesquelles le matriau Water est appliqu. Ces objets enregistrs en tant qulments prfabriqus peuvent tre facilement utiliss depuis le panneau Project. Il vous suffit en effet douvrir le dossier Standard Assets/Water. Faites glisser llment prfabriqu Daylight Simple Water dans la scne, puis positionnezle (500, 4, 500) en indiquant ces valeurs dans les champs PositionX, YetZ du composant Transform dans le panneau Inspector. Afin daugmenter lchelle de llment prfabriqu Water pour quil forme une mer tout autour de lle, donnez la valeur1600 aux paramtresX etZ de Scale. Leau est ainsi place au centre de la carte, quatre mtres au-dessus du fond marin. Cela recouvrira les coins de lle et masquera la nature carre du terrain (voir Figure2.34).
Chapitre 2
Environnements
53
Figure2.34
tape 11. Randonne sur lle

Dans le panneau Project, affichez le contenu du sous-dossier Prefabs du paquet de ressources Standard Assets: il contient un seul lment prfabriqu: lobjet First Person Controller (contrleur la premire personne). Vous allez le faire glisser et le dposer dans la scne afin de vous promener sur votre terrain laide du clavier et de la souris. Faites glisser cet lment prfabriqu depuis le panneau Project dans le panneau Scene. Vous ne pouvez pas le positionner prcisment lorsque vous le dposez dans la scne, mais vous pouvez le faire par la suite. Maintenant que lobjet First Person Controller est un objet de jeu actif, il apparat 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 axesX etZ, car vous avez cr un terrain de 1000mtres de ct. La valeur35 sur laxeY 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 valeurY pour placer le personnage en haut de la colline au dbut de la partie.
54

Info
Pour voir plus facilement o votre objet personnage est plac, assurez-vous quil est slectionn dans le panneau HIERARChY, placez le curseur sur le panneau SCENE et appuyez sur la toucheF. La vue dans le panneau SCENE se centre alors sur lobjet slectionn.
Cliquez maintenant sur le bouton Play pour tester le jeu. Vous devriez pouvoir vous promener sur votre le! Les contrles par dfaut du personnage sont les suivants:
Haut/W: avancer; Bas/S: reculer; Gauche/A: pas sur le ct gauche (aussi connu sous le nom de strafing); Droit/D: pas sur le ct droit; Souris: examiner les alentours ou faire pivoter le joueur lorsquil se dplace.
Grimpez au sommet dune colline et tournez-vous jusqu ce que vous puissiez voir le reflet du soleil. Regardez ensuite droite du reflet: vous constatez que la skybox possde galement une zone claire pour reprsenter le soleil. Vous devez donc repositionner lobjet Directional Light afin quil corresponde au soleil de la skybox, comme nous lavons dj mentionn. Cliquez de nouveau sur le bouton Play pour interrompre le test du jeu. Il est essentiel darrter le jeu lorsque vous effectuez des modifications. Si vous le laissez sexcuter ou si vous cliquez sur Pause, les modifications que vous apportez la scne ne seront que temporaires elles seront annules ds que vous cliquerez de nouveau sur Play ou que vous quitterez Unity.
tape 12. Alignement du soleil et retouches finales

Slectionnez lobjet Directional Light dans le panneau Hierarchy, puis repositionnezle (500, 500, 500) dans le composant Transform du panneau Inspector. La lumire se place alors sur le ct de la carte o se trouve le soleil de la skybox. Faites ensuite pivoter lobjet de 120 sur laxe Y (bote centrale) pour que la position de lobjet Directional Light corresponde la lumire de la skybox.
Chapitre 2
Environnements
55
Enfin, comme nous avons lobjet First Person Controller, nous navons dsormais plus besoin de lobjet Main Camera ajout par dfaut. Unity le signale dailleurs en affichant un message (voir Figure2.35) dans la zone daperu de la console au bas de lcran lorsque vous testez le jeu.
Figure2.35
Pour remdier ce problme, il suffit de supprimer lobjet Main Camera. Pour cela, slectionnez-le dans le panneau Hierarchy, puis cliquez sur Edit> Delete ou appuyez sur Cmd+Retour arrire (MacOS) ou sur Suppr (Windows). Maintenant que cet objet a disparu, lle est termine. Enregistrez votre scne afin de ne rien perdre de votre travail. Pour cela, cliquez sur File> Save Scene et nommez la scne Island Level, par exemple. Unity propose automatiquement de lenregistrer dans le dossier Assets de votre projet car toutes les ressources doivent sy trouver. Pour organiser vos lments, vous pouvez crer un sous-dossier Niveaux o enregistrer votre scne. Flicitations, votre le est prte tre explore. Cliquez de nouveau sur le bouton Play et promenez-vous! Noubliez pas de cliquer sur Play de nouveau lorsque vous aurez termin.
Importer des modles

Votre le est prte pour le jeu! Vous allez donc apprendre importer des modles crs dans des applications externes. Les modles pour les exercices de ce livre tant fournis, vous aurez besoin dimporter un autre paquet Unity pour ajouter le premier modle un avant-poste votre projet.
Importer le paquet de ressources du modle

Cliquez sur Assets> Import Package dans Unity puis parcourez votre disque dur jusquau dossier Code_8181/8181_02_code/Outpost.unitypackage que vous avez extrait de larchive tlcharge (http://www.pearson.fr). Cliquez ensuite sur Assets> Import Package.
56
Figure2.36
Laissez tous les fichiers slectionns, 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 flche grise situe ct du nom de ce dossier dans le panneau Project pour afficher son contenu.
Figure2.37
Le dossier import contient le modle lui-mme ainsi que deux sous-dossiers: Materials pour les matriaux et Textures pour les images qui composent les textures de ces matriaux. Vous pouvez reprer un modle3D dans Unity grce son icne, un petit cube accompagn dune image de page. Cela permet de le diffrencier des lments prfabriqus, dont licne est un simple cube, comme vous le verrez plus loin.
Chapitre 2
Environnements
57
Les paramtres communs des modles

Avant dajouter un modle dans la scne active, vous devez toujours vous assurer dans le panneau Inspector que ses paramtres conviennent. Lorsque vous importez de nouveaux modles dans un projet, Unity les interprte laide de son format de fichier FBX. Avec le composant FBX Importer du panneau Inspector, vous pouvez slectionner le fichier du modle dans le panneau Project et rgler ses paramtres Meshes, Materials et Animations avant que le modle ne devienne partie intgrante de votre jeu.
Le maillage (Meshes)
la section Meshes du composant FBX Importer, vous pouvez dfinir les paramtres suivants:
Scale Factor. Gnralement fix la valeur1, ce paramtre indique quune unit est gale un mtre dans le monde du jeu. Pour utiliser une chelle diffrente, il suffit dajuster ce paramtre avant dajouter le modle la scne. Mais vous pouvez toujours modifier lchelle des objets lorsquils se trouvent dans la scne grce aux paramtres Scale du composant Transform. Generate Colliders (gnrer les composants de collisions). Cette option attribue un Mesh Collider chaque composant individuel du modle. Un Mesh Collider (composant de collisions respectant le maillage) est un collider (composant de collisions) complexe qui sadapte des formes gomtriques complexes. Il sagit par consquent du type habituel de collider appliquer toutes les parties dune carte ou dun modle3D de btiment. Calculate Normals. La normale est la face avant de chaque maillage du modle3D, autrement dit le ct visible aprs le rendu. En activant cette option, vous permettez Unity de sassurer que le rendu de toutes les surfaces est correctement dfini dans le jeu. Smoothing Angle. Lorsque vous utilisez la fonction Calculate Normals, le lissage permet de spcifier langle quune arte doit avoir pour tre considre comme une arte en dur par le moteur du jeu. Les autres pourront tre lisses par exemple pour le rendu des lumires sur une sphre. Split Tangents. Ce paramtre permet au moteur de corriger les modles imports avec un placage de relief incorrect. Le placage de relief, ou Bump mapping, utilise deux textures: une image qui reprsente lapparence du modle et une heightmap. En combinant les deux, il permet au moteur de rendu dafficher des surfaces planes de polygones comme si elles comportaient des dformations en 3D. Lorsque vous crez ces effets dans des applications tierces et que vous les transfrez dans Unity, les effets dclairage
58
peuvent parfois ne pas tre corrects. Cette option est conue pour corriger ce problme en interprtant leurs matriaux diffremment.
Swap UVs. Ce paramtre sert corriger les erreurs dimportation des shaders de lumire depuis des applications tierces.
Les matriaux (materials)

La section Materials permet de choisir la faon dont sont interprts les matriaux crs dans une application de modlisation 3D tierce. Dans le menu droulant Generation, vous pouvez choisir loption Per Texture, afin de crer un matriau Unity pour chaque image de texture trouve dans le fichier, ou loption Per Material, afin de crer des matriaux uniquement pour les matriaux existants dans le fichier original.
Les animations
la section Animations du composant Importer, vous interprtez les animations cres dans votre logiciel de modlisation de diffrentes faons. Vous pouvez choisir une des mthodes suivantes dans le menu droulant Generation:
Dont Import. Le modle est import sans aucune animation. Store in Original Roots. Le modle conserve les animations de chaque objet parent, car le parent ou la racine (root) des objets peut simporter de manire diffrente dans Unity. Store in Nodes. Le modle conserve les animations de chaque objet enfant, ce qui permet un contrle plus important de lanimation de chaque lment par le script. Store in Root. Le modle ne conserve que lanimation de lobjet parent de lensemble du groupe. Bake Animations. Indique Unity dinterprter les articulations dans les modles qui utilisent une armature pour tre anims (cinmatique inverse). Keyframes Reduction. Supprime les images cls inutiles dans les modles exports depuis des logiciels de modlisation. Cette option devrait toujours tre slectionne car elle amliore les performances du modle danimation puisque Unity na pas besoin de ces images-cls. Split Animations. Lorsque les animateurs crent des modles destins tre utiliss dans Unity, ils ralisent leurs animations sur une chelle de temps. Aprs en avoir not la dure, ils peuvent disposer chaque partie de lanimation dans son chelle de temps,
La section Animations contient trois cases cocher supplmentaires:
Chapitre 2
Environnements
59
en indiquant le nom et les images sur lesquelles chaque animation se droule. De cette manire, on peut ensuite appeler chaque animation par son nom laide dun script.
Le paramtrage du modle davant-poste

Le modle davant-poste que vous avez import tant slectionn dans le panneau Project, vous allez utiliser le composant FBX Importer du panneau Inspector pour ajuster ses paramtres. Assurez-vous des points suivants.
la section Meshes, loption Scale Factor est dfinie 1 et les options Generate Colliders et Calculate Normals sont slectionnes. la section Materials, loption Per Texture est slectionne dans le menu Generation. la section Animations, les options Keyframes Reduction et Split Animations sont slectionnes.
Cliquez sur le bouton + (Ajouter un symbole) droite du tableau situ au bas de la section Animations pour ajouter trois squences animes. La premire animation est automatiquement nomme idle (inactif), ce qui est parfait, mais vous devez indiquer le nombre dimages utiliser. Cliquez sur la premire valeur dans la colonne Start, saisissez 1 pour indiquer Unity de commencer cette animation sur limage1, puis indiquez une valeur de2 dans la colonne End. Rptez cette tape pour ajouter deux autres animations:
dooropen: de limage3 limage12; doorshut: de limage13 limage24. Les noms de ces animations sont sensibles la casse quand vous les appelez dans un script. Vous devez donc vous assurer de les crire exactement comme nous les indiquons.
Info
Loption Loop du tableau Animations peut tre trompeuse pour les nouveaux utilisateurs. Elle nest pas conue pour que lanimation que vous paramtrez soit lue en boucle (cest le paramtre Wrap Mode qui gre cela, une fois lanimation insre dans la scne). En fait, la fonction Loop permet dajouter une image aux animations lues en boucle lorsque la premire et la dernire image des animations provenant dapplications de modlisation tierces ne correspondent plus aprs leur importation dans Unity.
60
Figure2.38
Lorsque votre modle davant-poste est paramtr comme indiqu, cliquez sur le bouton Apply pour confirmer ces paramtres dimportation. Le modle est prt tre insr dans la scne et utilis dans votre jeu.
Chapitre 2
Environnements
61
En rsum
Ce chapitre vous a donn les bases du dveloppement de votre premier environnement. partir dune surface plate, vous avez cr en trs peu de temps une le complte explorer. Vous avez galement tudi lclairage et le son, deux principes de base qui sappliquent dans tous les types de projets de jeux que vous rencontrerez. Souvenez-vous que vous pouvez ractiver tout moment les outils de terrain dcrits ici afin dajouter des dtails votre terrain. Une fois que vous vous sentirez plus en confiance dans lutilisation du son, nous reviendrons sur ce sujet et nous montrerons comment ajouter dautres sources audio votre le. Continuez les exercices de ce livre et vous dcouvrirez tous les types de nuances supplmentaires que vous pouvez apporter aux environnements afin de les rendre plus crdibles pour le joueur. Vous dcouvrirez comment ajouter une touche dynamique lle lorsque nous aborderons lutilisation des particules, en ajoutant des feux de camp ainsi quun panache de fume et des cendres au volcan! Au prochain chapitre, vous allez intgrer le btiment davant-poste votre scne et voir comment dclencher ses animations lorsque le joueur sapproche de la porte. Pour cela, nous allons prsenter lcriture de code JavaScript pour Unity afin que vous commenciez dvelopper les interactions dans le jeu.
3
Personnages jouables
Vous allez largir le scnario de lle que vous avez cre prcdemment, en vous tournant vers la construction du personnage du joueur que vous avez dj ajout la scne. Stock sous forme dlment prfabriqu (un modle de donnes) offert par Unity Technologies dans le paquet de ressources Standard Assets, cet objet est un exemple de personnage jouable pour un jeu la premire personne. Vous allez voir comment la combinaison des objets et des composants qui le constituent permet dobtenir cet effet. Vous tudierez les coulisses de cet lment prfabriqu et vous dcouvrirez comment chacun de ses composants fonctionne pour constituer le personnage du joueur. Vous dcouvrirez galement les scripts JavaScript dans Unity. Cet lment prfabriqu tant dj ajout la scne du jeu, ce serait trop simple de continuer dvelopper le jeu en partant du principe que cet objet fonctionne correctement. En effet, chaque fois que vous implmentez une ressource cre en dehors de Unity, vous devez comprendre son fonctionnement. Dans le cas contraire, vous aurez des difficults pour ajuster cet lment ou corriger dventuelles erreurs.
64
Nous allons aborder les points suivants afin que vous compreniez comment la combinaison de quelques objets et de quelques composants peut crer un personnage part entire:
les tags, les calques et les lments prfabriqus dans le panneau Inspector; les relations parent-enfant dans les objets; les bases du langage JavaScript; lcriture de script pour les mouvements du joueur; le paramtrage de variables publiques dans le panneau Inspector; lutilisation de camras pour crer le point de vue.
Le panneau Inspector
Comme cest la premire fois que vous dissquez un objet dans le panneau Inspector, commenons par examiner les caractristiques de ce panneau, communes tous les objets. Le nom de lobjet slectionn saffiche en haut du panneau Inspector, prcd dune icne dlment prfabriqu (un cube rouge, vert et bleu) ou dune icne dobjet de jeu (un cube bleu clair) ainsi que dune case cocher permettant de le dsactiver temporairement ou dfinitivement. Pour lobjet de jeu Directional Light, qui nest pas cr partir dun lment prfabriqu existant, le haut du panneau Inspector se prsente comme la Figure3.1.
Figure3.1
Les faces rouges, vertes et bleues du cube de licne, indiquent quil sagit dun objet de jeu standard. Vous pouvez renommer cet objet trs simplement en cliquant sur le champ du nom de lobjet, puis en entrant un nouveau nom. Sous licne de lobjet et le champ indiquant son nom se trouvent la case cocher dactivation de lobjet et les options Tag et Layer.
Chapitre 3
65
Les tags
Les tags sont tout simplement des mots cls quon peut assigner un objet de jeu. Vous pouvez ensuite utiliser ces mots ou une phrase de votre choix pour faire rfrence lobjet (ou aux objets) de jeu dans le script (un tag peut tre utilis plusieurs fois). Si vous connaissez Adobe Flash, vous pouvez comparer les tags aux noms doccurrences dans Flash, au sens o il sagit dans les deux cas de mots cls utiliss pour reprsenter les objets dans une scne. Lattribution dun tag un objet de jeu se ralise en deux tapes: ajout du tag la liste du Tag Manager, puis application lobjet. Pour vous habituer lutilisation des tags, vous allez dfinir et appliquer votre premier tag lobjet Directional Light. Slectionnez-le dans le panneau Hierarchy, puis cliquez sur le menu droulant Tag qui indique pour le moment Untagged. Ce menu contient la liste des tags existants. Vous pouvez soit choisir lun deux ou en crer un. Slectionnez Add Tag au bas du menu afin dajouter un tag la liste du Tag Manager.
Figure3.2
Le panneau Inspector affiche alors le Tag Manager et non plus les composants de lobjet slectionn. Le Tag Manager contient la fois les Tags et les Layers. Pour ajouter un nouveau tag, cliquez sur la flche grise situe gauche de Tag, pour afficher les paramtres Size et Element. Vous pouvez alors saisir le nom du tag dans le champ vierge situ droite de Element0. Entrez le nom Sunlight (vous pouvez nommer les tags comme cela vous convient), puis appuyez sur Entre pour valider. La valeur du paramtre Size sincrmente dune unit ds que vous appuyez sur Entre, et un nouveau champ Element devient disponible pour un prochain tag.
66
Figure3.3
Le paramtre Size correspond ici au nombre de tags actuellement dfinis. Unity utilise les noms Size et Element dans plusieurs menus diffrents du panneau Inspector, comme vous le verrez par la suite. Vous avez ajout un tag la liste, mais il nest pas encore attach lobjet Directional Light. Par consquent, slectionnez de nouveau cet objet dans le panneau Hierarchy, puis cliquez sur le menu droulant Tag en haut du panneau Inspector. Le tag Sunlight que vous venez de crer apparat maintenant sur la liste. Pour lappliquer, il vous suffit de le slectionner dans le menu droulant (voir Figure3.4).
Figure3.4
Les calques (layers)

Les calques sont un moyen supplmentaire de regrouper des objets afin de leur appliquer des rgles spcifiques, en particulier pour le rendu des lumires et des camras. Toutefois,
Chapitre 3
67
ils peuvent aussi tre utiliss avec une technique physique appele raycasting (trac de rayon), afin disoler certains objets de faon slective. Aprs avoir plac des objets sur un calque, vous pouvez les dslectionner partir du paramtre Culling Mask dune lumire afin quils ne soient pas affects par celle-ci. Comme les tags, les calques se crent dans le Tag Manager ils apparaissent en dessous de la liste des tags.
Les lments prfabriqus dans le panneau Inspector

Si lobjet de jeu que vous slectionnez dans le panneau Hierarchy provient dun lment prfabriqu, le panneau Inspector propose alors quelques paramtres supplmentaires (voir Figure3.5).
Figure3.5
Trois boutons supplmentaires saffichent sous les champs Tag et Layer et permettent dinteragir avec lobjet cr partir dun lment prfabriqu.
Select. Permet de localiser et de mettre en vidence llment prfabriqu auquel appartient cet objet dans le panneau Project. Revert. Annule tous les paramtres des composants de lobjet actif et rtablit les paramtres utiliss par llment prfabriqu dans le panneau Project. Apply. Applique les valeurs utilises dans loccurrence slectionne aux paramtres de llment prfabriqu. Toutes les copies de cet lment prfabriqu intgres dans la scne en cours sont galement mises jour.
Maintenant que vous connaissez les paramtres supplmentaires disponibles dans le panneau Inspector, nous pouvons commencer tudier le personnage du joueur.
Lobjet First Person Controller en dtail

Commenons par regarder les objets qui constituent lobjet First Person Controller (FPC) avant de nous pencher sur les composants qui le font fonctionner.
68
Dans le panneau Hierarchy, cliquez sur la flche grise gauche de lobjet First Person Controller, afin dafficher les objets qui y sont imbriqus. Lorsque les objets sont imbriqus de cette manire, il sagit dune relation parent-enfant. Dans cet exemple, lobjet First Person Controller est le parent, et les objets Graphics et Main Camera, ses enfants. Les objets enfants saffichent en retrait dans le panneau Hierarchy afin de montrer leurs relations lobjet parent (voir Figure3.6).
Figure3.6
Les relations parent-enfant

Vous devez retenir certaines rgles essentielles concernant les objets imbriqus ou les objets enfants. Les valeurs de position et de rotation dun objet enfant sont relatives celles de ses parents. On parle alors de position locale et de rotation locale. Par exemple, si les coordonnes dun objet sont (500, 35, 500), et que celles dun de ses objets enfants sont (0, 0, 0), on remarque que celui-ci semble avoir la mme position que son parent. Il sagit en effet de la position relative de lobjet enfant: en plaant un objet enfant (0, 0, 0), vous le positionnez aux coordonnes dorigine de son parent, autrement dit par rapport la position du parent. Cliquez sur lobjet Graphics situ sous lobjet parent FPC dans le panneau Hierarchy. Comme vous pouvez le constater, lobjet FPC se trouve au centre de lle et, pourtant, les valeurs du composant Transform de lobjet Graphics sont de (0, 0, 0). En consquence, chaque fois que lobjet parent est dplac, ses enfants laccompagnent, tout en conservant leur position et leur rotation locale selon la position et la rotation du parent dans le monde du jeu.
Chapitre 3
69
Les objets de First Person Controller

Cet objet se compose des trois lments suivants: 1. First Person Controller. Lobjet FPC, ou parent du groupe, sur lequel sont appliqus le script et le collider (composant de collision) principal pour contrler son comportement. Le mouvement de cet objet est contrl par deux scripts: le premier permet de le dplacer laide du clavier et le second de le faire pivoter en dplaant la souris gauche et droite. 2. Graphics. Tout simplement la forme primitive Capsule (voir Figure 3.7), qui vous permet en tant que dveloppeur de voir o vous avez plac lobjet FPC. 3. Main Camera. Plac au niveau des yeux du joueur, cet objet fournit le point de vue. Des scripts lui sont appliqus afin que le joueur puisse regarder vers le haut et vers le bas. En raison de la relation parent-enfant, lorsque lobjet FPC se dplace ou pivote, les objets Graphics et Main Camera suivent. Slectionnez lobjet First Person Controller dans le panneau Hierarchy, placez le curseur sur le panneau Scene, puis centrez la vue sur cet objet (toucheF). Lobjet FPC devrait safficher comme la Figure3.7.
Figure3.7
70
Cliquez maintenant sur le bouton Play, puis nimporte o dans le panneau Game et commencez dplacer le personnage tout en lobservant dans le panneau Scene. Vous constatez que lorsque vous modifiez la position du personnage avec les touches du clavier et que vous le faites tourner laide de la souris, la position des objets enfants change galement. WINDOw> Pour afficher les panneaux GAME et SCENE en mme temps, cliquez sur LAYOUTs> 2BY3, puis dplacez les panneaux votre convenance.
Info
Objet 1. Lobjet First Person Controller (parent)

Lobjet First Person Controller tant toujours slectionn dans le panneau Hierarchy, observez ses composants dans le panneau Inspector.
Figure3.8
Lobjet FPC est form de quatre composants : Transform, FPSWalker (Script), Character Controller et Mouse Look (Script) [voir Figure3.8].
Chapitre 3
71
Le composant Transform
Comme tous les objets de jeu actifs, lobjet FPC possde un composant Transform qui indique ses paramtres de position, de rotation et dchelle et permet de les ajuster.
Le composant FPSWalker (Script)

Ce script, crit en JavaScript, permet de contrler le dplacement du personnage vers larrire et vers lavant avec les touches directionnelles Haut et Bas (ouW etS), sur le ct (le strafing dans le jargon des joueurs) laide des touches directionnelles Gauche et Droite (ouA etD), et de le faire sauter en utilisant la touche de saut, qui est, par dfaut, la barre despacement. Ce script compte trois variables publiques Speed, JumpSpeed et Gravity, visibles dans le panneau Inspector. Il est ainsi possible dajuster ces valeurs sans mme ouvrir le script. Le moteur physique de Unity peut contrler les objets avec un composant Rigidbody, mais notre personnage nen possde pas. Sa propre gravit doit donc tre indique dans une partie du script. Cette variable permet daugmenter leffet de la gravit, ce qui a pour consquence dentraner une chute plus rapide du personnage.
Script est le premier paramtre (avant les variables publiques) de tous les com-
ce Astu
posants de type script. Il permet de slectionner un autre script sans devoir remplacer le composant. Cest particulirement utile lorsque vous amliorez progressivement les scripts existants vous pouvez alors simplement dupliquer les scripts, les modifier, puis les utiliser tour de rle en les slectionnant dans le menu droulant situ droite du nom du script. De cette manire, vous conservez les paramtres existants des variables publiques dans le panneau INspECTOR.
Le composant Character Controller

Cet objet agit comme un collider (un composant de collision qui donne lobjet la capacit physique dinteragir avec dautres objets) et il est spcialement conu pour sappliquer aux mouvements du personnage et leur contrle dans le monde du jeu. Ses paramtres sont les suivants:
Height. La hauteur du personnage, qui dfinit la taille du collider en forme de capsule du personnage.
72
Radius. La largeur du collider en forme de capsule. La valeur par dfaut correspond au rayon de lobjet enfant Graphics. Toutefois, si vous souhaitez agrandir la circonfrence du personnage, soit pour restreindre ses mouvements soit pour augmenter lespace dans lequel les collisions sont dtectes, vous pouvez augmenter la valeur de ce paramtre. Slope Limit. Ce paramtre permet de dfinir le degr dune pente que le personnage peut gravir. En lincluant, le composant Character Controller empche que le joueur puisse gravir les parois verticales ou les zones les plus escarpes du terrain, ce qui serait bien entendu peu raliste. Step Offset. Dans un univers du jeu qui inclut des escaliers, ce paramtre sert dfinir quelle distance du sol le personnage peut slever plus la valeur est importante, plus le personnage peut sloigner du sol pour gravir un obstacle. Skin Width. Comme le personnage va entrer en collision avec dautres objets de jeu dans la scne, et souvent grande vitesse, ce paramtre vous permet de prciser quelle profondeur les autres colliders peuvent croiser les colliders du personnage avant quune raction ne se produise. Cela aide rduire les conflits qui peuvent notamment occasionner une secousse lgre 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 ragir en consquence, celui-ci les dsactive ou les carte les uns des autres de manire imprvisible plutt que de se bloquer. Unity Technologies recommande de rgler cette valeur 10% du paramtre Radius du personnage. Min Move Distance. La distance minimale laquelle le personnage pourra se dplacer. Elle est gnralement dfinie 0; avec une valeur plus importante, le personnage ne peut bouger que si son dplacement est suprieur cette valeur (ce qui lempche alors de se mouvoir dans un lieu trop confin). Ce paramtre sutilise uniquement pour rduire les conflits, mais conserve la valeur0 dans la plupart des cas. Center. Ce paramtre de type Vector3 (valeursx, y, z) permet dloigner le collider du personnage de son point central local. Sa valeur est gnralement de0 et ne se modifie le plus souvent que pour les personnages vus la troisime personne, qui ont une forme plus complexe quune simple capsule. En modifiant la coordonneY par exemple, vous pouvez tenir compte du point de contact entre les pieds du personnage et le sol car cest lobjet Character Controller collider qui dfinit o lobjet repose sur le sol et non le maillage visible des pieds du personnage.
Le composant Character Controller collider est reprsent dans le panneau Scene par un contour vert en forme de capsule, de la mme manire que les autres colliders dans Unity. la Figure3.9, nous avons dsactiv temporairement le rendu de lobjet Graphics,
Chapitre 3
73
afin de vous aider mieux reprer le contour du composant Character Controller collider.
Figure3.9
Le composant Mouse Look (Script)

crit en C#, ce script permet de faire pivoter le personnage lorsquon dplace la souris, en laissant les dplacements latraux aux touches directionnelles Gauche et Droite. Ce script compte un certain nombre de variables publiques qui peuvent tre ajustes:
Axes. Dfinit sur MouseX dans ce cas. Vous pouvez choisir pour cette variable MouseX, MouseY ou MouseXAndY. Pour lobjet FPC, vous avez besoin que cette instance du script Mouse Look (lautre occurrence tant un composant de lobjet enfant Main Camera) soit dfinie sur laxeX uniquement pour faire pivoter le personnage entier gauche ou droite laide de la souris et donc lobjet enfant Main Camera.
Vous vous demandez peut-tre pourquoi ne pas choisir MouseXAndY pour le composant Mouse Look de lobjet Main Camera. Cela permettrait la camra de sincliner et de pivoter sur les deux axes, certes, mais alors le personnage ne ferait plus face lendroit quil regarde, car la camra pivoterait uniquement de faon locale. En consquence, le personnage pourrait regarder autour de lui, mais lorsque vous le dplaceriez avec les touches du clavier, il se dirigerait alatoirement. Avec cette instance du script Mouse Look sur lobjet parent (First Person Controller), vous faites pivoter le personnage, ce qui entrane une rotation de la camra puisque celle-ci est un objet enfant et suit donc la rotation de son parent.
74
Sensitivity X et Sensitivity Y. Comme vous nutilisez que laxeX de ce script, cette variable contrle uniquement linfluence des mouvements latraux de la souris sur la rotation de lobjet. Si la variable Axes tait dfinie pour agir galement sur laxeY, on pourrait alors ajuster la manire dont les mouvements de la souris vers le haut ou vers le bas affecteraient linclinaison de la camra. Vous remarquerez que loption SensitivityY est dfinie 0, puisque vous ne lutilisez pas, tandis que loption SensitivityX est rgle 15 plus cette valeur est importante et plus la rotation est rapide. Minimum X et Maximum X. Permet de dfinir lamplitude du panoramique, puisque ce script se charge de faire pivoter le personnage. Ces valeurs sont dfinies 360 et 360 respectivement, ce qui permet au joueur de pivoter compltement autour dun point. Minimum Y et Maximum Y. L encore, vous nutilisez pas laxeY, si bien que cette variable est dfinie 0. Ce paramtre limite normalement le dplacement de la vision du joueur vers le haut et vers le bas, comme le fait linstance de ce script attach lobjet enfant Main Camera.
Objet 2. Lobjet Graphics

Comme ce personnage est, par nature, destin un jeu la premire personne, le joueur ne pourra jamais voir son propre corps. La capsule qui le reprsente est simplement incluse dans cet lment prfabriqu pour aider le dveloppeur reprer facilement lobjet dans le panneau Scene lors du dveloppement et des tests du jeu. Les dveloppeurs dsactivent souvent le composant Mesh Renderer dans le panneau Inspector afin de sassurer que le maillage de la capsule ne soit pas rendu et donc quelle soit bien invisible, en particulier dans les jeux o le personnage du joueur est vu sous un autre angle dans certaines scnes. Slectionnez lobjet enfant Graphics dans le panneau Hierarchy, puis observez ses composants dans le panneau Inspector.
Figure3.10
Chapitre 3
75
Vous pouvez constater que cet objet possde un composant Transform et que sa position est (0, 0, 0), car il se situe au centre de lobjet parent First Person Controller. Cet objet ayant pour seul but doffrir une reprsentation visuelle du joueur, il ne dispose que des deux composants ncessaires 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 gnralement au nom de lobjet quil reprsente. Par consquent, lorsque vous utilisez des modles crs dans une application externe, les composants Mesh Filter portent le nom des diffrentes parties du modle. Ce composant est tout simplement celui qui contient le maillage, autrement dit la forme3D elle-mme. Il permet au moteur de rendu de tracer une surface partir de ce maillage.
Le composant Mesh Renderer

Un composant Mesh Renderer doit tre prsent afin de crer les surfaces sur le maillage dun objet 3D. Il gre galement la raction du maillage la lumire et les matriaux utiliss sur la surface pour afficher les couleurs ou les textures. Ses paramtres sont les suivants:
Cast Shadows. Dfinit si la lumire sur cet objet projette une ombre sur les autres surfaces (effectif uniquement dans la version Unity Pro; les ombres sont dsactives dans les lumires dans la version gratuite de Unity). Receive Shadows. Dfinit si les ombres projetes par dautres objets sont dessines sur cet objet (disponible uniquement dans la version Unity Pro; les ombres sont dsactives dans les lumires dans la version gratuite de Unity).
Dans cet exemple, aucune de ces deux options nest active. Tout dabord, la capsule ntant 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 glule, si bien quil lui semblerait plutt trange de voir une ombre de cette forme le suivre.
Materials. Ce paramtre utilise le systme Size et Element que nous avons vu dans le Tag Manager prcdemment. Il permet de dfinir un ou plusieurs matriaux et dajuster leurs paramtres directement, sans avoir chercher les matriaux utiliss, puis de les paramtrer sparment dans le panneau Project.
76
Comme lobjet Graphics ne ncessite ni ne possde de paramtre de couleur ou de texture, il nexiste pas de matriau prvisualiser. Vous tudierez les paramtres des matriaux au cours des prochains chapitres.
Objet 3. Lobjet Main Camera

Lobjet Main Camera permet de visualiser le monde virtuel dans le jeu. Dans llment prfabriqu First Person Controller, il est positionn la hauteur des yeux du personnage (en haut de la capsule Graphics). Grce des scripts, le joueur peut dplacer tout lobjet parent mais aussi la camra de faon indpendante pour regarder autour de lui tout en se dplaant. En plus de llment Transform habituel, les objets de jeu camra disposent habituellement de trois composants cls : Camera, GUILayer et Flare Layer ainsi que dun composant Audio Listener pour capter des sons, mme si ce dernier est gnralement supprim car Unity exige quun seul couteur audio soit prsent par scne. Dans cet exemple, la camra dispose galement dun composant de script unique appel Mouse Look (Script), qui gre la rotation et linclinaison de la camra en fonction de la position de la souris. Pour mieux comprendre les vues camra, nous allons tudier le fonctionnement de ces composants de base.
Le composant Camera
Cest llment principal de visualisation, mme sil est gnralement accompagn des composants GUILayer et Flare Layer. Afin de comprendre comment le composant Camera affiche le monde du jeu, nous allons examiner ses paramtres.
Figure3.11
Chapitre 3
77
Clear Flags. Gnralement dfini sur sa valeur par dfaut, Skybox, pour que la camra puisse effectuer le rendu de lobjet Skybox actuellement appliqu la scne. Ce paramtre permet au dveloppeur de dfinir et de grer plusieurs camras spcifiques ainsi que de procder au rendu de certaines parties de lunivers du jeu, en particulier lors de la conception du jeu. Toutefois, il est peu probable que vous commenciez utiliser ces techniques avant de connatre beaucoup mieux Unity. Back Ground Color. La couleur de fond est celle qui est rendue derrire tous les objets du jeu si aucun matriau skybox nest appliqu la scne. Vous pouvez la modifier, soit en cliquant sur le bloc de couleur puis en utilisant le slecteur de couleur, soit en chantillonnant une couleur sur lcran avec loutil Pipette situe droite du bloc de couleur. Normalized View Port Rect. Permet de dfinir les dimensions et la position de la vue Camra. Gnralement, il est dfini pour occuper tout lcran, ce qui est dailleurs le cas de lobjet Main Camera attach au joueur dans notre exemple.
Les coordonnes X et Y tant dfinies 0, la vision de la camra commence dans le coin infrieur gauche de lcran. tant donn que les options Width et Height ont une valeur de1, la vue de cette camra emplit tout lcran, car ces valeurs utilisent le systme de coordonnes de Unity, comprises entre0 et1. Ce systme est galement utilis dans dautres lments 2D dans Unity, notamment les lments de linterface graphique (GUI). Dfinir la taille et la position de notre vue permet de pouvoir utiliser plus dune camra dans un jeu. Dans un jeu de course automobile, par exemple, vous pourrez placer une camra dans le coin suprieur de lcran pour afficher une vue situe derrire la voiture du joueur afin quil puisse reprer les vhicules qui sapprochent de lui.
Near clip plane/Far clip plane. Les clip planes (plans de clipping) dsignent la distance des lments du jeu dont le rendu doit tre effectu; loption Near Plane dsignant le plan le plus proche et loption Far Plane le plan le plus loign, ou plutt la distance o le rendu se termine.
Afin dconomiser de la mmoire dans la mmoire tampon de la carte graphique (une partie de la mmoire utilise pour stocker des informations sur les effets visuels du monde du jeu), cette technique de clipping est souvent utilise pour que le dcor situ loin du joueur ne soit pas calcul. Les dveloppeurs recouraient cette technique dans les jeux 3D anciens, car les ordinateurs lpoque avaient moins de mmoire RAM dans laquelle crire; pour conomiser la mmoire, seul le rendu des plans les plus proches de la camra tait effectu afin que le jeu reste fluide.
78
Figure3.12
Plan proche
Plan loign
Field of view. Dfinit la largeur du cne de vision de la camra en degrs. Cet angle est fix 60, car cette valeur reproduit de faon raisonnable la vision de lil humain. Orthographic et Orthographic Size. Transforment la vision de la camra en vue orthographique, par opposition la vue en perspective3D standard. Les camras orthographiques sont le plus souvent utilises dans les jeux en vue isomtrique comme les jeux de stratgie en temps rel (RTS) ou les jeux2D. Depth. Lorsque vous utilisez plusieurs camras et que vous passez de lune lautre laide de scripts, le paramtre Depth permet de dfinir un ordre de priorit. Ainsi, le rendu de la camra dont la valeur de profondeur est la plus leve seffectue avant celui de la camra possdant une valeur plus faible. Ce paramtre peut galement tre utilis en association avec le paramtre Normalized View Port Rect, afin de placer des camras au-dessus de lcran principal. Pour le rtroviseur dun jeu de course, par exemple, la camra de la vue arrire doit possder une valeur Depth plus leve que la camra principale pour que son rendu saffiche en superposition de la vue principale (vers lavant) du jeu. Culling Mask. Fonctionne avec les calques de jeu de Unity, comme nous lavons dj mentionn, afin que vous puissiez procder leur rendu de manire slective. Si vous placez certains lments du jeu sur un calque, il vous suffira de dslectionner ce calque dans le menu droulant Culling Mask pour que la camra ne ralise pas leur rendu. Actuellement, notre objet Main Camera effectue le rendu de tous les lments de la scne, car il sagit de la seule camra dans le jeu.
Les composants GUILayer et Flare Layer

Ces deux composants ne possdent aucun paramtre. Ils permettent simplement le rendu des lments visuels additionnels. GUILayer permet le rendu des lments2D, comme les menus et laffichage tte haute (HUD). Flare Layer permet la camra deffectuer le rendu des effets de lumire, comme celui que vous avez ajout lobjet Directional Light au Chapitre2, "Environnements".
Chapitre 3
79
Le composant Mouse Look (Script)

Il sagit de la seconde occurrence du composant Mouse Look (Script) la premire se trouvant sur lobjet parent First Person Controller. Cependant, son paramtre Axes a cette fois pour valeur MouseY, car il gre le dplacement de la vue vers le haut ou vers le bas en contrlant la rotation de lobjet Main Camera autour de son axeX. Combin au script Mouse Look qui fait pivoter lobjet parent, il permet au joueur de tourner son regard o il le souhaite laide de la souris, puisque lobjet Main Camera pivote galement de gauche droite lorsque lobjet parent tourne.
Le composant Audio Listener

Le composant Audio Listener fonctionne comme loreille humaine et permet au joueur dentendre toutes les sources audio du jeu. Si cet couteur audio est plac sur la camra principale dans un jeu la premire personne, le joueur entendra de loreille gauche les sons mono (canal unique) provenant de sa gauche. Vous pouvez ainsi crer un environ nement qui reproduise limmersion auditive du monde rel en stro. Maintenant que vous savez comment le composant First Person Controller est constitu, vous allez vous familiariser avec le langage JavaScript dans Unity en tudiant le fonctionnement du script FPSWalker.
Les bases de la programmation

Lcriture de script est un lment essentiel matriser pour devenir un dveloppeur de jeux. Mme si Unity permet de crer des jeux sans avoir vraiment besoin de connatre le code source du moteur de jeu, vous devez cependant savoir crire les scripts qui commandent le moteur de Unity. Ces scripts utilisent un ensemble de classes prtes lemploi, que vous pouvez considrer comme des bibliothques dinstructions ou de comportements. En crivant des scripts, vous crerez vos propres classes en tirant parti des commandes existantes dans le moteur de Unity. Ce livre aborde principalement lcriture de scripts JavaScript dans Unity, car il sagit du langage le plus simple pour dbuter et celui sur lequel la documentation de rfrence de Unity fournit le plus de renseignements. Bien que les bases de lcriture de scripts soient prsentes, nous vous conseillons fortement de consulter en parallle le manuel de rfrence Scripting Manual de Unity fourni avec le programme et disponible en ligne ladresse suivante: http://unity3d.com/support/documentation/ScriptReference/
80
Les problmes que vous rencontrerez lors de lcriture de scripts trouvent souvent leur solution dans ce manuel. Si ce nest pas le cas, vous pouvez alors demander de laide sur les forums consacrs Unity ou sur le canal IRC (Internet Relay Chat) du logiciel. Pour plus dinformations, visitez lune des adresses suivantes: http://unity3d.com/support/community (en anglais) http://www.unity3d-france.com/ (en franais) Que vous rdigiez un nouveau script ou que vous utilisiez un script existant, celui-ci devient oprationnel seulement aprs que vous lavez attach un objet de jeu dans la scne courante. Un script attach un objet de jeu en devient un composant et le comportement crit dans le script sapplique cet objet. Cependant, les scripts ne se limitent pas appeler (activer ou excuter en terme de programmation) un comportement de lobjet de jeu auquel ils appartiennent, ils peuvent galement donner des instructions aux autres objets en faisant rfrence leur nom ou leur tag. Afin de mieux comprendre, voyons tout dabord quelques principes de base des scripts.
Les commandes
Les commandes sont des instructions donnes dans un script. Bien que vous puissiez les dissminer lintrieur dun script, vous contrlerez mieux le moment o elles sont appeles si vous les placez dans une fonction. Toutes les commandes en JavaScript doivent se terminer par un point-virgule de la faon suivante:
vitesse = 5;
Les variables
Les variables sont de simples conteneurs dinformations. Elles sont dclares (cres) avec le mot var, suivi dun 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 dun terme utilis dans le code du moteur de Unity. Le nom doit uniquement contenir des caractres alphanumriques et des traits de soulignement et ne pas commencer par un chiffre. Par exemple, le mot transform existe dj pour reprsenter le composant Transform dun objet de jeu, si bien que nommer ainsi une variable ou une fonction pourrait provoquer un conflit.
Chapitre 3
81
Les variables peuvent contenir du texte, des chiffres et des rfrences des objets, des ressources ou des composants. Voici un exemple dune dclaration de variable:
var vitesse = 9.0;
Notre variable commence par le mot var, suivi de son nom, vitesse. Sa valeur est ensuite dfinie laide dun seul symbole gal et se termine comme toute autre commande par un point-virgule. Dans linterface de Unity, les valeurs dcimales peuvent scrire avec une virgule ou un point (0,2 ou 0.2). Si on crit 0.2, la valeur est automatiquement convertie sous la forme avec une virgule (0,2). Mais dans le code, les valeurs dcimales doivent imprativement scrire 0.2. Avec 0,2, un message derreur saffiche.
ntion Atte
Types de donnes des variables

Lors de la dclaration des variables, vous devez aussi indiquer le type dinformation quelles stockent en dfinissant le type de donnes. Voici la mme dclaration de variable que lexemple prcdent, mais cette fois avec le type de donnes:
var vitesse: oat = 9.0;
Le nom de la variable est suivi de deux-points pour prciser le type de donnes. Dans cet exemple, la valeur de la variable est un nombre une dcimale, et nous indiquons que lesdonnes sont de type oat (abrviation de "floating point" pour "virgule flottante" autrement dit un nombre dcimal). Prciser le type de donnes de chaque variable que vous dclarez rend le script plus efficace car le moteur du jeu na pas besoin de dcider par lui-mme du type de la variable lors de sa lecture. De plus, cela facilite la dtection derreur (dbogage) et la relecture du code. Voici quelques-uns des types de donnes les plus courants que vous utiliserez:
string (chane de caractres). Combinaison de texte et de chiffes stocks entre guillemets, "comme ceci". int (entier). Abrviation dinteger. Sutilise pour les chiffres entiers sans dcimale. float. Valeur numrique dcimale. boolean (boolen). Une valeur vraie ou fausse utilise couramment comme condition respecter. Vector3. Un ensemble de valeurs XYZ.
82
Utiliser les variables

Une fois que les variables sont dclares, les informations quelles contiennent peuvent tre utilises ou redfinies. Pour cela, on emploie simplement le nom de la variable. Pour rgler la variable vitesse, par exemple, il suffit dcrire:
vitesse = 20;
var et le type de donnes sindiquent seulement dans la dclaration de la variable et non dans les commandes.
Il est galement possible dinterroger ou dutiliser la valeur dune variable dans certaines parties dun script. Par exemple, pour stocker une valeur gale la moiti de celle de la variable vitesse actuelle, on peut dfinir une nouvelle variable, comme dans lexemple suivant:
var vitesse: oat = 9.0; var moitieVitesse: oat; moitieVitesse = vitesse/2;
Notez galement que la valeur de la variable moitieVitesse nest pas dfinie dans sa dclaration. Elle lest, en fait, dans la commande suivante o la valeur de la variable vitesse est divise par deux.
Variables publiques et variables prives

Les variables dclares lextrieur dune fonction dans un script sont appeles variables globales ou proprits. Par dfaut, en JavaScript, de telles variables sont dites variables publiques, car elles saffichent automatiquement en tant que paramtres du script (considr alors comme un composant) dans le panneau Inspector. Lorsque vous affichez le script FPSWalker en tant que composant li lobjet First Person Controller par exemple, ses variables publiques Speed, JumpSpeed et Gravity sont alors visibles.
Figure3.13
La valeur de chacune de ces variables peut donc tre ajuste dans le panneau Inspector.
Chapitre 3
83
Si vous ne souhaitez pas rgler la valeur dune variable dans le panneau Inspector, vous devez alors utiliser le prfixe private pour quelle ne saffiche pas. Pour cacher la variable JumpSpeed, par exemple, vous devriez modifier la dclaration de cette variable dans le script de la faon suivante:
var speed = 6.0; private var jumpSpeed = 8.0; var gravity = 20.0;
Dans le panneau Inspector, le script safficherait alors comme la Figure3.14.

Figure3.14
ce Astu
Si vous ajustez une valeur dans le panneau INspECTOR, celle-ci remplace la valeur originale donne la variable lors de sa dclaration dans le script. En fait, la valeur indique dans le script nest pas rcrite mais elle est remplace par la nouvelle lors de lexcution du jeu. Vous pouvez galement restaurer les valeurs dclares dans le script en cliquant sur licne en forme dengrenage situe droite du nom du composant, puis en choisissant REsET dans le menu droulant qui saffiche.
Les fonctions
Les fonctions sont des ensembles dinstructions qui peuvent tre appeles un moment prcis lors de lexcution du jeu. Un script peut contenir de nombreuses fonctions et chacune peut appeler une ou plusieurs autres fonctions au sein du mme script. Les scripts peuvent faire appel de nombreuses fonctions prdfinies du moteur de Unity pour excuter des commandes des moments prcis ou selon les actions de lutilisateur. Vous pouvez galement crire vos propres fonctions et les appeler lorsque vous avez besoin de raliser des instructions spcifiques. Lcriture dune fonction commence par function suivi de son nom, puis daccolades douverture et de fermeture. Le dveloppeur peut ensuite passer des paramtres supplmentaires entre ces accolades. Voici quelques exemples de fonctions existantes.
84
Update() Tout nouveau fichier JavaScript cr dans Unity commence par la fonction Update() suivante:
function Update(){ }
Toutes les instructions ou les commandes dune fonction doivent se trouver entre ses accolades douverture et de fermeture, comme dans lexemple suivant:
function Update(){ speed = 5; }
Tant que les commandes sont crites entre les accolades de la fonction, elles se dclenchent chaque fois que le moteur du jeu fait appel cette fonction. Les jeux sexcutent un certain nombre dimages par seconde (FPS), si bien que la fonction Update() est appele une fois le rendu de chaque image effectu. En consquence, elle sutilise principalement pour toutes les commandes qui doivent tre excutes en permanence ou pour dtecter les modifications qui se produisent en temps rel dans le monde du jeu, comme les commandes en entre lorsque le joueur appuie sur des touches ou clique. Lorsquil sagit de commandes lies aux lois physiques, vous devez de prfrence utiliser la fonction FixedUpdate() car elle est synchronise avec le moteur physique, tandis que le dclenchement de la fonction Update() peut varier selon le nombre de FPS. OnMouseDown()
OnMouseDown() est un exemple de fonction appele un moment prcis : uniquement lorsque le joueur clique sur un objet de jeu ou sur un lment graphique dans le jeu.
Elle sutilise le plus souvent pour les jeux contrls la souris ou pour dtecter les clics dans les menus. Voici un exemple de fonction OnMouseDown() simple qui, lorsquelle est attache 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 crer un ensemble dinstructions susceptibles dtre appeles tout moment dans vos scripts. Si vous devez dfinir plusieurs
Chapitre 3
85
instructions pour dplacer un objet un endroit prcis dans le monde du jeu, vous pouvez alors crire une fonction personnalise contenant toutes les instructions ncessaires, puis appeler cette fonction partir dautres fonctions de votre script. Imaginons par exemple que vous deviez replacer le personnage du joueur au dbut du niveau, lorsquil tombe dans un pige et meurt. Plutt que dcrire les instructions ncessaires sur chaque partie du jeu qui provoque sa mort, vous pouvez les regrouper dans une seule fonction appele plusieurs fois. Cette fonction pourrait ressembler ceci:
function PlayerDeath(){ transform.position = Vector3(0,10,50); score=50; vies-}
Lorsque cette fonction PlayerDeath() est appele, les trois commandes quelle contient sont excutes: la position du joueur est redfinie X=0, Y=10 et Z=50, une valeur de50 est soustraite de la note variable nomme score et une valeur de1 soustraite dune variable nomme vies (les deux symboles de soustraction indiquent une soustraction dune unit; de la mme faon ++ dans un script signifie simplement lajout dune valeur de1). Pour appeler cette fonction, il vous suffit dcrire 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 vrifier des conditions dans les scripts. Si ces conditions sont remplies, linstruction if excute une srie dinstructions imbriques. Dans le cas contraire, ce sont les instructions par dfaut, appeles par else (sinon), qui le seront. Dans lexemple suivant, linstruction if vrifie si la variable boolenne grounded est dfinie sur true (vraie):
var grounded: boolean = false; var speed: oat; function Update(){ if(grounded == true){ speed = 5; } }
86
Si la condition nonce entre les crochets de linstruction if est atteinte, autrement dit si la variable grounded devient true, alors la valeur de la variable speed est fixe 5. Sinon, aucune valeur ne lui est attribue. Vous ne devez pas confondre le symbole daffectation (=), utilis pour dfinir la valeur de la variable, et le symbole de comparaison dgalit (==), qui permet de vrifier si linformation stocke dans la variable correspond une valeur.
ntion Atte
Pour tablir une condition alternative, vous pourriez ajouter une dclaration else aprs le if afin dindiquer ce qui doit se produire si les conditions ne sont pas remplies:
var grounded: boolean = false; var speed: oat; 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 vrification des conditions entrane davantage de consquences possibles, vous pouvez utiliser linstruction elseif avant le else facultatif. Si vous vrifiez des valeurs, le code peut alors scrire:
if(speed >= 6){ //faire quelque chose } else if(speed >= 3){ //faire quelque chose dautre } else{ //si aucune des conditions ci-dessus nest vraie, faire ceci }
Dans lexemple prcdent, les lignes qui commencent par le symbole // indiquent quil sagit de commentaires (du code non excut).
Chapitre 3
87
Les conditions multiples Vous pouvez galement vrifier plus dune seule condition dans une instruction if en utilisant loprateur logique ET, qui scrit &&. Si, par exemple, vous voulez vrifier ltat de deux variables la fois et excuter les instructions qui suivent si les valeurs des deux variables sont celles nonces, vous crirez alors:
if(speed >= 3 && grounded == true){ //faire quelque chose }
Pour vrifier une condition ou une autre, vous pouvez alors utiliser loprateur logique OU, qui scrit ||, de la faon 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 laide dune variable statique, et comment traiter linformation de manire hirarchique en utilisant la technique dcriture de script nomme syntaxe point. En programmation oriente objet (POO), les variables globales dune classe (dun script) sont aussi appeles proprits et les fonctions aussi appeles mthodes. Dfinir des variables statiques avec static Le nom des scripts crits en JavaScript correspond au nom de la classe. Cela signifie que, pour vous adresser aux variables ou aux fonctions dun autre script, vous pouvez faire rfrence cette classe en utilisant le nom de ce script suivi du nom de la variable ou de la fonction en question laide de la syntaxe point. En termes de programmation, une variable statique peut tre dfinie 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 situes dans le mme script mais aussi par nimporte quel script. Pour dclarer une variable globale dans un fichier JavaScript de Unity, on utilise le prfixe static de la manire suivante:
static var speed: oat = 9.0;
88
Si cette variable speed tait celle du script FPSWalker, vous pourriez alors accder sa valeur, ou la dfinir, depuis un autre script. Pour cela, on utilise le nom du script suivi dun point, du nom de la variable, puis de la dfinition de la valeur, comme dans lexemple suivant:
FPSWalker.speed = 15.0;
De la mme manire, il existe des fonctions publiques statiques pouvant tre appeles depuis dautres scripts. La fonction PlayerDeath(), par exemple, pourrait tre une fonction static, ce qui vous permettrait de lappeler depuis nimporte quel autre script du jeu sans mme avoir de rfrence vers lobjet concern. La syntaxe point Dans lexemple prcdent, nous avons utilis une technique de script appel syntaxe point. Bien que ce terme semble dsigner une forme dcriture complexe, ce nest pas vraiment le cas. On utilise simplement un point pour sparer les lments auxquels on fait rfrence et indiquer leur hirarchie, depuis llment situ le plus haut dans la hirarchie jusquau paramtre en particulier que lon souhaite dfinir. Ainsi, pour rgler la position verticale dun objet de jeu, par exemple, vous devez modifier sa coordonneY. Vous devez donc vous adresser aux paramtres de position du composant Transform de cet objet. Pour cela, on crit:
transform.position.y = 50;
La syntaxe point permet donc de dsigner nimporte quel paramtre en indiquant le composant auquel il appartient.
Les commentaires
Dans beaucoup de scripts prdfinis, vous remarquerez que certaines lignes commencent par deux barres obliques. Il sagit simplement des commentaires crits par lauteur du script. Nous vous conseillons dcrire vos propres commentaires afin dindiquer comment fonctionnent vos scripts, en particulier lorsque vous dbutez.
Lectures complmentaires
Il est essentiel que vous vous preniez lhabitude de vous rfrer au manuel de rfrence Scripting Manual de Unity install avec votre copie du programme et galement disponible sur le site web de Unity ladresse suivante: http://unity3d.com/support/documentation/ScriptReference/
Chapitre 3
89
Ce manuel de rfrence permet notamment de vrifier comment utiliser correctement les classes du moteur de Unity. Maintenant que vous connaissez les rudiments de lcriture de scripts, nous allons tudier le script FPSWalker qui contrle le dplacement de lobjet First Person Controller, autrement dit le personnage du joueur.
Le script FPSWalker
Pour visualiser un script dans Unity, vous devez louvrir dans lditeur de script. Pour cela, slectionnez le script dans le panneau Project puis double-cliquez sur son icne. Lditeur de script fourni par dfaut sappelle Unitron sous Mac OS et Uniscite sous Windows. Il sagit, dans les deux cas, dune application autonome permettant dditer diffrents formats de fichier texte, comme les scripts JavaScript et C# par exemple. Vous pouvez galement dfinir lditeur de texte de votre choix pour crire vos scripts destins Unity. Pour les besoins de cet ouvrage, nous utiliserons les diteurs de script par dfaut Unitron et Uniscite.
Lancer le script
Slectionnez lobjet First Person Controller dans le panneau Hierarchy, puis cliquez sur le nom du fichier de script sous le composant FPSWalker (Script) dans le panneau Inspector afin quil soit surlign en bleu (voir Figure3.15).
Figure3.15
Lemplacement du script saffiche galement en jaune dans le panneau Project (voir Figure 3.16) afin de vous aider le localiser. Une fois que vous avez repr licne du fichier, double-cliquez dessus pour le lancer dans lditeur de script par dfaut. Vous pouvez aussi double-cliquer directement sur le nom du script dans le composant.
90
Figure3.16
MacOS FPSWalker dans Unitron

Sous MacOS, le script FPSWalker souvre dans lditeur de script par dfaut Unitron (voir Figure3.17).
Figure3.17
Chapitre 3
91
Windows PC FPSWalker dans Uniscite

Sous Windows, le script FPSWalker souvre dans lditeur de script par dfaut Uniscite (voir Figure3.18).
Figure3.18
Bien quil sagisse du mme script, vous voyez que les deux diteurs utilisent des couleurs diffrentes pour mettre en valeur la syntaxe. Cela est propre lditeur lui-mme et na aucune incidence sur le fonctionnement du script.
Le script en dtail
Nous allons voir le fonctionnement dans la pratique des diffrents lments que nous venons de dcrire, en dcomposant leur utilisation dans le script FPSWalker.
92
Dclarer une variable

Comme la plupart des scripts, FPSWalker commence par une srie de dclarations de variables des lignes1 6:
var speed = private var var gravity private var private var 6.0; jumpSpeed = 8.0; = 20.0; moveDirection = Vector3.zero; grounded: boolean = false;
Les variables publiques des lignes1 et3 sont utilises plus tard dans le script comme coefficients de multiplication. Il sagit de valeurs dcimales, donc le type des donnes devrait tre dfini oat dans lidal (comme il sagit dun simple exemple de script de Unity Technologies, le type de donnes de toutes les variables nest pas indiqu). Les variables des lignes2, 5et6 sont des variables prives, car elles ne seront utilises que dans ce script. La variable prive moveDirection stocke la direction actuelle du joueur sous la forme dune valeur de type Vector3 (un ensemble de coordonnesX, Y,Z). Elle est dfinie (0,0,0) afin dviter que le joueur soit tourn dans une direction alatoire lorsque le jeu commence. La variable prive grounded est de type boolen (true ou false). Cette variable est utilise plus loin dans le script pour savoir si le joueur est en contact avec le sol ou non. Le personnage peut se dplacer et sauter uniquement dans le premier cas, car dans le cas contraire, cela signifie quil se trouve dj en lair.
Stocker les informations de mouvement

Le script se poursuit la ligne8, avec louverture de la fonction FixedUpdate(). Elle fonctionne de faon analogue la fonction Update(): une mise jour prdfinie est appele une cadence prdfinie. Elle est plus approprie la gestion des rgles physiques (comme lutilisation des corps rigides et les effets de gravit) que la fonction Update() standard, car lexcution de cette dernire varie selon le nombre dimages par seconde et donc de la puissance matrielle dont dispose le joueur. La fonction FixedUpdate() sexcute des lignes8 27. Dans cet ouvrage, une seule ligne de code peut de temps autre apparatre sur deux lignes diffrentes en raison de lindentation et des contraintes de mise en page. Lorsque vous recopiez ces scripts, assurez-vous que lextrait en question se trouve bien sur une seule ligne dans votre script.
Info
Chapitre 3
93
La premire instruction if dans la fonction sexcute sur les lignes9 18 (le commentaire du dveloppeur a t supprim dans lextrait 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 linstruction if imbrique (ligne15) sexcutent seulement si la condition if (grounded) est respecte. Il sagit dune forme dcriture raccourcie de la ligne suivante:
if(grounded == true){
Quand grounded devient true, cette instruction if agit trois fois sur la variable moveDirection. Premirement, elle lui assigne une nouvelle valeur Vector3 en donnant sa coordonneX la valeur actuelle de Input.GetAxis ("horizontal") et sa coordonneZ la valeur de Input.GetAxis ("vertical"), mais laisse la coordonneY dfinie 0:
moveDirection = new Vector3(Input.GetAxis("Horizontal"), 0, Input.GetAxis("Vertical");
Info
Dans cet exemple, Unity Technologies utilise le mot new comme prfixe du paramtre Vector3 utilis pour dfinir la variable moveDirection. Il sagit dune convention du langage C# destine faciliter la conversion entre les langages JavaScript et C#. Toutefois, ce terme nest pas ncessaire en JavaScript, ce qui explique pourquoi les autres exemples de ce livre nutilisent pas ce prfixe.
Mais que font les commandes Input.GetAxis ? Elles reprsentent tout simplement les valeurs comprises entre 1et1 obtenues en entre partir des touches directionnelles. Par dfaut, ces touches sont les suivantes:
A (Gauche) et D (Droit) pour laxe horizontal; W (Haut) et S (Bas) pour laxe vertical.
Lorsque aucune touche nest utilise, ces valeurs sont gales 0, car Unity donne automatiquement un tat idle (inactif) aux entres qui grent les axes. Par consquent, si vous
94
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 relchant lune ou lautre 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 valeursX etZ des touches presses, tout en laissant la valeurY dfinie 0. La variable moveDirection est ensuite de nouveau modifie la ligne12:
moveDirection = transform.TransformDirection(moveDirection);
La variable moveDirection est ici dfinie 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 dfinie sur la ligne prcdente est ici passe en paramtre de la commande TransformDirection afin que cette dernire modifie le format de ses coordonnes XYZ en un ensemble de coordonnes globales. Enfin, moveDirection est multiplie par la variable speed la ligne13:
moveDirection *= speed;
Puisque speed est une variable publique, multiplier les valeurs XYZ de moveDirection par speed implique que vous pouvez augmenter la vitesse de dplacement du personnage sans avoir diter le script. Il vous suffit en effet daugmenter la valeur de speed dans le panneau Inspector, puisque cest la valeur de moveDirection ainsi obtenue qui est utilise plus tard dans le script pour dplacer le personnage. Linstruction grounded contient enfin une autre instruction if imbrique aux lignes15 17:
if (Input.GetButton ("Jump")) { moveDirection.y = jumpSpeed; }
Cette instruction if se dclenche lorsque la touche nomm Jump est presse. Par dfaut, ce bouton de saut est affect la barre d'espacement. Ds que cette touche est enfonce, la valeur de laxeY de la variable moveDirection est fixe la valeur de la variable jumpSpeed. Par consquent, moins que la variable jumpSpeed nait t modifie dans le panneau Inspector, moveDirection.y prend une valeur de8.0. Lors du dplacement du personnage plus loin dans le script, cette modification soudaine de la valeur sur laxeY (de0 8.0) produira leffet de saut. Mais comment le personnage
Chapitre 3
95
redescend-il ensuite ? En effet, aucun composant Rigidbody nest attach lobjet du personnage, si bien quil nest pas soumis au contrle de la gravit dans le moteur physique. Cest pourquoi la ligne21 modifie 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 leffet dun saut mais dplacerait plutt 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 rsultat obtenu en multipliant la variable gravity par une commande appele Time.deltaTime. En multipliant une valeur lintrieur dune fonction Update() ou FixedUpdate() par Time.deltaTime, vous ne tenez pas compte de la nature de cette fonction base sur la cadence des images ou des appels et vous convertissez leffet de la commande en secondes. Autrement dit, en crivant:
moveDirection.y = gravity * Time.deltaTime;
la valeur de gravit est soustraite chaque seconde plutt qu chaque image ou appel.
Dplacer le personnage
Comme le commentaire de la ligne 23 lindique, les lignes 24 26 sont charges du mouvement du personnage. la ligne 24, une nouvelle variable controller est dclare avec le type de donnes CharacterController. Elle est ensuite dfinie pour reprsenter le composant CharacterController laide de la commande GetComponent():
var controller: CharacterController = GetComponent(CharacterController);
La commande GetComponent() permet daccder tous les composants de lobjet auquel un script est attach. Il suffit dindiquer son nom entre les parenthses. Ainsi, chaque fois que vous utilisez la rfrence de variable controller, vous pouvez accder tous les paramtres de ce composant et utiliser la fonction Move pour dplacer lobjet. Ce qui est exactement ce que ralise la ligne25, en plaant ce mouvement dans une variable ags:
var ags = controller.Move(moveDirection * Time.deltaTime);
La fonction CharacterController.Move sattend recevoir une valeur Vector3 afin de dplacer un contrleur de personnage dans les directionsX, YetZ. Donc le script utilise les donnes stockes plus tt dans la variable moveDirection et les multiplient par
96
Time.deltaTime afin que le dplacement soit en mtres par seconde plutt quen mtres
par image.
Vrifier grounded
Une valeur est attribue la variable moveDirection uniquement si la variable boolenne grounded est dfinie sur true. Alors, comment dcider si le personnage est en contact avec le sol ou non? Comme tous les autres colliders, le composant Character Controller (le contrleur de collision du personnage) peut dtecter les collisions avec dautres objets. Toutefois, contrairement aux colliders standard, il dispose de quatre raccourcis de collision spcifiques, dfinis dans lensemble CollisionFlags:
None (aucun); Sides (sur les cts); Above (au-dessus); Below (en dessous).
Ils sont chargs de vrifier les collisions avec la partie spcifique du collider quils dcrivent lexception de None, qui signifie tout simplement quaucune collision ne se produit. Ces indicateurs (ou flags) sont utiliss pour dfinir la variable grounded la ligne26:
grounded = (ags & CollisionFlags.CollidedBelow)!= 0;
Cette ligne peut sembler complexe en raison des nombreux symboles dgalit quelle contient, mais il sagit simplement dune forme dcriture abrge pour vrifier une condition et dfinir une valeur sur une seule ligne. Premirement, la variable grounded est dfinie laide dun symbole dgalit. Puis, dans la premire srie de parenthses, une technique de masque de bits est applique afin de dterminer si les collisions dans la variable ags (le mouvement du contrleur) corres pondent la valeur dfinie en interne CollidedBelow:
(ags & CollisionFlags.CollidedBelow)
Lutilisation dune seule esperluette (&) indique une opration qui seffectue entre deux valeurs sous forme binaire. Vous navez pas besoin de comprendre ce que cela signifie pour le moment, car le systme de classe de Unity offre un raccourci pour la plupart des calculs de ce type. Si le contrleur entre en collision avec ce qui se trouve en dessous de lui (le terrain, logiquement), alors cette opration sera non nulle.
Chapitre 3
97
Cette opration est suivie de !=0. Un point dexclamation devant un symbole dgalit signifie "est diffrent de". Cette comparaison renvoie donc true (vrai) si lopration entre parenthses est non nulle. Par consquent, grounded est dfini 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 ligne27, suivie de la seule commande @script suivante:
@script RequireComponent(CharacterController)
Les commandes @script sutilisent pour raliser des actions que vous devriez normalement effectuer manuellement dans linterface de Unity. Dans cet exemple, une fonction RequireComponent() est excute, ce qui force Unity ajouter le composant indiqu entre parenthses, au cas o lobjet sur lequel est attach ce script ne possde pas ce composant. De mme, si vous essayez de supprimer ce composant, Unity indique quun autre composant (le script) ncessite sa prsence. Comme ce script sappuie sur CharacterController pour contrler le personnage, il est logique dutiliser une commande @script pour sassurer que le composant est prsent et que le script peut donc par consquent sadresser lui. Il est galement intressant de noter que les commandes @script sont les seuls exemples de commandes qui ne doivent pas se terminer par un point-virgule.
En rsum
Au cours de ce chapitre, vous avez examin le premier lment interactif de jeu pour le moment: lobjet First Person Controller. Vous avez galement dcouvert les bases des scripts utiliss pour les jeux dans Unity, une premire 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 apprendrez plus sur la dtection de collision. Pour cela, vous utiliserez le modle davant-poste que vous avez import au Chapitre2, "Environnements", vous lintgrerez la scne 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 dtail, dautres interactions et nous plonger dans deux lments essentiels au dveloppement dun jeu: la dtection de collision et le raycasting (trac de rayon). Pour dtecter les interactions physiques entre les objets de jeu, la mthode la plus courante consiste utiliser un collider un filet invisible tout autour dun objet charg de dtecter les collisions avec dautres objets. La dtection de collision regroupe la fois la dtection et la rcupration des informations provenant de ces collisions. Il est non seulement possible de dtecter que deux colliders (composants de collision) nteragissent, mais galement danticiper une collision et deffectuer de nombreuses autres i tches laide dune technique appele raycasting, qui dessine un rayon une ligne vectorielle invisible (non rendue) trace entre deux points dans lespace3D qui peut aussi tre utilis pour dtecter une intersection avec le collider dun objet de jeu. Le raycasting permet galement de rcuprer de nombreuses autres informations utiles comme la longueur du rayon (et donc la distance entre deux objets) ou le point dimpact de la fin de la ligne.
100
Figure4.1
Y Z X
Fin du rayon
Dans cet exemple, un rayon pointant vers lavant part de notre personnage. On peut lui donner une direction mais galement une longueur spcifique, ou le projeter jusqu ce quil trouve un objet. Au cours de ce chapitre, vous travaillerez avec le modle davant-poste que vous avez import au Chapitre2, "Environnements". Nous avons cr pour vous lanimation douverture et de fermeture de la porte et vous allez voir comment les dclencher une fois le modle intgr dans la scne en implmentant la dtection de collision et le raycasting. Commenons par examiner la dtection de collision et voir quand la remplacer ou la complter par le raycasting.
Les collisions
Lorsque des objets entrent en collision dans nimporte quel moteur de jeu, des informations sur cet vnement deviennent alors disponibles. En enregistrant diffrentes informations au moment de limpact, le moteur de jeu peut ensuite ragir de manire raliste. Dans un jeu tenant compte des lois physiques par exemple, si un objet tombe au sol dune certaine hauteur, le moteur a besoin de savoir quelle partie de cet objet touche le sol en premier pour contrler de faon correcte et raliste la raction de lobjet cet impact. Bien entendu, Unity gre ce type de collisions et stocke ces informations pour vous, si bien que vous avez seulement les rcuprer afin de dfinir la raction qui doit se produire. Dans le cas de louverture dune porte, vous avez besoin de dtecter les collisions entre le collider du personnage du joueur et celui situ sur ou prs de la porte. Cela naurait gure de sens de dtecter les collisions ailleurs, puisque lanimation de la porte doit se dclencher lorsque le joueur est assez proche pour esprer quelle souvre ou pour franchir le seuil. Par consquent, vous allez vrifier les collisions entre le collider du personnage et celui de la porte. Vous devez toutefois tendre la profondeur du collider de la porte afin que celui du personnage du joueur nait pas besoin de sappuyer contre la porte pour que la collision se
Chapitre 4
Interactions
101
dclenche (voir Figure4.2). Cependant en tendant la profondeur du collider, son interaction avec le jeu devient irraliste.
Figure4.2
Y Z X ------ les contours du collider
Dans notre exemple, si le collider de la porte dpassait de la surface visuelle de la porte, le personnage entrerait en collision avec une surface invisible qui larrterait net. En outre, bien que vous puissiez utiliser cette collision pour dclencher lanimation douverture de la porte, limpact initial dans le collider semblerait peu naturel pour le joueur, ce qui nuirait son immersion dans le jeu. Si la dtection de collision fonctionne trs bien entre le collider du personnage et celui de la porte dun point de vue technique, cette approche prsente donc trop dinconvnients pour quun dveloppeur de jeux cratif ne recherche pas une approche plus intuitive. Cest l quintervient le raycasting.
Le raycasting
Bien quil soit possible de dtecter les collisions entre le collider du personnage et un collider qui sadapte lobjet porte, il semble plus judicieux que la porte souvre lorsque le joueur lui fait face et une certaine distance, ce qui peut tre ralis en projetant un rayon dune longueur limite depuis lavant du personnage. Ainsi, le joueur na pas besoin de savancer jusqu la porte ou dentrer en collision avec un collider tendu pour que le rayon soit dtect. Cette mthode garantit galement que le joueur ne peut pas ouvrir la porte sil
102
lui tourne le dos; avec le raycasting, il doit faire face lobjet pour lutiliser, ce qui est plus logique. Cette mthode est couramment utilise lorsque la dtection de collision se montre trop imprcise pour obtenir une raction correcte, par exemple lorsque les ractions doivent se produire un niveau de dtail trs prcis (image par image) car elles se produisent alors trop rapidement. Dans notre exemple, vous avez besoin de dtecter lavance si la collision est susceptible de se produire plutt que dy ragir. Prenons un exemple pratique de ce problme.
Limage manquante
Dans le cas dun jeu de tir en 3D, le raycasting sutilise pour prdire limpact dune balle tire. En raison de la vitesse dune balle relle, il est trs difficile den reprsenter visuel lement le trajet vers la cible de faon satisfaisante pour le joueur, car cette vitesse est largement suprieure la cadence des images rendues dans les jeux. Lors dun tir au pistolet dans le monde rel, la balle met si peu de temps pour atteindre sa cible que lvnement semble instantan lil nu. On peut donc admettre que la balle devrait atteindre son objectif en quelques images seulement dans le jeu, mme avec un rendu suprieur 25images par seconde.
Distance parcourue 0 15 3 4,5 6 7,5 9
Balle tire
4 Images
Figure4.3
la Figure4.3, une balle est tire dun pistolet. Pour que son parcours soit raliste, elle devrait se dplacer une vitesse de 150mtres par seconde. une cadence de 25images par seconde, la balle se dplace donc de 6mtres par image. Or la circonfrence dun corps humain est environ de 1,50mtre, si bien que la balle manquerait trs probablement les ennemis situs 5et 7,50mtres. Voil pourquoi on utilise la dtection a priori.
Chapitre 4
Interactions
103
La dtection de collision a priori

Au lieu de vrifier la collision avec un objet Balle, il sagit de dcouvrir si une balle atteindra sa cible. En projetant un rayon depuis lobjet Pistolet (en tenant donc compte de son orientation) sur la mme image que celle o le joueur appuie sur le bouton de tir, vous pouvez immdiatement vrifier quels objets coupent le rayon. Cela est possible car les rayons sont tracs immdiatement. Vous pouvez comparer le rayon un pointeur laser: lorsquon allume un laser, lil humain ne peroit pas le dplacement de la lumire vers lavant en raison de sa vitesse, si bien que le rayon laser semble tout simplement apparatre. Dans le raycasting, les rayons fonctionnent de la mme faon. Chaque fois que le joueur appuie sur le bouton de tir, un rayon est trac dans la direction vise. Il est alors possible de rcuprer des informations sur le collider que ce rayon touche. Une fois le collider identifi, un script peut alors dsigner lobjet de jeu lui-mme et scnariser son comportement en consquence. Vous pouvez obtenir des informations trs dtailles, comme le point dimpact, et les utiliser pour dfinir la raction de la cible (faire reculer lennemi dans une direction particulire par exemple).
Figure4.4
L'ennemi vis
Z 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 lennemi dont le collider touche le rayon. Comme le rayon est immdiat, cette raction peut seffectuer sur limage suivant celle sur laquelle le rayon croise le collider de lennemi. Laraction tant enregistre immdiatement, leffet produit par le tir est raliste.
104
Il est galement intressant de noter que les jeux de tir affichent souvent des rayons normalement invisibles pour aider le joueur viser. Ne confondez toutefois pas ces lignes avec le raycasting car ces rayons sont simplement utiliss pour effectuer le rendu des lignes de la vise.
Lajout de lavant-poste
Avant de commencer utiliser la fois la dtection de collision et le raycasting pour ouvrir la porte, vous devez intgrer la scne lavant-poste que vous avez dfini au Chapitre2, "Environnements". Plus loin, vous crirez le script qui contrle les tats danimation de ce modle. Faites glisser le modle davant-poste depuis le panneau Project dans le panneau Scene. Souvenez-vous que vous ne pouvez pas positionner le modle lors du glisser-dposer, mais seulement une fois que celui se trouve dans la scne (autrement dit, aprs avoir relch le bouton de la souris).
Figure4.5
Chapitre 4
Interactions
105
Une fois lavant-poste dans le panneau Scene, son nom apparat dans le panneau Hierarchy et il est automatiquement slectionn. Vous tes maintenant prt dfinir sa position et le redimensionner.
Positionner le modle
Comme la conception de votre terrain peut tre diffrente de la ntre, slectionnez loutil Transform, puis placez lavant-poste dans une zone de terrain dgage en faisant glisser ses poignes daxe dans la scne. Soyez prudent lorsque vous utilisez les poignes daxe pour dplacer un modle. Faire glisser le carr blanc o convergent les poignes modifie les trois axes la fois, ce qui est viter en vue Perspective. Assurez-vous de faire glisser chaque poigne individuellement en gardant le curseur lextrieur du carr blanc. Si vous souhaitez que lobjet reste plaqu sur la surface du terrain en vue Perspective, appuyez sur Cmd/Ctrl et faites glisser le carr blanc.
ce Astu
Figure4.6
Nous avons plac lavant-poste (500, 30.8, 505) mais vous devrez peut-tre le dplacer manuellement. Rappelez-vous quaprs avoir positionn lobjet laide de ses poignes daxe dans le panneau Scene, vous pouvez saisir des valeurs spcifiques dans les champs Position du composant Transform dans le panneau Inspector.
106
Redimensionner le modle
Lorsque vous travaillez comme ici avec deux applications le logiciel de modlisation dans lequel la ressource outpost a t cre et Unity , il est courant que la taille du modle import ne corresponde pas aux units mtriques utilises dans Unity et que vous deviez modifier ses dimensions. Bien quil soit possible de dfinir les valeurs dchelle dans les champs Scale du panneau Inspector, il est gnralement prfrable dutiliser le paramtre Scale Factor de la ressource originale. Slectionnez le modle outpost dans le dossier Outpost du panneau Project. Le composant FBXImporter saffiche alors dans le panneau Inspector. Ses paramtres dimportation affectent toutes les occurrences du modle que vous placez dans le panneau Scene. Dans ce cas prcis, modifiez la valeur Scale Factor de12, puis cliquez sur le bouton Apply. Ainsi, la taille de lavant-poste est suffisante pour que lobjet Character Controller passe par la porte et la taille de la pice sera raliste lorsque le personnage se trouvera lintrieur.
Colliders et tag de la porte

La porte doit tre identifie comme un objet particulier pour pouvoir souvrir lorsquelle entre en collision avec le joueur. Pour cela, lobjet doit possder un composant Collider et un tag spcifique qui dsignera lobjet dans le script. Cliquez sur la flche grise situe gauche du nom de lobjet outpost dans le panneau Hierarchy pour afficher tous ses objets enfants. Slectionnez lobjet door, puis placez le curseur sur le panneau Scene et centrez la vue sur cet objet (toucheF).
Figure4.7
Chapitre 4
Interactions
107
La porte est maintenant visible dans le panneau Scene. Cet objet tant slectionn, ses composants apparaissent galement dans le panneau Inspector, notamment Mesh Collider (un composant de collision respectant le maillage de lobjet). Ce collider prcis est assign tous les maillages des objets enfants dun modle lorsque loption Generate Colliders est active, ce que vous avez fait pour cette ressource outpost au Chapitre2, "Environnements". Avec cette option, Unity attribue par dfaut un composant Mesh Collider chaque lment enfant, car le programme ne sait pas quelle quantit de dtails sont prsents dans les modles imports. Chaque Mesh Collider adopte la forme du maillage de lobjet. Ici, la porte tant une forme cubique simple, vous devez le remplacer par un collider plus simple et plus efficace en forme de bote. Cliquez sur Component> Physics> Box Collider dans le menu principal. Une premire bote de dialogue, Losing Prefab, signale que lajout dun nouveau composant entranera la fin de la connexion entre cet objet et lobjet parent dans le panneau Project. Autrement dit, la copie place dans le panneau Scene ne sera plus identique la ressource dorigine et toute modification apporte la ressource dans le panneau Project ne sera pas rpercute sur cette copie. Cliquez simplement sur le bouton Add pour confirmer.
Figure4.8
Vous navez pas vous inquiter de ce message qui saffiche chaque fois que vous commencez personnaliser les modles imports dans Unity. Vous avez gnralement besoin dajouter des composants un modle, pour cela, vous pouvez crer vos propres lments prfabriqus. tant donn quun collider est dj assign lobjet, une seconde bote de dialogue apparat dans laquelle vous indiquez si vous voulez ajouter ce collider votre objet (Add), le remplacer (Replace) ou annuler lopration (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 plutt que den ajouter un nouveau. Comme nous navons plus besoin du Mesh Collider, cliquez sur Replace.
108
Le composant Box Collider que vous venez dajouter apparat alors autour de la porte, figur par un contour vert.
Figure4.9
Un Box Collider (un composant de collision en forme de bote) est un exemple de collider primitif, car sa forme est constitue de primitives. Unity dispose de plusieurs colliders de forme prdfinie de ce type, notamment Box, Sphere, Capsule et Wheel. Tous les composants colliders primitifs saffichent sous la forme dun trac vert. Vous lavez peut-tre remarqu lorsque vous avez tudi le collider du contrleur de personnage, un collider de type capsule, qui saffiche donc aussi en vert. Enfin, vous avez besoin dattribuer un tag lobjet door, puisque vous y ferez rfrence plus tard dans le script. Lobjet enfant door tant toujours slectionn, cliquez sur le menu droulant Tag situ en haut du panneau Inspector, puis choisissez Add Tag. Ajoutez le tag outpostDoor dans le Tag Manager qui saffiche dans le panneau Inspector (voir Figure4.10).
Figure4.10
Chapitre 4
Interactions
109
Comme lajout de balises est un processus en deux tapes, vous aurez ensuite besoin de slectionner de nouveau lobjet enfant door dans le panneau Hierarchy pour choisir votre nouveau tag outpostDoor dans le menu droulant Tag et lattribuer cet objet.
Dsactiver lanimation automatique

Par dfaut, Unity suppose que toutes les animations des objets placs sur la scne doivent tre lues automatiquement. Cest pourquoi vous avez dsactiv (idle) lanimation de cette ressource. Si vous laissez Unity lancer automatiquement les animations des objets, ceuxci risquent de safficher dans un des tats danimation plutt quavec leur apparence par dfaut. Pour corriger ce problme, il suffit de dcocher la case Play automatically dans le panneau Inspector pour lobjet parent du modle. Vous nauriez pas besoin de le faire sil sagissait dune animation en boucle se rptant constamment dans le jeu un drapeau claquant au vent ou la lumire tournante dun phare par exemple mais puisque lanimation de lavant-poste ne doit pas se dclencher avant que le joueur nait atteint la porte, vous devez viter la lecture automatique dune des animations que cet objet contient. Pour cela, slectionnez nouveau lobjet parent outpost dans le panneau Hierarchy, puis dsactivez loption Play automatically du composant Animations dans le panneau Inspector. Le panneau Inspector devrait prsenter la mme apparence qu la Figure4.11.
Figure4.11
110
Info
Nous avons affich les options du paramtre ANIMATIONs afin de visualiser les diffrents tats de lanimation de cet objet.
Lobjet outpost est maintenant prt interagir avec le personnage du joueur. Vous allez donc commencer crire les scripts pour grer les collisions avec la porte, en utilisant soit la dtection de collision soit le raycasting.
Louverture de la porte
Nous allons tudier les deux mthodes permettant de dclencher lanimation afin que vous puissiez ensuite utiliser lune ou lautre lors du dveloppement de vos jeux en fonction de la situation. Dans un premier temps, vous utiliserez la dtection de collision une notion essentielle connatre lorsque vous commencez travailler sur des jeux dans Unity. Puis dans un second temps, vous implmenterez simplement une projection de rayon depuis le personnage du joueur.
Mthode 1. La dtection de collision

Pour commencer crire le script qui va dclencher lanimation douverture de la porte et ainsi permettre au joueur dentrer dans lavant-poste, vous devez choisir lobjet auquel le script se destine. Lors du dveloppement de jeux, il est souvent plus efficace dcrire un seul script pour un objet qui interagira avec plusieurs autres objets, plutt que dcrire de nombreux scripts pour chacun des objets afin de vrifier 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.
Crer de nouvelles ressources

Avant de crer un nouveau type de ressource dans un projet, il est conseill de crer 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 droulant qui saffiche. Slectionnez ce dossier, appuyez sur la touche Entre (Mac OS) ou F2 (Windows) et renommez-le Scripts. Le dossier Scripts toujours slectionn, crez-y ensuite un fichier JavaScript. Pour cela, cliquez de nouveau sur le bouton Create dans le panneau Project et choisissez cette fois JavaScript.
Chapitre 4
Interactions
111
ce Astu
En slectionnant le dossier, vous indiquez lemplacement de la ressource que vous allez crer. Vous naurez donc pas ensuite le dplacer.
Modifiez le nom par dfaut du script NewBehaviourScript en PlayerCollisions. Les fichiers JavaScript portent lextension de fichier .js mais celle-ci ne saffiche pas dans le panneau Project. Il nest donc pas ncessaire dessayer dajouter cette extension lorsque vous renommez des ressources. Vous pouvez galement identifier le type de fichier dun script grce son icne dans le panneau PROJECT. Licne des fichiers JavaScript porte la mention "JS", les fichiers C#, tout simplement "C#" et les fichiers Boo, une image dun fantme Pacman.
Info
crire le script pour la dtection de collision du personnage

Double-cliquez sur licne du script dans le panneau Project pour lancer lditeur de script Unitron (MacOS) ou Uniscite (Windows) et commencer lditer. Utiliser OnControllerColliderHit Par dfaut, tous les nouveaux scripts JavaScript contiennent la fonction Update(), qui saffiche lorsque vous les ouvrez pour la premire fois. Pour commencer, vous allez dclarer les variables que vous utiliserez. Ce script doit commencer par la dfinition de six variables, trois prives et trois publiques, dont le but respectif est le suivant:
doorIsOpen. Une variable prive true/false (boolenne) pour vrifier si la porte est
ouverte.
doorTimer. Une variable prive numrique dcimale, utilise pour dcompter le temps
coul aprs louverture de la porte et la refermer automatiquement une fois termin le dlai dfini.
currentDoor. Une variable prive de type GameObject qui stocke ltat courant de la
porte. Elle vite, si vous ajoutez plus dun avant-poste dans le jeu, que louverture de lune des portes entrane celle de toutes les autres, en gardant en mmoire la dernire porte avoir t touche.
112
doorOpenTime. Une variable publique numrique de type oat (ventuellement dcimale) permettant de fixer 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-dposer dans le panneau Inspector.
Pour dfinir ces variables, ajoutez les lignes suivantes au tout dbut du script Player
Collisions que vous modifiez:
private var doorIsOpen: boolean = false; private var doorTimer: oat = 0.0; private var currentDoor: GameObject; var doorOpenTime: oat = 3.0; var doorOpenSound: AudioClip; var doorShutSound: AudioClip;
Avant daborder la fonction Update(), vous allez tablir la fonction de dtection de collision elle-mme. Insrez deux lignes aprs:
function Update(){ }
Et ajoutez la fonction suivante:

function OnControllerColliderHit(hit: ControllerColliderHit){ }
Cette fonction de dtection de collision, appele OnControllerColliderHit, est spcialement destine aux personnages jouables qui utilisent le composant Character Controller, comme cest le cas ici. Son seul paramtre, hit, est une variable qui stocke des informations lorsquune collision se produit, notamment lobjet 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 vrifie deux conditions: tout dabord, si lobjet avec lequel le personnage entre en contact a le tag outpostDoor, puis si la variable doorOpen est actuellement dfinie false. Rappelez-vous que deux symboles dgalit (==) indiquent une comparaison et que deux symboles esperluette (&&) signifient simplement "et". Autrement dit, si le personnage entre en contact avec le collider de la porte que vous avez marqu dun tag et que la porte nest pas dj ouverte, une srie dinstructions sera excute. Ce script utilise la syntaxe point pour faire rfrence lobjet dont on vrifie les collisions, en descendant successivement la hirarchie depuis hit (la variable qui contient les informations sur les collisions) gameObject (lobjet touch), puis au tag sur cet objet. Si les conditions de cette instruction if se vrifient, un ensemble dinstructions doit alors se raliser pour ouvrir la porte. Il sagira de jouer un son, de lancer la lecture dune des animations sur le modle et de dfinir la variable boolenne doorOpen true. Comme vous allez appeler plusieurs instructions et que vous aurez peut-tre besoin dutiliser leur rsultat dans une autre condition, par la suite lorsque vous implmenterez la technique du raycasting , vous allez les placer dans leur propre fonction personnalise appele OpenDoor. Avant dcrire cette nouvelle fonction, vous allez ajouter lappel cette fonction dans instruction if que vous venez de crer. Pour cela, saisissez la ligne suivante: l
OpenDoor();
La fonction de collision complte doit maintenant tre semblable celle-ci:

function OnControllerColliderHit(hit: ControllerColliderHit){ if(hit.gameObject.tag == "outpostDoor" && doorIsOpen == false){ OpenDoor(); } }
crire des fonctions personnalises Vous pouvez crire vos propres fonctions pour stocker des ensembles dinstructions appeler par la suite. De cette manire, vous pouvez simplement appeler une fonction tout moment pour excuter de nouveau lensemble des instructions quelle contient au lieu de devoir crire plusieurs fois une srie dinstructions ou de "commandes" dans un script. Cela facilite galement la localisation des erreurs dans le code procdure connue sous le nom de dbogage , car le nombre dendroits o les erreurs peuvent se trouver est ainsi rduit. Vous venez dcrire un appel une fonction nomme OpenDoor dans la fonction de dtection de collision. Les parenthses qui suivent le nom de la fonction, OpenDoor, sont utilises
114
pour stocker les paramtres ventuels que vous souhaitez passer la fonction vous pouvez ainsi transmettre des comportements supplmentaires aux instructions situes lintrieur de la fonction (voir la section "Des fonctions plus efficaces" de ce chapitre). Ici, les parenthses sont vides, aucun comportement nayant encore t pass la fonction. Dclarer la fonction Pour crer 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 appele, de la mme manire que vous avez dfini les conditions dune instruction if. Lire les fichiers audio La premire instruction doit lancer la lecture de la squence audio assigne la variable doorOpenSound. Pour cela, ajoutez la ligne suivante entre les accolades aprs { et avant }:
audio.PlayOneShot(doorOpenSound);
La fonction doit maintenant tre la suivante:

function OpenDoor(){ audio.PlayOneShot(doorOpenSound); }
Cette ligne sadresse au composant Audio Source attach lobjet de jeu auquel ce script est appliqu (le personnage du joueur, autrement dit lobjet First Person Controller). Vous aurez donc besoin plus tard de vous assurer que ce composant est bien li lobjet car cette commande provoquerait une erreur si ce ntait pas le cas. Le fait de dsigner le composant Audio Source par le terme audio vous donne ensuite accs quatre fonctions : Play(), Stop(), Pause() et PlayOneShot(). On utilise ici PlayOne Shot car cette option reprsente la meilleure faon de jouer une seule occurrence dun effet sonore, par opposition la lecture de plusieurs squences audio en continu, comme de la musique. La variable doorOpenSound passe dans les parenthses de la commande PlayOneShot permet de dclencher la lecture du fichier audio assign cette variable dans le panneau Inspector. Vous tlchargerez et assignerez ce fichier audio ainsi que celui de la fermeture de la porte aprs avoir complt le script.
Chapitre 4
Interactions
115
Vrifier ltat de la porte Une condition de linstruction if dans la fonction de dtection de collision exige que la variable boolenne doorIsOpen soit dfinie false. Par consquent, la deuxime commande de la fonction OpenDoor() a pour rle de dfinir cette variable true. En effet, le personnage du joueur peut entrer en collision avec la porte plusieurs reprises lors du contact. Sans cette variable boolenne, la fonction OpenDoor() pourrait se dclencher plusieurs fois, ce qui entranerait la rptition des sons et des animations chaque collision. Ainsi, la fonction OpenDoor() sexcute lorsque la variable est dfinie false, puis elle est immdiatement dsactive et la variable doorIsOpen dfinie true. On vite ainsi que toute collision supplmentaire dclenche de nouveau la fonction OpenDoor(). Ajoutez la ligne suivante entre les accolades de la fonction OpenDoor() aprs la commande que vous venez dajouter:
doorIsOpen = true;
Lancer lanimation Au Chapitre2, "Environnements", vous avez import le paquet de ressources outpost et tudi ses diffrents paramtres avant de lintgrer dans le jeu au dbut de ce chapitre. Lors du processus dimportation, vous avez dfini les animations dans le panneau Inspector. En slectionnant cette ressource dans le panneau Project, vous avez prcis dans le panneau Inspector quelle contenait les trois animations suivantes:
idle (un tat "inactif"); dooropen (porte ouverte); doorshut (porte ferme).
Dans la fonction OpenDoor(), vous allez faire appel une de ces animations laide dune chane de caractres, ou string. Toutefois, vous devez au pralable indiquer quel objet de la scne contient lanimation lire. Comme le script que vous crivez concerne le personnage du joueur, vous devez faire rfrence un autre objet avant de faire rfrence au composant danimation. Pour cela, ajoutez la ligne:
var myOutpost: GameObject = GameObject.Find("outpost");
Vous dclarez ici une nouvelle variable myOutpost de type GameObject puis vous slectionnez lobjet de jeu outpost par son nom laide de la commande GameObject.Find. La commande Find permet de slectionner dans le panneau Hierarchy un objet prsent dans la scne actuelle par son nom. Elle peut donc sutiliser comme une alternative aux tags.
116
prsent quune variable reprsente lobjet de jeu outpost, vous pouvez utiliser la syntaxe point afin de la dsigner et appeler lanimation de la faon suivante:
myOutpost.animation.Play("dooropen");
Cette ligne dsigne le composant danimation attach lobjet outpost et lance la lecture de lanimation dooropen. La commande Play() peut transmettre nimporte quelle chane de caractres. Toutefois, cela fonctionne uniquement si les animations ont t dfinies sur lobjet en question. Votre fonction personnalise OpenDoor() complte doit maintenant tre analogue ceci:
function OpenDoor(){ audio.PlayOneShot(doorOpenSound); doorIsOpen = true; var myOutpost: GameObject = GameObject.Find("outpost"); myOutpost.animation.Play("dooropen"); }
Inverser la procdure Maintenant que vous avez cr un ensemble dinstructions pour ouvrir la porte, comment allez-vous la refermer? Pour des raisons de jouabilit, vous nobligerez pas le joueur fermer lui-mme la porte. Vous allez donc crire un script qui la referme aprs un certain dlai. Pour cela, vous allez utiliser la variable doorTimer, vous lui ajouterez une valeur de temps pour que le script commence dcompter ds louverture de la porte, puis vous vrifierez si cette variable atteint une valeur particulire avec une instruction if. Comme il sagit dun dcompte dans le temps, vous devez utiliser une fonction constamment mise jour, comme la fonction Update() cre en mme temps que le script. Insrez des lignes vierges dans la fonction Update() pour dcaler son accolade de fermeture } de quelques lignes vers le bas. Vous devez premirement vrifier si la porte a t ouverte, car il est videmment inutile dincrmenter la variable de dcompte du temps si la porte est ferme. crivez linstruction if suivante pour augmenter la valeur de la variable dans le temps lorsque la variable door IsOpen est dfinie true:
if(doorIsOpen){ doorTimer += Time.deltaTime; }
Chapitre 4
Interactions
117
Ces lignes vrifient si la porte est ouverte la variable est par dfaut dfinie false et devient true uniquement la suite dune collision entre le personnage du joueur et la porte. Si la variable doorIsOpen est true, on ajoute alors la valeur Time.deltaTime lavariable 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 indpendamment du nombre
Info
dimages par seconde. Cest important car votre jeu peut tre excut sur diffrents ordinateurs, si bien quil serait trange que le temps ralentisse ou acclre en fonction de la puissance de lordinateur qui excute le jeu. Cest pourquoi on utilise Time.deltaTime pour calculer le temps ncessaire laffichage de la dernire image. Avec cette information, vous pouvez automatiquement corriger le dcompte en temps rel.
Vous devez ensuite vrifier si la variable doorTimer atteint une certaine valeur, autrement dit quune certaine quantit de temps sest coule. Pour cela, vous allez imbriquer une instruction if dans celle que vous venez dajouter: elle sera seulement vrifie si la condition doorIsOpen est valide. Ajoutez les lignes de script suivantes sous la ligne qui incrmente la variable dans la dclaration if existante:
if(doorTimer > doorOpenTime){ shutDoor(); doorTimer = 0.0; }
Cet ajout est constamment vrifi ds que la variable doorIsOpen est gale true puis il attend que la valeur doorTimer dpasse celle de la variable doorOpenTime. Puisque vous utilisez Time.deltaTime comme valeur dincrmentation, trois secondes en temps rel scouleront avant que cela ne se produise, moins bien sr que vous ne modifiiez la valeur de cette variable fixe 3 par dfaut dans le panneau Inspector. Une fois que la valeur doorTimer est suprieure 3, une fonction appele shutDoor() estappele et la variable doorTimer remise 0 afin quelle puisse tre de nouveau utilise laprochaine fois que louverture de la porte sera dclenche. Sans cette rinitialisation, la valeur de doorTimer resterait suprieure 3, si bien que la porte se refermait ds quelle serait ouverte. Votre fonction Update() complte doit maintenant tre comme ceci:
118
function Update(){ if(doorIsOpen){ doorTimer += Time.deltaTime; if(doorTimer > 3){ shutDoor(); doorTimer = 0.0; } } }
Vous allez prsent ajouter la fonction shutDoor() au bas de votre script. Son rle est en grande partie le mme que celui de la fonction openDoor(). Notez simplement quune animation diffrente de lobjet outpost est appele et que la variable doorIsOpen est redfinie false afin que toute la procdure puisse tre excute de nouveau:
function shutDoor(){ audio.PlayOneShot(doorShutSound); doorIsOpen = false; var myOutpost: GameObject = GameObject.Find("outpost"); myOutpost.animation.Play("doorshut"); }
Des fonctions plus efficaces Maintenant que vous disposez dun script qui contrle louverture et la fermeture de la porte, vous allez voir comment amliorer ce script avec des fonctions sur mesure. Pour le moment, vous disposez de deux fonctions personnalises, OpenDoor() et shutDoor(), qui effectuent les trois mmes tches : elles lancent la lecture dun son, dfinissent une variable boolenne et dclenchent une animation. Pourquoi ne pas alors crer une seule fonction qui soit capable de jouer diffrents sons, de dfinir si la variable boolenne est true ou false et de lire les diffrentes animations? Pour obtenir ce rsultat, vous devez passer ces trois tches en tant que paramtres de la fonction. Pour dclarer des paramtres dans une fonction, vous devez crire chacun deux entre les parenthses de la fonction en les sparant par des virgules et en indiquant leur type de donnes. 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 dclaration compte quatre paramtres: aClip, openCheck, animName et thisDoor. Il sagit en fait de variables qui sont dfinies lors de lappel de la fonction et dont la valeur est utilise lintrieur de celle-ci. Pour ouvrir la porte, par exemple, vous pourriez appeler cette fonction et dfinir chaque paramtre de la faon suivante:
Door(doorOpenSound, true, "dooropen", currentDoor);
Ainsi, la valeur de la variable doorOpenSound est transmise au paramtre aClip, la valeur true au paramtre openCheck, la chane de texte "dooropen" au paramtre animName et la variable currentDoor au paramtre thisDoor. Vous pouvez maintenant remplacer lappel la fonction OpenDoor() situ lintrieur de la fonction de dtection de collision. Cependant, vous devez encore dfinir la variable currentDoor. Pour cela, supprimez dabord la ligne suivante qui appelle la fonction OpenDoor() dans la fonction OnControllerColliderHit():
OpenDoor();
Et remplacez-la par les deux lignes suivantes:

currentDoor = hit.gameObject; Door(doorOpenSound, true, "dooropen", currentDoor);
La variable currentDoor dsigne ici le dernier objet entrer en collision avec le personnage du joueur. Vous pouvez ensuite passer cette information votre fonction pour vous assurer douvrir uniquement la porte autrement dit, dclencher lanimation de lavant-poste avec lequel le joueur entre en collision, plutt que celle dun autre avant-poste possdant une porte marque dun tag. Dans la dernire ligne de la fonction Door, thisDoor.transform.parent.animation lance la lecture de lanimation adquate. La syntaxe point permet de remonter dans la hirarchie jusquau composant danimation sur lequel vous devez agir. La variable thisDoor reoit comme valeur lobjet le plus rcemment touch stock dans la variable currentDoor , puis le script fait rfrence lobjet parent de la porte, cest--dire lobjet outpost luimme, puisque cest lui que le composant danimation est attach, et non la porte. Vous ne pourriez pas par exemple crire:
thisDoor.animation.Play(animName);
Unity signalerait alors quil nexiste aucun lment danimation. Vous devez donc dsigner le composant Transform du parent de lobjet enfant door lobjet auquel il appartient dans le panneau Hierarchy pour slectionner le composant danimation depuis ce point.
120
Enfin, comme vous utilisez cette nouvelle mthode pour ouvrir et fermer les portes, vous devez modifier le code de fermeture de la porte dans la fonction Update(). Dans linstruction if qui vrifie si la variable doorTimer dpasse la valeur de la variable doorOpenTime, remplacez lappel 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 personnalise Door() les remplace toutes les deux. En crant des fonctions de cette faon, vous vitez les rptitions dans vos scripts, ce qui les rend plus efficaces et permet de rduire le temps ncessaire lcriture de plusieurs fonctions. Finaliser le script Pour complter le script, vous allez vous assurer que lobjet quil ajoute possde un composant Audio Source, ce qui est ncessaire pour lire les extraits sonores puisque votre fonction Door dclenche 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 quon pourrait attendre. En fait, cette commande est spcifique Unity, et non dune partie du code JavaScript.
@script RequireComponent(AudioSource)
Attacher le script lobjet

Enregistrez votre script dans lditeur de script afin que Unity mette jour les modifications que vous avez effectues 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 situe au bas de linterface indique que le script contient des erreurs. Si cest le cas, double-cliquez sur cette erreur et assurez-vous que votre script correspond celui indiqu dans les pages prcdentes. Vous prendrez lhabitude dutiliser le rapport derreurs pour vous aider corriger vos scripts. Pour vous assurer que votre script ne contient pas derreur, commencez par vrifier que le nombre douvertures et de fermetures des accolades est bien pair autrement dit, que toutes les fonctions et les instructions if sont correctement fermes. Si le script ne contient aucune erreur, il vous suffit alors de slectionner, dans le panneau Hierarchy, lobjet sur lequel vous souhaitez lappliquer: lobjet First Person Controller ici.
Chapitre 4
Interactions
121
Il existe deux mthodes pour attacher un script un objet dans Unity : faire glisser le script depuis le panneau Project sur lobjet dans les panneaux Hierarchy ou Scene, ou tout simplement slectionner lobjet 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 affichera le vtre ds que vous laurez cr et sauvegard. Le panneau Inspector de lobjet First Person Controller devrait maintenant contenir le composant Player Collisions (Script). Un composant Audio Source a galement t ajout automatiquement en raison de lutilisation de la commande RequireComponent la fin du script.
Figure4.12
Comme vous pouvez le constater, les variables publiques doorOpenTime, doorOpenSound et doorShutSound saffichent dans le panneau Inspector. Vous pouvez donc ajuster la valeur de doorOpenTime et assigner des fichiers audio aux deux variables qui grent le son par glisser-dposer depuis le panneau Project. Cela est vrai pour toutes les variables publiques des scripts le prfixe private permet dempcher que les variables saffichent de cette manire, ce qui cest le cas des trois autres variables utilises dans le script. Gardez lesprit que lors de lutilisation de variables prives, vous devez leur assigner un type de donnes ou une valeur dans le script pour viter les erreurs. Dans le cas contraire, ces variables sont "null" (nont aucune valeur). Vous trouverez les fichiers audio OpenDoor et DoorClose dans larchive disponible sur la page ddie cet ouvrage sur le site web Pearson (http://www.pearson.fr). Procdez si ncessaire lextraction des fichiers, puis recherchez le paquet doorSounds.unitypackage. Pour limporter, revenez dans Unity, cliquez sur Assets > Import Package, parcourez votre disque dur jusquau dossier le contenant puis slectionnez-le. Cliquez sur Ouvrir pour afficher les deux fichiers que contient le paquet de ressources dans la bote de dialogue
122
Importing package. Il vous suffit de cliquer sur le bouton Import pour confirmer limportation des fichiers. Les lments audio doorSlideOpen et doorSlideShut sont alors disponibles dans la liste des ressources du panneau Project (voir Figure4.13).
Figure4.13
prsent que ces ressources se trouvent dans le dossier de votre projet, faites glisser chacune delles sur la variable publique approprie du composant Player Collisions (Script) dans le panneau Inspector (voir Figure4.14).
Figure4.14
Vous pouvez maintenant lancer le jeu et essayer douvrir la porte. Pour cela, cliquez sur le bouton Play en haut de linterface, marchez jusqu la porte de lavant-poste et entrez en contact avec elle. La collision entre le joueur et la porte est dtecte, ce qui entrane louverture de la porte. Puis celle-ci se referme automatiquement aprs 3 secondes. Cliquez de nouveau sur le bouton Play pour terminer le test. Pour que la porte souvre sans que le joueur ait besoin de la toucher, vous allez agrandir la taille du collider de la porte, comme nous lavons voqu au dbut du chapitre. Cliquez sur la flche grise situe devant lobjet de jeu outpost dans le panneau Hierarchy pour afficher ses objets enfants puis slectionnez lobjet enfant door. Placez le curseur sur le panneau Scene et appuyez sur la toucheF pour centrer la vue sur cet objet.
Chapitre 4
Interactions
123
Figure4.15
Dans le panneau Inspector, cliquez sur la flche situe devant le paramtre Size du composant Box Collider pour afficher ses options et ainsi pouvoir ajuster la valeurZ (la profondeur) du collider lui-mme. Donnez-lui une valeur de1,5 afin dtendre le collider (voir Figure4.16).
Figure4.16
Testez de nouveau le jeu. Vous pouvez constater que la porte souvre plus tt lorsque vous vous en approchez, puisque la limite du collider dpasse davantage de la porte visible. Cependant, une collision physique se produit dans le collider, entranant une raction de repoussement. Vous pouvez contrer cet effet en utilisant le mode Trigger (dclencheur) du collider, comme vous le verrez au chapitre suivant. Pour linstant, vous allez implmenter la seconde approche de dtection : le raytracing. En projetant un rayon vers lavant du personnage du joueur, il naura plus besoin de collider pour toucher le collider de la porte.
124
Mthode 2. Le raycasting
Bien que lutilisation de la dtection de collision ou de dclencheur soit une mthode tout fait valable, le raycasting vous permet de vous assurer que le joueur ouvre seulement la porte de lavant-poste sil lui fait face. En effet, le rayon part toujours dans la direction vers laquelle lobjet First Person Controller est tourn, si bien quil ne coupera pas la porte si le joueur lui tourne le dos, par exemple.
Dsactiver la dtection de collision utiliser les commentaires

Pour viter davoir crire un script supplmentaire, vous allez simplement placer en commentaires cest--dire dsactiver temporairement une partie du script qui contient la fonction de dtection de collision. Pour convertir le script de collision en commentaires ou le commenter , vous devez ajouter certains caractres. En programmation, les commentaires peuvent tre conservs mais ne sont jamais excuts. Pour dsactiver une partie du script, il vous suffit donc de la transformer en commentaires. Revenez votre diteur de script (Unitron ou Uniscite), placez-vous au dbut de la ligne:
function OnControllerColliderHit(hit: ControllerColliderHit){
et insrez les caractres suivants:

/*
Dans un script, cette barre oblique (ou "slash") suivie dun astrisque marque le dbut dun commentaire sur plusieurs lignes (par opposition aux deux barres obliques qui sont utilises pour les commentaires dune seule ligne). Allez ensuite la fin de la fonction de dtection de collision et insrez un astrisque suivi dune barre oblique. La couleur de toute la fonction devrait avoir chang dans lditeur de script et se prsenter de la faon suivante:
/* function OnControllerColliderHit(hit: ControllerColliderHit){ if(hit.gameObject.tag == "outpostDoor" && doorIsOpen == false){ currentDoor = hit.gameObject; Door(doorOpenSound, true, "dooropen", currentDoor); } } */
Chapitre 4
Interactions
125
Rinitialiser le collider de la porte

Comme vous voulez viter leffet de repoussement qui survient lors du contact avec le collider invisible de la porte, slectionnez lobjet enfant door du composant Box Collider dans le panneau Inspector, puis donnez au paramtre Size une valeur de 0,1 sur laxeZ. Cela correspond la profondeur visuelle de la porte.
Ajouter le rayon
Revenez lditeur de script et insrez quelques lignes aprs louverture de la fonction Update(). Le raycasting est plac dans la fonction Update() pour la simple raison que le rayon doit tre projet vers lavant 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 premire ligne, on cre un rayon en dclarant une variable prive appele hit, qui est de type RaycastHit. Notez que cette variable na pas besoin du prfixe private pour ne pas safficher dans le panneau Inspector. En effet, il sagit obligatoirement dune variable prive, car elle est dclare dans une fonction. Elle sera utilise pour stocker des informations sur le rayon lorsquil croisera des colliders. Nous utiliserons cette variable chaque fois que nous ferons rfrence ce rayon. Suivent ensuite deux instructions. La premire condition if est charge de la projection du rayon et utilise la variable cre la ligne prcdente. Comme la projection du rayon se trouve dans une instruction if, lappel linstruction if imbrique se produira uniquement si le rayon frappe un objet, ce qui rend le script plus efficace. La commande Physics.Raycast de la premire condition if projette le rayon. Elle possde quatre paramtres indiqus entre parenthses:
Le point dmission du rayon (transform.position). Indique la position de lobjet sur lequel ce script sapplique, autrement dit lobjet First Person Controller.
126
La direction du rayon (transform.forward). Le rayon est dirig vers lavant de lobjet sur lequel sapplique ce script. La structure des donnes RaycastHit que nous avons dfinies comme variable hit. Le rayon est stock sous la forme dune variable. La longueur du rayon (5). La distance exprime dans lunit du jeu, le mtre.
Ensuite, linstruction if imbrique vrifie tout dabord 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 dtection de collision, que la valeur de la variable boolenne doorIsOpen est false. L encore, il sagit de sassurer que le dclenchement de lanimation ne se rpte pas plusieurs fois lorsque la porte a commenc souvrir. Une fois les deux conditions if runies, la variable currentDoor est dfinie sur lobjet stock dans la variable hit puis le script appelle la fonction Door() de la mme manire quil le faisait dans la fonction de dtection 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 approchez de la porte, celle-ci souvre non seulement avant que vous ne la percutiez, mais aussi quelle souvre uniquement lorsque vous lui faites face. En effet, le rayon qui dtecte la porte est projet dans le mme sens que celui o le personnage du joueur se dirige.
En rsum
Ce chapitre vous a permis dexplorer deux mthodes essentielles pour dtecter les interactions entre les objets dans les jeux3D. Vous devez matriser le raycasting et la dtection de collision car vous aurez souvent les rutiliser dans Unity pour vos futures crations. Le chapitre suivant sintresse une autre mthode de dtection de collision, en utilisant les colliders des objets comme des dclencheurs. Ce mode Trigger permet de dtecter les collisions sans quil y ait besoin quun objet soit prsent physiquement le joueur peut ainsi collecter des objets sans les percuter, par exemple. Considrez les dclencheurs comme des collisions sans aucun impact. Vous auriez pu adopter cette mthode pour la
Chapitre 4
Interactions
127
porte de lavant-poste, cependant il est important que vous appreniez dabord les principes de base de la dtection de collision. Voil pourquoi nous les prsentons dans cet ordre particulier. Vous allez crer un mini-jeu de collecte dans lequel le joueur devra trouver quatre piles afin de recharger le mcanisme douverture de la porte de lavant-poste. Par consquent, laccs lavant-poste lui sera interdit tant quil naura pas obtenu ces piles.
5
lments prfabriqus, collections et HUD
Au cours de ce chapitre, vous continuerez le travail du Chapitre4. En utilisant une mthode analogue celle du chapitre prcdent, vous allez en apprendre plus sur la dtection des collisions en utilisant les colliders (composants de collision) comme dclencheurs. Les dclencheurs sont souvent considrs comme des composants. Pourtant, pour rester simple, il sagit de colliders qui possdent un mode Dclencheur pouvant tre activ avec loption IsTrigger dans le panneau Inspector (voir Figure5.1).
Figure5.1
130
Vous avez dj un avant-poste dont la porte souvre, mais vous allez maintenant forcer le joueur trouver certains objets pour quil puisse accder ce btiment. En affichant des instructions lcran lorsque le joueur sapproche de la porte, vous lui ferez savoir que louverture de la porte ncessite une source dalimentation. Pour linciter rechercher plusieurs exemplaires de cet objet dissmins proximit afin de disposer de suffisamment de puissance pour actionner le mcanisme douverture de la porte, vous ferez ensuite apparatre une pile vide en 2D lcran. En crant ce jeu simple, vous apprendrez :
travailler avec des objets 2D en utilisant des textures GUI; contrler laffichage du texte lcran avec les lments GUI Text; utiliser des lments prfabriqus pour crer plusieurs exemplaires dun objet de jeu et les stocker comme ressources.
La cration de llment prfabriqu batterie

cette section, vous importerez un modle de pile que vous convertirez en lment prfabriqu de Unity (un modle de donnes qui peut tre utilis pour crer plusieurs copies dun modle possdant certains paramtres prdfinis). Si vous avez dj utilis Adobe Flash, vous pouvez comparer cela MovieClip, qui permet de crer plusieurs copies identiques et de modifier chacune delles aprs leur cration.
Tlcharger, importer et positionner

Pour commencer crer le jeu, vous aurez besoin du paquet de ressources de larchive fournie sur le site web de Pearson (http://www.pearson.fr). Procdez, si besoin, lextraction des fichiers, puis recherchez le package batteries.unitypackage. Revenez ensuite dans Unity et cliquez sur Assets> Import Package. Parcourez le disque dur jusquau dossier contenant le package et slectionnez-le comme fichier importer pour afficher la liste des ressources dans la bote de dialogue Importing package. Cliquez ensuite sur Import pour importer les ressources suivantes:
un modle 3D de pile; cinq fichiers image dune batterie de remplissage avec charge; un fichier audio qui sera lu lorsque le joueur collectera une pile.
Les fichiers doivent maintenant safficher dans le panneau Project (voir Figure5.2).
Chapitre 5
131
Figure5.2
Faites glisser le modle 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 toucheF pour centrer la vue sur cet objet. La position de la pile est arbitraire, vous la repositionnerez une fois que vous aurez cr votre lment prfabriqu.
Ajouter un tag
Pour pouvoir dtecter une collision avec lobjet battery, vous devez lui assigner un tag pour lidentifier dans le script que vous allez bientt crire. Cliquez sur le menu droulant Tag, et slectionnez AddTag. Le panneau Inspector affiche alors le Tag Manager. Ajoutez un tag battery dans le premier lment disponible (voir Figure5.3).
Figure5.3
132
Appuyez sur Entre pour valider la cration de ce tag. Slectionnez de nouveau lobjet battery dans le panneau Hierarchy, puis choisissez le tag battery dans le menu droulant Tag du panneau Inspector.
chelle, collider et rotation

Vous allez maintenant prparer la pile devenir un lment prfabriqu en dfinissant les composants et les paramtres qui seront conservs sur chaque copie de la batterie.
Redimensionner la batterie
Llment que vous crez devra avoir une taille suffisante pour que le joueur puisse le reprer dans le jeu. Comme nous avons dj vu comment modifier lchelle des objets dans le composant FBXImporter, vous allez ici simplement le redimensionner laide du composant Transform dans le panneau Inspector. Lobjet battery tant toujours slectionn dans le panneau Hierarchy, donnez une valeur de6 tous les paramtres Scale du composant Transform dans le panneau Inspector.
Ajouter un dclencheur 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 cest 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 Dclencheur de son collider. Pour cela, choisissez loption IsTrigger dans le nouveau composant Capsule Collider.
Crer un effet de rotation

Vous allez maintenant crire un script pour faire pivoter lobjet battery, de manire ajouter un effet visuel et le rendre plus visible pour le joueur. Slectionnez 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 Entre/F2 et modifiez le nom du fichier (NewBehaviourScript par dfaut) en RotateObject. Double-cliquez ensuite sur son icne pour louvrir dans lditeur de script.
Chapitre 5
133
Insrez une ligne au dbut de votre nouveau script, avant la fonction Update(), et crez-y une variable publique virgule flottante rotationAmount dune valeur de 5.0 de la faon suivante:
var rotationAmount: oat = 5.0;
Cette variable vous servira dfinir la vitesse de rotation de lobjet battery. Il sagit dune variable publique (elle se trouve en dehors de toute fonction et nest pas dclare comme private), vous pourrez donc galement ajuster cette valeur dans le panneau Inspector une fois le script attach lobjet battery. Dans la fonction Update(), ajoutez la commande suivante pour faire pivoter lobjet battery sur son axeY 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 valeursX etZ sont ici dfinies 0 tandis que la valeurY est celle de la variable. Comme cette commande se trouve dans la fonction Update(), elle sexcutera chaque image, si bien que la pile effectuera une rotation de 5degrs de chaque image. Cliquez sur File> Save dans lditeur de script, puis revenez dans Unity. Pour lier ce script lobjet battery, assurez-vous que ce dernier est slectionn dans le panneau Hierarchy. Cliquez ensuite sur Component> Scripts> RotateObject. Vous pouvez galement simplement faire glisser le script depuis le panneau Project sur lobjet dans le panneau Hierarchy. Cliquez sur le bouton Play situ en haut de linterface pour vous assurer que lobjet battery tourne bien sur lui-mme dans le jeu. Si cela ne fonctionne pas, vrifiez que votre script ne contient pas derreur et quil est attach lobjet adquat. Noubliez pas de cliquer de nouveau sur Play pour terminer vos tests avant de poursuivre.
Enregistrer comme lment prfabriqu

prsent que lobjet battery est termin, vous devez le cloner trois reprises pour disposer dun total de quatre piles. La meilleure mthode pour cela consiste utiliser le systme dlment prfabriqu de Unity. Un lment prfabriqu est simplement un modle de donnes qui stocke les paramtres dun objet cr dans la scne. Il peut ensuite tre clon lors de ldition ou de linstanciation (sa cration la vole) lors de lexcution du jeu.
134
Crez un dossier dans le panneau Project pour stocker llment prfabriqu et ceux que vous crerez plus tard. Pour cela, assurez-vous dabord quaucun dossier existant nest slectionn en cliquant dans lespace gris sous les objets dans le panneau Project. Cliquez ensuite sur le bouton Create et slectionnez Folder, puis appuyez sur Entre/F2 et nommez ce nouveau dossier Prefabs. Slectionnez le dossier Prefabs, puis cliquez sur le bouton Create et choisissez Prefab pour crer un nouvel lment prfabriqu vide dans ce dossier. Licne dun lment prfabriqu vide est un cube gris, tandis que celle dun lment prfabriqu ayant un contenu est un cube bleu clair.
Info
Renommez llment prfabriqu vide battery. Faites ensuite glisser lobjet battery sur lequel vous avez travaill depuis le panneau Hierarchy jusque sur llment prfabriqu vide battery dans le panneau Project. La pile devient alors un lment prfabriqu. Une copie de cet lment prfabriqu est galement cre dans la scne courante. Par consquent, toute modification apporte llment prfabriqu dans le panneau Project se rpercute sur sa copie dans la scne. Le nom des objets de la scne lis des ressources du projet saffiche en bleu dans le panneau Hierarchy, tandis que le nom des objets existant uniquement dans la scne saffiche en noir.
Disperser les batteries

Comme lobjet battery est maintenant stock sous la forme dun lment prfabriqu, la duplication de la copie dans la scne entrane la cration doccurrences de cet lment prfabriqu. Veillez ce que lobjet battery soit toujours slectionn dans le panneau Hierarchy, puis cliquez sur Edit > Duplicate ou utilisez le raccourci clavier Cmd/ Ctrl+D pour le dupliquer trois fois dans la scne. Lorsque vous dupliquez des objets dans la scne, les copies sont cres dans la mme position, ce qui peut entraner une certaine confusion. En effet, Unity duplique chaque paramtre des objets, y compris leur position. Le plus simple est de se souvenir que les copies se trouvent dans la mme position que loriginal et doivent simplement tre dplaces.
ce Astu
Chapitre 5
135
Slectionnez chacune des quatre piles dans le panneau Hierarchy et utilisez loutil Transform pour les disposer autour de lavant-poste. Noubliez pas que vous pouvez utiliser laxe3D situ dans le coin suprieur droit du panneau Scene pour passer de la vue Perspective aux vues Haut, Bas et latrales. Placez les piles une hauteur qui ne soit pas trop leve pour que le joueur puisse les atteindre. Une fois que vous avez dispos les quatre piles autour de lavant-poste, vous devriez obtenir un rsultat comparable celui illustr la Figure5.4.
Figure5.4
Laffichage dune interface graphique pour la pile

Maintenant que les piles sont en place, vous devez indiquer au joueur ce quil doit collecter grce une reprsentation visuelle de lobjet. Les textures importes avec le paquet de ressources ont t conues pour montrer clairement que le joueur devra collecter quatre batteries afin de dverrouiller la porte. Pour crer lillusion que cet lment dinterface est dynamique, vous pouvez remplacer limage de la pile vide par celle montrant la pile charge dune unit lorsque le joueur collecte la premire pile, puis par limage de la pile charge deux units lorsquil obtient la deuxime, et ainsi de suite.
136
Crer lobjet GUI Texture

Un dossier de textures a t import en mme temps que le paquet de ressources contenant les piles. Ce dossier contient cinq fichiers image: un pour la pile vide et quatre pour les diffrentes tapes de chargement. Cres 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 limage soit compresse. La couche alpha est celle qui cre la transparence dans une image en complment des couches rouge, vert et bleu qui constituent limage. Pour crer linterface graphique montrant le chargement progressif de la pile, vous allez ajouter limage de la pile vide dans la scne laide du composant GUI Texture de Unity. Affichez le contenu du dossier textures dans le panneau Project, puis slectionnez le fichier nomm battery_nocharge. Vous ne pouvez pas dposer directement cette ressource dans le panneau Scene. Vous devez crer un nouvel objet possdant un composant GUI Texture, puis utiliser limage battery_nocharge comme texture de ce composant. Bien que cette procdure se droule techniquement en trois tapes, elle peut tre ralise en une seule. Pour cela, slectionnez 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 fichier image, si bien que les valeurs du paramtre Pixel Inset sont dj dfinies dans le panneau Inspector (voir Figure5.5).
Figure5.5
Chapitre 5
137
Les valeurs du paramtre Pixel Inset dfinissent les dimensions et la superficie daffichage dun objet. Gnralement, les paramtres Width et Height doivent tre spcifis pour correspondre aux dimensions dorigine de votre fichier de texture, et les valeursX etY tre fixes la moiti de ces dimensions. Lorsque vous crez lobjet aprs avoir slectionn la texture, Unity dfinit ces valeurs pour vous. Si vous slectionnez limage que vous souhaitez utiliser en premier, vous indiquez Unity quen crant le nouvel objet, il doit utiliser ce fichier comme texture et dfinir les dimensions du composant GUI TEXTURE en fonction de celle-ci. De plus, lorsque vous slectionnez une image et crez un objet GUI TEXTURE laide du menu principal, lobjet cr est nomm selon le nom de la texture, ce qui est trs utile pour trouver lobjet dans le panneau HIERARChY aprs sa cration.
ce Astu
Slectionnez au besoin lobjet battery_nocharge que vous avez cr dans le panneau Hierarchy, appuyez sur Entre/F2 et renommez-le Battery GUI.
Positionner lobjet GUI Texture

Vous avez besoin dutiliser les coordonnes relatives lcran lorsque vous travaillez avec des lments2D car ils fonctionnent uniquement sur les axesX etY laxe Z tant utilis pour dfinir la priorit daffichage des diffrents lments GUITexture. Les coordonnes relatives lcran sincrmentent de0 1 avec des nombres dcimaux. Pour positionner lobjet Battery GUI o il doit apparatre (dans le coin infrieur gauche de lcran), vous avez besoin de dfinir les valeursX etY de son composant Transform. Donnez une valeur de 0,05 au paramtreX et une valeur de 0,2 au paramtreY. Limage doit maintenant safficher dans le panneau Game (voir Figure5.6).
138
Figure5.6
Vous pouvez galement afficher les dtails 2D dans le panneau Scene en cliquant sur le bouton Game Overlay (voir Figure5.7).
Figure5.7
Chapitre 5
139
Modifier linterface graphique laide dun script

La pile qui saffiche dans le coin de lcran 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 possde. Slectionnez 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 dfaut), puis double-cliquez sur son icne pour louvrir dans lditeur de script. Le script servira contrler le composant GUI Texture de lobjet Battery GUI. Aussi, il est prfrable quil soit attach cet objet, afin que les scripts connexes soient joints aux objets appropris. Avec ce script, la texture affiche lcran dpendra du nombre de piles qui ont t collectes ces informations seront stockes dans une variable numrique entire (de type integer). Une fois lcriture du script termine, vous modifierez le script PlayerCollisions, en ajoutant une dtection de dclencheur de collision pour les piles. Chaque fois quune collision sera dtecte entre le personnage et une pile, la variable numrique sera incrmente dans le script BatteryCollect, ce qui modifiera la texture utilise par le composant GUI Texture de lobjet Battery GUI. Le script commence par la dclaration dune variable de type static une variable statique accessible depuis dautres scripts , qui stocke ltat de chargement de la pile. Cette variable est un entier, car il est impossible que sa valeur soit dcimale. Ajoutez la ligne suivante avant la premire du script:
static var charge: int = 0;
Vous avez ensuite besoin de cinq variables pour stocker les textures qui reprsentent les cinq tats diffrents de lobjet Battery GUI la pile vide et les quatre tapes de chargement. Pour cela, ajoutez les cinq variables suivantes de type Texture2D sans valeur dfinie:
var var var var var charge1tex: charge2tex: charge3tex: charge4tex: charge0tex: Texture2D; Texture2D; Texture2D; Texture2D; Texture2D;
Comme il sagit de variables publiques, vous pourrez assigner chaque fichier image en faisant glisser les textures du panneau Project sur les champs des variables dans le panneau Inspector lorsque ce script sera slectionn.
140
Pour configurer les paramtres par dfaut du composant GUI Texture, ajoutez la fonction Start() suivante aprs les variables que vous venez de dclarer:
function Start(){ guiTexture.enabled = false; charge = 0; }
La fonction Start() sexcutera une fois au dbut de ce niveau du jeu (ou de la scne, pour reprendre le terme utilis dans Unity). Avec la ligne:
guiTexture.enabled = false;
vous vous assurez que le composant nest pas activ et donc que la pile nest pas visible lorsque le jeu commence. La variable charge est dfinie galement 0 au dbut du jeu, afin que le script considre quaucune pile na t collecte lorsque la scne commence. Insrez ensuite quelques lignes avant laccolade de fermeture de la fonction Update(), puis ajoutez linstruction if suivante:
if(charge == 1){ guiTexture.texture = charge1tex; guiTexture.enabled = true; }
Ici, le script vrifie si la variable charge a une valeur de1 puis il excute deux commandes:
guiTexture.texture = charge1tex;. Cette ligne dfinit quelle est limage assigne UI la variable charge1tex qui doit tre utilise comme texture par le composant G
Texture de lobjet sur lequel ce script est attach.

guiTexture.enabled = true;. Cette ligne active le composant lui-mme. Vous avez indiqu que lobjet Battery GUI nest pas visible (cest--dire inactiv) lorsque le jeu dmarre, afin dviter toute confusion pour le joueur et pour viter dencombrer lcran. La pile vide doit uniquement safficher aprs que le joueur a essay douvrir la porte.
Linstruction if de cette ligne du script permet donc dactiver linterface graphique lorsque le joueur a collect une pile. Vous ajouterez plus tard quelques lignes de script Collisions afin au raytracing qui dtecte la collision avec la porte dans le script Player dafficher la pile vide si lutilisateur essaie dentrer dans lavant-poste avant davoir collect sa premire pile. Vous allez ensuite ajouter trois instructions if supplmentaires dans la fonction Update() pour vrifier ltat 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
141
else if, puisque celles-ci sont vrifies uniquement lorsque lune ou lautre des autres instructions if sexcute dj.
Si vous deviez utiliser une instruction if pour chacune des conditions suivantes, elles seraient toutes vrifies simultanment, ce qui rendrait le script inefficace. Ajoutez le code suivant aprs laccolade de fermeture de linstruction 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 affiche par le composant GUI Texture dutiliser les diffrentes variables publiques dclares au dbut du script (vous assignerez plus tard les fichiers dimages ces variables dans le panneau Inspector). Vous navez pas besoin dactiver le composant dans ces conditions else if car il a dj t activ lorsque le joueur a ramass la premire pile. Enfin, il suffit dajouter une instruction else la fin de la suite de conditions if et else if au cas o la variable charge aurait une valeur de0, puisque la dclaration else signifie "si aucune des conditions qui prcdent nest vraie, alors procdez comme suit". Autrement dit, puisque les dclarations if et else if recherchent une valeur de chargement allant de1 4, linstruction else se chargera de laffichage quand le jeu commencera (quand la variable de charge sera gale 0). Cela reprend pour lessentiel la fonction Start():
else{ guiTexture.texture = charge0tex; }
Maintenant que le script est termin, cliquez sur File> Save dans lditeur de script et revenez Unity. Slectionnez lobjet BatteryGUI dans le panneau Hierarchy, puis cliquez sur Compolobjet nent> Scripts> BatteryCollect dans le menu principal pour assigner le script Battery GUI. Les cinq variables publiques en attente daffectation devraient safficher dans le panneau Inspector (voir Figure5.8).
142
Figure5.8
Faites glisser les cinq fichiers de texture depuis le dossier textures du panneau Project que vous avez import plus tt sur les variables publiques appropries (voir Figure5.9).
Figure5.9
prsent que linterface graphique de la collecte des piles est prte, il vous reste lajouter au script PlayerCollisions attach lobjet First Person Controller, afin de dtecter si le personnage du joueur interagit avec les dclencheurs de collision des objets battery.
La collecte des piles avec des dclencheurs

Pour dclencher les diffrents tats de lobjet BatteryGUI, vous allez utiliser une fonction OnTriggerEnter() pour dtecter linteraction avec les objets qui disposent de colliders en mode Dclencheur, cest--dire les piles collecter. Avant dcrire cette fonction dans le script PlayerCollisions, vous ajouterez une variable publique pour stocker un lment audio. Ce son se dclenchera lorsque le joueur ramassera une pile afin de complter les indications visuelles sur le chargement de la pile. Double-cliquez sur licne du script PlayerCollisions dans le dossier Scripts du panneau Project pour louvrir dans lditeur de script si ncessaire. Ajoutez la ligne suivante au dbut du script pour crer une variable publique:
var batteryCollect: AudioClip;
Seul le type de donnes (AudioClip) de la variable est dclar dans le script. Sa valeur nest pas dfinie; elle pourra ltre par la suite dans le panneau Inspector.
Chapitre 5
143
Insrez ensuite une ligne avant la dernire ligne du script:

et ajoutez la fonction suivante:

function OnTriggerEnter(collisionInfo: Collider){ }
Cette fonction est spcifiquement conue pour dtecter les collisions avec les colliders en mode Dclencheur. Toute collision avec ce type de collider est place dans le paramtre collisionInfo, qui est de type Collider, si bien que pour effectuer une requte sur ces informations, vous devez faire rfrence lobjet attach au collider qui a t touch. Ajoutez linstruction if suivante lintrieur de la fonction OnTriggerEnter() (cest-dire avant son accolade de fermeture) pour interroger tous les dclencheurs avec lesquels le personnage du joueur entre en collision:
if(collisionInfo.gameObject.tag == "battery"){ BatteryCollect.charge++; audio.PlayOneShot(batteryCollect); Destroy(collisionInfo.gameObject); }
Cette dclaration if effectue une requte sur le paramtre collisionInfo de la fonction afin de vrifier si le collider de la collision courante est attach un objet de jeu portant le tag battery sil sagit dune pile. Si tel est le cas, le script:
Incrmente la valeur de la variable statique (globale) charge du script BatteryCollect laide de la syntaxe point et de loprateur ++. En augmentant la valeur de la variable charge chaque collision avec une pile, vous dclenchez le changement de texture dans le script BatteryCollect pour reprsenter lcran le chargement de la pile, compltant ainsi le lien entre les collisions et linterface graphique. Lance une seule fois la lecture de la squence audio assigne la variable battery Collect dans le panneau Inspector. Retire de la scne, grce la commande Destroy(), lobjet avec lequel le personnage du joueur est entr en collision. La syntaxe point permet de prciser que lobjet dtruire est celui qui est impliqu dans la collision. Cette opration est rgie par une instruction if et sexcute donc uniquement en cas de collision avec un objet portant le tag battery. Il est donc impossible quun autre objet soit dtruit. Dans cet exemple, la commande Destroy() prend un objet de jeu comme seul paramtre, mais elle peut galement avoir une valeur dcimale comme second paramtre (spar du premier par une virgule) pour indiquer le temps aprs lequel un objet doit tre supprim.
144
Cliquez sur File> Save dans lditeur de script pour enregistrer le script, puis revenez dans Unity. Slectionnez lobjet First Person Controller dans le panneau Hierarchy. Comme vous pouvez le constater, le composant PlayerCollisions (Script) dans le panneau Inspector possde maintenant une nouvelle variable publique BatteryCollect qui attend que lui soit affecte une ressource AudioClip (voir Figure5.10).
Figure5.10
Faites glisser la ressource audio battery_collect situe dans le dossier Sounds du panneau Project sur la variable Battery Collect, ou cliquez sur la flche grise droite de None (Audio Clip) et slectionnez battery_collect dans la liste droulante qui saffiche. Cliquez sur le bouton Play et testez le jeu. Chacune des piles doit disparatre lorsque le personnage du joueur entre en contact avec elle; limage de la pile doit safficher puis sa charge augmenter chaque pile que vous obtenez. Vous devez galement entendre leffet sonore jouer chaque nouvelle pile, aussi assurez-vous que le volume sonore de votre ordinateur nest pas zro! Cliquez de nouveau sur le bouton Play pour arrter le test une fois que vous avez vrifi que vous pouvez recueillir toutes les piles.
Restreindre laccs lavant-poste

Cet exercice a pour principal objectif de vous montrer comment contrler certaines situations dans le jeu. Dans cet exemple, nous voulons que le joueur puisse uniquement ouvrir la porte de lavant-poste aprs avoir collect quatre piles. Du point de vue du dveloppeur, cette nigme ncessite de rsoudre deux questions principales:
Comment le joueur sait-il quil 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?
Considrons la premire question: vous allez chercher conserver une part de mystre dans votre jeu. Vous proposerez au joueur un indice pour ouvrir la porte, uniquement sil cherche entrer dans lavant-poste. Pour cela, vous aurez besoin que des instructions saffichent lcran lorsquil sapprochera de la porte la premire fois. Vous ajouterez galement
Chapitre 5
145
de nouvelles instructions dans le cas o il sapprocherait de nouveau de la porte aprs avoir rassembl quelques piles mais pas toutes. Afin de vrifier si le joueur peut ouvrir la porte et, par consquent, si des instructions doivent safficher lcran, vous pouvez utiliser le script BatteryCollect existant. Comme sa variable statique charge contient la quantit de piles collectes et stockes, vous saurez en linterrogeant si sa valeur est gale 4 autrement dit, si toutes les piles ont t collectes.
Restreindre laccs
Avant de donner des instructions au joueur, vous allez modifier la partie du script PlayerCollisions qui gre louverture de la porte afin quelle sactive uniquement lorsque le joueur a collect les quatre piles. Au chapitre prcdent, vous avez crit une fonction personlouverture et nalise Door() dans le script PlayerCollisions dont les paramtres graient la fermeture des portes que le joueur rencontre de la manire 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 dune squence sonore, garantit que la porte ne peut tre rouverte et dclenche lanimation douverture de la porte. Elle est appele au sein de la fonction Update(), dans la partie du script consacre au raycasting (la ligne vectorielle projete dans la mme direction que le regard du joueur et qui vrifie 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 louvrir, puis recherchez lextrait de code de la fonction Update() dans lequel se trouve lappel la fonction Door() qui ouvre la porte:
if(hit.collider.gameObject.tag=="outpostDoor" && doorIsOpen == false){ Door(doorOpenSound, true, "dooropen", currentDoor); }
146
Pour que la porte reste ferme aussi longtemps que toutes les piles nont pas t collectes, il suffit dajouter une troisime condition linstruction if existante, en utilisant une autre paire desperluettes, &&:
if(hit.collider.gameObject.tag=="outpostDoor" && doorIsOpen == false && BatteryCollect.charge >= 4){ Door(doorOpenSound, true, "dooropen", currentDoor); }
En ajoutant la condition:
BatteryCollect.charge >= 4
vous vrifiez si la valeur de la variable statique charge du script BatteryCollect est gale ou suprieure 4. Ainsi, la porte ne souvrira pas tant que le joueur naura pas ramass toutes les piles disperses dans lle.
La commande GetComponent()
Une fois que le joueur peut entrer dans lavant-poste, vous devez supprimer lobjet Battery GUI de lcran. Pour cela, vous avez besoin daccder son composant GUI Texture. Le dclenchement de la porte se trouvant dans le script PlayerCollisions dans lequel vous travaillez actuellement, vous devez faire rfrence un composant attach un objet diffrent (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 mme objet que le composant GUI Texture. Mais cela nest pas possible dans un script qui ne se trouve pas sur un objet possdant un composant GUI Texture. Vous devez donc utiliser la commande GetComponent(), la suite de la rfrence lobjet 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 linstruction if que vous venez de modifier:
GameObject.Find("Battery GUI").GetComponent(GUITexture).enabled=false;
Cette ligne de script utilise la commande GameObject.Find, en indiquant le nom de lobjet dans le panneau Hierarchy, puis passe le composant GUI Texture en paramtre de GetComponent() laide de la syntaxe point, pour le dsactiver enfin de la manire habituelle, en dfinissant sa valeur false (enabled = false;).
Chapitre 5
147
Il ne sagit pas de dtruire cet objet, car vous avez encore besoin de ce script dans le jeu pour rfrencer le nombre de piles dj collectes. Cest pourquoi vous dsactivez simplement le composant visuel. Cliquez sur File> Save dans lditeur de script, puis revenez Unity. Cliquez sur le bouton Play et testez le jeu. Assurez-vous que vous ne pouvez pas entrer dans lavant-poste sans avoir recueilli les quatre piles. Si ce nest pas le cas, vrifiez que votre script correspond bien celui que nous vous avons indiqu jusqu prsent. Noubliez 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 lavant-poste, va jusqu celle-ci et essaie dentrer? Dans lidal, vous devriez alors:
Lui indiquer par du texte que le mcanisme de la porte doit tre recharg. Mme sil est facile dcrire: "Collectez quelques piles!", il est plus intressant de lui fournir des conseils, comme: "Le mcanisme de la porte semble manquer de puissance" Afficher lobjet Battery GUI pour que le joueur comprenne quil doit charger une pile.
Le deuxime indice est beaucoup plus facile implmenter, aussi allons-nous laborder en premier.
Lindice Battery GUI

Revenez lditeur de script dans lequel le script PlayerCollisions est toujours ouvert. Si vous lavez ferm pour une raison quelconque, vous pouvez le rouvrir depuis le panneau Project. Aprs laccolade de fermeture de linstruction if sur laquelle vous avez travaill, ajoutez une autre instruction else if. Elle vise les mmes conditions que la prcdente, mais elle vrifie cette fois si la valeur de la variable charge de BatteryCollect est infrieure 4:
else if(hit.collider.gameObject.tag=="outpostDoor" && doorIsOpen == false && BatteryCollect.charge < 4){ }
Dans cette instruction else if, vous utilisez la mme ligne qui dsactive le composant GUITexture dans la premire instruction if mais, cette fois, elle aura au contraire pour effet de lactiver. Insrez la ligne suivante dans la dclaration else if:
GameObject.Find("Battery GUI").GetComponent(GUITexture).enabled=true;
148
Cliquez sur File> Save dans lditeur de script, puis revenez Unity. Cliquez sur le bouton Play et vrifiez que si vous approchez de la porte sans aucune batterie, lobjet Battery GUI saffiche. Cliquez sur le bouton Play de nouveau pour arrter lessai.
Lindice textuel
Le moyen le plus simple pour crire du texte en 2D qui doit safficher lcran consiste utiliser un composant GUIText. Vous allez donc crer un nouvel objet GUI Text qui possde les deux composants Transform et GUIText. Cliquez sur GameObject> Create Other> GUI Text. Lobjet GUI Text saffiche alors dans le panneau Hierarchy. Le texte 2D "Gui Text" apparat galement dans le panneau Scene (voir Figure5.11).
Figure5.11
Slectionnez cet objet dans le panneau Hierarchy, appuyez sur Entre/F2 et renommez-le TextHint GUI. Slectionnez lobjet GUI Text dans le panneau Hierarchy pour afficher le composant lui-mme dans le panneau Inspector. Vous allez conserver la valeur par dfaut (0,5) pour les coordonnesX etY du composant Transform. En effet, lobjet GUI Text utilisant galement les coordonnes relatives lcran, une valeur de 0,5 sur ces deux axes place le texte au milieu de lcran, ce qui est parfait pour attirer lattention du joueur.
Chapitre 5
149
Le composant GUIText de lobjet possde galement un paramtre Anchor qui permet daligner le texte gauche, droite ou encore au centre, comme dans un logiciel de traitement de texte. Cliquez sur la double flche situe droite du paramtre Anchor et slectionnez middle center afin que le texte stire depuis et non vers le centre de lcran. Bien que le paramtre Text du panneau Inspector permette dentrer le texte que doit afficher le composant GUIText (voir Figure5.12), vous allez contrler ce texte dynamiquement grce un script.
Figure5.12
Slectionnez le dossier Scripts dans le panneau Project, cliquez sur le bouton Create et choisissez JavaScript dans le menu droulant. Renommez ce script TextHints, puis double-cliquez sur son icne pour louvrir dans lditeur de script. Pour commencer, dclarez les trois variables suivantes au dbut du script:
static var textOn: boolean = false; static var message: String; private var timer: oat = 0.0;
La premire variable statique, textOn, est de type boolen, car elle doit agir comme un simple interrupteur. Nous reviendrons bientt plus en dtail sur ce point. Ensuite, le script dclare une autre variable statique message de type string, que vous utiliserez pour transmettre toutes les informations au paramtre Text du composant. Ces deux variables sont statiques car nous aurons besoin de faire rfrence elles depuis le script PlayerCollisions. La troisime variable, timer, est prive car elle na besoin ni dtre utilise par dautres scripts ni de safficher dans le panneau Inspector. Elle servira dcompter le temps coul partir du moment o le message saffiche lcran, afin de le faire disparatre aprs un certain dlai.
150
Ajoutez ensuite la fonction Start() suivante, afin de dfinir certains tats lorsque la scne commence:
function Start(){ timer = 0.0; textOn = false; guiText.text = ""; }
Ces lignes sassurent simplement que la variable timer est dfinie 0, que la variable textOn est false (aucun texte ne doit safficher au dbut du jeu) et quaucun texte ne se trouve actuellement dans le paramtre text du composant guiText. Pour cela, il suffit de crer une chane de caractres vide laide 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 procdure simple:
Vrifie si la variable textOn devient true. Quand cest le cas, elle:
Active le composant GUIText. Donne au paramtre text la valeur de la variable message de type string. Commence incrmenter la variable timer laide de la commande Time.deltaTime.
Contrle si la variable timer a atteint une valeur de 5secondes. Si cela est le cas, elle:
Dfinit la variable boolenne textOn false (la premire instruction if nest alors plus valide). Dsactive le composant GUIText. Rinitialise la variable timer 0.0.
Chapitre 5
151
Cliquez sur File> Save dans lditeur de script, puis revenez Unity. Slectionnez lobjet TextHint GUI dans le panneau Hierarchy, puis cliquez sur Component> Scripts> TextHints afin de lier le script que vous venez dcrire cet objet. Maintenant que vous disposez dun script qui contrle lobjet TextHint GUI, il vous reste dclencher son affichage en appelant les variables statiques quil contient. tant donn que le moment o les messages doivent apparatre dpend de la collision du personnage avec la porte, vous allez appeler ces variables statiques depuis le script PlayerCollisions. Pour cela, commencez par louvrir dans lditeur de script. Trouvez les dernires dclarations else if que vous avez ajoutes la fonction Update() (elles accompagnent les lignes qui dtectent la projection du rayon sur la porte), puis crivez les deux lignes suivantes:
TextHints.message = "le mcanisme 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 dfinit la valeur de la variable boolenne textOn du mme script true. Voici la dclaration complte 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 mcanisme de la porte semble manquer de puissance..."; TextHints.textOn = true; }
Comme vous avez activ le composant en dfinissant la variable textOn true, le script TextHints se charge du reste! Cliquez sur File> Save dans lditeur de script puis revenez Unity. Cliquez sur le bouton Play pour tester le jeu. Marchez jusqu la porte sans collecter les quatre piles ncessaires. Un indice textuel saffiche pendant cinq secondes lcran. Cliquez de nouveau sur Play pour arrter le test du jeu. Cliquez sur File> Save dans Unity pour sauvegarder votre travail. Pour finir, vous allez modifier la police de caractres du texte de lindice pour amliorer son apparence.
Utiliser les polices

Pour utiliser des polices dans un projet Unity, vous devez les importer comme ressources, comme pour tous les autres lments. Pour cela, vous pouvez simplement ajouter un fichier TTF (polices TrueType) ou OTF (polices OpenType) dans le dossier Assets depuis le Finder
152
(MacOS) ou lExplorateur (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, trs intressantes pour les travaux typographiques). Lutilisation des polices proposes sur certains sites web peut tre soumise conditions. Rendez-vous sur ce site et tlchargez une police dont vous aimez lapparence et qui soit lisible. Noubliez pas quelle servira donner des instructions au joueur: elle doit donc tre aisment lisible. Tlchargez la police Sugo si vous souhaitez avoir la mme que nous, dcompressez-la, puis appliquez les mthodes mentionnes plus tt pour ajouter le fichier Sugo.ttf comme ressource votre projet. Une fois cette ressource importe dans votre projet, localisez et slectionnez la police dans le panneau Project. Pour la rendre plus lisible, vous allez augmenter sa taille chaque fois quelle est utilise. la section True Type Font Importer du panneau Inspector, dfinissez une Font Size (taille de la police) de 24, puis cliquez sur le bouton Apply (voir Figure5.13). Si vous avez choisi une police diffrente, la taille adopter peut tre diffrente, mais noubliez pas que vous pouvez modifier le paramtre Font Size tout moment.
Figure5.13
Pour que lobjet TextHint GUI utilise cette police, slectionnez-le dans le panneau Hierarchy, puis choisissez la police dans le menu droulant situ droite du paramtre Font du composant GUIText dans le panneau Inspector. Vous pouvez galement faire glisser la police du panneau Project sur ce paramtre 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 saffiche lcran. Puis il disparat cinq secondes aprs que le personnage du joueur nentre plus en collision avec la porte, comme vous lavez dfini plus tt. Cliquez de nouveau sur le bouton Play pour arrter le test du jeu, puis cliquez sur File> Save pour sauvegarder vos modifications.
Chapitre 5
153
En rsum
Au long de ce chapitre, vous avez cr et rsolu un scnario de jeu. En prvoyant ce que le joueur sattend rencontrer dans le jeu que vous lui prsentez sans tenir compte de ce que vous savez des vnements pralables , vous pouvez dfinir au mieux la mthode adopter en tant que dveloppeur. Essayez de considrer chaque nouvel lment dans le jeu du point de vue du joueur. Pour cela, entranez-vous avec des jeux existants, pensez des situations du monde rel et, surtout, vitez tout a priori. Les jeux les plus intuitifs sont toujours ceux qui trouvent un quilibre entre les difficults des tches raliser et qui informent correctement le joueur sans le drouter. Il est crucial que les informations visuelles ou sonores destines au joueur soient appropries ; 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 scnario de jeu de base et vu comment construire et contrler les lments dune interface graphique, vous allez dcouvrir un scnario de jeu plus avanc. Au prochain chapitre, vous dcouvrirez deux concepts essentiels de plus : linstanciation et la physique des corps rigides.
6
Instanciation et corps rigides
Vous allez tudier deux concepts essentiels la conception dun jeu3D. Nous examinerons dans la premire moiti la notion dinstanciation le processus de cration dobjets au cours de lexcution du jeu. Puis vous la mettrez en pratique en utilisant la physique des corps rigides (Rigid Body dans Unity). Lorsque vous construisez diffrentes scnes de jeu, tous les objets ncessaires dans chacune delles ne doivent pas tre prsents au dbut du jeu. Cest vrai pour une grande varit de jeux, notamment les jeux de puzzle comme Tetris. Les pices de formes alatoires sont cres ou instancies en haut de lcran intervalles dfinis, car toutes ne peuvent pas y tre stockes indfiniment. Maintenant, prenons lexemple de votre jeu dexploration dune le. Au cours de ce chapitre, vous allez tudier la physique des corps rigides en crant une mthode qui permette au personnage du joueur de lancer des noix de coco. Or, les noix de coco ne doivent pas tre prsentes au chargement de la scne du jeu. Cest l que linstanciation entre en scne.
156
En spcifiant une ressource (gnralement un lment prfabriqu dun objet), sa position et sa rotation, vous pouvez crer des objets au cours de lexcution du jeu et donc crer une noix de coco chaque pression du joueur sur le bouton de tir. Afin de relier cette nouvelle partie au jeu tel quil se prsente actuellement, vous allez supprimer une des piles ncessaires pour entrer dans lavant-poste. Pour lobtenir, le joueur devra participer un jeu de massacre avec des noix de coco. partir du modle de noix de coco fourni, vous devrez crer un lment prfabriqu et contrler lanimation des cibles dans le jeu laide dun script en dtectant la collision des noix de coco avec les cibles. Comme les cibles fournies sont animes (lorsquelles sont "touches" puis "rinitialises"), vous allez galement dfinir laide dun script le temps qui scoulera entre le moment o la cible est renverse et celui o elle se reprend sa position initiale. Le joueur pourra gagner ce mini-jeu seulement si les trois cibles sont abaisses en mme temps, ce qui requiert de sa part une dose dhabilet supplmentaire. Au cours de ce chapitre, vous apprendrez :
prparer des lments prfabriqus pour linstanciation; utiliser la commande dinstanciation en pratique; vrifier une action du joueur en entre; utiliser les corps rigides pour quun objet soit rgi par le moteur physique; fournir des informations au joueur.
Prsentation de linstanciation
cette section, vous apprendrez comment reproduire et dupliquer des objets en cours de jeu. Ce concept est utilis dans de nombreux jeux pour crer des projectiles, des objets collecter, voire certains personnages comme les ennemis.
Le concept
Linstanciation est tout simplement une mthode de cration (ou de reproduction) dobjets pendant lexcution du jeu partir dun modle (un lment prfabriqu dans Unity). Ellesert galement pour dupliquer des objets de jeu dj prsents dans la scne. Linstanciation dun objet se droule gnralement de la faon suivante:
On cre lobjet instancier dans la scne, puis on lui ajoute les composants ncessaires.
Chapitre 6
157
On cre, dans le projet, un lment prfabriqu, sur lequel on fait glisser lobjet ralis auparavant. On supprime lobjet original de la scne afin de conserver uniquement la ressource prfabrique. On crit un script contenant la commande Instantiate() quon attache un objet de jeu actif. On dfinit ensuite llment prfabriqu comme lobjet cr par cette commande.
Le script
La commande Instantiate() compte trois paramtres et scrit de la faon suivante:
Instantiate (objet crer, position o le crer, rotation lui donner);
En comprenant comment dfinir ces trois paramtres, vous serez ensuite capable dutiliser la commande Instantiate() dans toutes les situations.
Passer un objet
Pour transmettre un objet, il suffit dindiquer le nom dune variable publique pour le premier paramtre de la commande Instantiate(). Quand une variable publique de type GameObject est cre au dbut dun script, vous pouvez ensuite, dans le panneau Inspector de Unity, faire glisser dessus un lment prfabriqu puis utiliser cette variable comme paramtre de lobjet, comme dans lextrait de code suivant:
var myPrefab: GameObject; Instantiate(myPrefab, position o le crer, rotation lui donner);
Vous pouvez galement vous assurer que seuls certains types dlments prfabriqus peuvent tre stocks dans la variable myPrefab en dfinissant un type de donnes plus prcis. Vous pourriez ainsi crire, par exemple:
var myPrefab: Rigidbody; Instantiate(myPrefab, position o le crer, rotation lui donner);
Ainsi, seuls les objets prfabriqus dots dun composant Rigidbody peuvent tre utiliss.
Position et rotation
La position et la rotation des objets crer doivent tre indiques 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
mais elles peuvent galement tre hrites dun autre objet en utilisant ses valeurs de position. Lorsque vous dfinissez la position dun objet instancier, vous devez tenir compte, dune part, de la position o il sera cr et, dautre part, sil doit ltre dans lespace local ou dans lespace global. Vous allez crer les lments prfabriqus de noix de coco, par exemple, un point dans le monde du jeu dfini par un objet de jeu vide, qui sera un enfant de lobjet reprsentant le personnage du joueur. Par consquent, on peut considrer quil sera cr dans lespace local un endroit diffrent chaque fois mais toujours une position relative identique par rapport lendroit o se tient le personnage du joueur et la direction vers laquelle il se tourne. Cette dcision vous permet de dcider o crire le code, autrement dit quel objet attacher le script. Si vous lattachez lobjet vide qui reprsente la position o les noix de coco doivent tre cres, vous pouvez simplement faire rfrence la variable transform.position laide de la syntaxe point pour indiquer la position de lobjet dans la commande Instantiate(). De cette manire, lobjet cr hrite de la position du composant Transform de lobjet vide, puisque cest sur celui-ci que le script est attach. Cette mthode peut galement servir pour la rotation de la nouvelle occurrence de lobjet afin quelle corresponde celle de lobjet parent vide. La commande Instantiate() se prsenterait alors de la faon suivante:
var myPrefab: GameObject; Instantiate(myPrefab, transform.position, transform.rotation);
Vous mettrez tout cela en pratique plus loin, mais nous allons dabord voir la physique des corps rigides et son importance dans les jeux.
Prsentation des corps rigides

Les moteurs physiques des jeux permettent de simuler le ralisme des lois physiques. Ils sont donc une caractristique commune presque tous les moteurs de jeux, nativement ou sous forme de plugin. Unity utilise PhysX de Nvidia, un moteur physique prcis et rcent que lon retrouve dans de nombreux jeux commerciaux. Le moteur physique permet non seulement que les objets ragissent aux lois physiques, comme le poids et la gravit, mais galement de tenir compte de manire raliste des effets de frictions, du couple mcanique et des impacts.
Chapitre 6
159
Les forces
On appelle force linfluence du moteur physique sur les objets. Ces forces peuvent tre appliques de diffrentes faons laide de composants ou de scripts. Pour tre soumis aux forces de la physique, un objet doit possder un corps rigide, autrement dit un composant Rigidbody.
Le composant Rigidbody
Pour quun objet puisse utiliser le moteur physique dans Unity, vous devez lui attribuer un composant Rigidbody. Cela indique simplement au moteur quil doit utiliser le moteur physique pour cet objet en particulier vous navez pas besoin de lappliquer toute une scne. Le moteur physique fonctionne tout simplement en arrire-plan. Aprs quun composant Rigidbody a t ajout un objet, ses paramtres saffichent dans le panneau Inspector de la mme manire que nimporte quel autre objet (voir Figure6.1).
Figure6.1
Les composants Rigidbody possdent des paramtres que vous pouvez ajuster ou contrler laide de scripts:
Mass. Le poids de lobjet en kilogrammes. Noubliez pas que le fait de dfinir la masse des diffrents corps rigides les conduit se comporter de manire raliste. Par exemple, si un objet lourd heurte un objet plus lger, celui-ci sera repouss plus loin. Drag. La rsistance de lair sur un objet en mouvement. Plus cette valeur est leve, plus le dplacement de lobjet dans les airs ralentira rapidement. Angular Drag. Ce paramtre est analogue au prcdent, mais il affecte simplement la vitesse de rotation. Il dfinit quel point lair agit sur lobjet pour ralentir sa rotation. Use Gravity. Comme son nom lindique, ce paramtre dtermine si le corps rigide sera affect par la gravit ou non. Lorsque cette option est dsactive, lobjet est toujours
160
soumis aux forces et aux impacts du moteur physique et ragit en consquence, mais comme sil se trouvait en apesanteur.
Is Kinematic. Cette option permet de disposer dun objet de corps rigide non soumis aux lois physiques. Vous pouvez lutiliser si vous souhaitez quun objet repousse un corps rigide soumis la gravit mais sans tre affect par le choc cest le cas, par exemple, des flippers qui repoussent la balle dun billard lectrique. Interpolate. Ce paramtre peut tre utilis si le mouvement des objets de corps rigide est saccad. Linterpolation et lextrapolation permettent de lisser le mouvement, soit en se basant sur limage prcdente, soit en prvoyant limage suivante. Freeze Rotation. Peut tre utilis pour verrouiller les objets afin que les forces appliques par le moteur physique ne les fassent pas pivoter. Cest particulirement utile pour les objets qui doivent utiliser la gravit mais ne pas basculer, comme les personnages de jeux.
Crer le mini-jeu
Pour mettre en pratique ce que vous venez dapprendre, vous allez crer un jeu de lancer de noix de coco qui permettra au joueur daccder lavant-poste. En rcompense, le joueur obtiendra la dernire pile ncessaire pour charger le mcanisme douverture de la porte. Vous avez dj dispos quatre piles dans le jeu, il vous suffit donc den enlever une de la scne de manire que le joueur nait accs qu trois dentre elles. Slectionnez un des objets battery dans le panneau Hierarchy, puis appuyez sur Cmd+Retour arrire (MacOS) ou Suppr (Windows) pour le supprimer.
Crer llment prfabriqu pour la noix de coco

Maintenant que vous connaissez les principes de linstanciation, vous allez commencer la conception du mini-jeu en crant le projectile, cest--dire la noix de coco. Cliquez sur Game Object> Create Other> Sphere.
Chapitre 6
161
Un objet sphrique (bas sur une forme primitive) est alors cr dans la scne. Il napparat pas directement au premier plan, mais vous pouvez facilement zoomer dessus. Pourcela, placez le curseur sur le panneau Scene puis appuyez sur la toucheF (pour focus). Slectionnez lobjet Sphere dans le panneau Hierarchy, appuyez sur Entre/F2 et renommezle Coconut. Vous allez modifier ses dimensions et sa forme pour quil ressemble davantage une noix de coco. Pour cela, vous rduirez sa taille et augmenterez lgrement la valeur sur laxeZ. Dans le composant Transform du panneau Inspector, donnez la valeur 0,5 aux paramtres ScaleX etZ de lobjet Coconut et la valeur0,6 au paramtreY. Les textures utiliser sur la noix de coco se trouvent dans larchive disponible sur la page web consacre cet ouvrage (www.pearson.fr). Cliquez sur Assets> Import Package, parcourez votre disque dur jusquau package CoconutGame.unitypackage, slectionnez-le puis cliquez sur Import. Le dossier Coconut Game qui saffiche dans le panneau Project contient les lments suivants:
une image pour la texture de la noix de coco; une texture en forme de cible; quatre squences audio; deux modles 3D, platform et target; un dossier Materials pour les modles3D.
Crer la texture de la noix de coco

Pour appliquer la texture de la noix de coco, vous avez besoin de crer un nouveau matriau lui appliquer. Cliquez sur le bouton Create dans le panneau Project, puis slectionnez Material dans le menu droulant. Appuyez sur Entre/F2 et nommez ce nouveau matriau Coconut Skin. Pour appliquer la texture ce matriel, faites simplement glisser la texture coconut du panneau Project sur le rectangle vide situ droite du paramtre Base (RGB) du matriau dans le panneau Inspector. Un aperu du matriau doit safficher dans la fentre au bas du panneau Inspector (voir Figure6.2).
162
Figure6.2
Cet aperu montre laspect du matriau sur une sphre. Il sagit de laspect par dfaut des prvisualisations de matriaux dans Unity; cela na rien voir avec le fait que vous utilisez ici un objet sphrique. Ensuite, vous devez appliquer le matriau Coconut Skin sur lobjet Coconut Game que vous avez plac dans la scne. Pour cela, il vous suffit de faire glisser le matriau du panneau Project sur le nom de lobjet dans le panneau Hierarchy ou sur lobjet luimme dans le panneau Scene.
Ajouter des comportements physiques

Comme lobjet de jeu Coconut doit avoir un comportement raliste, vous devez lui ajouter un composant pour quil utilise le moteur physique. Slectionnez cet objet dans le panneau Hierarchy puis cliquez sur Component> Physics> Rigidbody. Un composant Rigidbody est alors ajout lobjet pour grer la gravit. Par consquent, lorsque le joueur lancera lobjet vers lavant, celui-ci se rapprochera peu peu du sol comme dans le monde rel. Les paramtres par dfaut du composant Rigidbody peuvent tre conservs pour le moment.
Chapitre 6
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 lment prfabriqu

Maintenant que votre objet de jeu Coconut est termin, vous devez le stocker comme lment prfabriqu dans votre projet afin de pouvoir linstancier autant de fois que ncessaire laide dun script. Slectionnez le dossier Prefabs dans le panneau Project, puis cliquez sur le bouton Create et slectionnez Prefab. Nommez le nouvel lment prfabriqu Coconut Prefab. Faites glisser lobjet de jeu Coconut du panneau Hierarchy sur llment prfabriqu dans le panneau Project pour lenregistrer. Enfin, slectionnez lobjet original dans le panneau Hierarchy, puis appuyez sur Cmd+Retour arrire (MacOS) ou Suppr (Windows) pour le supprimer de la scne.
Crer lobjet Launcher

Pour permettre au joueur de lancer llment prfabriqu noix de coco que vous venez de crer, vous avez besoin dun script, pour grer linstanciation, et dun objet de jeu vide, pour dfinir la position de rfrence o seront crs les objets dans le monde du jeu. Dans le monde rel, lorsquon lance une balle la manire dun lanceur de base-ball, elle entre dans notre champ de vision sur le ct, au fur et mesure que notre bras se tend pour la librer. Par consquent, il faut positionner un objet juste lextrieur du champ de vision du joueur et sassurer quil conserve la mme position relative au personnage o que celui-ci regarde. Le point de vue du joueur est gr par lobjet Main Camera, qui est un enfant de lobjet First Person Controller. Par consquent, si vous crez un objet vide enfant de lobjet Main Camera, celui-ci suivra les mouvements de la camra, puisque sa position restera toujours la mme par rapport son parent. Cliquez sur GameObject> Create Empty pour crer un objet de jeu vide dans la scne. Slectionnez ce nouvel objet dans le panneau Hierarchy (il se nomme GameObject par dfaut) et renommez-le Launcher. Cliquez ensuite sur la flche grise gauche de lobjet First Person Controller dans le panneau Hierarchy pour afficher les lments qui le composent. Faites glisser lobjet Launcher sur lobjet Main Camera pour quil en devienne un enfant. Si lopration est correcte, une flche grise apparat devant le nom de lobjet Main Camera pour indiquer quil possde des objets enfants. Lobjet Launcher saffiche en retrait et en dessous (voir Figure6.3).
164
Figure6.3
Enfant de lobjet Main Camera, Launcher se dplace et tourne avec son parent. Mais il doit tre repositionn. Commencez par rinitialiser sa position dans le composant Transform du panneau Inspector. Pour cela, vous pouvez soit remplacer toutes les valeurs du paramtre Position par0, soit, et cela est plus rapide, cliquer sur le bouton en forme dengrenage et slectionner Reset Position dans le menu droulant (voir Figure6.4).
Figure6.4
ce Astu
Le bouton en forme dengrenage est disponible pour chaque composant dans le panneau INspECTOR et permet deffectuer rapidement certaines oprations. Vous pouvez galement lutiliser pour supprimer des composants dont vous navez plus besoin ou qui ont t ajouts par erreur.
Une fois la position de lobjet enfant Launcher rinitialise 0, celui-ci se place exactement au centre (position identique) de son parent. Bien sr, ce nest pas sa position dfinitive, mais cest un bon point de dpart. Vous ne devez pas le laisser dans cette position pour les deux raisons suivantes:
Les noix de coco lances sembleraient sortir de la tte du joueur, ce qui serait assez bizarre. Lorsque vous instanciez des objets, vous devez vous assurer quils sont crs une position o leur collider (composant de collision) nen croise pas un autre, car cela forcerait le moteur physique carter ces colliders, ce qui pourrait interrompre la force applique lors du lancer de la noix de coco.
Chapitre 6
165
Pour viter cela, vous avez simplement besoin de dplacer lobjet Launcher vers lavant et vers la droite de sa position actuelle. Donnez la valeur1 aux optionsX et Y du paramtre Position du composant Transform. Votre objet Launcher devrait maintenant tre plac lendroit o est cens se trouver le bras droit du personnage du joueur lorsquil lance un objet (voir Figure6.5).
Figure6.5
Enfin, pour que la trajectoire de la noix de coco aille vers le centre du champ de vision, vous devez faire pivoter lgrement lobjet Launcher sur laxeY. Dans le paramtre Rotation du composant Transform, donnez une valeur de 352 laxeY pour que lobjet pivote de 8degrs. Vous devez maintenant crire le script pour instancier la noix de coco et permettre au joueur de la lancer lorsquil appuie sur le bouton de tir.
Le script du lancer de noix de coco

Comme les noix de coco sont lances lorsque le joueur appuie sur le bouton de tir, vous devez vrifier, chaque image, sil appuie sur une touche lie une entre dans Unity. Les touches ainsi que les axes et les boutons de la souris sont lis par dfaut aux entres nommes dans le gestionnaire Input Manager de Unity, mais vous pouvez les modifier votre guise. Cliquez sur Edit> Project Settings> Input, cliquez sur la flche grise situe gauche de Axes, puis sur la flche grise avant Fire1. Les trois principaux paramtres observer ici sont Name, Positive et Alt Positive. Le script fera rfrence cet axe par son nom et coutera les paramtres Positive et Alt Positive, puisquil sagit des touches et des boutons eux-mmes. Vous pouvez ajouter de
166
nouveaux axes en augmentant simplement la valeur Size en haut du panneau Input Manager cela cre un axe que pouvez ensuite personnaliser.
Figure6.6
Pour que le joueur lance des noix de coco vers les cibles que vous disposerez dans la scne plus tard , le script doit implmenter deux tapes cls:
linstanciation de lobjet Coconut lancer lorsque le joueur presse le bouton de tir; lattribution dune vitesse au composant Rigidbody pour que la noix de coco soit propulse vers lavant ds quelle a t cre.
Pour cela, commencez par crer un nouveau fichier JavaScript de la faon suivante: 1. Slectionnez le dossier Scripts dans le panneau Project. 2. Cliquez sur le bouton Create et choisissez JavaScript dans le menu droulant. 3. Appuyez sur Entre/F2 et nommez le script CoconutThrow. 4. Double-cliquez sur licne du script pour louvrir dans lditeur de script.
Vrifier les actions du joueur en entre

Vous devez couter sur quelles touches le joueur appuie chaque image. Pour cela, vous avez besoin dcrire le code du lanceur lintrieur de la fonction Update(). Insrez quelques lignes avant laccolade de fermeture de cette fonction (}), puis ajoutez linstruction if suivante pour couter les pressions sur la touche Fire1:
Chapitre 6
167
if(Input.GetButtonUp("Fire1")){ }
Cette instruction vrifie la classe Input et attend que les boutons lis lentre Fire1 (la touche Ctrl gauche et le bouton gauche de la souris) soient relchs. Vous devez ensuite placer les actions excuter lorsque le joueur relche lun ou lautre bouton dans cette instruction if. Pour commencer, un son doit se faire entendre pour indiquer le lancement. Sil sagissait dun jeu de tir, on entendrait certainement la dtonation dune arme feu. Ici, vous utiliserez simplement un son de souffle pour reprsenter le lancement de la noix de coco.
Lancer la lecture du son

Une variable doit reprsenter la squence sonore jouer. Aussi, placez la variable publique suivante au dbut du script:
var throwSound: AudioClip;
Cette variable est publique ; vous pourrez donc lui assigner la squence audio dans le panneau Inspector aprs avoir crit ce script. Vous devez maintenant dfinir laction permettant de lire cette squence audio. Pour cela, ajoutez la ligne suivante aprs laccolade douverture de votre instruction if:
audio.PlayOneShot(throwSound);
Ainsi, la lecture du son se dclenchera lorsque le joueur relchera le bouton Fire1.
Instancier la noix de coco

Vous devez ensuite crer la noix de coco proprement dite dans linstruction if courante. tant donn que vous avez cr la noix de coco puis que vous lavez enregistre comme un lment prfabriqu, vous devez ajouter une autre variable publique afin dassigner par la suite cet lment prfabriqu une variable dans le panneau Inspector. Ajoutez la ligne suivante au dbut du script, sous la dclaration de la variable throwSound:
var coconutObject: Rigidbody;
Une variable publique du type de donnes Rigidbody est alors cre. Bien que la noix de coco soit stocke comme lment prfabriqu, son instanciation cre un objet de jeu possdant un composant Rigidbody sur la scne. Il est donc important dindiquer son type de donnes pour interdire quun objet dun type de donnes diffrent puisse tre attribu cette variable dans le panneau Inspector. De plus, en limitant strictement le type de donnes
168
Rigidbody, vous navez pas besoin de la commande GetComponent() pour slectionner au pralable le composant Rigidbody, vous pouvez crire un script qui communique direc tement avec lui. Insrez la ligne suivante sous la deuxime ligne de la condition if dans la fonction Update():
var newCoconut: Rigidbody = Instantiate(coconutObject, transform.position, transform.rotation);
Ici, le script dclare une variable locale newCoconut. Cette variable est prive puisquelle est dclare dans la fonction Update(), si bien quil est impossible dutiliser explicitement le prfixe private. Le script transmet la cration (linstanciation) dun nouveau Game Object et donc son type de donnes dans cette variable. Noubliez pas que les trois paramtres de la commande Instantiate() sont le nom de lobjet, sa position et sa rotation. Vous verrez que nous avons utilis la variable publique pour crer une occurrence de notre lment prfabriqu qui hrite des paramtres de position et de rotation de lobjet sur lequel ce script est attach, cest--dire lobjet Launcher.
Nommer les occurrences

Chaque fois que vous crez des objets lors de lexcution du jeu avec la commande Instantiate(), Unity nomme les nouvelles occurrences partir du nom de llment prfabriqu auquel il ajoute "(clone)". Comme il sagit dun nom assez peu pratique pour tre utilis dans le script vous y ferez rfrence plus tard lorsque vous dfinirez 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 rfrence la dernire occurrence cre de llment prfabriqu, pour dsigner le paramtre name de la variable.
Dfinir une vitesse

Bien que cette variable cre une occurrence de la noix de coco, le script nest pas encore termin, car vous devez galement lui assigner une vitesse. Sans ce paramtre, la noix de coco tomberait au sol sa cration. Pour vous permettre de grer la vitesse de la noix de coco que le joueur lance, crez une autre variable publique au dbut du script. Afin que la prcision soit correcte, cette variable sera de type oat et pourra prendre une valeur dcimale:
var throwForce: oat;
Chapitre 6
169
Maintenant, ajoutez la ligne suivante sous la commande Instantiate() dans la dclaration if:
newCoconut.rigidbody.velocity = transform.TransformDirection (Vector3(0,0, throwForce));
Le script fait ici rfrence la nouvelle instance de noix de coco par son nom de variable (newCoconut) puis il utilise la syntaxe point pour dsigner le composant Rigidbody et dfinir sa vitesse. La vitesse est fixe avec la commande transform.TransformDirection, qui cre une direction de lespace local lespace global. Vous devez procder ainsi car lobjet Launcher sera constamment en mouvement et jamais orient dans la mme direction. La direction de laxeZ de lespace global est toujours la mme. Lorsquon dfinit la vitesse dun objet, on peut alors prendre un axe local spcifique en lui attribuant une valeur de type Vector3. Cest pourquoi les paramtresX etY de la variable de type Vector3 ont ici une valeur de0. Sassurer de la prsence du composant Pour viter quune erreur se produise lorsque le script fait rfrence un composant qui ne serait pas attach un objet, vous pouvez vrifier si ce composant existe et ajoutez-le si ce nest pas le cas. Dans notre exemple, vous pourriez vrifier lexistence dune nouvelle occurrence newCoconut pour le composant Rigidbody de la faon suivante:
if(!newCoconut.rigidbody) { newCoconut.AddComponent(Rigidbody); }
Ainsi, si aucun composant Rigidbody nest attach loccurrence de la variable courante, le script lui ajoute un lment de ce type. Pour crire "il ny a pas de rigidbody", on place simplement un point dexclamation au dbut de la condition if une pratique courante dans les scripts. Comme llment prfabriqu que vous avez prpar possde un composant Rigidbody, vous navez pas besoin de le faire ici.
viter les collisions inutiles

Bien que vous ayez loign lobjet Launcher du collider du personnage du joueur (lobjet Collider Controller), nous vous conseillons de toujours inclure ce dernier morceau de script afin dviter dinstancier de nouvelles noix de coco qui risqueraient de croiser le collider du joueur.
170
Pour cela, vous pouvez utiliser la commande IgnoreCollision() de la classe Physics. Cette commande prend gnralement trois arguments:
IgnoreCollision(Collider A, Collider B, doit tre ignor ou pas);
Vous avez donc besoin dindiquer les deux colliders pour lesquels le moteur physique ne doit pas ragir et dfinir le troisime paramtre true. Ajoutez la ligne suivante sous la dernire ligne que vous avez crite:
Physics.IgnoreCollision(transform.root.collider, newCoconut.collider, true);
Le premier paramtre de cette commande, transform.root, dsigne le collider du personnage du joueur. Cette commande trouve tout simplement le premier objet parent de tous les objets sur lesquels lobjet Launcher est attach. Ici, cet objet est un enfant de lobjet Main Camera mais celui-ci ne possde pas de collider. La commande transform.root permet donc de trouver lobjet parent sur lequel la camra est attache, savoir First Person Controller. Le script transmet ensuite le nom de la variable newCoconut, qui reprsente la dernire occurrence cre de noix de coco. Pour ces deux paramtres, le script utilise la syntaxe point pour faire rfrence au composant Collider. Ici, vous aviez besoin de trouver lobjet parent de tous ces objets, mais vous pouvez utiliser la commande transform.parent si vous faites seulement rfrence au parent direct dun objet.
ce Astu
Inclure le composant Audio Source Enfin, comme le lancer de la noix de coco saccompagne dune squence audio, vous pouvez utiliser la commande @script afin que Unity intgre un composant Audio Source lorsque ce script est ajout un objet. Ajoutez la ligne suivante tout en bas du script, aprs la fermeture de la fonction Update():
Cliquez sur File> Save pour enregistrer votre script et revenez dans Unity.
Assigner le script et les variables

Assurez-vous que lobjet Launcher est toujours slectionn dans le panneau Hierarchy, puis cliquez sur Component> Scripts> Coconut Throw dans le menu principal. Unity
Chapitre 6
171
ajoute le script que vous venez dcrire en tant que composant, ainsi que le composant Audio Source requis. Les valeurs ou les ressources des variables publiques du script CoconutThrow doivent tre dfinies puisque vous ne lavez pas fait manuellement dans le script.
Figure6.7
Des ressources doivent tre attribues aux deux variables publiques ThrowSound et CoconutObject vous pouvez facilement les identifier car leur type de donnes dfini dans le script est indiqu. La troisime variable publique, bien que son type de donnes dfini dans le script soit indiqu, prend simplement la valeur par dfaut dans le format appropri: une valeur numrique de0. Cliquez sur la flche situe droite de None (Audio Clip) et slectionnez la squence audio throw sur la liste des ressources audio disponibles. Faites glisser lobjet CoconutPrefab du panneau Project sur le champ None (Rigidbody). Ainsi, cet lment prfabriqu est directement li cette variable, ce qui signifie que le script crera des instances de cet objet. Enfin, donnez une valeur de 25 la variable Throw Force. Gardez lesprit que le script ne change pas quand vous modifiez les valeurs dans le panneau Inspector; cela annule simplement les valeurs prcdemment dfinies dans le script. Noubliez pas non plus que ces variables publiques peuvent tre modifies sans que vous ayez besoin de recompiler ou de modifier le code source. Pour des raisons de commodit et de gain de temps, nous vous conseillons de prendre lhabitude dajuster les valeurs des variables publiques dans le panneau Inspector.
Figure6.8
172
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. Aprs avoir vrifi que tout fonctionne correctement, cliquez de nouveau sur le bouton Play pour arrter le test. Si ce nest pas le cas, vrifiez que votre script correspond au script complet suivant:
var throwSound: AudioClip; var coconutObject: Rigidbody; var throwForce: oat; 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 linstanciation
Cette mthode dinstanciation des objets est la mieux adapte au systme dlments prfabriqus de Unity, car elle permet de facilement crer un objet sur la scne et de le dupliquer lors de lexcution du jeu. Toutefois, la cration de nombreux clones dun objet possdant un corps rigide peut tre coteuse, car chacun de ces objets fait appel au moteur physique et interagit avec dautres objets dans le monde en3D, ce qui utilise des cycles CPU (sollicite la puissance du processeur). Imaginez que vous permettiez au joueur de crer une quantit infinie dobjets contrls par le moteur physique vous comprendrez alors que votre jeu puisse ralentir aprs un certain temps. Quand trop de cycles CPU et de mmoire sont utiliss, le nombre dimages par seconde diminue. Votre jeu auparavant fluide devient saccad, ce qui est videmment dsagrable pour le joueur et compromet lavenir commercial de votre cration. Pour viter quun trop grand nombre dobjets ralentissent le jeu, vous allez:
permettre au joueur de lancer des noix de coco seulement dans une zone dfinie de lunivers du jeu; crire un script qui supprime les noix de coco instancies dans le monde du jeu aprs un certain temps.
Chapitre 6
173
Si linstanciation se droulait sur une plus grande chelle (lors de la cration de balles de pistolet, par exemple), vous devriez alors ajouter galement un dlai avant que le joueur ne Up() puisse "recharger" larme. Ce nest pas ncessaire ici, puisque la commande GetButton empche le joueur de lancer un trop grand nombre de noix de coco la fois: il doit relcher la touche de tir avant quune noix de coco ne soit lance.
Activer le lancer de noix de coco

Pour ce premier point, vous allez utiliser une variable boolenne de commutation. Elle doit avoir une valeur true afin que le joueur puisse lancer des noix de coco. Ce sera le cas uniquement lorsque le personnage du joueur se tiendra dans une zone prcise de la plateforme (qui constituera le pas de tir pour le lancer des noix de coco). Indpendamment des considrations sur les performances, il est logique de limiter cette action, puisque cela naurait pas vraiment de sens si le joueur pouvait lancer au hasard des noix de coco dans tout le niveau. Double-cliquez sur licne du script CoconutThrow dans le panneau Project si vous lavez ferm ou revenez dans lditeur de script pour continuer lditer. Vous avez vu plus tt comment activer et dsactiver des scripts laide du paramtre dactivation dun composant. Dans ce cas prcis, vous pourriez galement utiliser la commande GetComponent(), slectionner ce script et le dsactiver lorsque vous ne voulez pas que le joueur puisse lancer des noix de coco. Cependant, et cest le cas pour tout ce qui concerne les scripts, il existe de nombreuses solutions un problme. Cest pourquoi vous allez voir ici de quelle faon employer des variables statiques pour communiquer entre diffrents scripts. Ajoutez la ligne suivante tout en haut du script CoconutThrow:
static var canThrow: boolean = false;
Ce prfixe static plac avant la variable est le moyen employ par JavaScript dans Unity pour crer une variable globale une valeur laquelle les autres scripts peuvent accder. Vous devez maintenant ajouter une autre condition linstruction 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 suffit dajouter deux esperluettes && avant laccolade de fermeture de linstruction if et dindiquer le nom de la variable statique, comme suit:
if(Input.GetButtonUp("Fire1") && canThrow){
Souvenez-vous qucrire tout simplement le nom de la variable est lquivalent abrg de:
if(Input.GetButtonUp("Fire1") && canThrow==true){
174
Vous avez dfini la variable canThrow false lorsque vous lavez dclare. Comme il sagit dune variable statique (ce nest donc pas une variable publique), vous avez besoin dajouter quelques lignes de script pour la dfinir true. Puisque le joueur doit se tenir un certain emplacement pour pouvoir lancer des noix de coco, la meilleure faon de procder consiste ici utiliser la dtection de collision afin de vrifier si le joueur est en contact avec un objet en particulier. Si cest le cas, cette variable statique est alors dfinie true. Ouvrez maintenant le script PlayerCollisions et recherchez la fonction OnControllerColliderHit() suivante place en commentaires:
/* function OnControllerColliderHit(hit: ControllerColliderHit){ if(hit.gameObject.tag == "outpostDoor" && doorIsOpen == false){ Door(doorOpenSound, true, "dooropen"); } } */
Supprimez les caractres /* et */ afin que cette fonction ne soit plus en commentaires et redevienne active. Supprimez ensuite la condition if, puisque vous nen avez plus besoin pour grer louverture et la fermeture de la porte. Il ne devrait plus rester que la fonction elle-mme, comme ceci:
function OnControllerColliderHit(hit: ControllerColliderHit){ }
Une partie du modle platform que vous avez tlcharg, appele 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 linstruction if else suivante dans la fonction:
if(hit.collider == GameObject.Find("mat").collider){ CoconutThrow.canThrow=true; }else{ CoconutThrow.canThrow=false; }
Ici, le script vrifie si le collider avec lequel le contact seffectue est gal au collider de lobjet de jeu qui porte le nom mat dans la scne (le signe de double galit est un oprateur de comparaison). Si cette condition est respecte, le script redfinit true la valeur de la variable statique canThrow dclare dans le script CoconutThrow laide de la syntaxe point, ce qui permet la commande Instantiate() du script CoconutThrow de fonctionner. Dans le cas contraire, le script sassure que cette variable est dfinie false, ce qui signifie
Chapitre 6
175
que le joueur ne pourra pas lancer de noix de coco sil ne se trouve pas sur le pas de tir de la plate-forme. Cliquez sur File> Save dans lditeur de script, puis revenez dans Unity.
Supprimer les noix de coco

Comme nous lavons expliqu plus tt, un nombre trop lev dobjets contrls par le moteur physique dans la scne peut srieusement affecter les performances du jeu. Par consquent, lorsquil nest pas utile de conserver les objets, comme cest le cas ici, vous pouvez crire un script pour les supprimer automatiquement aprs un certain temps. Slectionnez le dossier Scripts dans le panneau Project, cliquez sur le bouton Create etslectionnez JavaScript pour crer un script. Appuyez sur Entre/F2 et renommez ce script CoconutTidy. Double-cliquez ensuite sur son icne pour louvrir dans lditeur descript. Supprimez la fonction Update() par dfaut car vous nen avez pas besoin. Pour supprimer un objet dune scne, il suffit dutiliser la commande Destroy() dont le second paramtre permet de dfinir un dlai dattente. Ajoutez la fonction et la commande suivantes votre script:
function Start(){ Destroy(gameObject, 5); }
Avec la commande Start(), lappel la commande Destroy() seffectue ds lapparition de lobjet dans le monde du jeu, lorsquil est instanci par le joueur qui appuie sur le bouton de tir. La rfrence gameObject signifie simplement: "lobjet sur lequel ce script est attach". Le second paramtre, aprs la virgule, dfinit le dlai en secondes avant lexcution de la commande. Avec ce script, la noix de coco est supprime du monde du jeu cinq secondes aprs son lancement. Cliquez sur File > Save dans lditeur de script, puis revenez dans Unity. Jusqu prsent, vous avez attach tous vos scripts aux objets de la scne sur laquelle vous travaillez. Toutefois, vous avez fini de travailler sur llment prfabriqu Coconut et il nexiste plus de copies de noix de coco dans la scne. Il existe deux mthodes pour appliquer le script que vous venez dcrire llment prfabriqu. La manire la plus simple consiste slectionner llment prfabriqu Coconut dans le panneau Project puis cliquer sur Component> Scripts> CoconutTidy.
176
Mais vous pouvez galement procder en plusieurs tapes, en modifiant llment prfa briqu dans le panneau Scene de la manire suivante: 1. Faites glisser llment prfabriqu Coconut dans le panneau Scene ou dans le panneau Hierarchy. 2. Cliquez sur Component> Scripts> CoconutTidy, cliquez sur Add pour confirmer que lajout du composant mettra un terme la relation de lobjet llment prfa briqu parent. 3. Cliquez sur GameObject> Apply Changes to prefab pour rpercuter cette mise jour sur llment prfabriqu original. 4. Supprimez linstance de lobjet dans la scne laide du raccourci clavier Cmd+Retour arrire (MacOS) ou Suppr (Windows). Nous vous conseillons dutiliser la premire mthode, en une seule tape. Cependant, dans certains cas, il peut tre utile de placer un lment prfabriqu dans la scne et de le modifier avant dappliquer les modifications llment prfabriqu lui-mme. Par exemple, si vous travaillez sur un lment visuel, comme un systme de particules, vous aurez alors besoin de voir leffet de vos modifications ou des nouveaux composants sur cet objet. Il devient par consquent indispensable de placer un objet issu de llment prfabriqu dans la scne pour le modifier. Une fois le script attach llment prfabriqu, cliquez sur File> Save Project dans Unity pour sauvegarder votre travail.
Ajouter la plate-forme
Maintenant, vous tes prt implmenter les ressources du mini-jeu que vous avez tlcharges plus tt. Vous allez importer une plate-forme et trois cibles dans la scne. Vous dtecterez ensuite les collisions entre les noix de coco et les cibles et vrifierez si les trois cibles sont renverses la fois ce qui est lobjectif du mini-jeu laide dun script. Dans le panneau Project, ouvrez le dossier Coconut Game qui a t import lorsque vous avez tlcharg les ressources ncessaires ce chapitre. Slectionnez le modle3D platform pour afficher ses proprits dans le panneau Inspector.
Les paramtres dimportation

Avant de placer une plate-forme et les cibles dans la scne, assurez-vous que les dimensions de ces objets sont correctes et, en crant des colliders pour chaque partie des modles, que le joueur peut interagir avec eux.
Chapitre 6
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 loption Generate Colliders est active pour que Unity assigne un Mesh Collider (un composant de collision respectant le maillage de lobjet) chaque partie du modle. Ainsi, le personnage du joueur pourra marcher sur la plate-forme. Pour confirmer ces modifications, cliquez sur le bouton Apply au bas du panneau Inspector. Faites maintenant glisser le modle depuis le panneau Project dans le panneau Scene puis, avec loutil Transform, positionnez-le proximit de lavant-poste, afin que le joueur comprenne que les deux lments sont lis. Assurez-vous que le modle de plateforme touche le sol pour que le personnage du joueur puisse monter les marches situes lavant du modle (voir Figure6.9).
Figure6.9
Les cibles et les collisions des noix de coco Slectionnez le modle target dans le dossier Coconut Game du panneau Project afin dafficher les paramtres dimportation de ses diffrents composants dans le panneau Inspector. Dans le composant FBXImporter du panneau Inspector, activez loption Generate Colliders pour vous assurer que la cible bascule lorsquune partie du modle est touche souvenez-vous que, sans collider, les objets3D ne peuvent entrer en contact les uns avec les autres. Donnez galement la valeur1 au paramtre Scale Factor.
178
Dans le composant Animations, vous devez dfinir et nommer les images pour chaque tat de lanimation de ce modle, de la mme manire que vous lavez fait pour les animations de la porte de lavant-poste. Vous pourrez ensuite les appeler dans vos scripts lorsquune collision se produit entre une noix de coco et la bonne partie de la cible. Pour ajouter trois tats danimation (voir Figure6.10), cliquez sur licne plus (+) situe droite dans le tableau Animations, puis indiquez le nom des tats dans la colonne Name ainsi que la premire et la dernire image de chaque animation dans les colonnes Start etEnd.
Figure6.10
Une fois le tableau Animations complt, noubliez pas de cliquer sur le bouton Apply au bas du panneau pour confirmer tous les changements que vous avez apports aux paramtres de cette ressource.
Positionner les cibles

Pour placer les cibles facilement sur la plate-forme, vous allez les dfinir comme des enfants de lobjet platform dj prsent dans la scne. Pour cela, faites simplement glisser le modle target depuis le dossier Coconut Game du panneau Project sur lobjet parent platform dans le panneau Hierarchy.
Chapitre 6
179
Une bote de dialogue vous informe que lajout de cet objet enfant entranera la perte de sa connexion avec llment prfabriqu. Cliquez sur le bouton Continue. Ce message indique simplement que les modifications apportes aux composants attachs au modle dorigine dans le panneau Project les paramtres de script, par exemple ne sappliqueront plus cette copie dans la scne puisque le lien entre cette occurrence et la ressource originale ou llment prfabriqu est rompu. Une fois que la cible est un enfant de lobjet platform, tous les objets enfants de ce dernier saffichent dans le panneau Hierarchy, y compris celui que vous venez dajouter. Comme la cible se place par dfaut au centre de la plate-forme, modifiez les valeurs du composant Transform dans le panneau Inspector pour lui donner une position approprie. Placez-la (0,1.7,1.7).
Le script de dtection des noix de coco

Vous avez besoin de dtecter les collisions entre la cible du modle target (par opposition son support ou son socle), vous devez donc crire un script de dtection de collision sur cette partie du modle. Slectionnez le dossier Scripts dans le panneau Project, puis cliquez sur le bouton Create et slectionnez JavaScript dans le menu droulant. Renommez ce script CoconutCollision, puis double-cliquez sur son icne pour louvrir dans lditeur de script. Dclarer les variables Vous devez dabord dclarer cinq variables :
une variable publique GameObject pour stocker lobjet target lui-mme; une variable boolenne beenHit pour vrifier ltat de la cible; une variable prive virgule flottante timer pour dfinir un dlai avant la rinitialisation de la cible; une variable publique audio hitSound; une variable publique audio resetSound.
Pour cela, ajoutez les lignes suivantes au dbut du script:

var targetRoot: GameObject; private var beenHit: boolean = false; private var timer: oat = 0.0; var hitSound: AudioClip; var resetSound: AudioClip;
180
beenHit et timer sont des variables prives. Leurs valeurs sont uniquement utilises dans le script et nont pas besoin dtre dfinies dans le panneau Inspector. Le prfixe private permet de ne pas les y afficher, contrairement aux variables publiques.
La dtection de collision Insrez ensuite la fonction de dtection 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 diffrente des fonctions OnControllerColliderHit() et OnTriggerEnter() que vous avez dj rencontres. En effet, cette fonction gre les collisions ordinaires entre les colliders classiques ceux qui ne sont ni en mode Dclencheur, ni intgrs lobjet First Person Controller. Dans cette fonction, le paramtre 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 impliqus dans une collision. Par consquent, la condition if interroge simplement cette classe, afin de savoir si ce paramtre stocke un objet gameObject nomm coconut. Pour sassurer que la cible ne puisse pas tre frappe plusieurs reprises, linstruction if contient une condition supplmentaire qui vrifie si la variable beenHit est dfinie false, ce qui sera le cas au lancement du jeu. Lorsque cette collision se produit, beenHit prend la valeur true pour quil soit impossible de la dclencher accidentellement deux reprises. Cette fonction lance galement la lecture du fichier audio attribu la variable hitSound, puis lit ltat danimation nomm down de lobjet que vous attribuez par glisser-dposer la variable targetRoot. Vous assignerez lobjet parent target cette variable dans le panneau Inspector aprs avoir crit le script. Rinitialiser la cible Dans la fonction Update(), vous avez besoin dutiliser la variable beenHit pour que la variable timer lance un dcompte de trois secondes. Autrement dit, la variable timer
Chapitre 6
181
omptera jusqu3 partir de limage o la cible est touche avant de dclencher sa rinic tialisation. Pour cela, vous avez besoin de deux instructions if : une pour vrifier si la variable beenHit est true et incrmenter la valeur de la variable timer, lautre pour vrifier 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 premire instruction if attend que la variable beenHit ait la valeur true puis incrmente la variable timer laide du compteur Time.deltaTime. Ce compteur est indpendant du nombre dimages par seconde, si bien que le dcompte seffectue en temps rel. La seconde instruction if attend que la variable timer dpasse trois secondes puis lance la lecture du son assign la variable resetSound, lit ltat danimation du modle attribu la variable targetRoot et rinitialise les variables beenHit et timer leurs valeurs dorigine pour que la cible puisse tre atteinte de nouveau. Intgrer la source audio Des sons tant lus, vous avez besoin dajouter la commande RequireComponent habituelle au bas du script afin de vous assurer quune source audio est ajoute lobjet sur lequel ce script est attach. Placez la ligne suivante au bas du script aprs laccolade de fermeture de la fonction Update():
Cliquez sur File> Save dans lditeur de script et revenez dans Unity.
Assigner le script
Dans le panneau Hierarchy, cliquez sur la flche qui prcde le modle target que vous avez ajout lobjet platform afin de voir les lments qui le constituent. Affichez ensuite le contenu du groupe enfant target_pivot pour voir la cible et ses supports (voir Figure6.11).
182
Figure6.11
Dans cette figure, nous avons slectionn la cible elle-mme. Vous devez faire de mme pour vous assurer que le script que vous venez dcrire est affect cet objet et non lobjet parent target. Vous devez vrifier les collisions avec cet objet enfant; en effet, la collision ne doit pas se dclencher si le joueur lance une noix de coco sur les supports qui soutiennent la cible, par exemple. Une fois cet objet slectionn, cliquez sur Component> Scripts> CoconutCollision pour lui attacher le script que vous venez dcrire et un composant Audio Source. Faites ensuite glisser lobjet parent target du panneau Hierarchy sur la variable publique Target Root et les fichiers audio targetHit et targetReset du panneau Project sur les variables publiques adquates dans le panneau Inspector (voir Figure6.12).
Figure6.12
Cliquez sur File> Save Scene dans Unity pour sauvegarder vos progrs. Cliquez ensuite sur le bouton Play pour tester le jeu; marchez sur la plate-forme, en veillant vous placer
Chapitre 6
183
sur le pas de tir vous devriez maintenant tre en mesure de jeter des noix de coco et dabattre la cible. Cliquez de nouveau sur Play pour terminer le test. Pour complter le mini-jeu, vous allez ajouter trois cibles supplmentaires laide du systme dlments prfabriqus.
Crer des cibles supplmentaires

Pour crer dautres cibles, vous allez dupliquer la cible actuelle, aprs lavoir transforme en lment prfabriqu. Pour cela, slectionnez le dossier Prefabs dans le panneau Project, cliquez sur le bouton Create et choisissez Prefab, puis renommez ce nouvel lment prfabriqu Target Prefab. Faites ensuite glisser lobjet parent target du panneau Hierarchy sur cet lment prfabriqu pour lenregistrer. Le nom de lobjet parent target dans le panneau Hierarchy doit devenir bleu, pour i ndiquer quil est li un lment prfabriqu du projet. Slectionnez lobjet parent target dans le panneau Hierarchy puis appuyez sur Cmd/ Ctrl+D pour le dupliquer. La copie tant slectionne, rglez sa positionX 1,8 dans le composant Transform du panneau Inspector. Rptez cette duplication pour crer une troisime cible puis dfinissez sa positionX 1,8.
Gagner la partie
Pour terminer le mini-jeu le joueur doit obtenir la dernire pile dont il a besoin pour charger le mcanisme de la porte de lavant-poste. Vous devez crire un script qui vrifie si les trois cibles sont renverses la fois. Slectionnez le dossier Scripts dans le panneau Project puis cliquez sur le bouton Create pour crer un fichier JavaScript. Renommez ce script CoconutWin, puis double-cliquez sur son icne pour louvrir dans lditeur de script.
Dclarer les variables

Ajoutez les quatre variables suivantes au dbut du script:
static var targets: int = 0; private var haveWon: boolean = false; var win: AudioClip; var battery: GameObject;
184
La premire variable, targets, est un compteur qui stocke le nombre de cibles abattues. Cette valeur proviendra dune modification que vous apporterez au script CoconutCollision plus tard. La variable prive haveWon est ensuite dfinie true afin quil soit impossible de rejouer ce mini-jeu une fois le challenge remport. Les deux variables publiques suivantes stockent respectivement la squence audio lire en cas de victoire et llment prfabriqu battery. Cela permet ce script dinstancier ces lments lorsque le joueur abat les trois cibles.
Vrifier 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 dclaration if a deux conditions: elle garantit que la valeur de targets atteint la valeur3, autrement dit que toutes les cibles ont t abattues, et que la variable haveWon est false, ce qui signifie ce qui signifie que le joueur na pas encore remport ce challenge. Lorsque ces conditions sont remplies, les commandes suivantes sont excutes:
Le script rinitialise la variable targets 0 (ce qui est simplement un autre moyen de sassurer que linstruction if ne se dclenche pas de nouveau). La squence audio win est lue pour fournir un signal sonore au joueur. Une instance de lobjet que vous assignez la variable battery est instancie. Sa position Vector3 est dfinie en fonction des valeurs de position X et Z de la plate-forme (puisque ce script sera appliqu cet objet), en ajoutant2 la valeurY. La variable est dfinie true afin que le joueur ne puisse plus gagner de nouveau ce jeu et gnrer davantage de piles.
Enfin, comme vous allez utiliser du son, ajoutez la ligne suivante la dernire ligne du script:
Cliquez sur File> Save dans lditeur de script et revenez dans Unity.
Chapitre 6
185
Assigner le script
Slectionnez lobjet parent platform dans le panneau Hierarchy, puis cliquez sur Component> Scripts> Coconut Win. Pour finir, assignez llment prfabriqu battery situ dans le dossier Prefabs du panneau Project la variable publique battery et leffet sonore Win du dossier Coconut Game la variable publique Win. Le composant devrait tre identique la Figure6.13.
Figure6.13
Grer le nombre de cibles abattues

Enfin, pour que le jeu fonctionne, vous devez revenir au script CoconutCollision afin daugmenter de1 la valeur de la variable statique targets du script CoconutWin lorsque le joueur abat une cible, et diminuer de1 cette valeur lorsque les cibles se rinitialisent. Cest simple raliser, puisque le script qui gre ces deux vnements existe dj. Doublecliquez sur licne du script CoconutCollision dans le dossier Scripts pour louvrir dans lditeur de script. Augmenter la valeur Dans la fonction de dtection de collision OnCollisionEnter(), linstruction if contient une ligne dfinissant la variable beenHit true. Ajoutez la ligne:
CoconutWin.targets++;
sous la ligne:
beenHit=true;
Diminuer la valeur Comme la rinitialisation de la cible est gre 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
Dans les deux cas, vous passez par la syntaxe point pour accder au script CoconutWin (qui est, en fait, une classe) puis vous indiquez le nom de la variable, targets. Cliquez sur File> Save dans lditeur 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 instancie. Appuyez sur la barre despacement afin de sauter par-dessus la barrire 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 finale
Pour amliorer ce mini-jeu, vous allez ajouter un viseur qui saffichera lorsque le joueur se tiendra sur le pas de tir, puis vous utiliserez lobjet 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 lcran, procdez de la faon suivante: 1. Ouvrez le dossier Coconut Game dans le panneau Project. 2. Slectionnez le fichier de texture Crosshair. 3. Cliquez sur GameObject> Create Other> GUI Texture pour crer un objet GUI Texture du mme nom et aux mmes dimensions que le fichier de texture Crosshair. Cet objet est automatiquement slectionn dans le panneau Hierarchy, si bien que son composant GUI Texture saffiche dans le panneau Inspector. Limage en forme de rticule de vise doit tre visible dans le panneau Game et dans le panneau Scene lorsque loption Game Overlay est active. Comme elle est place au centre de lobjet par dfaut, cela fonctionne parfaitement avec ce fichier de texture de petite taille (6464). Lorsque nous avons cr le fichier de texture de cet exemple, nous avons veill ce que les contours du viseur soient bien contrasts afin quil soit parfaitement visible aussi bien sur un fond clair que sombre. Si vous crez un objet GUI TEXTURE sans slectionner de fichier de texture, il utilisera le logo de Unity. Vous devez alors changer cette image par votre texture dans le panneau INspECTOR et indiquer ses dimensions manuellement. Cest pourquoi il est prfrable de toujours choisir au pralable la texture utiliser pour lobjet GUI TEXTURE.
Info
Chapitre 6
187
Afficher le viseur GUI Texture Ouvrez le script PlayerCollisions situ dans le dossier Scripts du panneau Project. Vous constatez que la fonction OnControllerColliderHit() contient dj un script qui vrifie si le joueur se trouve sur le pas de tir. Le viseur ne doit tre visible que si le joueur sy trouve. Vous allez donc ajouter quelques lignes ces instructions if. Placez-vous avant linstruction 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 premire variable retrouve lobjet en forme de viseur laide de la commande Game Object.Find suivie du nom de lobjet, tandis que la seconde utilise la commande GetComponent() pour reprsenter la valeur prcdente de la variable dans le composant GUITexture. De cette manire, vous pouvez facilement activer et dsactiver le rticule de vise laide des instructions if et else. Ajoutez maintenant la ligne suivante dans linstruction if indique prcdemment:
crosshair.enabled = true;
Puis ajoutez la ligne suivante dans linstruction else qui laccompagne:

crosshair.enabled=false;
Informer le joueur
Vous allez utiliser lobjet TextHints GUI que vous avez cr au Chapitre5, "lments prfabriqus, collections et HUD", pour afficher un message lcran qui indiquera au joueur ce quil doit faire lorsquil se trouve sur le pas de tir. Ajoutez les lignes suivantes dans linstruction 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
Le script affiche lobjet TextHint GUI en dfinissant sa variable statique textOn true puis il envoie une chane de caractres sa variable statique message. La minuterie du script TextHints fera disparatre ce message lorsque le joueur quittera laire de lancement. Le script utilise galement la commande GameObject.Find pour sadresser lobjet TextHint GUI lui-mme et dfinir sa position sur laxeY 0,2. En effet, les messages de lobjet TextHint GUI apparaissent au centre de lcran, si bien quils chevaucheraient limage du viseur. Pour viter cela, la dernire des trois lignes de lextrait de code prcdent dcale le message vers le bas de lcran. Ajoutez maintenant le texte suivant dans linstruction else de la fonction OnController ColliderHit():
GameObject.Find("TextHint GUI").transform.position.y = 0.5;
Cela rinitialise simplement lobjet TextHint GUI sa position dorigine lorsque le joueur a termin le mini-jeu et quitte le pas de tir. La fonction OnControllerColliderHit() complte 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 lditeur de script pour sauvegarder vos modifications 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 apparatre. Quittez laire de lancement: le viseur doit disparatre immdiatement de lcran, 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
189
En rsum
Au cours de ce chapitre, nous avons abord divers sujets essentiels la cration dun scnario de jeu. Vous avez vu comment implmenter les objets corps rigides qui utilisent le moteur physique et vous avez tudi le concept de linstanciation, quil est trs important dapprendre matriser. En effet, linstanciation est un outil majeur pour le concepteur car elle permet de crer ou de cloner nimporte quelle ressource prfabrique ou nimporte quel objet de jeu lors de lexcution. Vous avez galement fourni au joueur des informations supplmentaires, en rutilisant lobjet TextHint GUI que vous aviez cr au Chapitre5. Vous avez vu comment envoyer ces informations cet objet dans le script. Vous continuerez vous servir de toutes ces notions au fil des pages de cet ouvrage et dans vos futurs projets. Au prochain chapitre, nous allons dlaisser provisoirement lcriture de script pour tudier les effets visuels de Unity. Vous dcouvrirez les systmes de particules visant crer un feu proximit de lavant-poste, afin de donner au joueur une rcompense visuelle aprs quil a gagn le mini-jeu et ouvert la porte.
7
Systmes de particules
Ce chapitre aborde certains effets de rendu que les dveloppeurs peuvent employer dans Unity. Pour crer des mondes 3D plus dynamiques, outre les matriaux et les textures simples, on peut utiliser des effets pour reproduire les caractristiques du monde rel, souvent en les exagrant. De nombreux jeux3D ont ainsi adopt les conventions visuelles du cinma, comme les effets de reflet sur lobjectif ou les tranes de lumire que lil humain ne peroit pas dans la ralit. Vous avez dj vu leffet de reflet du soleil sur lobjectif au Chapitre2, "Environnements", avec lecomposant Light de lobjet Directional Light. Ici, vous allez dcouvrir comment obtenir des effets plus polyvalents avec les systmes de particules dans le monde3D. Les jeux utilisent les effets de particules pour de nombreux effets, du brouillard la fume en passant par les tincelles et les lasers. Vous verrez aux sections suivantes comment simuler leffet dun feu grce deux systmes de particules. Au cours de ce chapitre, vous apprendrez:
de quoi est constitu un systme de particules ses composants et ses paramtres; comment crer des systmes de particules pour simuler le feu et la fume;
192
afficher de nouveau des instructions et des informations lcran pour le joueur; utiliser des variables pour activer les systmes de particules au cours de lexcution du jeu.
Quest-ce quun systme de particules?

Dans Unity, un systme de particules est plus quun composant. En effet, un certain nombre dlments doivent tre combins pour que leffet escompt fonctionne correctement. Avant de commencer travailler avec les systmes de particules, vous devez connatre leurs diffrents composants et comprendre leurs rles respectifs.
Lmetteur de particules
Dans tout systme de particules, le composant metteur est charg de linstanciation des particules individuelles. Unity dispose dun composant Ellipsoid Particle Emitter et dun composant Mesh Particle Emitter. Le composant Ellipsoid Particle Emitter sutilise gnralement pour les effets de fume, la poussire et les autres lments de lenvironnement qui peuvent tre crs dans un espace ferm. Il est dit ellipsode car il cre des particules lintrieur dune sphre pouvant tre tire. Le composant Mesh Particle Emitter cre des particules lies directement un maillage3D et qui peuvent tre soit animes le long des sommets du maillage soit mises sur les points du maillage. Il sert principalement lorsquon doit contrler directement la position dune particule. Le dveloppeur, en ayant la possibilit de suivre les sommets dun maillage, peut ainsi concevoir des systmes de particules extrmement prcis et de nimporte quelle forme3D. En tant que composants, les deux metteurs disposent des paramtres communs suivants:
Size. La taille visible dune particule. Energy. La dure de vie dune particule dans le monde avant son autodestruction. Emission. Le nombre de particules mises la fois. Velocity. La vitesse laquelle les particules se dplacent.
Nous examinerons quelques-uns des rglages spcifiques de chaque type dmetteur. Pour crer un feu, vous choisirez Ellipsoid Particle Emitter qui permet dobtenir un effet plus alatoire car il nest pas li un maillage.
Chapitre 7
193
Figure 7.1
Lanimateur de particule
Le composant Particle Animator rgit le comportement de chaque particule dans le temps. Pour sembler dynamiques, les particules ont une dure de vie dfinie puis elles sautodtruisent. Dans lexemple dun feu, lidal serait que chaque particule soit anime et change dapparence au cours de sa vie dans le monde. Pour reproduire les variations de couleurs dun feu dans le monde rel, ce composant est intressant pour faire varier la couleur et la visibilit et pour appliquer des forces aux particules elles-mmes.
Figure 7.2
Le rendu des particules

Le composant Particle Renderer dfinit laspect visuel de chaque particule. Les particules sont, en fait, des images carres en2D (des sprites). Leur rendu seffectue gnralement de la mme manire que celui de lherbe que vous avez ajoute au terrain au Chapitre2: la
194
technique du billboarding est applique afin que les particules semblent toujours faire face la camra. Dans Unity, le composant Particle Renderer peut afficher les particules diffremment, mais le billboarding est la mthode la mieux approprie dans la plupart des cas. Le composant Particle Renderer gre galement les matriaux appliqus au systme de particules. Ces dernires tant rendues comme de simples sprites, si vous appliquez des shaders de particules aux matriaux dans le composant, vous pouvez crer lillusion que les sprites ne sont pas carrs en plaant tout autour des textures sur une couche alpha (transparente). La Figure7.3 illustre cette mthode que vous allez bientt utiliser sur le matriau feu (la zone sombre de limage reprsente les zones transparentes).
Figure7.3
Grce la transparence, les particules nont plus laspect carr que le rendu donne habituellement aux sprites2D. En combinant le rendu de la partie visible de cette texture avec des valeurs dmission plus leves, vous pouvez obtenir un effet de densit. Les moteurs de rendu des particules peuvent aussi animer celles-ci avec lanimation UV de textures plusieurs images sont alors utilises pour modifier les textures dune particule au cours de sa dure de vie. Mais comme cette technique dpasse la porte de ce livre, nous vous conseillons de vous reporter au manuel de Unity plus en savoir plus ce sujet.
En rsum
Un systme de particules fonctionne grce la collaboration de ses composants: lmetteur, qui cre les particules ; lanimateur, qui rgit leur comportement et leur volution
Chapitre 7
195
dans le temps; et le moteur de rendu, qui dfinit leur aspect visuel en utilisant diffrents matriaux et paramtres daffichage. Vous allez maintenant voir comment crer un lment indit dans votre jeu: un feu compos de deux systmes de particules, un pour les flammes et un autre pour le panache de fume.
Le but du jeu
Pour linstant, votre jeu consiste collecter quatre piles pour entrer dans lavant-poste. Depuis le chapitre prcdent, une de ces piles sobtient en abattant les trois cibles avec des noix de coco. Une fois dans lavant-poste, le joueur risque dtre assez du, car le btiment est vide. Vous allez donc ajouter une bote dallumettes au centre de la pice. Vous crerez galement un feu proximit de lavant-poste qui pourra sallumer uniquement si le joueur possde cette bote dallumettes. En voyant le tas de bois attendant de prendre feu, le joueur sera incit trouver les allumettes et donc remplir les tches dfinies (cest--dire, ouvrir la porte). Pour crer ce jeu, vous devez:
installer un paquet de ressources, puis ajouter un modle de feu de bois la scne prs de lavant-poste; crer des systmes de particules pour les flammes et la fume lorsque le feu est allum, puis empcher quils se dclenchent trop tt laide dun script; utiliser la dtection de collision entre le personnage du joueur et lobjet feu de bois de faon que lallumage du feu dclenche le composant metteur; ajouter le modle dallumettes dans lavant-poste et mettre en place une dtection de collision pour que le joueur puisse les collecter et soit ensuite capable dallumer le feu; utiliser lobjet TextHint GUI pour donner des indications au joueur lorsquil sapproche du feu sans possder les allumettes.
Tlcharger les ressources

Pour obtenir les ressources ncessaires la ralisation de cet exercice, recherchez le fichier nomm firePack.unitypackage extrait de larchive fournie. Cliquez ensuite dans Unity sur Assets> Import Package, puis parcourez votre disque dur jusquau dossier o vous avez extrait ce paquet de ressources et slectionnez-le. Les fichiers suivants requis pour crer cette partie du jeu sont alors imports:
un modle 3D dun feu de camp;
196
une texture de flamme pour le systme de particules du feu; une texture de fume pour le systme de particules de la fume; une squence sonore de feu qui crpite; un dossier Material contenant les modles3D.
Tous ces fichiers sont regroups dans le dossier Fire feature du panneau Project.
Ajouter le tas de bois

Slectionnez le modle campfire dans le dossier Fire feature du panneau Project, puis donnez la valeur 0,5 au paramtre Scale Factor dans le composant FBXImporter du panneau Inspector si elle nest pas dj dfinie. Vous garantissez ainsi que le modle est import dans la scne une taille raisonnable par rapport aux autres objets dj prsents. Cliquez sur le bouton Apply au bas du panneau Inspector pour valider. Faites glisser ce modle dans le panneau Scene, puis avec loutil Transform placez-le prs de lavant-poste et de la plate-forme de lancer des noix de coco dj prsents (voir figure7.4).
Figure7.4
Ce modle doit disposer dun collider (composant de collision) afin que le joueur ne puisse pas passer au travers. Pour des modles aussi complexes, on utilise habituellement le composant FBX Importer pour crer des Mesh Colliders (composants de collision respectant le maillage de lobjet) sur chaque maillage du modle. Toutefois, tant donn
Chapitre 7
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 dconomiser la puissance de calcul car le processeur naura pas construire un collider sur chaque partie du modle. Slectionnez lobjet feu campfire dans le panneau Hierarchy, puis cliquez sur Component> Physics> Capsule Collider. La bote de dialogue Losing Prefab saffiche alors et vous demande de confirmer la suppression de la connexion entre ce modle et loriginal. Cliquez sur le bouton Add comme dhabitude. Un petit collider sphrique apparat alors la base du modle de feu. Vous devez augmenter sa taille afin quil recouvre tout le modle. Dans le nouveau composant Capsule Collider du panneau Inspector, donnez la valeur2 au paramtre Radius et la valeur5 au paramtre Height. Affichez ensuite les valeurs du paramtre Center puis donnez la valeur1,5 Y (voir Figure7.5). Testez le jeu pour vrifier que le joueur est bloqu par lobjet.
Figure7.5
Crer les systmes de particules pour le feu

cette section, vous allez crer deux systmes de particules diffrents, un pour le feu et lautre pour sa fume. En utilisant deux systmes distincts, vous contrlerez mieux lanimation des particules dans le temps car vous pourrez animer les flammes et la fume indpendamment.
198
Crer le feu
Pour commencer construire le systme de particules du feu, vous allez ajouter un objet de jeu possdant les trois composants essentiels pour les particules. Pour cela, cliquez sur GameObject> Create Other> Particle System. Un nouvel objet de jeu Particle System apparat alors dans les panneaux Scene et Hierarchy. Appuyez sur Entre/F2 et renommez-le FireSystem, en vous assurant que le nom ne contient pas despace: cest essentiel pour le script que vous allez crer ensuite. Vous navez pas besoin de positionner le feu avant davoir termin sa cration. Vous pouvez tout fait continuer sa conception l o Unity la plac de faon alatoire dans le monde3D. Par dfaut, les particules prennent lapparence de petits points blancs aux contours flous et ressemblent un peu un nuage de lucioles. Il sagit tout simplement des paramtres les plus gnriques de chaque composant. Pour le moment, lmetteur de particules gnre le plus petit nombre possible de particules, lanimateur rgit lapparition et la disparition progressive des particules, et le moteur de rendu nutilise aucun matriau. Vous allez maintenant dfinir chaque composant individuellement. Lorsque vous rglez les paramtres dans le panneau Inspector, vous pouvez visualiser un aperu du systme de particules dans le panneau Scene. Les paramtres du composant Ellipsoid Particle Emitter Commencez par dfinir la valeur de Min Size 0,5 et celle de Max Size 2. La taille des flammes augmente alors considrablement par rapport aux paramtres par dfaut. Comme avec tous les paramtres Min et Max, la taille des particules cres par lmetteur varie entre ces deux valeurs. Donnez maintenant la valeur1 au paramtre Min Energy et la valeur1,5 au paramtre Max Energy. Ces paramtres dfinissent la dure de vie des particules: elles sautodtruiront entre une seconde et une seconde et demie aprs leur cration. Donnez les valeurs15 au paramtre Min Emission et 20 au paramtre Max Emission pour dfinir le nombre de particules prsentes dans la scne tout moment. Plus ces valeurs sont leves et plus les particules seront nombreuses lcran, rendant ainsi le feu plus dense. Cependant, comme le cot pour le processeur peut tre important, il est prfrable en gnral de conserver des valeurs aussi faibles que possible pour ces paramtres, partir du moment o le rsultat visuel est acceptable. Dfinissez la valeur Y du paramtre World Velocity 0,1 pour que les particules slvent au cours de leur dure de vie, comme le font les flammes. Ce paramtre sert pour les objets qui doivent toujours slever dans le monde du jeu. Si vous utilisiez le paramtre
Chapitre 7
199
Local Velocity sur un objet pouvant tre dplac et si celui-ci pivotait au cours du jeu, son axeY local ne correspondrait alors plus laxeY global. Un baril enflamm rgi par le moteur physique, par exemple, peut tomber, voire rouler au sol. Pourtant, les flammes doivent toujours slever dun point de vue global. Bien que le feu de camp ne puisse pas tre dplac, vous devez comprendre la diffrence entre espace local et espace global dans ce cas prcis. Dfinissez ensuite la valeur Y de Rnd Velocity (Random, pour alatoire) 0,2 pour que des flammes slvent un peu plus haut que les autres, de temps autre et de faon alatoire. Fixez le paramtre Tangent Velocity 0,2 sur les axesX etZ, en laissant laxeY 0. Ce paramtre dfinit la vitesse originale de chaque particule. Avec une valeur faible surX etZ, vous acclrez donc la vitesse des flammes sur le plan horizontal. Le paramtre Emitter Velocity Scale sert uniquement contrler la vitesse laquelle les particules se dplacent lorsque lobjet parent du systme de particules est en mouvement. Ilpeut donc tre dfini 0 ici, puisque la position de ce feu ne changera pas. Le paramtre Simulate in Worldspace sera dsactiv, puisque les particules doivent tre cres en fonction de la position du systme et non selon une position dans lespace global. Le paramtre One Shot peut lui aussi rester dsactiv, car lmission des particules doit tre continue. Ce paramtre serait plus utile pour reprsenter la fume sortant dun canon, par exemple. Toutes les valeurs du paramtre Ellipsoid peuvent tre dfinies 0,1. Cette valeur est faible, mais lchelle du systme de particules est galement rduite cette valeur devra, par exemple, tre beaucoup plus leve pour le systme de particules du panache de fume. Les paramtres du composant Particle Animator prsent, vous devez dfinir les paramtres du composant Particle Animator, qui rgit 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 laide de couleurs (tons de rouge et dorange) et vous leur appliquerez des forces pour que les flammes aient un comportement plus raliste. Commencez par vous assurer que le paramtre Does Animate Color est activ, afin que les cinq paramtres Color Animation jouent un rle. Cliquez ensuite sur chacun des champs de couleur situs droite. Dans la bote de dialogue Color qui saffiche, slectionnez la couleur blanche pour Color Animation[0], une couleur orange fonc pour Color Animation[4] et des teintes intermdiaires pour les paramtres restants.
200
Modifiez galement la valeur A (alpha) de chaque couleur au bas du slecteur de couleurs Color afin que les paramtres Color Animation[0] et Color Animation[4] aient une valeur alpha de0, et que les tats intermdiaires forment un fondu. La ligne blanche et noire sous chaque bloc de couleur dans le panneau Inspector reprsente la valeur alpha. Vous pouvez utiliser la Figure7.6 comme modle pour vos couleurs.
Figure7.6
Le systme de particules dans le panneau Scene doit prsent se comporter de faon plus naturelle grce aux couleurs et aux valeurs alpha que vous avez dfinies. Leffet du systme Color Animation peut tre plus ou moins visible selon les shaders spcifiques que les matriaux appliqus au systme de particules utilisent, car certains shaders rvlent un peu plus de couleur que dautres. Ceux avec de la transparence, par exemple, peuvent montrer les couleurs de manire moins efficace.
Info
Conservez toutes les valeurs par dfaut de 0 sur tous les axes des paramtres World Rotation Axis et Local Rotation Axis, puis donnez la valeur0,3 au paramtre Size Grow. Avec une valeur ngative, les particules diminuent de taille au cours de leur dure de vie, ce qui donne un aspect plus dynamique au feu. Vous allez maintenant ajouter des forces pour rendre le mouvement du feu plus raliste. Elles sont diffrentes des vitesses ajoutes dans le paramtre Emitter, car elles sont appliques lors de linstanciation ce qui entrane une acclration puis une dclration des particules. Cliquez sur la flche grise situe gauche du paramtre Rnd Force pour afficher ses options, puis donnez la valeur1 aux axesX etZ. Affichez ensuite les options du paramtre Force de la mme manire et entrez la valeur1 pour laxeY. Dfinissez la valeur du paramtre Damping 0,8. Le damping (amortissement) dfinit le ralentissement des particules au cours de leur dure de vie. La valeur par dfaut,1, nentrane aucun amortissement et les valeurs comprises entre0 et1 provoquent un ralentissement (0causant le ralentissement le plus important). On utilise ici une valeur de 0,8 afin que les particules ne ralentissent pas de manire trop artificielle.
Chapitre 7
201
Vous pouvez laisser le dernier paramtre Autodestruct dsactiv. Toutes les particules sautodtruisent naturellement la fin de leur dure de vie, mais ce paramtre porte sur lobjet de jeu parent lui-mme. Sil est activ, toutes les particules sautodtruisent, puis lobjet de jeu est dtruit. On lutilise seulement lorsque le paramtre One Shot est activ dans le composant metteur. Pour un coup de canon, par exemple, lobjet de jeu serait dtruit ds que toutes les particules se seraient autodtruites, ce qui conomiserait les ressources du CPU, du GPU et de la RAM. Les paramtres du composant Particle Renderer Pour le systme de particules du feu, vous avez simplement besoin dappliquer un matriau de type particle-shaded contenant limage du feu que vous avez tlcharge et importe. Mais avant cela, assurez-vous que le rendu des particules est correctement configur. Comme les particules ou les flammes doivent techniquement mettre de la lumire, vous allez dsactiver les paramtres Cast Shadows et Receive Shadows afin quaucune ombre ne soit projete 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 contrle des ombres dynamiques). Actuellement, aucun matriau nest appliqu ce systme de particules, si bien que le paramtre Materials est vide (vous allez y remdier trs bientt). Assurez-vous que le paramtre Camera Velocity Scale a une valeur de0 ce paramtre sutilise uniquement lorsque le rendu des particules seffectue avec une autre technique que le billboarding (toujours face lcran). Si vous aviez prvu de dformer les particules en fonction de langle de vue, vous devriez utiliser ce paramtre pour dfinir linfluence du mouvement de la camra sur ltirement des particules. Le paramtre Stretch Particles doit tre dfini sur Billboard pour garantir que les particules seront cres face au joueur, quel que soit langle partir duquel celui-ci observe le feu. Comme les paramtres Length Scale et Velocity Scale sutilisent uniquement avec les particules tires en fonction de langle de vue, vous pouvez conserver leurs valeurs 0, les modifier naurait aucune influence sur le rendu des particules par la technique du billboarding. Max Particle Size est le dernier paramtre considrer, puisque nous nutilisons pas les options UV Animation. Ce paramtre contrle la taille quune particule peut avoir par rapport la hauteur de lcran. Si sa valeur est de1, par exemple, la taille des particules peut tre gale la hauteur de lcran; si elle est de0,5, leur taille maximale est gale la moiti de la hauteur de lcran, et ainsi de suite. Les particules de ce feu nauront jamais besoin dune taille aussi importante que la hauteur de lcran, vous pouvez donc conserver la valeur par dfaut de 0,25 pour ce paramtre.
202
Ajouter un matriau Maintenant que le systme de particules est dfini, il ne vous reste plus qu crer un matriau qui utilise la texture de feu. Slectionnez le dossier Fire feature dans le panneau Project, cliquez sur le bouton Create en haut du panneau et choisissez Material pour crer une nouvelle ressource New Material dans le dossier. Renommez-la ensuite simplement Flame, puis slectionnez-la pour afficher ses proprits dans le panneau Inspector. Ouvrez le menu droulant Shader et choisissez Particles> Additive (soft) pour obtenir une particule base sur la couche alpha avec un rendu de la texture que vous appliquez. Faites glisser la texture appele Fire1 du dossier Fire feature dans le panneau Project, sur la place vide la droite du paramtre Particle Texture qui indique pour linstant None (Texture2D). Pour appliquer ce matriau, faites-le simplement glisser du dossier Fire feature dans le panneau Project sur lobjet FireSystem dans le panneau Hierarchy. Positionner lobjet FireSystem Afin de placer le systme de particules du feu plus facilement, vous devez crer un objet enfant de lobjet campfire dj prsent dans la scne. Dans le panneau Hierarchy, faites glisser lobjet FireSystem sur lobjet campfire pour le premier devienne lenfant du second. Rinitialisez ensuite sa position en cliquant sur licne en forme dengrenage situe droite du composant Transform de lobjet FireSystem et choisissez Reset.
Figure 7.7
Le fait de rinitialiser sa position place le systme 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, slectionnez lobjet dans le panneau Hierarchy, placez le curseur sur le panneau Scene et appuyez sur la toucheF pour centrer la vue sur cet objet. Toujours dans le composant Transform, dfinissez une valeur de0,8 sur laxeY pour dcaler lgrement le systme de particules vers le haut.
Chapitre 7
203
Il est temps de tester! Cliquez sur le bouton Play pour tester le jeu et admirez votre travail! Noubliez pas de cliquer de nouveau sur Play pour mettre un terme au test avant de passer la section suivante.
Crer la fume
Comme le dit ladage, "Il ny a pas de fume sans feu" et vice versa. Cest pourquoi vous avez besoin quun panache de fume schappe du sommet de votre feu de camp pour le rendre plus raliste. Pour commencer, cliquez sur GameObject> Create Other> Particle System pour ajouter un systme de particules la scne. Renommez-le SmokeSystem dans le panneau Hierarchy (encore une fois, vous ne devez pas utiliser despace dans le nom de lobjet). Les paramtres du composant Ellipsoid Particle Emitter Nous avons dj tudi les diffrents paramtres lors de lexercice prcdent, aussi vous pouvez utiliser la liste suivante et observez les modifications que vous apportez au fur et mesure. Tous les paramtres qui ne figurent pas sur cette liste doivent conserver leur valeur par dfaut:
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 paramtres du composant Particle Animator Configurez le composant Particle Animator pour que lanimation des particules seffectue sur des nuances de gris (voir Figure7.8).
204
Figure7.8
Encore une fois, les particules doivent tre animes entre deux valeurs alpha gales 0 afin quelles apparaissent et disparaissent de faon moins abrupte et plus naturelle. Modifiez ensuite les paramtres suivants:
Size Grow: 0,2; Rnd Force: (1.2, 0.8, 1.2); Force: (0.1, 0, 0.1); Autodestruct: non slectionn.
Les paramtres du composant Particle Renderer Avant de crer un matriau et de lappliquer la fume, vrifiez que les paramtres suivants sont appliqus au composant Particle Renderer:
Cast/Receive Shadows: dslectionns 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 lexercice "Ajouter un matriau" la section "Crer le feu" de ce chapitre. Cette fois, en revanche, nommez le matriau Smoke, assignez-lui la texture smoke1 et faites-le glisser sur lobjet de jeu SmokeSystem. Positionnement Rptez ltape de positionnement du feu pour la fume. Faites glisser lobjet SmokeSystem sur lobjet parent campfire dans le panneau Hierarchy. Cliquez ensuite sur licne en forme dengrenage dans le panneau Inspector et choisissez Reset, puis redfinissez la valeur de la positionY 0,9. Cliquez sur le bouton Play. Le feu devrait maintenant sallumer et le panache de fume slever dans le ciel (voir Figure 7.9). Comme toujours, noubliez pas de cliquer de nouveau sur Play pour arrter le test.
Chapitre 7
205
Figure7.9
Ajouter du son au feu de camp

Maintenant que laspect visuel du feu est correct, vous devez ajouter un son qui reproduise latmosphre du crpitement du feu. Le fichier audio fire_atmosphere fourni dans le paquet de ressources que vous avez tlcharg est une squence audio mono, conue pour tre lue en boucle. Ce fichier tant monophonique, le volume sonore diminue lorsque le joueur sloigne du feu de camp, ce qui semble logique. Slectionnez lobjet campfire dans le panneau Hierarchy, puis cliquez sur Component> Audio> Audio Source pour ajouter un composant audio source lobjet. Faites ensuite simplement glisser la squence audio fire_atmosphere depuis le dossier Fire feature du panneau Project sur le paramtre Audio Source dans le panneau Inspector. Pour finir, activez loption Loop. Cliquez sur le bouton Play et approchez-vous du feu de camp en coutant le crpitement des flammes. loignez-vous ensuite pour entendre le son dcrotre peu peu.
206
Allumer le feu
Maintenant que la conception du feu est termine, vous allez dsactiver les systmes de particules et laudio afin quil soit teint au lancement du jeu. Slectionnez lobjet campfire dans le panneau Hierarchy, puis dsactivez le paramtre Play on Awake du composant Audio Source dans le panneau Inspector. Slectionnez lobjet enfant FireSystem de lobjet campfire, puis dsactivez le paramtre Emit dans le composant Ellipsoid Particle Emitter. Slectionnez lobjet enfant SmokeSystem de lobjet campfire et dsactivez le paramtre Emit dans le composant Ellipsoid Particle Emitter. Il est temps maintenant dajouter la bote dallumettes collecter et de crer linterface qui indiquera que le joueur possde les allumettes. Pour cela, vous devez: ajouter dans lavant-poste le modle matchbox que vous avez tlcharg plus tt pour donner au joueur une raison douvrir la porte; crer une interface graphique (Gui Texture) en utilisant une texture du dossier Fire feature, puis lenregistrer comme lment prfabriqu; modifier le script PlayerCollisions existant et ajouter une dtection de collision pour la bote dallumettes afin que celle-ci puisse tre dtruite, puis instancier llment prfabriqu matchbox GUI.
Ajouter la bote dallumettes

Slectionnez le modle matchbox dans le dossier Fire feature du panneau Project, puis faites-le glisser sur lobjet outpost dans le panneau Hierarchy pour que la bote dallumettes devienne un objet enfant de lavant-poste. Elle sera ainsi plus facile positionner. Lobjet matchbox tant toujours slectionn, dfinissez 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 bote dallumettes, cet objet doit possder un collider qui dtecte les collisions avec lui. Lobjet matchbox toujours slectionn, cliquez sur Component> Physics> Box Collider, puis cliquez sur Add dans la bote de dialogue Losing Prefab. Pour viter que le contact entre le joueur et lobjet entrane un heurt, vous allez utiliser le mode Dclencheur pour ce collider. Pour cela, activez loption Is Trigger du composant Box Collider dans le panneau Inspector. Pour montrer de faon plus vidente au joueur quil peut collecter cet objet, vous allez lui attacher le script que vous avez dj utilis pour faire tourner les piles sur elles-mmes. Cliquez sur Component> Scripts> Rotate Object. Donnez ensuite la valeur2 au paramtre Rotation Amount dans le nouveau composant Rotate Object (script) qui saffiche dans le panneau Inspector.
Chapitre 7
207
Crer linterface graphique Matches GUI

Slectionnez le fichier de texture MatchGUI dans le dossier Fire feature du panneau Project, puis cliquez sur GameObject> Create Other> GUI Texture. Vous navez pas besoin de dfinir la position de cette texture lcran, vous pourrez le faire lorsque vous linstancierez en tant qulment prfabriqu. Slectionnez le dossier Fire feature dans le panneau Project, cliquez sur le bouton Create et slectionnez Prefab. Renommez cet lment prfabriqu MatchGUIprefab puis faites glisser lobjet MatchGUI du panneau Hierarchy sur cet lment prfabriqu vide dans le panneau Project. Enfin, slectionnez de nouveau lobjet original MatchGUI dans le panneau Hierarchy puis appuyez sur Cmd+Retour arrire (MacOS) ou Suppr (Windows) pour le supprimer de la scne.
La collecte des allumettes

Ouvrez le script PlayerCollisions situ dans le dossier Scripts du panneau Project. Pour que le joueur sache sil a collect les allumettes ou non, vous allez ajouter dans le script une variable boolenne qui aura pour valeur true quand le joueur les aura en sa possession. Ajoutez la ligne suivante au dbut du script:
private var haveMatches: boolean = false;
Vous avez galement besoin dune variable publique pour reprsenter llment prfabriqu Matches GUI Texture afin de pouvoir linstancier lorsque le joueur collecte la bote dallumettes. Ajoutez la variable suivante au dbut du script:
var matchGUI: GameObject;
Maintenant, faites dfiler le script jusqu la fonction OnTriggerEnter(), puis ajoutez cette instruction if la suite de celle qui y est dj:
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 vrifie le paramtre collisionInfo, qui enregistre chaque objet avec lequel le joueur entre en collision. La commande gameObject.name vrifie si collisionInfo
208
contient un objet nomm matchbox puis compare ce nom la chane de caractres "Matchbox". Si ces conditions sont runies, alors le script:
Dtruit lobjet matchbox, en faisant rfrence lobjet gameObject courant stock dans collisionInfo. Dfinit la variable haveMatches true. Lance la lecture de la squence audio assigne la variable batteryCollect. Comme le joueur est dj habitu ce son lorsquil collecte des objets, il est logique de le rutiliser. Instancie une occurrence de lobjet de jeu assign la variable publique matchGUI et la positionne (0.15,0.1,0). Souvenez-vous que, pour les objets2D, laxeZ permet tout simplement de superposer plusieurs calques, do la valeur 0. La commande transform.rotation permet dhriter de la rotation de lobjet parent il est inutile de dfinir un paramtre de rotation pour les objets2D. Nomme la nouvelle instance de lobjet laide de la variable matchGUIobj qui est cre dans la ligne de linstanciation. Elle sera utilise plus tard pour supprimer linterface graphique de lcran.
Cliquez sur File > Save dans lditeur 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 aprs tre entr dans lavant-poste. La texture de la bote dallumettes doit galement safficher dans le coin infrieur gauche de lcran. Maintenant, vous allez dcider si le feu peut tre allum ou non avec la variable haveMatches.
Allumer le feu
Afin dallumer le feu, vous devez vrifier les collisions entre le joueur et lobjet campfire. Pour cela, revenez dans lditeur de script pour modifier le script Player Collisions. Si vous lavez ferm, double-cliquez sur son nom dans le dossier Scripts du panneau Project. Recherchez la premire ligne de la fonction OnControllerColliderHit():
function OnControllerColliderHit(hit: ControllerColliderHit){
puis ajoutez linstruction if suivante sur la ligne en dessous:

if(hit.collider.gameObject == GameObject.Find("campre")){ }
Cette condition permettra de vrifier si le joueur touche lobjet campfire. Toutefois, vous devez galement vrifier que le joueur dispose des allumettes. Pour cela, ajoutez les lignes suivantes lintrieur de cette instruction if:
Chapitre 7
209
if(haveMatches){ haveMatches = false; lightFire(); }else{ TextHints.textOn=true; TextHints.message = "vous avez besoin dallumettes pour allumer ce feu..."; }
Ici, le script vrifie si la variable haveMatches est true. Si ce nest pas le cas (else), il utilise le script TextHints pour afficher linterface graphique TextHint GUI qui indique au joueur ce quil doit faire. Si haveMatches est true, le script appelle une fonction lightre(), que vous allez crire, pour lancer la lecture de la squence audio et dclencher les systmes de particules. Placezvous la fin du script et ajoutez la fonction suivante avant la ligne @script:
function lightFire(){ var campre: GameObject = GameObject.Find("campre"); var campSound: AudioSource = campre.GetComponent(AudioSource); campSound.Play(); var ames: GameObject = GameObject.Find("FireSystem"); var ameEmitter: ParticleEmitter = ames.GetComponent(ParticleEmitter); ameEmitter.emit = true; var smoke: GameObject = GameObject.Find("SmokeSystem"); var smokeEmitter: ParticleEmitter = smoke.GetComponent(ParticleEmitter); smokeEmitter.emit = true; Destroy(GameObject.Find("matchGUI")); }
Cette fonction ralise quatre oprations:
Elle lance la lecture de la boucle audio pour le feu. Elle dclenche le systme de particules Fire. Elle dclenche le systme de particules Smoke. Elle supprime linterface graphique Matches GUI de lcran pour indiquer que les allumettes ont t utilises.
Pour les trois premires oprations, le script doit crer une variable pour reprsenter lobjet auquel il sadresse, par exemple:
var campre: GameObject = GameObject.Find("campre");
210
Cette ligne nomme la variable, dclare son type de donnes sur GameObject et utilise la commande Find pour la dfinir comme gale lobjet de jeu campre. Puis il sadresse un composant spcifique de cet objet laide de la variable qui vient dtre tablie et de la commande GetComponent:
var campSound: AudioSource = campre.GetComponent(AudioSource);
On dclare l encore une nouvelle variable pour reprsenter le composant, on fixe son type de donnes sur AudioSource et on utilise cette variable pour appeler une commande:
campSound.Play();
Comme la commande Play est spcifique aux composants Audio Source, Unity sait exactement quoi faire et lance simplement la lecture de la squence audio assigne dans le panneau Inspector. La mthode est la mme dans la deuxime et dans la troisime opration, sauf que le script concerne le paramtre emit du composant Particle Emitter, comme la ligne suivante:
ameEmitter.emit = true;
Enfin, cette fonction excute la commande Destroy(), qui trouve tout simplement lobjet GUI qui affiche la bote dallumettes, autrement dit lobjet nomm matchGUI linstan ciation (reportez-vous la section "La collecte des allumettes"). Cliquez sur File> Save dans lditeur de script et revenez dans Unity. Comme vous avez cr une variable publique pour llment prfabriqu MatchGUIprefab dans le script PlayerCollisions, vous devez maintenant lui assigner une valeur. Cliquez sur les flches grises qui prcdent tous les objets parents dans le panneau Hierarchy pour que seuls ceux-ci restent affichs, puis slectionnez lobjet First Person Controller afin dafficher ses composants dans le panneau Inspector. Localisez le composant Player Collisions (script) puis faites glisser llment prfabriqu MatchGUIprefab partir du dossier Fire feature du panneau Project sur la variable publique Match GUI. Flicitations! Le feu est maintenant termin. Cliquez sur File> Save Scene dans Unity pour sauvegarder votre projet.
Tests et confirmation
Chaque fois que vous modifiez votre jeu, il est essentiel deffectuer des tests. Au Chapitre9, vous verrez comment optimiser le jeu, comment vous assurer que les tests fonctionnent comme ils sont censs le faire, ainsi que diffrentes options pour diffuser votre jeu.
Chapitre 7
211
Pour linstant, vous devez vous assurer que votre jeu fonctionne normalement. Mme si aucune erreur ne sest affiche dans la console de Unity (pour lafficher, appuyez sur Cmd/ Ctrl+Maj+C), vous devez toujours vous assurer quaucune erreur ne se produit pendant les diffrentes tapes de la partie. Cliquez sur le bouton Play puis collectez les piles, lancez les noix de coco, rcuprez la bote dallumettes et allumez le feu pour vous assurer que tous ces lments fonctionnent. Si une erreur se produit, vrifiez que vos scripts correspondent bien ceux indiqus dans cet ouvrage. En cas derreurs pendant les tests, le bouton PAUsE situ en haut de linterface de Unity permet de mettre le jeu en pause, de regarder lerreur indique dans la console, puis de relancer le jeu. Lorsquune erreur saffiche dans la console, double-cliquez dessus pour afficher la ligne du script qui la contient ou, du moins, lemplacement o le script rencontre un problme. De l, vous pouvez diagnostiquer lerreur ou vrifier le script laide du manuel de rfrence Scripting Manual de Unity pour vous assurer que votre approche est la bonne. Si vous ne parvenez pas rsoudre les erreurs, demandez de laide 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.
Info
En rsum
Vous venez de voir comment intgrer les particules pour donner une touche plus dynamique votre jeu. Les particules sutilisent dans de nombreuses situations de jeu diffrentes, quil sagisse de reprsenter la fume qui schappe du pot dchappement dune voiture, des tuyres des vaisseaux spatiaux, du canon des armes feu, ou encore la vapeur des systmes de ventilation. La meilleure faon den apprendre plus sur ce sujet consiste effectuer des essais. Les paramtres sont nombreux, si bien quil vous faudra un certain temps pour savoir ce que vous pouvez raliser et pour obtenir les meilleurs rsultats. Au prochain chapitre, vous allez voir comment crer des menus pour votre jeu. Pour cela, vous utiliserez la classe GUI de Unity dans vos scripts, les ressources GUI Skin et vous crerez des comportements pour vos interfaces. La classe GUI est un lment particulier du moteur de Unity utilis spcifiquement pour crer des menus, des HUD (Heads Up Displays, affichage tte haute). En combinant la classe GUI et les ressources GUI Skin, vous pouvez crer des lments totalement personnalisables et rutilisables. Les ressources GUI Skin peuvent en effet tre appliques autant de scripts de la classe GUI que vous le souhaitez. Vous pouvez ainsi crer un style cohrent dans tous vos projets Unity.
8
Conception de menus
Afin de crer un exemple de jeu complet, vous allez voir au long de ce chapitre comment crer une scne distincte de la scne de lle qui servira de menu. Plusieurs mthodes existent pour concevoir des menus dans Unity, qui combinent des comportements intgrs et des textures2D. Les composants GUI Texture sutilisent pour les crans de dmarrage incluant les logos des dveloppeurs ou les crans de chargement. Par contre, pour les menus interactifs, deux manires diffrentes sont possibles. La premire repose sur lutilisation des composants GUI Texture que vous avez tudis au Chapitre 6, "Instanciation et corps rigides", pour ajouter un viseur, et au chapitre prcdent, pour afficher la bote dallumettes. Lautre mthode se base sur les classes UnityGUI et sur les ressources GUI skin pour crer une interface graphique personnalise. Au cours de ce chapitre, vous apprendrez :
concevoir une interface de deux manires diffrentes; contrler les composants GUI Texture avec des vnements souris scripts; rdiger un script simple UnityGUI;
214
paramtrer les ressources GUI skin; charger les scnes, les menus et le niveau de jeu. Mthode 1: composants GUI Texture et contrle des vnements souris par le script. Cette mthode consiste crer des objets GUI Texture puis grer laffichage de leurs textures laide de scripts bass sur les vnements souris survol du menu, clic, bouton relch. Elle ncessite moins de code pour crer les boutons eux-mmes, mais toutes les actions doivent tre contrles par des scripts. Mthode 2: classe UnityGUI et ressources GUI skin. Avec cette mthode, la totalit du menu est cre laide de scripts, contrairement la prcdente dans laquelle on cre des objets de jeu.
Vous dcouvrirez deux mthodes pour ajouter des menus interactifs:
La cration des lments de menu demande donc plus de code au dbut, mais des ressources GUI skin peuvent tre cres pour dfinir lapparence et le comportement des lments dans le panneau Inspector. Les dveloppeurs prfrent gnralement la seconde mthode pour crer des menus de jeu complet en raison de sa plus grande flexibilit. Les lments du menu eux-mmes sont crs dans le script, mais leur aspect est dfini laide des composants GUI. Cela est comparable lutilisation du code HTML et des CSS lors de la conception de pages web les CSS (Cascading Style Sheets, feuilles de styles en cascade) contrlent lapparence 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 justification, ce qui vous sera utile si vous avez une exprience du dveloppement web. Cependant, ne vous inquitez pas si ce nest pas le cas; linstar de la plupart des fonctionnalits de Unity, les paramtres des composants GUI sont conus pour quun minimum de connaissances pralables soit ncessaire.
Les interfaces et les menus

Les menus servent le plus frquemment pour dfinir les contrles et ajuster les paramtres 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 laccompagne ne gne pas laccs au jeu ou lun de ses paramtres. Cest avant tout du jeu lui-mme dont on se souvient, moins que les menus ne soient particulirement russis ou mal conus. Les dveloppeurs cherchent souvent relier le menu du jeu au thme ou au principe du jeu. Par exemple, dans lexcellent World of Goo de 2DBoy, le curseur prend lapparence dune boule de Goo (les petites cratures rondes du jeu) suivie dune trane lumineuse dans les
Chapitre 8
Conception de menus
215
menus afin de crer un lien visuel entre le concept du jeu et son interface. Ainsi, la navi gation dans le menu douverture permet dj au joueur de samuser. Dans LittleBigPlanet de Media Molecule, ce concept est pouss encore plus loin, puisque le joueur doit apprendre contrler le personnage jouable pour pouvoir naviguer dans le menu. Comme pour toute cration, limportant est de rester cohrent. Dans notre exemple, vous devez veiller utiliser des couleurs et une typographie en harmonie avec le contenu du jeu. Vous avez peut-tre dj rencontr des jeux mal conus et qui utilisent trop de polices de caractres diffrentes ou trop de couleurs qui jurent. Or, le menu tant le premier lment que le joueur dcouvre, ces erreurs crent demble un sentiment peu agrable et nuisent la viabilit commerciale du jeu. Les textures employes pour crer le menu de notre exemple de jeu sont disponibles sur la page web consacre cet ouvrage (www.pearson.fr). Dcompressez si ncessaire le fichier nomm Menu.unitypackage puis revenez dans Unity. Cliquez sur Assets > Import package, parcourez votre disque dur jusqu lemplacement de ces ressources et importez-les. Une fois limportation termine, un dossier Menu saffiche dans le panneau Project. Ilcontient les lments suivants:
des textures pour le menu principal du jeu et trois boutons : Play, Instructions et Quit; une squence audio (un bip pour les boutons de linterface).
Crer le menu principal

cette section, vous utiliserez lle elle-mme comme toile de fond de vos menus afin de donner aux joueurs un avant-got de lenvironnement quils exploreront et de fixer le cadre visuel du jeu. Vous allez dupliquer lle existante, lafficher en plaant une camra une certaine distance, puis vous superposerez des lments dinterface 2D en utilisant les deux mthodes que nous avons mentionnes au dbut de ce chapitre.
Crer la scne
Pour ces menus, lenvironnement insulaire que vous avez cr va vous servir. En plaant lle larrire-plan dans le menu, vous veillerez la curiosit du joueur en lui prsentant lenvironnement quil pourra explorer lors du lancement de la partie. Ce type dincitation
216
visuelle peut sembler anodin, mais cela encourage le joueur tester le jeu de manire quasi subliminale. Un exemple visuel La Figure8.1 montre laspect quaura votre menu une fois termin. Cet exemple est obtenu en suivant la mthode 1; les lments de menu crs avec la mthode 2 auront un aspect diffrent.
Figure8.1
Dupliquer lle Pour commencer, vous rutiliserez la scne Island Level que vous avez cre aux chapitres prcdents. Pour faciliter la gestion des lments, vous regrouperez les ressources essentielles de cet environnement afin de les distinguer des objets dont vous navez pas besoin, comme lavant-poste et les piles. De cette faon, il vous suffira ensuite de tout supprimer lexception du groupe que vous allez crer dans la copie du niveau. Il est aussi facile de regrouper des lments dans Unity que dimbriquer des objets enfants dans un objet parent vide.
Chapitre 8
Conception de menus
217
Regrouper les objets de lenvironnement 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 lobjet vide Environment. Vous tes maintenant prts dupliquer ce niveau pour crer le menu dans une scne distincte. Dupliquer la scne Suivez les tapes suivantes pour dupliquer la scne: 1. Cliquez sur File> Save Scene pour vous assurer que la scne Island Level est enregistre, puis slectionnez 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 numro au nom de lobjet ou de la ressource, si bien que cette copie est baptise Island Level1. Assurez-vous quelle est slectionne dans le panneau Project puis renommez-la Menu. 3. Double-cliquez sur cette scne dans le panneau Project pour la charger et commencer la modifier. 4. La scne 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 lexception du groupe Environment pour les slectionner. 5. Appuyez sur Cmd+Retour arrire (Mac OS) ou Maj+Suppr (Windows) pour les supprimer de cette scne. Comme lillustre la Figure 8.1, lle apparatra vue de loin et dans le coin infrieur de lcran dans le menu, tandis que le titre du jeu et le menu safficheront en surimpression du ciel et de la mer. Pour reproduire cela, vous devez ajouter une nouvelle camra dans la scne, car la seule camra existante tait celle attache lobjet First Person Controller. Il ny a donc aucune camra dans la scne actuelle, rien qui permette de visualiser le monde3D, si bien que le point de vue dans le panneau Game est maintenant compltement vide. Pour crer une camra, cliquez sur GameObject> Create Other> Camera. Assurezvous que ce nouvel objet Camera est slectionn dans le panneau Hierarchy, puis entrez les valeurs de Position suivantes dans le composant Transform du panneau Inspector: (150,250,650).
218
Annuler le mip mapping

Le mip mapping est une technique permettant de gnrer de plus petites versions de textures distantes dans un moteur de jeu, ce qui amliore les performances (jusqu 33 % dans le moteur de Unity). Toutefois, il ne sapplique quaux textures intgres dans le monde en3D et non aux textures2D comme celles que vous allez utiliser pour le titre et les trois boutons de menu. Vous devez donc dsactiver cette fonction dans les paramtres dimportation de chaque ressource. Commencez par slectionner le fichier de texture MainTitle dans le dossier Menu du panneau Project pour afficher les paramtres dimportation de cette texture dans le panneau Inspector. Dsactivez ensuite loption Generate Mip Maps. Rptez cette tape pour les textures suivantes dans le dossier Menu:
InstructionsBtn InstructionsBtnOver PlayBtn PlayBtnOver QuitBtn QuitBtnOver
Ajouter le titre
Maintenant, vous avez besoin dun logo pour le jeu. Le plus simple consiste partir dune texture que vous avez conue et la dfinir comme un objet GUI Texture dans Unity. Les formats des objets GUI Textures Slectionnez la texture MainTitle dans le dossier Menu du panneau Project. Cette texture cre dans Photoshop est enregistre au format TIFF (Tagged Image File Format), un format qui convient pour toutes les textures que vous comptez utiliser pour vos interfaces graphiques. Il prend en charge la transparence en haute qualit non compresse, ce qui permet dviter certains problmes avec les contours blancs que prsentent les formats GIF (Graphics Interchange Format) ou PNG (Portable Network Graphics) notamment. Crer les objets Cette texture toujours slectionne, cliquez sur GameObject > Create Other > GUI Texture pour crer un nouvel objet GUI Texture bas sur cette texture. Nous lavons
Chapitre 8
Conception de menus
219
dj vu, les dimensions de la texture slectionne sont automatiquement dfinies. Un nouvel objet, MainTitle, saffiche dans le panneau Hierarchy (lobjet prend le nom du fichier slectionn lors de sa cration). Positionnement La plupart des ordinateurs actuels sont capables de grer des rsolutions gales ou suprieures 1024768pixels. Vous allez donc utiliser cet objet comme une norme pour tester votre menu. Vous dfinirez sa position de faon dynamique avec la classe Screen, afin que cela fonctionne dans dautres rsolutions. Le menu droulant situ dans le coin suprieur gauche du panneau Game (voir Figure8.2) permet de spcifier diffrents ratios dcran et rsolutions. Cliquez dessus et slectionnez Standalone (1024 768) pour afficher un aperu de cette rsolution.
Figure8.2
ce Astu
Gardez lesprit que si la rsolution de votre propre ordinateur est proche de celle que vous slectionnez, le panneau GAME naffichera pas un aperu exact mais une version plus petite de limage, car linterface de Unity occupe une petite partie de lcran. Pour afficher le panneau GAME en mode plein cran (ainsi que tous les panneaux de linterface de Unity) et le rduire, placez le curseur dessus, puis appuyez sur la barre despacement. Lorsque vous positionnez des lments dinterface graphique, cette mthode vous permet de prvisualiser lapparence de cette interface dans le jeu fini.
Par dfaut, tous les objets GUI Texture se placent (0.5,0.5,0), ce qui correspond au milieu de lcran. On se souvient que les lments2D utilisent les coordonnes de lcran comprises entre0 et1. Dfinissez la position de lobjet 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 lcran. Maintenant, vous allez ajouter trois boutons laide dobjets GUI Texture supplmentaires.
220
La cration du menu mthode1

Avec cette premire mthode, vous crerez un menu avec une texture de fond transparente comme GUI Texture, de la mme manire que vous venez de le faire avec le logo du titre principal. Vous aurez ensuite besoin dcrire un script afin que la texture puisse recevoir les vnements souris (lorsque le curseur survole ou quitte le bouton et lorsque le joueur clique ou relche le bouton de la souris).
Ajouter le bouton Play/Jouer

Slectionnez la texture PlayBtn dans le dossier Menu du panneau Project, puis cliquez sur GameObject> Create Other> GUI Texture. Slectionnez lobjet PlayBtn que vous venez de crer dans le panneau Hierarchy et rglez sa position dans le composant Transform du panneau Inspector (0.5,0.6,0).
Le script du bouton GUI Texture

Comme il sagit du premier des trois boutons que vous allez crer et quils auront tous des fonctions en commun, ce script pourra tre utilis pour les trois boutons. Pour cela, vous choisirez des variables publiques pour dfinir les diffrents paramtres. Ainsi, chaque bouton doit:
lancer la lecture dun son lors du clic; charger un autre niveau (ou une scne, selon la terminologie de Unity) lors du clic; changer de texture lorsque la souris le survole pour tre mis en vidence.
Slectionnez le dossier Scripts dans le panneau Project, cliquez sur le bouton Create et slectionnez JavaScript dans le menu droulant. Renommez le script MainMenuBtns, puis double-cliquez sur son icne pour louvrir dans lditeur de script. Commencez par dclarer les quatre variables publiques suivantes au dbut du script:
var var var var levelToLoad: String; normalTexture: Texture2D; rollOverTexture: Texture2D; beep: AudioClip;
La premire 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 dappliquer ce script tous les boutons, puisque le niveau charger est dfini par le nom de la variable. Les deuxime et troisime variables sont dclares comme des variables de type Texture2D. Aucune texture en particulier nest dfinie afin quelles puissent tre assignes ensuite par glisser-dposer dans le panneau Inspector. Enfin, la variable de type AudioClip permet de lancer la lecture dun son au clic de la souris. Ajoutez maintenant la fonction suivante pour dfinir la texture utilise par le composant GUI Texture lorsque le curseur survole la zone que la texture occupe (on appelle gnralement cet tat rollover ou survol):
function OnMouseEnter(){ guiTexture.texture = rollOverTexture; }
Le paquet de ressources Menu que vous avez import contient une texture pour ltat normal et ltat survol de chaque bouton. Cette fonction OnMouseEnter() dfinit simplement que la texture utilise dans le composant correspond la valeur attribue la variable publique rollOverTexture dans le panneau Inspector. Afin de savoir quand le curseur sloigne 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 affiche. Le joueur verrait alors cette option de menu toujours en surbrillance. Pour grer le son et le chargement de la scne approprie, ajoutez la fonction suivante:
function OnMouseUp(){ audio.PlayOneShot(beep); yield new WaitForSeconds(0.35); Application.LoadLevel(levelToLoad); }
La premire commande concerne le son. Elle permet dtre sr quil se lancera avant le chargement de la scne suivante et quil ne sera pas coup. La commande yield place entre le dclenchement du son et le chargement de la scne suivante indique au script de faire une pause du nombre dfini de secondes. Vous pouvez ainsi crer rapidement un dlai sans devoir utiliser une commande timer. La commande yield sert ici crer un retard, mais elle peut galement servir excuter tout un ensemble dinstructions avant la ligne de code suivante. En programmation, on
222
appelle cette unit de traitement une coroutine pour la distinguer des autres procdures les routines. Ensuite, la commande Application.LoadLevel() charge la scne dans le jeu, en utilisant la valeur de la variable publique levelToLoad indique dans le panneau Inspector pour trouver le fichier appropri. Pour les interfaces, il est gnralement conseill de dclencher les actions lorsque le bouton de la souris est relch (mouse up) plutt quau moment du clic (mouse down). Cela permet au joueur de dplacer le curseur sans valider lorsquil sest tromp et a slectionn le mauvais lment.
ce Astu
Comme vous lancez la lecture dun son, vous devez vous assurer que lobjet possde un composant AudioSource en ajoutant la ligne RequireComponent suivante la fin du script:
Cliquez sur File > Save dans lditeur de script puis revenez dans Unity. Slectionnez lobjet PlayBtn dans le panneau Hierarchy, puis cliquez sur Component> Scripts> Main Menu Btns pour lui appliquer le script que vous venez dcrire. Le script doit alors apparatre sur la liste des composants de lobjet PlayBtn dans le panneau Inspector. En raison de la ligne RequireComponent, lobjet dispose galement dun composant Audio Source.
Assigner des variables publiques

Les variables publiques doivent tre assignes avant que le script ne puisse fonctionner. Entrez le nom Island Level dans le champ de la variable Level To Load, afin que ce niveau se charge lorsquon 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. Enfin, faites glisser la squence audio menu_beep du mme dossier sur la variable Beep. Une fois termin, le composant doit tre identique celui de la Figure8.3.
Figure8.3
Chapitre 8
Conception de menus
223
Tester le bouton
Cliquez sur le bouton Play pour tester la scne. Lorsque vous placez le curseur sur le bouton Play Game, la texture PlayBtnOver doit safficher (le texte saffiche en couleur et saccompagne dun motif de flamme sur la droite). Lorsque vous loignez le curseur du bouton, la texture par dfaut doit safficher de nouveau. Cliquez maintenant sur le bouton. Le message suivant saffiche alors dans la console derreur au bas de lcran: Level Island Level couldnt be loaded because it is not added to the build settings (Le niveau Island Level na pas pu tre charg car il nest pas ajout aux paramtres Build). Unity cherche ainsi sassurer que vous noublierez pas dajouter tous les niveaux inclus dans les paramtres Build Settings. Ces paramtres de compilation correspondent aux paramtres dexportation de votre jeu fini ou de la version de test. Ils doivent contenir la liste de toutes les scnes incluses dans le jeu. Pour corriger cette erreur, cliquez sur le bouton Play pour arrter 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 scne Menu sur laquelle vous travaillez actuellement. Lordre des scnes sur la liste, reprsent par le nombre droite du nom de la scne, indique lordre dans lequel ces scnes apparatront dans le jeu. Vous devez vous assurer que la premire scne qui se chargera sera toujours en position0. Faites glisser la scne Island Level du panneau Project sur la liste actuelle des scnes du panneau Build Settings afin quelle apparaisse sous la scne Menu.unity (voir Figure8.4).
Figure8.4
Le panneau Build Settings naffiche aucun message de confirmation ou de bouton permettant de sauvegarder les paramtres. Fermez-le, cliquez sur le bouton Play puis sur le bouton Play Game dans Unity pour tester le jeu. La scne Island Level doit se charger
224
aprs la lecture du son menu_beep. Cliquez de nouveau sur le bouton Play pour arrter le test et revenir la scne Menu.
Ajouter le bouton des instructions

Pour ajouter le deuxime bouton, il vous suffit de slectionner la texture InstructionsBtn dans le dossier Menu du panneau Project puis de cliquer sur GameObject > Create Other> GUI Texture. Un deuxime objet nomm InstructionsBtn est cr dans le panneau Hierarchy. Dfinissez sa position (0.5,0.5,0) dans le composant Transform du panneau Inspector. Comme vous avez dj crit le script ncessaire, cliquez simplement sur Component> Scripts> Main Menu Btns pour lajouter ce bouton, puis assignez les textures appropries et la squence audio menu_beep de la mme manire que vous lavez fait pour le bouton prcdent. La scne que ce bouton permettra de charger nest pas encore cre, aussi entrez Instructions pour la variable levelToLoad (vous veillerez nommer ainsi cette scne plus tard).
Ajouter le bouton Quit/Quitter

Ce bouton fonctionne de manire analogue aux deux premiers, mais il ne charge pas de scne. 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 systme dexploitation. Vous devez par consquent modifier le script MainMenuBtns pour tenir compte de cette diffrence. Double-cliquez sur ce script dans le dossier Scripts du panneau Project pour louvrir dans lditeur de script. Commencez par ajouter la variable boolenne publique suivante au dbut du script:
var QuitButton: boolean = false;
Lorsque cette variable sera dfinie true, le clic du bouton la fonction OnMouseUp() excutera la commande quit(). Lorsquelle sera dfinie false son tat par dfaut le niveau assign la variable levelToLoad se chargera. Pour cela, vous devez restructurer la fonction OnMouseUp() avec une instruction if else, comme le montre lextrait 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 modifie 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 appele; dans le cas contraire (else), le niveau est charg normalement. Cliquez sur File> Save dans lditeur de script puis revenez dans Unity. Slectionnez la texture QuitBtn dans le dossier Menu du panneau Project puis cliquez sur GameObject> Create Other> GUI Texture pour crer un objet nomm QuitBtn dans le panneau Hierarchy. Dfinissez ensuite sa position (0.5,0.4,0) dans le composant Transform du panneau Inspector. Lobjet QuitBtn tant toujours slectionn dans le panneau Hierarchy, cliquez sur Component> Scripts> Main Menu Btns pour lui attacher le script. Dfinissez ensuite les valeurs des variables publiques dans le panneau Inspector comme prcdemment, en laissant vide le champ de la variable level To Load, puis activez loption de la nouvelle variable Quit Button. Voici le script dans son intgralit pour que vous puissiez vrifier le vtre:
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
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 scne Island Level doit se charger lorsque vous cliquez sur le bouton Play Game. Un clic sur le bouton Instructions entrane laffichage de lerreur "level could not be loaded" (le niveau ne peut pas tre charg), comme nous lavons vu prcdemment, puisque cette scne na pas encore t cre. 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 naurez pas cr une version complte du jeu. Noubliez pas de cliquer de nouveau sur le bouton Play pour terminer le test. La cration dun menu par la premire mthode est termine.
Utiliser les commandes de dbogage pour vrifier les scripts

Bien que la commande Application.Quit() ne produise aucun effet dans lditeur de Unity, vous devez tout de mme vous assurer que le bouton Quit fonctionne. Pour tester une partie dun script, il vous suffit de la placer dans une commande de dbogage pour envoyer un message la console derreur de Unity qui saffiche au bas de linterface. Revenez au script MainMenuBtns dans lditeur de script, puis localisez la partie du script qui concerne le bouton quitButton:
if(QuitButton){ Application.Quit(); }
Une commande de dbogage peut tre enregistre sur une liste pour afficher des messages dans la console derreur. Elle se prsente gnralement comme suit:
Debug.Log("Cette partie fonctionne!");
En crivant cette ligne de code lendroit o vous prvoyez que le script sexcutera, vous pouvez dcouvrir si certaines parties de celui-ci fonctionnent effectivement. Si vous la placez aprs la commande Application.Quit() dans notre exemple, vous aurez alors la preuve que la commande sexcute sans problme. Ajoutez cette ligne votre script comme dans lextrait de code suivant:
if(QuitButton){ Application.Quit(); Debug.Log("Cette partie fonctionne!"); }
Chapitre 8
Conception de menus
227
Cliquez sur File> Save dans lditeur 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 afficher le message de la commande de dbogage au bas de linterface de Unity. Si ncessaire, appuyez sur Cmd/Ctrl+Maj+C pour ouvrir la console de Unity et afficher le message (voir Figure8.5).
Figure8.5
Cette technique peut tre trs utile pour diagnostiquer des problmes dans les scripts. Elle lest aussi lorsque vous concevez un script de faon thorique sans indiquer les vritables commandes. Vous allez maintenant voir comment crer un menu fonctionnel laide de la fonction OnGUI() (cette fonction est appele GUI 2.0 system dans Unity car elle est apparue dans la version2.0 du programme).
La cration du menu mthode 2

Comme vous disposez dj dun menu fonctionnel, vous allez dsactiver temporairement les objets qui le composent plutt que de le supprimer de la scne. De cette manire, vous pourrez choisir le menu que vous prfrez par la suite.
Dsactiver les Game Objects

Slectionnez lobjet PlayBtn dans le panneau Hierarchy, puis dcochez la case situe gauche de son nom dans le panneau Inspector pour le dsactiver. Rptez ensuite lopration pour les objets InstructionsBtn et QuitBtn. Assurez-vous que le nom de chacun de ces objets saffiche en gris clair dans le panneau Hierarchy et quils ont disparu dans laperu du panneau Game.
228
Rdiger un script OnGUI() pour un menu simple

Cliquez sur GameObject> Create Empty pour crer un objet vide GameObject dans le panneau Hierarchy. Cet objet possde 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 dun objet spcialement pour cette tche. Comme la position des lments OnGUI est gre par un script, cest inutile dajuster les valeurs de position du composant. Renommez simplement lobjet Menu2. Slectionnez le dossier Scripts dans le panneau Project, cliquez sur le bouton Create puis choisissez JavaScript. Renommez ce script MainMenuGUI2 puis double-cliquez sur son icne pour louvrir dans lditeur de script.
Les classes GUI et GUI Layout

Pour cet exemple, vous emploierez la classe GUI Layout de Unity, car elle dispose de plus doptions de positionnement que la classe GUI, dont la position est fixe. De nombreux dveloppeurs prfrent la classe GUI Layout car elle dispose automatiquement les lments comme les formulaires et les boutons, les uns en dessous des autres. Elle permet donc au dveloppeur de consacrer plus de temps dfinir leur aspect laide la ressource GUI skin qui, lorsquelle est applique un script OnGUI(), fonctionne dune manire analogue aux feuilles de styles utilises pour la conception sur le Web.
Les variables publiques

Pour commencer le script, dclarez les quatre variables publiques suivantes:
var var var var beep: AudioClip; menuSkin: GUISkin; areaWidth: oat; areaHeight: oat;
Ce script cre la mme variable beep que dans la premire mthode, puis une variable pour la ressource GUI skin appliquer et enfin deux variables numriques permettant de dfinir la taille globale de la zone occupe par linterface graphique.
Chapitre 8
Conception de menus
229
La fonction OnGUI()
Ajoutez ensuite la fonction suivante:
function OnGUI(){ GUI.skin = menuSkin; }
Ainsi, laspect de tous les lments GUI placs dans cette fonction OnGUI() (les boutons et les formulaires, notamment) sera rgi par le style de thme (skin) appliqu la variable menuSkin. Il est alors facile de permuter les skins et donc de modifier totalement lapparence de linterface graphique en une seule opration.
Le positionnement flexible des interfaces graphiques

Vous devez maintenant dfinir la zone quoccuperont les boutons. Vous disposez dj des variables areaWidth et areaHeight, mais vous devez vous assurer que la zone rectangulaire occupe par linterface graphique tiendra compte de la rsolution de lcran sur lequel le jeu sexcutera. Sans cela, linterface graphique safficherait de faon diffrente selon la rsolution, ce qui semblerait assez peu professionnel. Vous allez donc crer quelques variables prives au sein de la fonction OnGUI() qui stockeront le centre de lcran. Vous navez pas besoin de prfixe private car vous dfinissez ces variables lintrieur de la fonction ; elles sont implicitement prives. Aprs la ligne GUI.skin que vous venez dajouter, dclarez 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 rsultat dune soustraction compose de deux parties:
((Screen.width * 0.5) - (areaWidth * 0.5));
Dans la ligne qui prcde, (screen.width * 0.5) utilise le paramtre width (largeur) de la classe Screen (cran) pour obtenir la largeur actuelle de lcran. En divisant ensuite cette valeur par deux, on obtient le centre de lcran. Notez que le script utilise * 0.5 plutt que /2. En effet, une multiplication ncessite environ cent cycles CPU de moins quune division pour obtenir des valeurs dans Unity.
Info
230
(areaWidth * 0.5) prend la largeur de la zone occupe par linterface graphique et trouve
son centre en divisant cette valeur par deux. On soustrait ensuite celle-ci du centre de lcran car le point dorigine du trac des zones GUI se trouve toujours gauche. Cette zone serait par consquent dcale sur la droite si elle tait trace depuis le centre de lcran (voir Figure8.6).
Figure8.6
Centre de l'cran
Zone GUI
Zone GUI
En soustrayant la moiti de la largeur de linterface graphique, on obtient une position centrale (voir Figure8.7).
Figure8.7
Centre de l'cran
Zone GUI
Les deux parties de la somme sont places entre parenthses afin que la soustraction porte sur leur rsultat, qui devient la valeur de la variable. Ce processus se rpte ensuite pour une seconde variable, screenY, afin de dfinir la position verticale de linterface graphique. Il est essentiel de dfinir la zone occupe par linterface graphique pour la classe GUILayout. Sans cela, la fonction OnGUI() suppose que vous tracerez un menu sur toute la surface de lcran, depuis son coin suprieur gauche. Vous devez donc utiliser la commande Begin Area() et prciser quatre paramtres:
GUILayout.BeginArea(Rect(distance depuis la gauche de lcran, distance depuis le haut de l'cran, largeur, hauteur));
La commande Rect() dfinit la zone rectangulaire quutilisera la commande BeginArea(). Vous pouvez indiquer la position de la zone rectangulaire tracer avec les variables prives ScreenX et ScreenY. Pour dfinir sa largeur et sa hauteur, vous reprendrez les variables publiques dclares au dbut du script.
Chapitre 8
Conception de menus
231
Ajoutez la ligne suivante dans la fonction OnGUI() la suite des deux variables prives que vous venez de dclarer:
GUILayout.BeginArea (Rect (ScreenX,ScreenY, areaWidth, areaHeight));
Le dessin de la zone doit galement tre ferm laide de la commande EndArea(). Cela marquant la fin du trac de la zone, tout le code de linterface graphique doit se trouver avant cette ligne dans la fonction. Insrez plusieurs lignes aprs la commande BeginArea(), puis ajoutez la ligne suivante pour terminer le trac de linterface graphique:
GUILayout.EndArea();
Ajouter des boutons UnityGUI

Pour crer le premier bouton, ajoutez les lignes suivantes avant la ligne EndArea():
if(GUILayout.Button ("Play")){ OpenLevel("Island Level"); }
Un nouveau bouton GUILayout.Button est ralis sur lequel est inscrit le mot Play. En plaant cette instruction dans une condition if, le script cre non seulement le bouton mais indique galement Unity laction effectuer lorsquon clique dessus. Cette instruction appelle une fonction personnalise nomme OpenLevel() possdant un seul paramtre le nom du niveau. Vous crirez la fonction OpenLevel() une fois la fonction OnGUI() complte. Ajoutez ensuite les deux conditions suivantes pour crer les deux autres boutons:
if(GUILayout.Button ("Instructions")){ OpenLevel("Instructions"); } if(GUILayout.Button ("Quit")){ Application.Quit(); }
La deuxime condition if fait appel la mme fonction personnalise OpenLevel() mais transmet une chane de caractres diffrente son seul paramtre le nom du niveau Instructions qui reste crer. Le bouton de la troisime condition if ne charge pas un niveau, mais appelle simplement la commande Application.Quit(), comme dans la premire mthode de cration du menu.
232
Lancer des scnes laide de fonctions personnalises

Il vous faut maintenant crire la fonction personnalise qui sera appele pour charger un niveau en particulier. Placez-vous aprs laccolade de fermeture de la fonction OnGUI(), puis dclarez cette nouvelle fonction de la faon suivante:
function OpenLevel(level: String){ }
Cette fonction contient un paramtre nomm level de type String. Cela signifie que, tant que lon passe une chane de caractres pour appeler la fonction, on peut ensuite utiliser le terme level pour dsigner le texte transmis. Or, dans la fonction OnGUI(), vous venez dajouter lappel suivant:
OpenLevel("Island Level");
Dans cet exemple, les mots "Island Level" sont passs au paramtre level de la fonction OpenLevel(). Notez quil est inutile dcrire level = "Island Level" puisque le script sait quil doit appliquer ce texte au paramtre de la fonction OpenLevel(). Une erreur saffiche si le type de donnes transmis nest pas le bon (un chiffre ou un nom de variable, par exemple), car seules les donnes de type String sont appropries pour le paramtre level. Le script lira la chane de caractres transmise chaque fois que le paramtre 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 mthode1. Vous pouvez vous y reporter, si ncessaire, mais la diffrence essentielle noter ici tient lutilisation du paramtre level pour passer la chane de caractres dans la commande Application.LoadLevel(). Pour complter le script, assurez-vous que la squence audio sera lance en ajoutant la ligne RequireComponent habituelle la fin du script:
Cliquez sur File> Save dans lditeur de script et revenez dans Unity. Voici le script en intgralit si vous souhaitez vrifier que vous navez pas fait derreur:
var beep: AudioClip; var menuSkin: GUISkin;
Chapitre 8
Conception de menus
233
var areaWidth: oat; var areaHeight: oat; 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 modifier lapparence du menu De retour dans Unity, slectionnez lobjet 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 squence 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 paramtres Area Width et Area Height. Cliquez sur le bouton Play pour afficher le menu. Comme la classe GUI est compile partir dun script, son rendu seffectue uniquement lorsque le jeu est test. Laspect du menu que vous venez de crer avec le script est un peu terne (voir Figure8.8).
234
Figure8.8
Vous allez donc lui appliquer un style pour amliorer son apparence laide des ressources GUI skins. Pour cela, une ressource GUI skin doit tre assigne la variable menuSkin. Slectionnez le dossier Menu dans le panneau Project, puis cliquez sur le bouton Create et slectionnez GUI Skin dans le menu droulant. Renommez MainMenu la nouvelle ressource New GUISkin.
Les paramtres de lobjet GUI Skin

Les objets GUI Skins possdent des paramtres pour chaque lment de la classe GUI:
Boxes (botes); Buttons (boutons); Toggles (boutons bascule); Labels (tiquettes); Text fields et Text areas (champs et zones de texte); Sliders (curseurs), scrollbars et scrollviews (barres de dfilement et daffichage).
Chapitre 8
Conception de menus
235
Le premier paramtre Font (police) est commun tous les lments rgis par le thme (skin). Pour commencer, slectionnez la police utilise dans le jeu (la police Sugo si vous avez pris la mme que nous) dans le panneau Project et dposez-la sur ce paramtre. Ce thme (skin) va vous servir dfinir le style des lments boutons. Cliquez sur la flche grise gauche de llment Button du composant GUISkin dans le panneau Inspector pour afficher ses paramtres (voir Figure8.9).
Figure8.9
Cliquez sur la flche grise qui prcde les paramtres Normal, Hover et Active afin dafficher les options Background et Text Color de chacun deux (voir Figure8.10). Le paramtre Background dfinit la texture utilise pour le fond du bouton par dfaut, Unity utilise une image aux coins arrondis et lgrement diffrente pour les tats Hover et Active afin de les mettre en surbrillance. Conservez-les pour lexemple de ce livre, mais nhsitez pas essayer dautres couleurs lorsque vous crerez les menus de vos propres jeux. Pour le moment, cliquez sur chaque bloc de couleur de loption 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
Figure8.10
Affichez ensuite les options du paramtre Padding et donnez la valeur6 aux options Top et Bottom pour augmenter lespace entre les bords suprieur et infrieur du bouton et le texte lui-mme. Ce paramtre fonctionne de la mme faon quavec les CSS. Pour espacer davantage les boutons verticalement, vous devez augmenter la marge du bas. Pour cela, affichez les options du paramtre Margin, puis donnez la valeur10 loption Bottom. Maintenant que vous avez ajust ces paramtres, vous tes prt les appliquer au script GUI. Slectionnez lobjet Menu2 dans le panneau Hierarchy, puis faites glisser lobjet MainMenu depuis le panneau Project sur la variable publique Menu skin dans le composant Main Menu GUI2. Cliquez sur le bouton Play pour vrifier que le skin a t appliqu et pour afficher le rendu du script GUI (voir Figure8.11).
Figure8.11
Le menu a maintenant un aspect plus professionnel et il sintgre mieux au logo du jeu car sa police est la mme que celle du jeu. Le menu complet doit maintenant ressembler celui de la Figure8.12.
Chapitre 8
Conception de menus
237
Figure8.12
Cliquez sur le bouton Play pour terminer le test du jeu puis sur File> Save Scene dans Unity.
Lheure des dcisions

Cest maintenant votre tour de faire preuve de crativit! Choisissez la mthode et le rsultat que vous prfrez. partir de ce que vous avez appris la section "Dsactiver les Game Objects" de ce chapitre, vous pouvez choisir la deuxime mthode et laisser les trois objets de jeu GUI Texture dsactivs, ou dsactiver Menu2 et ractiver ces objets en cochant leurs cases dans le panneau Inspector. Toutefois, nous vous conseillons de continuer avec la seconde mthode base sur UnityGUI. Elle permet de crer beaucoup plus que de simples menus: prsenter des statistiques au cours du test, par exemple, ou proposer des paramtres de compilation que le lecteur Unity peut ensuite ajuster. Autant de techniques plus avances que vous rencontrerez sans doute lorsque vous connatrez mieux Unity.
238
En rsum
Nous venons dtudier les deux principales mthodes de cration des lments dinterface dans Unity: les scripts GUI et les GUI Texture. Vous devriez maintenant savoir comment implmenter lune ou lautre mthode pour raliser des interfaces. Nous navons abord ici que les notions essentielles dont vous aurez besoin chaque fois que vous crirez un script GUI, mais cette mthode offre beaucoup plus de possibilits. Il vous reste encore crer la scne Instructions contenant des informations destines au joueur. Ne vous inquitez pas, vous allez le faire au prochain chapitre en dcouvrant de nouvelles techniques danimation, tout en apportant certaines retouches au jeu lui-mme.
9
Dernires retouches
Vous allez ici apporter les dernires retouches lle afin de transformer ce simple exemple de jeu en un produit prt tre dploy. Jusqu prsent, nous vous avons prsent un seul exemple la fois afin que vous appreniez diffrentes comptences. Vous allez maintenant revoir certaines des notions dj abordes et voir en dtail la faon dajouter certains effets qui ne sont pas essentiels la jouabilit, ce qui explique pourquoi il est prfrable de les raliser la fin du cycle de dveloppement. Un jeu repose avant tout sur ses mcanismes de fonctionnement. Vous devez mettre en place ses lments physiques fonctionnels avant de pouvoir ajouter des illustrations et amliorer laspect visuel de lenvironnement. Dans la plupart des cas, vous serez contraint par le temps pour crer votre jeu, que cela soit de votre fait ou impos par lditeur pour lequel vous travaillez. Vous devez consacrer tout votre temps llment le plus important du jeu le gameplay (la jouabilit) et procder aux dernires retouches la toute fin du cycle de dveloppement seulement. Pour les besoins de cet ouvrage, nous partons du principe que les mcanismes de votre jeu sont termins et fonctionnent comme prvu. Voyons maintenant ce que vous pouvez ajouter lenvironnement de lle et du jeu en gnral pour lamliorer.
240
Au cours de ce chapitre, vous ajouterez les lments suivants: un systme de particules lintrieur du volcan; le bruit du grondement de la lave que le joueur entendra lorsquil sapprochera du volcan; des tranes de lumire afin de montrer la trajectoire des noix de coco; du brouillard, pour rendre lhorizon plus raliste; une scne anime Instructions pour expliquer le but du jeu au joueur; un fondu en entre lors du chargement du niveau Island Level laide dune interface graphique constitue dune texture et dun script qui modifie sa transparence; un message indiquant au joueur quil a termin le jeu. Pour finir, vous verrez comment dployer le jeu et comment procder des tests pour rechercher les problmes ventuels. Enfin, vous aborderez la distribution du jeu via des canaux indpendants. Commenons tout dabord par rendre le volcan plus dynamique.
Le volcan
Pour cette tape, vrifiez que la scne Island Level est ouverte dans Unity. Si ce nest pas le cas, double-cliquez sur son fichier dans le panneau Project ou cliquez sur File > Open Scene, puis slectionnez-la dans le dossier Assets. Les fichiers de scne sont faciles reprer car ils utilisent le logo du programme Unity comme icne. Au Chapitre2, "Environnements", vous avez cr une le et le cratre dun volcan avec lditeur de terrain. Pour rendre ce volcan un peu plus raliste, vous allez lui ajouter un panache de fume et une source audio mono, qui reproduit le bouillonnement de la lave en fusion. Grce ces lments sonores et visuels, lenvironnement devient plus dynamique et raliste, ce qui devrait amliorer le sentiment dimmersion du joueur dans le jeu. Cliquez sur GameObject> Create Other> Particle System pour crer un systme de particules dans Unity. Assurez-vous ensuite que ce systme de particules, Particle System, est slectionn dans le panneau Hierarchy, puis renommez-le Volcano Smoke.
Positionner le systme de particules

Pour positionner un objet de faon relative, on le dfinit gnralement comme lenfant dun autre objet, puis on rinitialise sa position locale (0,0,0). Mais comme le volcan est une partie de lobjet terrain et non un objet indpendant, il nest pas possible de dfinir la position relative des particules de cette manire.
Chapitre 9
Dernires retouches
241
Dans ce cas, vous devez utiliser laxe3D du panneau Scene. Commencez par cliquer sur laxeY (vert) de laxe3D pour passer de la vue Perspective une vue du dessus de lle. Lemot Top saffiche alors sous laxe3D.
Figure9.1
Pour voir o se trouve le systme de particules, assurez-vous quil est slectionn dans le panneau Hierarchy, puis slectionnez loutil Transform (toucheW) afin dafficher ses axes dans le panneau Scene. Le systme de particules a t cr au centre de la vue actuelle dans le panneau Scene, aussi devez-vous le repositionner lintrieur du volcan dans cette vue du dessus (Top). Vous devez voir la fois les axes du systme de particules et le volcan lui-mme. Si vous devez zoomer en arrire, activez loutil Hand (touche Q), appuyez sur Cmd/Ctrl puis faites glisser la souris vers la gauche. Slectionnez ensuite loutil Transform (toucheW) de nouveau pour afficher les poignes daxes de lobjet. laide de loutil Transform, faites glisser lune aprs lautre les poignes des axesX (rouge) etZ (bleu) pour placer le systme de particules au centre du cratre (voir Figure9.2).
Figure9.2
242
Ne vous inquitez pas si la poigne daxe que vous slectionnez saffiche en jaune, il sagit toujours de la bonne poigne! Cliquez ensuite sur la poigne de laxeX (rouge) sur laxe3D en haut du panneau Scene afin dafficher une vue latrale de lle. Avec loutil Transform, faites glisser la poigne daxeY (vert) du systme de particules pour le placer au centre du volcan (voir Figure9.3).
Figure9.3
la figure prcdente, notez que la poigne daxe verte est actuellement slectionne et saffiche donc en jaune. Enfin, cliquez sur le cube blanc au centre de laxe3D en haut du panneau Scene pour afficher de nouveau la vue en perspective.
Importer les ressources

Vous avez maintenant besoin dajouter certains lments votre projet pour complter le volcan. Vous trouverez ces ressources dans larchive disponible sur la page web consacre cet ouvrage (www.pearson.fr). Dcompressez cette archive si ncessaire, localisez le paquet de ressources volcanoPack.unitypackage, puis revenez Unity. Cliquez sur Assets > Import Package, parcourez votre disque dur jusquau paquet de ressources volcanoPack.unitypackage, slectionnez-le et cliquez sur Ouvrir. Cliquez ensuite sur le bouton Import dans le panneau Importing package pour confirmer. Un dossier Volcano est alors ajout votre projet. Il contient:
la texture de fume du volcan;
Chapitre 9
Dernires retouches
243
un fichier audio pour reprsenter le grondement de la lave; un fichier de texture, nomm white, que vous utiliserez par la suite pour faire apparatre le niveau en fondu enchan.
Crer un matriau pour la fume

Maintenant que vous avez import les ressources adquates, vous devez crer un matriau pour la texture de fume du volcan. Afin que les lments restent organiss, vous allez le crer dans le dossier Volcano. Slectionnez-le dans le panneau Project, cliquez sur le bouton Create et choisissez Material dans le menu droulant. Renommez ce nouveau matriau Volcano Smoke Material, puis assurez-vous quil est slectionn dans le panneau Project et que ses paramtres saffichent dans le panneau Inspector. Choisissez ensuite Particles > Multiply dans le menu droulant Shader afin que le style de rendu du matriau soit adapt des particules loption Multiply permet dafficher le fond transparent des textures des particules et adoucit leurs contours. Faites glisser le fichier de texture volcano_smoke du dossier Volcano sur lemplacement vide droite du paramtre Particle Texture. Conservez les valeurs par dfaut des paramtres Tiling et Offset. Faites glisser le matriau Volcano Smoke Material du dossier Volcano dans le panneau Project sur le systme de particules Volcano Smoke dans le panneau Hierarchy pour lappliquer cet objet.
Les paramtres du systme de particules

Comme pour tout effet visuel, en particulier les systmes de particules, de nombreux essais sont ncessaires pour obtenir le rsultat souhait. Cest pourquoi nous vous conseillons dutiliser les paramtres indiqus ici comme guides, puis de prendre ensuite le temps de les ajuster par vous-mme afin dobtenir un effet:
dont vous aimez lapparence; qui fonctionne bien avec le style du cratre de volcan que vous avez cr sur votre terrain.
Notez que seuls les paramtres dont la valeur par dfaut a t modifie sont indiqus ici.
244
Les paramtres 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 paramtres 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).
Figure9.4
Prenez maintenant le temps de rgler ces paramtres afin que le systme de particules sintgre au mieux votre terrain.
Chapitre 9
Dernires retouches
245
Ajouter le son du volcan

Pour complter le volcan et le rendre plus raliste, vous allez lui ajouter une boucle sonore comme source audio. Nous lavons dj indiqu, le volcan nest pas un objet de jeu proprement dit, si bien que vous ne pouvez pas lui ajouter de composant. Cependant, vous disposez prsent dun objet au centre du volcan, le systme de particules, que vous pouvez utiliser pour ajouter le composant audio. Assurez-vous que lobjet Volcano Smoke est slectionn dans le panneau Hierarchy, puis cliquez sur Component> Audio> Audio Source. Un composant source audio sajoute alors au bas de la liste de composants dans le panneau Inspector. Le systme de particules ayant plusieurs composants, vous devrez peut-tre faire dfiler le contenu du panneau Inspector vers le bas pour afficher le composant Audio Source. Assignez la squence audio volcano_rumble du dossier Volcano au paramtre Audio Clip, puis veillez ce que loption Play On Awake soit active la lecture du son se dclenchera ainsi automatiquement ds le chargement de la scne. Rglez les paramtres Volume et Max Volume 200 afin que le son du volcan:
Soit suffisamment lev pour couvrir le son dambiance stro hillside appliqu au terrain. Atteigne cette valeur lorsque le joueur est proche de la source audio autrement dit, lorsquil se tient prs du volcan.
Laissez la valeur de Min Volume 0 pour que ce son soit inaudible lorsque le joueur se trouve loin du volcan. Le paramtre Rolloff Factor (facteur dloignement) permet ensuite de dfinir la distance laquelle doit se trouver le joueur pour que le volume diminue. Sur notre terrain, une valeur de 0,025 convient avec ce paramtre, plus la valeur est leve, plus le joueur doit tre prs de la source pour lentendre. Par consquent, quand la valeur est faible, comme ici, le son sentend de loin, comme un volcan qui gronde est cens le faire. Vous pouvez commencer par cette valeur, puis en essayer dautres lorsque vous testez le jeu. Enfin, activez loption Loop pour que le son se rpte indfiniment.
246
Tester le volcan
Maintenant que le volcan est termin, vous devez tester lefficacit des dernires modifications apportes. Cliquez dabord sur File> Save Scene, afin de vous assurer de ne pas perdre votre travail, puis sur le bouton Play et marchez jusquau volcan. Les particules devraient slever dans le ciel. Plus vous approchez du volcan et plus le volume sonore devrait augmenter. Sil nest pas assez fort votre got, modifiez simplement les valeurs du paramtre Volume; sil ne porte pas assez loin, diminuez la valeur du paramtre Rolloff Factor dans le composant Audio Source. Souvenez-vous que toutes les modifications que vous apportez dans le panneau INspECTOR lors du test du jeu sont annules lorsque vous cliquez de nouveau sur le bouton PLAY pour interrompre le test. Aprs les avoir testes, vous devez donc de nouveau entrer ces valeurs dans le panneau INspECTOR lorsque vous avez cess de tester le jeu.
ce Astu
Pour les tests, vous souhaiterez peut-tre augmenter la vitesse de dplacement de lobjet First Person Controller afin datteindre les diffrentes parties de lle plus rapidement. Pour cela, slectionnez cet objet dans le panneau Hierarchy pendant le test du jeu. Donnez la variable publique Speed du composant FPSWalker(script) la valeur souhaite. Ce paramtre est modifi uniquement pour la dure du test et reprend sa valeur prcdente lorsque vous cliquez de nouveau sur le bouton Play. Vous pouvez donc tout fait dfinir une vitesse totalement irraliste pour le test sans modifier la vitesse du personnage dans le jeu.
Tranes de lumire
Vous allez maintenant amliorer laspect visuel du jeu en ajoutant des tranes de lumire llment prfabriqu coconut. Ainsi, lorsque le joueur lancera les noix de coco, une trane lumineuse suivra la trajectoire du projectile, ce qui devrait donner un effet visuel intressant.
Modifier llment prfabriqu

Pour effectuer cette modification, vous devez revenir llment prfabriqu Coconut Prefab du Chapitre6, car llment Trail Renderer que vous allez utiliser doit lui tre attach. Faites glisser la ressource Coconut Prefab depuis le dossier Prefabs du panneau
Chapitre 9
Dernires retouches
247
Project dans le panneau Scene afin de la modifier. Vous pourriez diter les ressources directement dans le panneau Project, mais il est prfrable de les placer dans la scne afin de visualiser et de tester leffet que vous crez. Souvenez-vous que vous pouvez zoomer directement lemplacement de lobjet slectionn en appuyant sur la toucheF lorsque le curseur se trouve sur le panneau Scene.
Le composant Trail Renderer

Pour ajouter ce composant, assurez-vous que llment prfabriqu Coconut Prefab est toujours slectionn dans le panneau Hierarchy, puis cliquez sur Component > Particles> Trail Renderer. Un message indique que la connexion entre cet objet et llment prfabriqu est rompue. Ne vous inquitez pas, vous mettrez jour llment prfabriqu une fois la trane termine. Ce composant trace simplement une ligne vectorielle courbe en ajoutant une suite de points derrire un objet lorsque celui-ci se dplace travers le monde en 3D. En spcifiant la longueur, le matriau et la largeur du dbut et de la fin de la ligne, vous pouvez obtenir leffet recherch. Cliquez sur le bouton Play pour afficher la configuration par dfaut 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 derrire elle. Premirement, nous devons tenir compte des performances: comme vous navez pas besoin que des ombres soient projetes sur ou par cette ligne, dcochez ces deux paramtres du composant Trail Renderer dans le panneau Inspector (les utilisateurs de la version Pro de Unity peuvent utiliser des ombres dynamiques). Les ombres ont gnralement un cot lev et le rendu de la trane lumineuse elle-mme sollicite davantage le processeur de lordinateur du joueur. On doit faire tout ce qui est possible pour le soulager. Cliquez sur la flche qui prcde le paramtre Materials pour afficher ses options Size et Element0. Vous pouvez dfinir la texture de la trane. Pour cela, vous allez rutiliser le matriau Flame que vous avez cr car le type de shader quil utilise Additive (soft) convient parfaitement pour une trane lumineuse. Ouvrez le dossier Fire Feature dans le panneau Project, puis faites glisser le matriau Flame sur le paramtre Element0 dans lecomposant Trail Renderer du panneau Inspector. Pour vous assurer que la longueur de la trane lumineuse ne sera pas excessive, donnez la valeur1 au paramtre Time: la trane durera une seconde. Autrement dit, les points situs la fin de la ligne seront supprims aprs ce laps de temps. Donnez la valeur0,25 Start Width et la valeur0,15 End Width. Ces options dfinissent la largeur du rendu du matriau chaque extrmit de la ligne. En rgle gnrale, il est logique que la largeur de la trane lumineuse aille en diminuant.
248
Affichez les options du paramtre Colors afin danimer lapparition de la trane en modifiant sa couleur et sa visibilit (ses paramtres alpha). Vous conserverez les couleurs de la texture de flamme et modifierez simplement la transparence de la trane. Cliquez sur le premier bloc de couleur, puis modifiez sa valeurA (alpha) 80. Rptez la mme opration sur les autres blocs de couleur en rduisant chaque fois la valeur alpha de 20, jusqu ce que la dernire soit gale 0.
Figure9.5
Vous devez obtenir un rsultat analogue celui de la Figure9.6.

Figure9.6
Les autres paramtres peuvent tre laisss leurs valeurs par dfaut. Le paramtre Min Vertex Distance dfinit la distance la plus courte entre deux points de la ligne plus le nombre de points est important et plus la ligne est dtaille, mais plus son cot est lev. Le paramtre Autodestruct na pas besoin non plus dtre activ, car le script Coconut Tidy que vous avez crit au Chapitre6, "Instanciation et corps rigides" est attach cet objet et gre dj la suppression de ces lments prfabriqus.
Chapitre 9
Dernires retouches
249
Mettre jour llment prfabriqu

Vous travaillez sur une instance de llment prfabriqu qui a perdu sa connexion avec la ressource originale do le message davertissement apparu lorsque vous avez ajout le composant Trail Renderer. Vous devez donc maintenant appliquer ces modifications la ressource dorigine afin que toutes les nouvelles occurrences de llment prfabriqu disposent de la trane lumineuse. Pour cela, deux options soffrent vous: soit slectionner lobjet 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.
Figure9.7
Une fois llment prfabriqu mis jour, vous navez plus besoin de linstance dans la scne. Slectionnez-la puis appuyez sur Cmd+Retour arrire (Mac OS) ou Maj+Suppr (Windows). Pour visualiser leffet, testez et essayez le mini-jeu de lancer de noix de coco. Vous devriez voir une trane flamboyante suivre chaque noix de coco que vous lancez.
Lamlioration des performances

cette section, vous allez voir comment augmenter les performances de votre jeu final. Ilest essentiel deffectuer ce processus doptimisation une fois que vous tes sr que votre jeu fonctionne comme prvu.
Modifier la distance du rendu des objets et ajouter du brouillard

Pour donner un aspect visuel plus agrable lle, vous activerez le brouillard. Dans Unity, il peut tre activ trs simplement et tre utilis en conjonction avec le paramtre Far Clip Plane pour ajuster la distance daffichage. Le rendu des objets situs au-del dune certaine distance nest pas effectu, ce qui permet damliorer les performances. Ce brouillard permet de masquer la coupure entre les objets rendus et ceux qui ne le sont pas, ce qui
250
amliore le ralisme visuel du terrain. Vous avez dj vu les paramtres Far Clip Plane au Chapitre 3, "Personnages jouables", lorsque vous avez tudi lobjet First Person Controller. Maintenant, vous allez ajuster cette valeur pour rduire la distance laquelle la camra procde au rendu des objets et ainsi amliorer les performances du jeu.
Cliquez sur la flche grise gauche de lobjet First Person Controller dans le panneau Hierarchy pour afficher ses objets enfants. Slectionnez lobjet enfant Main Camera. Donnez la valeur600 au paramtre Far Clip Plane du composant Camera dans le panneau Inspector. En rduisant cette distance, exprime en mtres, vous diminuez la porte de la vision du joueur, mais la brume masquera cette diffrence.
Cliquez sur Edit > Render Settings pour remplacer le panneau Inspector par le panneau Render Settings. Activez loption Fog, puis cliquez sur le bloc de couleur droite du paramtre Fog Color pour dfinir la couleur et la transparence du brouillard. Dfinissez une valeur Alpha(A) de 60% environ et une valeur Fog Density de 0,004 (voir Figure9.8).
Figure9.8
Avec les valeurs par dfaut ou des valeurs suprieures pour les paramtres alpha de Fog Color et de Fog Density, le brouillard rduirait tant la porte de la vision du joueur que les particules du volcan deviendraient invisibles, moins quil ne se tienne tout prs du volcan.
La lumire ambiante
Le panneau Render Settings dispose galement dun paramtre Ambient Light pour la scne. Bien que lobjet Directional Light gre lclairage principal, en agissant comme le soleil dans notre exemple, le paramtre Ambient Light permet de dfinir la luminosit gnrale et donc de simuler diffrentes heures du jour ou de la nuit. Cliquez sur le bloc de couleur droite de ce paramtre puis, avec la pipette de la bote de dialogue Color, testez diffrentes valeurs.
Chapitre 9
Dernires retouches
251
La scne Instructions
Pour finaliser le jeu, vous allez complter le menu que vous avez ralis au Chapitre8, en crant la scne Instructions que le joueur devra lire. Pour cela, vous implmenterez une animation laide de scripts et vous utiliserez une nouvelle commande appele Linear interpolation. Pour que la scne Instructions imite le reste du menu, vous prendrez la scne Menu comme point de dpart. Avant cela, cliquez sur File> Save Scene pour vous assurer que la scne Island Level est enregistre. Slectionnez ensuite la scne Menu dans le panneau Project puis appuyez sur Cmd/Ctrl+D pour la dupliquer. Renommez cette copie Instructions puis double-cliquez sur son icne pour louvrir.
Ajouter du texte lcran

Comme les instructions destines au joueur doivent safficher sur cet cran, vous allez utiliser un objet GUI Text. Cliquez sur GameObject > Create Other > GUI Text, puis slectionnez ce nouvel objet GUI Text dans le panneau Hierarchy et renommez-le Instruction Text. Pour rester cohrent, vous devez utiliser la mme police de caractres que dans les autres scnes du jeu (la police libre de droit Sugo dans notre exemple). Pour cela, faites-la glisser du panneau Project sur le champ du paramtre Font dans le composant GUI Text. crivez ensuite un court paragraphe qui explique au joueur le but du jeu. Ici, il sagit allumer le feu de camp avec les allumettes pour survivre: d "Vous tes bloqu sur une le dserte et risquez de prir de froid. Trouvez et allumez le feu de camp avant que la nuit ne tombe" Afin que le texte se place sur plusieurs lignes dans le champ Text de ce composant, appuyez sur Option+Entre (MacOS) pour passer la ligne suivante. Sous Windows, crez le texte sur le bloc-notes, puis copiez-le et collez-le dans le champ Text. Enfin, 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 laligner avec le logo en haut de lcran (voir Figure9.9).
252
Figure9.9
Animer le texte avec linterpolation linaire

Vous allez maintenant animer ce texte laide dun script. Slectionnez le dossier Menudans le panneau Project, cliquez sur Create et choisissez JavaScript dans le menu droulant. Renommez ce nouveau script Animator, puis double-cliquez sur son icne pour louvrir dans lditeur de script. Vous commencerez par dclarer quelques variables publiques afin de contrler le comportement de lanimation de texte dans le panneau Inspector. Ajoutez les lignes suivantes au dbut du script:
var startPosition: oat = -1.0; var endPosition: oat = 0.5; var speed: oat = 1.0; private var StartTime: oat;
Le nom de ces variables indique leurs fonctions respectives les variables startPosition et endPosition contrlent la position du texte selon les coordonnes de lcran (do la valeur de1 pour la position de dpart, cest--dire en dehors de lcran). Il sagit de variables publiques que vous pourrez ajuster dans le panneau Inspector. La variable speed servira multiplier la vitesse de lanimation au cours du temps, donc sa valeur par dfaut est1.
Chapitre 9
Dernires retouches
253
Enfin, la variable StartTime de type oat est utilise uniquement dans le script, aussi estelle dclare comme prive. Elle stockera la valeur de temps dj coule au moment o la scne est charge. Sans cela, les instructions seraient prsentes lcran si le joueur revenait cette scne, car la valeur de temps que vous allez utiliser dcompte partir du premier chargement du jeu. Pour dfinir la valeur de cette variable, vous enregistrerez la commande time de Unity lors du chargement de la scne laide de la fonction suivante:
function Start(){ StartTime = Time.time; }
prsent, la variable StartTime utilise cette valeur au chargement de la scne. Elle va vous servir crer lanimation du texte. Insrez quelques lignes avant laccolade 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 laxe spcifique du paramtre Position du composant Transform sur lequel il va agir:
transform.position.x
Puis il dfinit cette valeur comme gale une fonction mathmatique Mathf , appele lerp (pour linear interpolation), qui effectue une interpolation linaire entre deux valeurs. Les valeurs transmises cette fonction sont dfinies 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 laxeX. Le troisime paramtre de la fonction lerp correspond limportance de linterpolation; avec une valeur de1, la valeur renvoye passe compltement de la valeur de dbut la valeur de fin, tandis quaucun changement ne se produit avec une valeur de0. Comme cette interpolation doit se drouler dans le temps, le script nutilise pas une seule valeur mais la commande prdfinie time.time de Unity pour compter le temps coul et lui soustraire la valeur de StartTime dfinie plus tt une rinitialisation relle de sa valeur afin de compter partir de0. Enfin, cette ligne modifie le temps en multipliant le rsultat par la variable speed. Actuellement, cette variable speed est dfinie 1, donc aucun changement ne sera apport, mais toute valeur suprieure 1 aura pour effet daugmenter la vitesse, et toute valeur infrieure 1 de la diminuer.
254
Cette commande doit tre place dans la fonction Update(), car les changements progressifs produits par la fonction lerp doivent seffectuer 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 vrifier:
var startPosition: oat = -1.0; var endPosition: oat = 0.5; var speed: oat = 1.0; private var StartTime: oat; function Start(){ StartTime = Time.time; } function Update () { transform.position.x = Mathf.Lerp(startPosition, endPosition, (Time.timeStartTime)*speed); }
Cliquez sur File> Save dans lditeur de script puis revenez dans Unity. Maintenant, vous allez appliquer le script et rgler les paramtres des variables publiques dans le panneau Inspector pour vous assurer quil ralise ce que vous souhaitez. Slectionnez lobjet Instructions Text dans le panneau Hierarchy puis cliquez sur Component> Scripts> Animator pour ajouter ce script comme composant. Les valeurs par dfaut des variables publiques dfinies dans le script saffichent.
Figure9.10
Pour voir cet effet en action, vous devez lancer la lecture de la scne. Mais avant, vous devez supprimer le menu qui a t dupliqu depuis la scne Menu originale. Si vous avez choisi le menu bas sur lobjet GUI Texture, vous devez alors dsactiver les trois objets boutons. Si vous utilisez le menu bas sur le script, dsactivez lobjet sur lequel ce script est attach en tant que composant. Reportez-vous au chapitre prcdent pour en savoir plus sur la dsactivation des lments, si ncessaire.
Chapitre 9
Dernires retouches
255
Une fois le menu dsactiv, revenez lobjet Instructions Text. Dfinissez le paramtre Anchor sur Middle Center et le paramtre Alignment sur Left dans le composant GUIText, puis cliquez sur le bouton Play pour visualiser lanimation. Votre texte doit se dplacer sur laxeX et apparatre depuis la gauche de lcran pour se placer une position centrale de0,5. Cliquez de nouveau sur Play pour terminer le test avant de poursuivre. Pour que lapparition du texte se produise de la droite vers la gauche, la valeur de la variable publique Start Position doit tre suprieure 1,0 puisque cela correspond aux coordonnes du bord droit de lcran. En revanche, pour que lanimation se droule sur laxeY, vous devriez modifier laxe dans le script, en indiquant par exemple: transform. position.y = Mathf (...).
Revenir au menu
La scne sur laquelle vous travaillez est distincte du menu principal et vous avez donc besoin dintgrer un bouton qui permettra au joueur de revenir la scne Menu elle-mme. Sinon, il resterait coinc sur cet cran Instructions! Pour cela, vous choisirez la technique dcriture de scripts GUI aborde au chapitre prcdent et vous dupliquerez une partie des travaux existants, ce qui vous fera gagner du temps. Slectionnez le script MainMenuGUI2 dans le dossier Scripts du panneau Project, puis dupliquez-le (Cmd/Ctrl+D). Unity numrote les objets et les ressources quil cre, cette copie se nomme donc MainMenuGUI3. Renommez ce script BackButtonGUI, puis doublecliquez sur son icne pour louvrir dans lditeur de script. Dans la premire instruction if de la fonction OnGUI(), modifiez le texte sur le bouton pour que le mot Back saffiche au lieu de Play. Remplacez ensuite la chane de caractres Island Level dans lappel la fonction OpenLevel() par Menu. La condition doit tre:
if(GUILayout.Button ("Back")){ OpenLevel("Menu"); }
Ce script doit seulement gnrer un bouton; vous devez supprimer les deux autres instructions if de la fonction pour ne conserver que celle qui concerne le retour la scne Menu. Le seul problme concerne ici le positionnement du bouton. Comme nous utilisons la variable screenY du script MainMenuGUI2, la zone de linterface graphique dans laquelle est dessin le bouton se trouve au centre de lcran, si bien que ce dernier risque de chevaucher le texte. Pour contourner ce problme et dcaler le bouton vers le bas, modifiez la dcla ration de la variable screenY pour quelle utilise une valeur lgrement infrieure:
var ScreenY = ((Screen.height / 1.7) - (areaHeight / 2));
Ainsi, le bouton sera plac plus bas que le texte contenant les instructions.
256
Le script termin BackButtonGUI doit tre le suivant:

var var var var beep: AudioClip; menuSkin: GUISkin; areaWidth: oat; areaHeight: oat;
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 lditeur de script puis revenez Unity. Comme pour tous les lments dinterface grs par le script, vous devez attacher le script un objet pour que ce bouton saffiche. Aussi, cliquez sur GameObject> Create Empty pour crer 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 dcrire. Les valeurs des variables publiques du script doivent tre dfinies. Vous devez donc:
faire glisser la squence 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; dfinir la variable Area Width 200; dfinir la variable Area Width 75, puisque lcran ne compte quun seul bouton.
Le bouton Back est maintenant termin. Avant de tester le menu entier, vous devez ajouter la scne Instructions aux paramtres 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
Dernires retouches
257
Laliste des niveaux dans les paramtres Build Settings doit maintenant correspondre celle de la Figure9.11.
Figure9.11
Fermez la bote de dialogue Build Settings puis cliquez sur le bouton Play pour tester la scne. Le bouton Back doit safficher et lanimation de lapparition du texte se drouler. Cliquez sur le bouton Back pour afficher la scne Menu. Si rien de tout cela ne fonctionne, vrifiez que votre script correspond aux changements numrs prcdemment. La Figure9.12 illustre laspect que doit avoir lcran prsentant les instructions.
Figure9.12
Terminez le test de la scne, puis cliquez sur File> Save Scene pour la sauvegarder.
258
Lapparition en fondu de la scne Island Level

Afin damliorer larrive du joueur dans lenvironnement du jeu, vous allez faire apparatre le niveau de lle avec un fondu en entre, laide dune texture GUI qui couvrira tout lcran avant de disparatre peu peu. Pour cela, vous appliquerez la technique dinter polation linaire que vous venez dapprendre. Double-cliquez sur licne de la scne Island Level pour louvrir. Le dossier Volcano que vous avez import plus tt contient un fichier de texture nomm white. Cette texture est une image de couleur blanche unie de 6464pixels cre dans Photoshop. Ces dimensions peuvent sembler trop petites pour recouvrir tout lcran, mais il nest pas utile que le fichier soit plus grand puisquil sagit dun aplat de couleur vous allez donc simplement lagrandir la taille de lcran. Slectionnez la texture, puis dcochez la case Generate Mip Maps dans le composant Texture Importer du panneau Inspector pour que Unity ne cre pas de versions plus petites de cette texture (cette option est utile pour les textures sur les objets3D). Cliquez ensuite sur le bouton Apply situ au bas du composant pour confirmer cette modification. Vous allez crire un script pour que cette texture occupe la totalit de lcran puis, laide dune interpolation, quelle disparaisse en fondu lors du lancement de la scne. Le jeu saffichera depuis un fondu au blanc. Slectionnez le dossier Scripts, cliquez sur le bouton Create et slectionnez JavaScript dans le menu droulant. Renommez ce script FadeTexture, puis double-cliquez sur son icne pour louvrir dans lditeur de script. Commencez par dclarer les deux variables publique et prive suivantes:
var theTexture: Texture2D; private var StartTime: oat;
La premire variable stocke la texture blanche prte tre tire sur toute la surface de lcran. La seconde est un nombre virgule flottante 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 dure coule car Time.time sexcute au moment o la premire scne du jeu (le menu) est charge. Ce menu est le premier lment du jeu que voit le joueur, aussi Time.time nest pas gal 0 quand la scne Island Level se charge.
Chapitre 9
Dernires retouches
259
Vous soustrairez ensuite cette valeur de la variable qui stocke le temps courant afin dobtenir une valeur partir de laquelle compter. Insrez le script suivant dans la fonction Update():
if(Time.time-StartTime >= 3){ Destroy(gameObject); }
Cette instruction if contrle la valeur actuelle de Time.time et lui soustrait le temps coul au chargement de la scne courante, StartTime. Si cette valeur est suprieure ou gale 3, alors le script dtruit lobjet de jeu sur lequel ce script est attach aprs trois secondes. En effet, une fois que leffet fondu sest produit, cet objet na plus aucune utilit dans la scne.
Le rendu de la texture UnityGUI

Crez 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 sadresse directement la classe GUI. La premire ligne dsigne le paramtre color et le dfinit comme gal une constante prdfinie de la classe Color nomme white. Une fois cette couleur dfinie, le script utilise la commande GUI.color.a pour dsigner son paramtre alpha sa visibilit. La mme commande Mathf.Lerp que vous avez utilise pour animer lobjet GUI Text plus tt cre ici une interpolation de la valeur alpha de1.0 (entirement visible) 0.0 (invisible). Le troisime paramtre de la boucle dfinit la dure de cette interpolation. Comme celle-ci dpend du rsultat de la soustraction Time.timeStartTime, le dcompte commence effectivement 0.0, puis sa valeur augmente mesure que le temps passe. Ainsi, linterpolation linaire volue dans le temps et produit un effet de fondu. La troisime ligne procde au rendu de la texture elle-mme, laide de la commande
DrawTexture de la classe GUI. Le paramtre Rect sert tracer une zone rectangulaire
partir de0.0 le coin suprieur gauche de lcran puis sassurer que cette texture stire sur la totalit de lcran laide de screen.width et screen.height. En adaptant ainsi automatiquement la taille de la texture celle de lcran, le fondu fonctionnera quelle que soit la rsolution. Cliquez sur File> Save dans lditeur de script et revenez dans Unity.
260
Dans Unity, cliquez sur GameObject > Create Empty pour crer un objet GameObject dans le panneau Hierarchy. Renommez-le Fader puis cliquez sur Component > Scripts> Fade Texture pour lui attacher le script que vous venez dcrire. 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. Lcran doit safficher en blanc puis la scne apparatre en fondu avant que lobjet white du panneau Hierarchy ne soit supprim aprs trois secondes. Terminez le test, puis cliquez sur File> Save Scene pour sauvegarder le projet.
Notifier la fin du jeu

Pour finir, vous allez indiquer au joueur quil a termin avec succs le jeu quand le feu est allum, le but atteindre. Ouvrez le script PlayerCollisions dans le dossier Scripts du panneau Project puis faites dfiler son contenu vers le bas. Vous allez ajouter quelques commandes supplmentaires dans la dernire fonction du script, lightre(). Pour cela, insrez quelques lignes avant son accolade de fermeture, la suite de cette ligne:
Destroy(GameObject.Find("matchGUI"));
Insrez ensuite les commandes suivantes:

TextHints.textOn=true; TextHints.message = "Vous avez allum le feu et vous survivrez cette preuve, flicitations!"; yield new WaitForSeconds(5); Application.LoadLevel("Menu");
Ces lignes utilisent lobjet GUI TextHints pour afficher lcran la chane de caractres: "Vous avez allum le feu". La commande yield met ensuite le script en pause pendant cinq secondes, puis charge le niveau Menu du jeu, afin que le joueur puisse recommencer la partie. Cliquez sur le bouton Play et testez le jeu dans son intgralit. Vous devez pouvoir collecter trois piles, gagner la quatrime en abattant les trois cibles coups de noix de coco, entrer dans lavant-poste, ramasser les allumettes et enfin allumer le feu. Le message du script prcdent doit alors safficher et vous devez revenir lcran du menu principal. Aprs avoir vrifi cela, arrtez le test, puis cliquez sur File> Save Scene pour sauvegarder votre projet.
Chapitre 9
Dernires retouches
261
En rsum
Nous venons de voir comment apporter diffrentes touches de finition aux jeux. Les effets visuels, de lumire et les animations abords ici ne font queffleurer la surface de ce quil est possible de faire avec Unity. Cependant, mme si Unity permet de polir laspect de votre jeu afin quil se dmarque vraiment, vous devez garder lesprit que ces oprations seffectuent uniquement une fois que le gameplay de votre projet est termin. Comme leur nom lindique, les finitions sont un excellent moyen de finaliser un projet, mais la jouabilit doit toujours primer. prsent que le jeu est termin, vous verrez au prochain chapitre comment le compiler et tester diffrentes versions et vous apprendrez ce que recouvre ce processus de dploiement. Vous dcouvrirez galement certaines optimisations supplmentaires et la manire de publier votre jeu en tant que dveloppeur indpendant.
10
Compilation et partage
Afin de transformer ce simple exemple de jeu en une version de test, vous devez tenir compte des diffrentes plates-formes sur lesquelles il sera dploy et ladapter une diffusion sur le Web. La meilleure mthode pour un dveloppeur consiste partager son travail. Unity permet de crer diffrentes versions dun jeu, diffrentes tailles et avec plusieurs niveaux de compression des textures et des ressources. Vous devez galement implmenter une mthode de dtection de la plate-forme pour les jeux destins au Web. En effet, certains paramtres devront tre ajusts lors du dploiement en ligne, ce qui est inutile pour une application autonome. Les versions standard et Pro de Unity permettent de crer des applications autonomes pour MacOS et Windows, des widgets pour le Dashboard (Tableau de bord) de MacOSX ou des jeux destins aux navigateurs web (le joueur doit tlcharger un plugin). Au cours de ce chapitre, vous dcouvrirez de quelle manire personnaliser les ressources selon que vous crez un jeu destin au Web ou une application autonome. Vous verrez comment:
ajuster les paramtres Build Settings afin dexporter le jeu; concevoir une version web et une version autonome du jeu;
264
dtecter la plate-forme client pour supprimer des lments dans le jeu destin au Web; partager les jeux avec dautres personnes et en savoir plus sur le dveloppement dans Unity.
Les paramtres Build Settings

Dans Unity, cliquez sur File> Build Settings, et observez les options disponibles. Vous devriez voir les diffrentes options mentionnes prcdemment (voir Figure10.1).
Figure10.1
Dans la bote de dialogue Build Settings, les crations destines une utilisation sous MacOS sont marques par le prfixe OSX, la gnration actuelle de ce systme dexploitation. Plusieurs options sont disponibles car il existe diffrentes gnrations de Mac dont vous devez tenir compte: la gnration prcdente utilisait le processeur PowerPC tandis que la gnration actuelle sarticule autour des processeurs Intel. Le paramtre Universal Binary cre un fichier binaire OSX qui peut sexcuter aussi bien sur les anciens systmes PowerPC que sur les nouveaux systmes Intel. Le fichier est alors plus volumineux, puisque lapplication contient dans les faits deux copies de votre jeu.
Chapitre 10
265
Dans notre exemple, la bote de dialogue Build Settings contient la liste des scnes que vous avez ajoutes au projet jusqu prsent, commencer par la scne Menu. Il est important que la premire scne vue par le joueur soit le premier lment de la liste Scenes to build. Si votre menu ou la premire scne nest pas en tte de cette liste, faites glisser le nom des scnes vers le haut ou vers le bas pour modifier leur ordre dapparition dans le jeu. Commenons par examiner les diffrentes options et voir ce que chacune delles permet dobtenir.
Loption Web Player

Pour diffuser sur le Web du contenu ncessitant un plugin, vous devez intgrer ce contenu en tant quobjet qui appelle le plugin install. Les joueurs devront tlcharger le plugin pour leur navigateur web afin dafficher les crations effectues dans Unity, de la mme manire que le contenu Adobe Flash oblige les utilisateurs tlcharger le lecteur Flash Player. Loption Web Player cre un fichier de jeu qui porte lextension .unity3D et appelle le plugin Web Player, ainsi quun fichier HTML qui contient le code dintgration ncessaire. Ce code HTML peut ensuite tre intgr dans une page web de votre propre conception.
Les paramtres du lecteur web

Les lecteurs web utilisent le navigateur pour charger le code HTML contenant lappel au plugin. Par consquent, le navigateur sollicite dj le processeur de lordinateur sur lequel le jeu sexcute. Il est donc conseill de rduire la rsolution du jeu par rapport celle que vous utiliseriez pour une application autonome. Le jeu de notre exemple a t conu avec une rsolution dentre de gamme de 1024768pixels. Toutefois, lors du dploiement sur un site web, la taille de lcran doit tre rduite (640480 par exemple). Cela permet de diminuer la charge sur le processeur car les images quil doit crer sont plus petites, ce qui amliore les performances. Pour rgler ces paramtres, vous devez tudier les paramtres Player Settings. Cliquez sur Edit > Project Settings > Player pour afficher les paramtres du projet dans le panneau Inspector. Lors de la finalisation du jeu, votre projet se place effectivement dans un lecteur qui appelle lui-mme le plugin une fois sur le Web. Les paramtres Player Settings vous permettent de dfinir certains lments que le joueur utilisera, comme la rsolution de lcran.
266
Figure10.2
Vous devez commencer par indiquer certains dtails sur votre projet. Ajoutez le nom de lentreprise dans le champ Company Name et le nom du produit dans le champ Product Name (rien de trs officiel dans notre exemple). Indiquez ensuite la largeur et la hauteur de lcran par dfaut dans les champs Default Screen Width et Default Screen height, en entrant 1024768, soit la rsolution laquelle le jeu a t conu. Donnez aux paramtres Default Web Screen Width et Default Web Screen Heigth les valeurs640 et480 respectivement (voir Figure10.2). Le seul autre paramtre important pour le dploiement 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 crer des crans de chargement dans votre jeu. Si tel est le cas, vous devez alors utiliser ce paramtre pour choisir le premier niveau qui contient les ressources charger en indiquant son numro sur la liste de la bote de dialogue Build Settings. Dans notre exemple, le premier cran (le menu) contient les ressources de lle, si bien que vous pouvez conserver la valeur par dfaut,0, pour ce paramtre. Nous tudierons bientt plus en dtail les paramtres du lecteur lorsque vous verrez comment crer une application autonome.
Loption Web Player Streamed

Les utilisateurs sont gnralement impatients, et il est important que vous limitiez autant que possible le temps dattente lorsque vous crez des jeux destins au Web. Avec loption Web Player Streamed (lecteur web en continu), le joueur peut commencer jouer avant que la totalit des ressources ne soit charge le chargement se poursuit pendant que le joueur interagit avec la premire scne.
Chapitre 10
267
Ce facteur est absolument essentiel lorsque vous prsentez votre cration sur un portail de jeux comme www.shockwave.com, www.wooglie.com ou www.blurst.com. Pour ces sites, votre jeu doit tre jouable ds que 1 Mo de donnes environ a t tlcharg. En acceptant ces directives, vous augmentez vos chances de voir ces sites prsenter votre jeu, ce qui vous permet de toucher une plus large audience. Pour plus dinformations ce sujet, visitez le site web de Unity.
Loption OS X Dashboard Widget

Sur les systmes dexploitation MacOS (version10.4 et suivantes), le Dashboard regroupe un ensemble doutils et dapplications simples, les widgets, qui peuvent tre affichs tout moment en superposition sur lcran. Unity peut publier votre jeu sous la forme dun widget, vous offrant ainsi un autre moyen pour le diffuser. Ce type de dploiement peut tre adapt pour un puzzle ou un jeu de passe-temps simple. Toutefois, cette mthode est moins adapte notre jeu de randonne la premire personne. La Figure 10.3 illustre laspect de notre jeu publi pour le Dashboard de MacOS:
Figure10.3
268
Dans lidal, les jeux dploys en tant que widgets doivent rester simples. Il est en effet prfrable dviter le chargement de nombreuses donnes dans un widget car ce dernier reste en mmoire et le jeu se poursuit lorsque le Dashboard est activ et dsactiv.
Les options OSX/Windows Standalone

Les applications autonomes sont des programmes part entire qui peuvent tre distribus de la mme manire quun jeu commercial. En crant une application autonome pour Mac OS X, vous obtenez un seul fichier applicatif qui regroupe toutes les ressources ncessaires. Sous Windows, cette option cre un dossier contenant un fichier .exe. (excutable) et les ressources ncessaires au fonctionnement. Une application autonome est la meilleure faon de garantir que les performances du jeu seront les meilleures, dune part parce que les fichiers sont stocks en local et non en ligne mais aussi parce que la puissance du processeur nest pas partiellement sollicite par un navigateur ou par le Dashboard de MacOSX.
Gnrer le jeu
Maintenant que vous tes prt gnrer le jeu, vous devez examiner ces diffrentes mthodes de dploiement et adapter votre projet pour le diffuser sur le Web et en tant que jeu autonome.
Adapter les paramtres pour le Web

Dans Unity, le moteur redimensionne le monde 3D sur lequel vous travaillez en fonction de la rsolution que vous dfinissez dans les paramtres Player Settings. Vous avez galement conu les menus de ce projet pour quils sadaptent diffrentes rsolutions, en utilisant la classe Screen, pour que les lments de linterface graphique se placent en fonction de la rsolution en cours. Toutefois, afin den apprendre davantage sur la dtection de la plateforme, vous allez supprimer un lment qui ne doit pas apparatre dans la version en ligne: le bouton Quit. Double-cliquez sur licne du script MainMenuGUI2 situ dans le dossier Scripts du panneau Project, pour louvrir dans lditeur de script.
Chapitre 10
269
Ajouter ou supprimer automatiquement le bouton Quit Comme il sagit dune version du jeu destine au Web, le bouton Quit du menu nest pas utile. En effet, la commande Application.Quit() ne fonctionne pas lorsquun jeu Unity est excut dans un navigateur web. Les joueurs ferment tout simplement la page sur laquelle se trouve le jeu ou se rendent une autre adresse lorsquils ont fini de jouer. Vous devez donc retirer ce bouton du menu pour la version destine au Web, mais sans le supprimer de votre script, puisquil doit tre prsent dans la version autonome du jeu. Pour rsoudre ce problme, vous allez utiliser une autre partie de la classe Application appele platform, qui permet de dtecter le type de dploiement (application autonome, Web ou widget du Dashboard) choisi pour le jeu. Pour cela, vous devez ajouter la ligne suivante aprs linstruction if:
if(Application.platform == RuntimePlatform.OSXWebPlayer || Application.platform == RuntimePlatform.WindowsWebPlayer)
Cette ligne vrifie le paramtre platform de la classe Application afin de savoir si le jeu est en cours dexcution sous Mac OS (OSXWebPlayer) ou sous Windows (WindowsWebPlayer) le symbole || signifie simplement "OU". Autrement dit, si le jeu est en cours dexcution sur un lecteur web, le script doit raliser une opration. Vous devez en outre combiner cette condition avec une instruction else car le rendu du bouton Quit doit tre effectu si le jeu nest pas dploy pour le Web. Localisez linstruction if charge de crer le bouton Quit dans la fonction OnGUI():
if(GUILayout.Button ("Quit")){ Application.Quit(); }
Ajoutez la structure if else suivante, en plaant linstruction 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
Nous avons laiss une ligne vide lorsque la condition if est satisfaite et plac le code du bouton Quit dans la partie else, afin quil soit cr uniquement si le script dtecte que le jeu ne sexcute pas sur le Web. Maintenant localisez les deux instructions if qui procdent 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 linstruction if que vous venez dajouter, afin 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 dtection initiale dcouvre que le jeu sexcute en ligne et le rendu du bouton Quit si le jeu nest pas en ligne. Mais vous avez galement besoin des boutons Play et Instructions pour lapplication autonome. Pour cela, copiez et collez la partie du code de ces boutons dans linstruction else galement. Linstruction de dtection termine doit tre la suivante:
if (Application.platform == RuntimePlatform.OSXWebPlayer || Application.platform == RuntimePlatform.WindowsWebPlayer){ if(GUILayout.Button ("Play")){ OpenLevel("Island Level"); }
Chapitre 10
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 concerns dans la condition if, tandis que la condition else agit sur le rendu des boutons Play, Instructions et Quit. Cliquez sur File> Save dans lditeur de script puis revenez dans Unity. Le rendu du bouton Quit seffectue automatiquement si le jeu nest pas diffus sur le Web. Vous disposez maintenant dun ensemble de ressources de scne qui peuvent tre places sur la liste des paramtres Build Settings avec le niveau Island Level pour le lecteur web Player ou Web Player Streamed. Maintenant, voyons comment crer la fois les versions Web et autonome du jeu.
La compression des textures et le dbogage

Lorsque vous slectionnez un systme dexploitation, Unity compresse pour vous les textures utilises dans le jeu en fonction de leurs paramtres dimportation. Dans la plupart des cas, vous devez galement dsactiver loption Development build lorsque votre jeu est prt tre gnr afin de supprimer tout le code superflu de la classe Debug de vos scripts comme la commande Debug.Log que vous avez utilise au Chapitre8.
Crer une version autonome

Les versions autonomes du jeu souvrent par dfaut sur un cran de dmarrage, la bote de dialogue Resolution Dialog, qui permet aux utilisateurs de personnaliser la rsolution du jeu, voire les paramtres dentre et daffichage. En tant que dveloppeur, vous pouvez ajouter une image dans cet cran.
272
La Figure 10.4 illustre laspect la bote de dialogue Resolution Dialog par dfaut (version MacOS):
Figure10.4
La plupart des dveloppeurs prfrent garder cet cran activ, car il permet au joueur de choisir la rsolution et la qualit daffichage qui correspondent le mieux son ordinateur. Cependant, vous pouvez le dsactiver si vous souhaitez forcer les utilisateurs jouer dans une rsolution en particulier. Pour dsactiver cet cran, cliquez sur Edit> Project Settings> Player et slectionnez Disabled pour le paramtre Display Resolution Dialog. Enfin, vous pouvez activer loption Default is Full Screen pour que le jeu sexcute obligatoirement en mode plein cran, si vous ne voulez que le jeu souvre dans une fentre, comme cest le cas par dfaut. Nanmoins, les joueurs peuvent toujours afficher la bote de dialogue Resolution Dialog en appuyant sur la touche Alt (aussi appele Option sous MacOS) lors du lancement de lapplication (ce raccourci peut tre trs utile pour les versions de test). Pour intgrer une bannire graphique qui saffiche dans la partie suprieure de la bote de dialogue REsOLUTION DIALOg, vous devez enregistrer une image de 432163pixels dans votre projet, puis la slectionner dans le menu droulant REsOLUTION DIALOg BANNER du panneau PLAYER SETTINgs.
ce Astu
Chapitre 10
273
Cliquez sur File> Build Settings et veillez ce que les trois scnes suivantes saffichent sur la liste Scenes to build:
Menu.unity Island Level.unity Instructions.unity Si une scne ne figure pas sur la liste, vous pouvez toujours la faire glisser depuis le panneau PROJECT sur la liste BUILD SETTINgs.
Info
Il est important que la scne Menu soit en premire position sur la liste car elle doit se charger en premier. Aussi, assurez-vous quelle est en position0. La compression des textures permet au jeu de se charger plus rapidement mais la premire compilation du jeu peut prendre plus de temps, car les textures sont compresses pour la premire fois. Slectionnez le format utiliser: Windows, pour crer une application pour WindowsXP, Vista7 et les versions suivantes, ou MacOS en tenant compte des processeurs PowerPC, Intel ou des deux (universal binary). Cliquez sur le bouton Build au bas de la fentre de dialogue pour indiquer o vous souhaitez sauvegarder votre jeu. Parcourez ensuite le disque dur jusqu lemplacement 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 cre votre jeu. Diffrentes barres de progression indiquent que les ressources sont compresses, puis lavancement de la compilation de chaque niveau. Une fois le processus termin, le jeu finalis, prt tre utilis, souvre dans une fentre du systme dexploitation. Pour lancer le jeu, double-cliquez sur lapplication (MacOS) ou ouvrez le dossier contenant le jeu, puis double-cliquez sur le fichier .exe (Windows). Gardez lesprit que, si vous construisez une version Windows sous MacOS, 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 saffiche avant le chargement du jeu (voir Figure10.5). Ce nest pas le cas avec la version Pro de Unity.
274
Figure10.5
Les diffrences entre les deux versions, comme le manque dombres dynamiques dans la version gratuite, sont numres ladresse suivante: http://unity3d.com/unity/licenses.html.
Compiler pour le Web

Dans Unity, cliquez sur File> Build Settings pour ouvrir la bote de dialogue Build Settings, puis sur le bouton radio Web Player et, enfin, sur Build. Unity se charge des conversions et des compressions ncessaires pour crer un jeu fluide sur le Web. Et ce nest que lun de ses nombreux charmes! Indiquez le nom du jeu et lemplacement o enregistrer le fichier puis cliquez sur Enregistrer pour confirmer. Une fois le processus termin, le systme dexploitation affiche le dossier dans lequel le jeu est enregistr. Deux fichiers sont ncessaires pour que la compilation fonctionne: le jeu lui-mme (un fichier portant lextension .unityweb) et un fichier HTML contenant le script ncessaire (HTML et JavaScript) pour charger le jeu ou inviter lutilisateur tlcharger le plugin Unity Web Player.
Chapitre 10
275
Pour lancer le jeu, ouvrez le fichier HTML dans le navigateur web de votre choix.
Adapter le jeu destin au Web

Unity fournit par dfaut le code HTML/JavaScript ncessaire pour intgrer le fichier .unityweb dans une page web. Aussi, il vous suffit 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 dtection balise <HEAD> Ouvrez la page HTML qui accompagne le jeu compil dans lditeur de script fourni avec Unity ou votre diteur HTML favori, comme Dreamweaver, SciTE, TextMate ou Text Wrangler. Slectionnez tout le code de la partie <head> de la balise douverture <script> la balise de fermeture </script> puis copiez-le dans un nouveau document JavaScript. Enregistrez ensuite ce fichier sous le nom UnityDetect.js. Vous pouvez ensuite sauvegarder ce fichier dans le mme dossier que vos pages web et appeler ce code JavaScript dans la section den-tte (entre les balises <head>) de votre page web laide de la ligne de code HTML suivante:
<script type="text/JavaScript" src="UnityDetect.js"></script>
Intgrer lobjet balise <BODY> Pour intgrer lobjet lui-mme dans une page, copiez tout le code de la section <body> de la balise douverture <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 fichier .unityweb doit tre dans le mme dossier que la page contenant le code HTML qui lappelle.
Les paramtres de qualit

Lors de lexportation depuis Unity, vous pouvez contrler la qualit de votre production. Cliquez sur Edit > Project Settings > Quality pour afficher les paramtres Quality Settings dans le panneau Inspector. Vous pouvez choisir parmi six rglages de qualit prdfinis: Fastest, Fast, Simple, Good, Beautiful et Fantastic. Vous pouvez galement modifier ces prrglages pour obtenir des rsultats plus prcis. Comme vous dbutez avec Unity, nous allons voir et comparer le rglage privilgiant la fluidit, Fastest, celui qui privilgie la qualit, Fantastic.
276
Figure10.6
Comme vous pouvez le constater (voir Figure10.6), les paramtres de chaque option sont dfinis de manire trs diffrente:
Pixel Light Count. Le nombre de lumires au pixel qui peut tre utilis dans une scne. Le rendu des lumires dans Unity seffectue sous la forme dun pixel ou dun sommet, un processus qui amliore laspect des pixels mais qui est plus coteux pour le processeur. Ce paramtre Pixel Light Count permet de dfinir le nombre de lumires au pixel (les autres lumires tant rendues comme des lumires au sommet). Cest pourquoi il est dfini sur0 dans le rglage prdfini Fastest, avec lequel la qualit est la moins leve. Shadows. Cette fonctionnalit est seulement effective dans la version Pro de Unity. Elle permet dindiquer 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 lombre).
Chapitre 10
277
Shadow Resolution. Ce paramtre, effectif, lui aussi, uniquement dans Unity Pro, permet de dfinir la qualit du rendu des ombres. Cela peut tre utile pour amliorer les performances lorsque plusieurs objets ont des ombres dynamiques dans la scne choisir une basse rsolution permet doptimiser les ombres sans les dsactiver entirement. Shadow Cascades. Unity Pro profite de Cascade Shadow Maps pour amliorer laspect des ombres sur les lumires directionnelles dans la scne en utilisant la mme carte pour les ombres sur des zones plus importantes en fonction de la distance. Les zones les plus proches de la camra du joueur ont une carte dombres plus dtaille, ce qui amliore la qualit. Shadow Distance. Analogue au paramtre Far Clip Plane, qui limite la distance de rendu de la camra, ce paramtre est un autre niveau de rglage des dtails. Il peut tre utilis pour dfinir la distance aprs laquelle le rendu des ombres nest pas effectu. Blend Weights. Sert lorsque des personnages disposent dune ossature danimation, en contrlant son niveau de complexit. Unity Technologies conseille dutiliser loption 2Bones pour obtenir un bon compromis entre performance et qualit visuelle. Texture Quality. Comme son nom lindique, ce paramtre dfinit limportance de la compression des textures. Anisotropic Textures. Le filtrage anisotropique peut contribuer amliorer lapparence des textures vues sous un angle prononc, comme les collines, mais le cot en termes de performances est important. Gardez lesprit que vous pouvez galement configurer le filtrage de chaque texture dans les paramtres Import Settings des ressources. Anti Aliasing. Pour adoucir les contours des lments en3D, ce qui amliore considrablement laspect du jeu. Comme pour les autres filtres cependant, le cot est lev. Soft Vegetation. Permet aux lments de terrain de Unity, comme la vgtation et les arbres, dutiliser le paramtre alpha blending. Cela donne un meilleur aspect aux zones transparentes des textures utilises pour reprsenter la vgtation. Sync to VBL. Ce paramtre force le jeu se synchroniser avec le taux de rafrachissement du moniteur du joueur. En gnral, cela entrane une dgradation des performances mais permet dviter leffet de "dchirure" entre les lments dans le jeu: les sommets semblent mal aligns si bien que les textures saffichent dcales et spares par une coupure horizontale.
278
Vous pouvez modifier ces rglages prdfinis si cela apporte un avantage pour le joueur, puisque ce dernier aura la possibilit de les redfinir dans la bote de dialogue Rsolution Dialog (voir la section "Crer une version autonome" de ce chapitre) lors du lancement du jeu, moins que vous nayez dsactiv cette option. Toutefois, nous vous conseillons, dans la plupart des cas, dutiliser les rglages prdfinis de Unity comme guides et de simplement ajuster certains paramtres en particulier, si cela est ncessaire.
Les paramtres dentre du lecteur

Bien que le joueur puisse ajuster les contrles dentre de votre jeu sous longlet Input de la bote de dialogue Rsolution Dialog (voir Figure10.7) lorsquil sagit dune application autonome, sachez que vous pouvez dfinir vos propres valeurs de contrle par dfaut dans les paramtres Player Input Settings. Cest particulirement utile pour les jeux destins au Web, car le joueur ne peut alors pas modifier ces paramtres lors du chargement du jeu. Il est donc prfrable que vous les dfinissiez et les indiquiez au joueur dans linterface graphique du jeu.
Figure10.7
Dans Unity, cliquez sur Edit > Project Settings > Input pour afficher les axes de contrle disponibles dans le panneau Inspector. La valeur Size indique simplement le nombre de contrles existants. En augmentant cette valeur, vous pouvez crer vos propres contrles. Vous pouvez galement cliquer sur la flche grise gauche de chaque paramtre dentre pour afficher les axes disponibles et ajuster leurs valeurs.
Chapitre 10
279
Figure10.8
Vous pouvez voir comment lier ces axes dans le script CoconutThrow que vous avez crit plus tt:
if(Input.GetButtonUp("Fire1")
Ici, laxe Fire1 est rfrenc par son nom. En changeant la valeur du paramtre Name dans les paramtres dentre, vous pouvez dfinir ce qui doit tre crit dans le script. Pour plus dinformations sur les touches que vous pouvez lier ces paramtres, reportez-vous la page Input du manuel de rfrence de Unity disponible ladresse suivante: http://unity3d.com/support/documentation/Manual/Input.html.
280
Diffuser votre cration

Vous pouvez non seulement intgrer votre lecteur web dans votre propre site, mais aussi passer par diffrents portails de jeux indpendants qui permettent aux dveloppeurs de partager leurs travaux. Voici quelques sites que nous vous recommandons de visiter au moins une fois lorsque vous serez prt partager votre cration 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 dautres personnes, non seulement pour dmontrer vos talents de dveloppeur, 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 dliminer les bogues et de corriger les parties de votre jeu dont le fonctionnement ou le but, vidents pour vous, se rvlent peu intuitifs pour le joueur ordinaire. Sachez galement que certains sites ne pourront pas hberger votre jeu au format .unityweb mais seront prts indiquer un lien vers votre propre blog qui intgre le jeu ou sur lequel une version autonome peut tre tlcharge.
En rsum
Vous avez vu comment exporter votre jeu sur le Web et en tant quapplication autonome. En conclusion, nous allons revoir tout ce que nous avons abord au cours de ce livre et nous vous indiquerons comment amliorer vos comptences et o chercher de laide pour vos futurs dveloppements dans Unity.
11
Procdures de tests et lectures complmentaires
Nous avons abord tout au long de cet ouvrage les sujets essentiels pour vous aider dvelopper avec le moteur de jeu Unity. Vous dcouvrirez que chaque nouvel lment de jeu que vous dvelopperez dans Unity vous offrira de nouvelles possibilits damliorer vos connaissances. Mieux vous connatrez le fonctionnement des scripts et plus vous aurez des ides et des concepts de jeux. Au cours de ce chapitre, nous allons voir:
comment tester et finaliser votre travail; comment mesurer le nombre dimages par seconde pour les testeurs; o trouver de laide sur Unity et ce que vous devez tudier ensuite.
Pour amliorer vos comptences, vous devriez prendre le temps dapprofondir vos connaissances dans les domaines suivants: le script; le script; le script.
282
Ce nest pas de lhumour! Unity senorgueillit doffrir une interface graphique et des outils intuitifs permettant de crer des scnes et des objets de jeu et de dvelopper des jeux dune manire visuelle, mais vous devez absolument apprendre les classes et les commandes qui constituent le moteur de Unity lui-mme. En lisant le manuel de Unity, ainsi que les guides de rfrence Component Reference et Script Reference, qui sinstallent avec le programme Unity et sont galement disponibles en ligne, vous verrez quelles sont les meilleures mthodes pour crer tous les types dlments de jeu. Elles peuvent ne pas sappliquer votre projet en cours mais elles devraient vous aider travailler plus efficacement sur le long terme:
le manuel de rfrence des composants (http://www.unity3d.com/support/ documentation/Components/); le manuel de rfrence des scripts (http://www.unity3d.com/support/documentation/ ScriptReference/); le manuel de Unity (http://www.unity3d.com/support/documentation/Manual/).
Les tests et la finalisation

Pour le dveloppement dun jeu, il est particulirement important de le faire tester par des utilisateurs qui nont aucune ide prconue. Quel que soit votre projet, vous devez rester objectif, tre ouvert aux critiques et considrer les tests comme une ncessit technique. En tant que dveloppeur, vous connaissez les principes et les mcanismes de votre jeu, si bien que vous tes souvent incapable de voir "larbre qui cache la fort" et denvisager les ractions des joueurs.
Les tests publics

Lorsque vous voulez faire tester votre jeu, envoyez des versions de test diffrentes personnes capables de vous fournir en retour les informations suivantes:
La configuration de leur ordinateur: veillez ce que votre jeu soit test sur des machines diffrentes afin den savoir plus sur les performances du jeu. Le format: essayez denvoyer une version de test pour MacOS et Windows chaque fois que cest possible. La langue: vos testeurs parlent-ils tous la mme langue que vous? Peuvent-ils vous dire si vous expliquez convenablement les lments du jeu dans les interfaces?
Chapitre 11
283
On appelle version bta la version publique du jeu propose plusieurs testeurs la version alpha tant la version de test que dautres dveloppeurs et vous-mme testez. En formalisant ce processus, vous pouvez obtenir des retours trs utiles. Pour cela, tablissez un questionnaire commun pour tous les testeurs afin de connatre leur avis sur le jeu mais galement afin de recueillir des informations sur chacun deux en tant que joueur. De cette faon, vous pouvez tirer certaines conclusions sur votre jeu. Par exemple:
"Les joueurs de 18 24ans comprennent le but du jeu et aiment ses mcanismes mais les joueurs de plus de 45ans ne comprennent pas ce quils doivent faire sans lire les instructions."
en plus des informations techniques suivantes:
"Les joueurs dont le processeur a une frquence infrieure 2,4 GHz trouvent que le jeu ragit lentement." Le nombre dimages par seconde
Afin que les testeurs de votre jeu puissent vous fournir des informations prcises sur lesaspects techniques, comme le nombre dimages par seconde (la vitesse laquelle les images du jeu saffichent pendant lexcution), vous pouvez ajouter un lment dinterface graphique indiquant cette valeur. Nous ajouterons cette indication dans une scne travers un exemple concret. Ouvrez la scne pour laquelle vous souhaitez afficher le nombre dimages en superposition, puis cliquez sur GameObject> Create Other> GUI Text pour crer un nouvel objet GUI Text qui affiche ces informations. Renommez cet objet FPS Displayer, puis dfinissez le paramtre Anchor sur upper center et le paramtre Alignment sur center dans le composant GUIText du panneau Inspector. Slectionnez le dossier Scripts dans le panneau Project, cliquez sur le bouton Create et slectionnez JavaScript dans le menu droulant. Renommez ce script FPSdisplay puis double-cliquez sur son icne pour louvrir dans lditeur de script. Comme le nombre dimages par seconde du jeu varie selon la configuration matrielle et logicielle, vous devez effectuer une somme qui tienne compte du nombre dimages qui sont rendues dans le jeu chaque seconde. Pour commencer, dclarez les variables suivantes au dbut du script:
private private private private var var var var updatePeriod = 0.5; nextUpdate: oat = 0; frames: oat = 0; fps: oat = 0;
284
Ces quatre variables sont dclares pour les raisons suivantes: updatePeriod. Le nombre de fois par seconde o le texte de linterface graphique doit tre mis jour, et donc la priode pendant laquelle le script value le nombre dimages 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 infrieure, le chiffre serait mis jour trop souvent pour tre lu aisment. Avec une valeur suprieure, une seconde par exemple, le rsultat serait moins prcis, car la frquence des images peut varier considrablement en une seule seconde. nextUpdate. Cette valeur stocke le moment o vous devez vrifier et mettre jour le nombre dimages par seconde. frames. Un numro incrment chaque image qui stocke la quantit dimages qui ont t rendues. fps. Stocke le nombre dimages par seconde. Cette valeur correspond au nombre dimages courant et sobtient en divisant la valeur de la variable frames par la variable updatePeriod. Insrez 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 oprations suivantes:
La variable frames sincrmente de1 chaque fois que la fonction Update() sexcute (aprs chaque image). Linstruction if attend que la valeur de Time.time qui dcompte en rel le temps coul depuis le dbut du jeu soit suprieure la valeur de la variable nextUpdate. Comme nextUpdate a une valeur de0 au lancement du jeu, cela se produit immdia tement aprs le chargement de la scne dans laquelle ce script se trouve. Cette instruction if dfinit ensuite si la variable fps est gale une valeur arrondie du dcompte des images divise par la valeur de updatePeriod, afin dobtenir un chiffre entier du nombre dimages par seconde et non par demi-seconde la valeur de0.5 de la variable updatePeriod. Le script sadresse au paramtre text du composant guiText et lui donne comme valeur la chane de caractres "Images par seconde:" suivie de la valeur de la variable fps.
Chapitre 11
285
La valeur de la variable nextUpdate est dfinie comme gale la somme de la valeur actuelle de time et de la variable updatePeriod. Cest essentiel pour que linstruction if sexcute de nouveau une demi-seconde plus tard. Enfin, la variable frames est rinitialise pour que lvaluation puisse recommencer partir de zro. Insrez maintenant la ligne suivante aprs la fermeture de la fonction Update(), afin de vous assurer que vous attachez ce script un objet disposant dun composant GUIText:
@script RequireComponent(GUIText)
Cliquez sur File> Save dans lditeur de script puis revenez dans Unity. Assurez-vous que lobjet FPS Displayer est toujours slectionn dans le panneau Hierarchy, puis donnez la valeur 0,9 ou 1 son paramtre Position Y. Cliquez ensuite sur Component> Scripts> FPS display. Testez ensuite votre scne. Lobjet GUI Text indiquant le nombre dimages par seconde saffiche en haut de lcran. Votre jeu se comporte diffremment en dehors de lditeur de Unity. Par consquent, vous devez tenir compte uniquement des mesures quaffiche lobjet FPS Displayer aprs avoir compil le jeu, quil sagisse dune version destine au Web ou dune application autonome. Demandez ensuite aux testeurs de noter les valeurs maximales et minimales afin de disposer de donnes utilisables. Demandez galement si certaines parties de votre jeu, comme les animations complexes de particules, ne sont pas particulirement exigeantes. Demander des relevs distincts peut tre intressant lorsque ces lments sont actifs. Comme le jeu fonctionne diffremment lintrieur et en dehors de lditeur de Unity, les valeurs affiches dans le jeu seront diffrentes de celles donnes dans longlet Stats du panneau Game (voir Figure11.1).
Figure11.1
286
Lamlioration des performances

Lamlioration des performances de votre jeu en fonction des tests est un domaine dtude part entire. Cependant, nous vous conseillons de tenir compte des points suivants pour vos dveloppements futurs:
Le nombre de polygones. Les modles 3D que vous importez doivent tre conus avec un nombre restreint de polygones (appels aussi modles low poly). Vous devez donc essayer de simplifier vos modles autant que possible pour amliorer les performances. La distance daffichage. Pensez rduire la distance du paramtre Far Clip Plane pour vos camras afin que le jeu effectue le rendu dune quantit moindre de terrain. La taille des textures. Intgrer des textures en haute rsolution peut amliorer la clart visuelle, mais elles sollicitent galement davantage le moteur du jeu. Essayez de rduire leur taille autant que possible, en utilisant votre logiciel de retouche dimage et en ajustant les paramtres dimportation de vos ressources. Des scripts efficaces. Il existe plusieurs faons diffrentes dcrire un script, aussi vous devez adopter la mthode la plus efficace. Commencez par lire le guide en ligne doptimisation des scripts dans Unity (http://unity3d.com/support/documentation/ ScriptReference/index.Performance_Optimization.html). La prsentation vido. Regardez cette prsentation sur loptimisation des performances de Joachim Ante, le programmeur en chef de Unity Technologies (http://unity3d.com/ support/resources/unite-presentations/performance-optimization).
Les mthodes dapprentissage

Au fur et mesure que vous progresserez, vous aurez besoin de dvelopper une mthode dtude. Sachez quand persvrer dans vos recherches pour trouver la solution par vousmme et quand demander de laide aux dveloppeurs plus expriments. Si vous suivez les conseils prsents ci-aprs, vous devriez pouvoir aider les autres membres de la communaut au fur et mesure que vous amliorez vos connaissances.
Couvrir le plus de bases possible

Il est frquent de devoir apprendre un nouveau logiciel ou un nouveau langage de programmation dans un certain dlai, que cela soit dans le cadre de votre travail ou en indpendant. Cela peut souvent conduire une approche qui consiste uniquement apprendre le strict
Chapitre 11
287
ncessaire. Mais cette mthode se rvle souvent nuisible long terme, car elle cre de mauvaises habitudes que lon conserve ensuite tel point quon en arrive utiliser des mthodes inefficaces. Cest pourquoi nous vous conseillons de prendre le temps de lire la documentation officielle chaque fois que vous le pouvez. Mme si vous tes bloqu sur un problme de dveloppement en particulier, elle peut souvent vous aider le considrer sous un jour diffrent.
Ne pas hsiter demander de laide

Il est galement utile dobserver la manire dont les autres dveloppeurs procdent pour crer un lment de jeu. Vous dcouvrirez quil existe souvent plusieurs mthodes pour aborder le mme problme (voir louverture de la porte de lavant-poste au Chapitre 5, "lments prfabriqus, collections et HUD"). Il est souvent tentant de recycler les comptences acquises pour rsoudre un problme prcdent, mais nous vous conseillons toujours de vrifier plusieurs fois que la mthode choisie est la plus efficace. En demandant des informations sur le forum ou sur le canal IRC (Internet Relay Chat) de Unity, vous pourrez dgager un consensus sur la manire la plus efficace deffectuer une tche de dveloppement en particulier le plus souvent pour dcouvrir que votre premire approche du problme tait beaucoup plus complexe que ncessaire. Lorsque vous sollicitez de laide, noubliez pas dindiquer chaque fois que possible:
Ce que vous essayez dobtenir. Quelle approche vous semble la meilleure. Ce que vous avez essay jusqu prsent.
Ces informations permettront aux autres de vous aider le mieux possible. Pour que les rponses soient adaptes votre problme, dvoilez autant dinformations que possible, mme si vous pensez quelles nont pas dimportance. La communaut Unity encourage lapprentissage par lexemple. Les sites tiers bass sur des wikis (www.unifycommunity.com/wiki) contiennent de trs nombreux exemples de scripts et de plugins, de didacticiels, et bien plus encore. Vous trouverez des extraits de code utiles, libres de droits, pour complter les exemples de scripts dans le manuel de rfrence et mme des informations sur la faon dimplmenter ce code grce des didacticiels.
288
En rsum
Vous avez vu comment dpasser le cadre de cet ouvrage et comment recueillir des informations auprs des testeurs pour amliorer votre jeu. Il ne nous reste plus qu vous souhaiter bonne chance pour vos dveloppements futurs dans Unity. Toutes les personnes qui ont contribu la cration de cet ouvrage vous remercient de lavoir lu et esprent que vous lavez apprci ce nest que le commencement!
Index
Symboles
@script (commandes) 97 3D camras 9 coordonnes 8 lments corps rigides 11 dtection de collision 12 polygones 10 shader 10 textures 10 espace local et espace global 8 matriaux 10 modles 60 ajouter dans la scne 196, 206 animations 58 format de fichier 57 importer 176 matriaux 58 paramtres communs 57 rotation 206 programmes de modlisation externe 22 vecteurs 9
A
Animations dclencher par script 115 dsactiver 109 Application.LoadLevel() (commande) 222 Assets (menu) 22 Audio composant Audio Source 51 formats 49 paramtres 51 Rolloff Factor 51 stro et mono 49 Axe Z 8
B
Botes de dialogue Create Lightmap 26 Project Wizard 23 Resolution Dialog 271 Build Settings (paramtres) OS X Dashboard Widget 267 OS X/Windows Standalone 268 Web Player Streamed 266
290 C
E
diteur de terrain composant Terrain (Script) 28 Terrain Settings 33 configurer le terrain 35 arbres 44 audio 48 contour 35 dtails 45 lumires 47 textures 40 fonctionnalits, Mass Place Trees 27 outils Paint Details 33 Paint Height 30 Paint Texture 31 Place Trees 32 Raise/Lower Terrain 29 Smooth Height 30 lments prfabriqus corps rigides 162 crer 160 dans le panneau Inspector 67 enregistrer 163 mettre jour 249 modifier 246 rupture du lien 179, 197 texture 161 Enregistrer, scripts 133 Espaces 3D, de lobjet 8
Camras FOV 9 Main Camera (objet) 76 Collisions, dtection a priori 103 collecte dobjets 144 Composants Animation 18 Collider 12, 99 Ellipsoid Particle Emitter 192 FBX Importer 57 Meshes 57 GUI Texture 136 Importer 58 Mesh Collider 12 Mesh Particle Emitter 192 Particle Animator, Color Animation 200 rfrences 282 rinitialiser 164, 202 Rigidbody 12 supprimer 164 Trail Renderer 247 Transform 18 vrifier la prsence (script) 169 Coordonnes cartsiennes 8 Corps rigides 160 composant Rigidbody 159 paramtres 159 forces 159 CSS (Cascading Style Sheets ou feuilles de styles en cascade) 214
F
First Person Controller 53, 79 Audio Listener 79 Camera 76 Character Controller 71 contrle au clavier 54 FPSWalker (Script) 71 Graphics 74 GUILayer 78 Mesh Filter 75 Mesh Renderer 75 Mouse Look (Script) 73, 79 Transform 71
D
Destroy() (commande) 175, 210 Dtection de collision 127 cibles 179 composant Capsule Collider 197 dsactiver 124 mode Dclencheur 129, 132 supprimer les collisions inutiles 169 DrawTexture (commande) 259
Index
291
G
Game Object 13 gameObject.name (commande) 207 Game (panneau) 19 GetButtonUp() (commande) 173 GIF (Graphics Interchange Format) 218 GUI.color.a (commande) 259
pour le Web bouton quitter 269 intgration HTML 275 rsolution 19 tester dans Unity 54, 211 tests publics 285
H
Heightmaps 25
L
Lightmap 26 Lumires ambiante 250 directionnelle 47, 54 point 47 spot 47
I
IgnoreCollision() (commande) 170 Instanciation 158 lment prfabriqu 167 nommer les occurrences 168 restreindre 172 script 157 supprimer des objets 175 vitesse 168 Instantiate() (commande) 157, 168 Interfaces graphiques 142 afficher un objet 207 classe GUI (script) 259 GUI Text 148, 152, 251 interpolation linaire 252 indices pour le joueur 152 animations 147 informer le joueur 187 positionner 229 textures GUI Texture 138 viseur 186
M
Mathf.Lerp (commande) 259 Menus 238 boutons 257 choix de la mthode 237 crer 215, 218 une scne 215 et interfaces 214 GUI skin 214, 237 boutons 231 lancer des scnes 232 modifier lapparence 233 script 233 GUI Texture 214, 227 bouton Instructions 224 Play 220 quitter 224 rsolution 219 Terrain heightmaps importer et exporter 25 rsolution 25 Moteur physique 11 proprits 12
J
Jeu collecte dobjets 144, 207 paramtres, Build Settings 268
292 O
Objets collecter dans le jeu 144 de jeu (GO) 13 dsactiver 227 dupliquer 183 effet de rotation 132 lments prfabriqus crer 134 dupliquer 134 enregistrer 133 importer 130 tags 131 relations parent-enfant 8, 68 Outils Hand 17 Scale 17 Translate 17
dentre 279 qualit 278 pour le Web 271, 275 rsolution 265
R
Raycasting 104, 126 RequireComponent() (commande) 181, 222 Ressources, importer 23, 195, 215, 242
S
Scnes apparition en fondu 259 dupliquer 217 enregistrer 55 Instructions 255 placer un modle 3D 105 redimensionner un modle 3D 106 regrouper les objets 217 Scripts attacher un objet 123, 170, 182, 185 bases 89 cibles rinitialiser 180 vrifier le nombre de cibles abattues 185 classes Collision 180 Input 167 Physics 170 collecte dobjets 207 commandes 80 Application.LoadLevel() 222 Destroy() 143, 210 DrawTexture 259 GameObject.Find() 146 gameObject.name 207 GetComponent() 146 GUI.color.a 259 Instantiate() 157, 168 Mathf.Lerp 259 RequireComponent 222 @script 97 time() 253
P
Panneaux afficher en plein cran 219 Game 19 Hierarchy 17 Inspector 18, 67 calques 66 tags 65 Project 19 bouton Create 19 Scene 17 outils 17 Performances, amliorer 250, 286 distance daffichage 249 PNG (Portable Network Graphics) 136, 218 Programmation 79 Projet 23 application autonome 273 diffusion 280 dossiers 19 gnrer 280 lecteur web 268 paramtres
Index
293
Time.deltaTime() 150 time.time 253 transform.rotation 208 yield 260 commentaires 88, 174 conditions 87 if else 85 multiples 87 contrler, audio 167 crer 139 dbogage 120, 211, 223, 226 diteurs Uniscite et Unitron 15 enregistrer 133 fonctions 85 amliorer 118 crire 84, 113 Update() 84, 111 FPS Walker 97 inclure composant 170 lancer des objets 172 contrles en entre 166 mettre en pause 260 rfrences 282 restreindre laccs des objets 146 syntaxe point 88 transmettre en paramtres 157 variables 83 publiques 222 publiques et prives 82 statiques 87 types de donnes 81 utilisation 82 victoire du joueur 183 Start() (commande) 175 Systmes de particules 211 animation 193 audio 205, 245 composants Ellipsoid Particle Emitter 192, 198, 203, 244 Mesh Particle Emitter 192 paramtres 192 Particle Animator 193, 199, 203, 244
Particle Renderer 193, 201, 204 crer 198, 203 feu 203 fume 204 dfinition 192 dsactiver 206 metteur de particules 192 matriau 202, 243 ombres 201 paramtres 243 positionner 202, 204, 240 rendu 193 tester 203, 246 tranes de lumire 249 transparence 202 volcan 244
T
Tags, Tag Manager 65 Terrain mer 52 textures Splats 31 Tester le jeu 54, 211 Textures compresser 271 dsactiver le mip mapping 218 rendu de UnityGUI 259 rsolution 11, 26 TIFF (Tagged Image File Format) 218 time (commande) 253 time.time (commande) 253 transform.parent (commande) 170 transform.root (commande) 170 transform.rotation (commande) 208
U
Unitron et Uniscite 15 Unity diffrences entre les versions 273 diteurs de scripts Uniscite et Unitron 15
294
Unity (suite) fonctionnalits 27 interface 20 menus Assets 22 Edit 18 mthodes dapprentissage 286 outils 34 paramtres Build Settings 224 principes de fonctionnement 15 Composants 14 lments prfabriqus 15 Objets de jeu 14 ressources 13 scnes 14 scripts 14
projet 23 application autonome 273 diffusion 280 dossiers 19 gnrer 280 paramtres dentre 279 de qualit 278 pour le Web 271, 275 rsolution 265 rfrences 282 ressources 22 dpendances 22 tester le jeu 54, 211
Y
yield (commande) 260
jeux 3D Unity
avec
Unity est une petite rvolution : outil de dveloppement 3D et moteur de jeux, il permet de produire simplement, grce une interface dintgration dobjets et de scripts trs intuitive, des jeux de standard professionnel pour Mac, PC et le Web. Une version du moteur existant galement pour la Wii, liPhone et lAndroid, il offre un accs aux consoles et aux mobiles une fois que vous en matrisez les bases. Ce livre vous explique tout ce quil faut savoir pour prendre en main Unity et tre en mesure de dvelopper ses propres jeux. Il propose un ensemble dexemples faciles qui vous conduiront la ralisation dun jeu de tir la premire personne (FPS) en 3D sur une le un environnement avec lequel le joueur pourra interagir. Partant des concepts communs aux jeux et la production 3D , vous verrez comment utiliser Unity pour crer un personnage jouable et comment raliser des nigmes que le joueur devra rsoudre pour terminer la partie. la n de ce livre, vous disposerez dun jeu en 3D entirement fonctionnel et de toutes les comptences requises pour en poursuivre le dveloppement et proposer lutilisateur nal, le joueur, la meilleure exprience vidoludique possible. Les codes sources www.pearson.fr. du livre sont disponibles sur
Dveloppez des
TABLE DES MATIRES Bienvenue dans la troisime dimension Environnements Personnages jouables Interactions lments prfabriqus, collections et HUD Instanciation et corps rigides Systmes de particules Conception de menus Dernires retouches Compilation et partage Procdures de tests et lectures complmentaires
propos de lauteur
Will Goldstone est concepteur et formateur dans le domaine de linteractivit. Ayant dcouvert Unity dans sa premire version, il semploie depuis promouvoir le dveloppement de jeux accessible tous.
Niveau : Tous niveaux Catgorie : Dveloppement de jeux Conguration : PC / Mac
ISBN : 978-2-7440-4141-9
Pearson Education France 47 bis, rue des Vinaigriers 75010 Paris Tl. : 01 72 74 90 00 Fax : 01 42 05 22 17 www.pearson.fr

Developper Des Jeux 3D Avec Unity

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Developper Des Jeux 3D Avec Unity

Uploaded by

Copyright:

Available Formats

http://www.free-livres.

Dveloppez des jeux 3D avec Unity

Table des matires

Dveloppez des jeux 3D avec Unity

Table des matires

Dveloppez des jeux 3D avec Unity

Le contenu de cet ouvrage

Dveloppez des jeux 3D avec Unity

Ce dont vous avez besoin

qui sadresse cet ouvrage

Dveloppez des jeux 3D avec Unity

Codes sources en ligne

Dveloppez des jeux 3D avec Unity

Lespace local et lespace global

Bienvenue dans la troisime dimension 

Y Z X L'espace local (de l'objet) Z

Dveloppez des jeux 3D avec Unity

Les polygones, les artes, les sommets et les maillages

Les matriaux, les textures et les shaders

Bienvenue dans la troisime dimension 

128128 256256 512512 10241024

La physique des corps rigides

Dveloppez des jeux 3D avec Unity

Masse Gravit Vlocit Friction

Les concepts essentiels de Unity

Bienvenue dans la troisime dimension 

Dveloppez des jeux 3D avec Unity

Les objets de jeu (Game Objects)

Bienvenue dans la troisime dimension 

Les lments prfabriqus

Dveloppez des jeux 3D avec Unity

Bienvenue dans la troisime dimension 

Les panneaux Scene et Hierarchy

Dveloppez des jeux 3D avec Unity

Bienvenue dans la troisime dimension 

Dveloppez des jeux 3D avec Unity

Dveloppez des jeux 3D avec Unity

Les logiciels de modlisation externes

Maya 3D Studio Max Cheetah 3D Cinema 4D Blender Carrara Lightwave XSI

Votre premier projet Unity

Dveloppez des jeux 3D avec Unity

Les fonctionnalits du menu Terrain

Importer et exporter des heightmaps

Dfinir la rsolution dune heightmap

Dveloppez des jeux 3D avec Unity

Crer la lightmap (la liste des lumires)

La fonction Mass Place Trees

La fonction Flatten Heightmap

La fonction Refresh Tree and Detail Prototypes

Dveloppez des jeux 3D avec Unity

Les outils de terrain

Le composant Terrain (Script)

Loutil Raise/Lower Terrain (lever/abaisser le terrain)

Dveloppez des jeux 3D avec Unity

Loutil Paint Height (peindre jusqu hauteur)

Loutil Smooth Height (adoucir les dnivels)

Loutil Paint Texture (peindre des textures)

Dveloppez des jeux 3D avec Unity

Loutil Place Trees (disposer des arbres)

La section Settings dispose des options suivantes:

Loutil Paint Details (peindre des dtails)

Terrain Settings (les paramtres de terrain)

Dveloppez des jeux 3D avec Unity

Table des matires

Bienvenue dans la troisime dimension

Bienvenue dans la troisime dimension

Bienvenue dans la troisime dimension

Bienvenue dans la troisime dimension

Bienvenue dans la troisime dimension

Bienvenue dans la troisime dimension