Comment créer une application Android avec Unity

Avant de commencer, je devrais probablement mentionner que ce sera un tutoriel assez long. Alors préparez-vous. À la fin de ce didacticiel, vous serez en mesure de conquérir le monde (au sens figuré).

Il y a environ 2 ans, je me suis plongé dans de nouveaux territoires et j'ai suivi un cours de Game Design. Je n'avais jamais essayé de faire un jeu correctement avant cela. J'avais essayé d'entrer dans la programmation, mais je ne pouvais pas m'y engager. J'ai peut-être écrit quelques programmes de ligne de commande très basiques de quelques lignes, puis j'ai abandonné car je n'arrivais pas à comprendre.

Donc, quand j'ai commencé mon cours, je n'y étais certainement pas habitué. Au cours des deux années, j'ai beaucoup appris et j'ai fait de très bons progrès et j'ai même conçu et programmé quelques jeux et applications, dont 2 pour Android.

Entrer dans un peu plus de détails. Comme il s'agissait d'un cours, je devais apprendre tout ce qui concernait la conception et le développement de jeux. J'ai appris comment générer des idées de jeux, comment écrire une histoire pour le jeu, comment conceptualiser des personnages (je n'ai pas vraiment conçu de personnages), comment créer un document de conception de jeu (ce qui est très utile, il n'a pas pour être extrêmement détaillé si vous êtes un développeur indépendant), comment utiliser Unity Game Engine pour réellement créer le jeu, comment tester correctement le jeu et comment créer un jeu pour différentes plates-formes.

Étape 1: Table des matières

1. Table des matières
2. Choses que vous devez savoir avant de commencer
3. Comment configurer Unity et Android Studio
4. Configuration d'un projet et création de préfabriqués de particules
5. Création et ajout d'un script d'effets
6. Création et ajout de commandes tactiles
7. Essai
8. Création du menu principal et du HUD
9. Organisation de la hiérarchie
10. Conclusion

Étape 2: Choses que vous devez savoir avant de commencer

Beaucoup de gens pourraient penser à tort que la conception / développement de jeux est extrêmement difficile et nécessite beaucoup de connaissances préalables pour en faire un. Cependant, c'est loin de la vérité. L'utilisation d'un moteur de jeu réduira considérablement la courbe d'apprentissage et vous permettra de vous concentrer davantage sur le plaisir du jeu. Il existe une variété de moteurs de jeu différents, les options les plus populaires sont:

• Unité
• Unreal Engine
• CryEngine

Unity et Unreal Engine sont plus populaires que CryEngine. En effet, ils s'adressent aux développeurs Indie et aux développeurs AAA, par opposition à CryEngine, qui s'adresse uniquement aux développeurs AAA. La différence entre Indie et AAA:

Les Indes sont composées de petites équipes, généralement de 1 à 20 personnes et elles ne disposent pas de fonds importants, etc.

Quelques exemples de développeurs indépendants:

• Coffee Stain Studios
• Halfbrick Studios
• Mojang
• Ndmeic Creations

Les AAA sont composés d'équipes beaucoup plus grandes et ont beaucoup d'expérience dans l'industrie ainsi que beaucoup de fonds. Quelques exemples:

• EA
• Ubisoft
• Gameloft
• Treyarch
• Activision

Un moteur de jeu est un programme conçu pour faciliter la conception et le développement de jeux. Au lieu d'avoir à coder vous-même tous les aspects du jeu, vous pouvez simplement écrire le comportement à l'aide d'un moteur de jeu. Cela est rendu possible par le fait que les moteurs de jeu font beaucoup de travail pour vous, des choses telles que la physique, l'éclairage, le rendu, etc. sont toutes faites pour vous. Tout ce que vous avez à faire est de créer les objets du jeu (ce ne sont que des conteneurs avec différents éléments attachés), de configurer l'ordre et la disposition, d'attribuer les propriétés pertinentes aux objets du jeu et de scripter le comportement.

Certains moteurs de jeu vous permettent en fait de créer un jeu entier sans aucun codage requis, le plus populaire est Unreal Engine. Il dispose d'un système Blueprints, qui utilise une structure basée sur les nœuds (qui est essentiellement juste un système qui utilise des boîtes et des flèches. Ces boîtes et flèches sont liées si elles font partie de la même fonction). Supposons que vous vouliez intercepter la saisie au clavier (cela signifie simplement dire au programme de rechercher une touche enfoncée sur le clavier), puis faire bouger le joueur tant que cette touche spécifique est maintenue enfoncée. Vous créeriez un nœud de base, qui contiendrait les sous-fonctions nécessaires. Dans ce nœud de base, vous déclareriez la clé que vous vouliez utiliser, puis créez un autre nœud indiquant au jeu quoi faire. Le nœud de base serait une boîte contenant la fonction permettant d'appuyer sur la touche.

Dans ce cas, le deuxième nœud entraînerait le joueur à se déplacer dans une direction (vers l'avant, par exemple) tant que la touche «W» est maintenue enfoncée. Le deuxième nœud serait une autre boîte liée à la première boîte. C'est extrêmement utile, non seulement pour les concepteurs mais aussi pour les programmeurs car cela leur permet de créer rapidement des prototypes. Unity possède également cette fonctionnalité, connue sous le nom de script visuel. Cependant, cela prend la forme d'un actif que vous devez acheter.

L'unité est en fait meilleure pour les débutants qui cherchent à créer des jeux car elle vous apprend à écrire. Unreal Engine est beaucoup plus avancé, même s'il propose des scripts visuels. Ce qui signifie qu'il y a une plus grande courbe d'apprentissage.

Étape 3: Comment configurer Unity et Android Studio

Alors maintenant, vous en savez un peu plus sur les moteurs de jeu et leur fonctionnement. Ce tutoriel utilisera Unity 5.3.5 qui est la dernière version en ce moment. Je vais vous apprendre à créer une application Android esthétiquement agréable. Ce didacticiel suppose que vous avez une compréhension de base de l'utilisation d'Unity. Si vous êtes un débutant complet et que vous souhaitez suivre ce tutoriel, veuillez visiter ce lien pour vous familiariser avec les bases de Unity: //pixelnest.io/tutorials/2d-game-unity/

Assurez-vous d'avoir toujours la dernière version d'Unity car ils contiennent des corrections de bogues et des améliorations. Si vous avez une ancienne version d'Unity, vous pouvez potentiellement rencontrer des erreurs. Ces erreurs peuvent généralement être corrigées par une mise à jour. Je dois également mentionner que la construction pour toute plate-forme mobile nécessite le SDK respectif installé sur votre ordinateur (pour Android, vous avez besoin d'Android Studio. Pour iOS, vous avez besoin d'un Mac avec Xcode installé.) Pour télécharger Android Studio, veuillez suivre ce lien et le configurer en utilisant les instructions fournies sur le site Web: //developer.android.com/studio/index.html

Une fois qu'il est installé, vous devrez installer les pilotes pour votre téléphone en ouvrant Android Studio, en cliquant sur Configurer> SDK Manager, puis en cliquant sur Launch Standalone SDK Manager. Une nouvelle fenêtre s'ouvrira, défilera jusqu'en bas et s'assurera que les pilotes USB et Web de Google sont tous les deux sélectionnés. Vous pouvez laisser les autres composants sélectionnés par défaut. Cliquez ensuite sur Installer les packages en bas à droite et attendez qu'il s'installe. Une fois cela fait, accédez à l'application Paramètres de votre téléphone> À propos / À propos du téléphone> Informations sur le logiciel et localisez l'en-tête «Build Number». Ce devrait être une collection de nombres avec des décimales et des «clés de libération» ajoutées à la fin. Appuyez plusieurs fois sur le «Numéro de build» jusqu'à ce qu'il dise «Félicitations, vous êtes maintenant développeur» ou quelque chose de similaire. Revenez ensuite à votre page Paramètres principaux et recherchez «Options pour les développeurs». Cliquez dessus et repérez la case «Débogage USB». Assurez-vous que cette case est cochée. Ensuite, branchez votre téléphone à votre ordinateur et assurez-vous que «Débogage USB activé» ou quelque chose de similaire s'affiche dans la barre de notification, vous devrez probablement développer la barre pour voir le message.

Que vous souhaitiez installer ou non les pilotes de votre téléphone pour l'utiliser dans Unity, vous devrez installer Android Studio, car sans lui, vous ne pouvez pas réellement créer l'application pour votre téléphone. Si la configuration des pilotes est trop fastidieuse, suivez les options alternatives de la section Test de ce didacticiel. Une fois que vous avez installé Android Studio et configuré le débogage USB, vous pouvez revenir et suivre ce tutoriel.

Ce tutoriel était basé sur un autre tutoriel, je vous en fournirai le lien si vous souhaitez le consulter. //pixelnest.io/tutorials/unity-touch-controls ...

Mon tutoriel couvre plus que l'original (Menu, HUD et Testing). Le langage de programmation que j'utiliserai pour ce tutoriel est C #. Unity prend également en charge JavaScript, cependant, C # a des fonctionnalités plus avancées, bien qu'il soit légèrement plus difficile à apprendre. Vous êtes libre de convertir le code C # en JS si vous connaissez déjà JS mais malheureusement, je ne serai pas en mesure de tenir compte des erreurs spécifiques à la langue si vous choisissez de l'utiliser. Je vais également vous enseigner quelques trucs et astuces que j'ai appris pendant mon temps à faire des jeux. Commençons.

Étape 4: Configuration du projet et création de préfabriqués de particules

Configuration du projet

Une fois que vous avez créé votre projet avec succès, assurez-vous que vous disposez des dossiers suivants dans votre dossier d'actifs:

• Les polices
• Matériaux
• Menu
• Préfabriqués
• Scènes
• Scripts
• Textures

Ce sont les seuls dossiers dont vous aurez besoin pour ce projet. Cependant, si vous décidez de l'étendre, vous êtes libre d'ajouter tout autre dossier comme bon vous semble (sons, animations, etc.)

Une fois que vous avez créé les dossiers ci-dessus, allez dans Fichier> Paramètres de construction. Dans cette fenêtre, cliquez sur l'option Android sous l'en-tête "Plateformes", puis cliquez sur "Switch Platform" dans le coin inférieur gauche. Cela indiquera à Unity que vous construisez pour Android et configurera le projet respectivement. Vous aurez besoin d'Android Studio installé pour que cela fonctionne. Enregistrez ensuite la scène en appuyant sur Ctrl + S ou en choisissant "Enregistrer la scène" dans le menu Fichier. Enregistrez cette scène en tant que «Scène principale» dans votre dossier «Scènes».

Création de préfabriqués de particules

Ci-dessus est une image d'une étoile avec un fond noir. Enregistrez cette image dans votre dossier Textures. Vous l'utiliserez pour le système de particules.

Définissez le type de texture sur Texture en cliquant sur l'image dans votre dossier Textures et en sélectionnant la valeur appropriée dans l'inspecteur, puis cliquez sur Appliquer. Assurez-vous que la case «Alpha est transparent» est cochée. Cela rendra l'arrière-plan de l'étoile transparent.

Créez ensuite un système de particules et configurez-le en utilisant les valeurs indiquées dans la capture d'écran ci-dessus.

N'hésitez pas à modifier ces valeurs si vous le souhaitez, elles ne sont qu'un guide. Jouer avec ces valeurs vous permettra de mieux comprendre comment cela fonctionne.

Assurez-vous que la texture du système de particules est définie sur la texture étoile en développant le shader et en sélectionnant la texture étoile dans la case de droite. Ou vous pouvez simplement faire glisser et déposer l'image de votre dossier Textures dans la boîte. Sélectionnez également le Shader Mobile / Particule / Alpha Blended en cliquant sur la liste déroulante à côté de Shader, puis Mobile> Particles> Alpha Blended. Cela indiquera au système de particules de rendre l'arrière-plan de l'étoile transparent et de l'optimiser pour Android. Remplacez le nom en haut de l'inspecteur par «Explosion» et faites de même dans la hiérarchie. Faites ensuite glisser ce système de particules d'explosion de la hiérarchie vers votre dossier Prefabs dans la vue Projet. Cela créera un préfabriqué de ce système de particules.

Ensuite, nous allons créer un Trail Prefab, qui dessinera un trail tant que vous faites glisser votre doigt sur l'écran. Lorsque vous soulevez votre doigt, la trace disparaîtra après quelques secondes.

Créez un nouvel objet de jeu vide (cliquez avec le bouton droit dans la hiérarchie et sélectionnez "Créer vide") et appelez-le Trails ou quelque chose de similaire. Ajoutez-y ensuite un composant Trail Renderer. Configurez-le en utilisant les valeurs fournies dans la capture d'écran ci-dessus.

Créez un nouveau matériau en cliquant sur le dossier Matériaux dans la vue du projet, puis cliquez avec le bouton droit dans la vue du projet et cliquez sur Créer> Matériel. Nommez le matériau en tant que matériau de sentiers ou tapis de sentiers.

Cliquez ensuite sur l'objet de jeu Trails dans la hiérarchie et faites glisser le tapis Trails de la vue Projet vers la fenêtre Inspecteur. Cela affectera le matériel à l'objet de jeu Trails. Faites ensuite glisser cet objet de jeu Trails vers votre dossier Prefabs pour en faire un Prefab.

Enfin, nous allons créer un autre système de particules qui sera différent du premier. Celui-ci explosera lentement vers l'extérieur, n'aura aucune gravité et disparaîtra lentement. Créez un autre système de particules, étiquetez-le Pinch Explosion (nous utiliserons un geste de pincement pour l'initialiser). Assurez-vous que le matériau en étoile est affecté à ce système de particules, puis faites-le dans un préfabriqué.

Ce sont tous les effets que nous utiliserons. N'hésitez pas à en créer plus si vous le souhaitez, ou à modifier ceux existants. Une dernière chose avant de passer à la programmation. Cliquez sur la caméra principale dans la hiérarchie. Changez la couleur d'arrière-plan en noir ou en une autre couleur sombre et changez sa taille (sous la liste déroulante Projection) de 5 à 10. Cela vous permettra de voir plus d'arrière-plan. Regardez la capture d'écran finale ci-dessus si vous êtes confus.

Étape 5: création et ajout d'un script d'effets

Création du script

Maintenant que nous avons créé tous les préfabriqués, nous pouvons passer à la programmation. Vous devrez écrire pas mal de code car il s'agit d'un tutoriel plus avancé. J'ai en fait un document qui explique les bases de la programmation si cela vous intéresse. Ceci est également une autre lecture approfondie. Je l'ai téléchargé sur Dropbox, voici le lien:

//bit.ly/29qhLDx

Créez un nouveau script C # dans votre dossier Scripts (cliquez sur le dossier Scripts, puis cliquez avec le bouton droit dans la fenêtre de projet> Créer> Script C #) et étiquetez ce script comme «SpecialEffects». Ouvrez-le dans votre IDE (Integrated Development Environment) souhaité et écrivez le code ci-dessous, mot pour mot. La raison pour laquelle je vous dis de l'écrire mot à mot plutôt que de le copier / coller est parce que le taper vous permettra de comprendre ce que le code fait mieux. Il vous permettra également de vérifier la présence d'erreurs dans votre code. Voici le code:

 {/ * Transforme ce script en une statique privée, ce qui signifie que les fonctions de ce script ne sont pas accessibles en dehors de ce script et ses valeurs ne changent jamais à moins que vous ne le disiez spécifiquement à * / private static SpecialEffects instance; 

 // Ce sont les préfabriqués publics ParticleSystem explosionEffect, pinchExplosionEffect; public GameObject trailsPrefab; 

 / * Cette fonction est activée lors de la première initialisation du script, avant la fonction Start. La fonction Start nécessite que ce script soit activé mais la fonction Awake s'exécute indépendamment du fait que ce script soit activé * / void Awake () {// Affectation de la valeur d'instance à ce script instance = this; } 

 // Utilisez ceci pour l'initialisation void Start () {// Assurez-vous que les préfabriqués sont tous activés si (explosionEffect == null) Debug.LogError ("Missing Explosion Effect"); if (pinchExplosionEffect == null) Debug.LogError ("Effet d'explosion de pincement manquant"); if (trailsPrefab == null) Debug.LogError ("Missing Trails Prefab"); } 

 // Explosion Effect public static ParticleSystem MakeExplosion (position Vector3) {// Si ce script est désactivé, enregistrez une erreur si (instance == null) {Debug.LogError ("Il n'y a pas de script SpecialEffects dans la scène"); return null; } 

 // Crée l'effet d'explosion à la position donnée. ParticleSystem effect = Instantiate (instance.explosionEffect) as ParticleSystem; effect.transform.position = position; // Détruit l'effet d'explosion une fois l'effet terminé. Destroy (effect.gameObject, effect.duration); effet de retour; } 

 // Pinch Explosion Effect public static ParticleSystem MakePinchExplosion (position Vector3) {// Si ce script est désactivé, enregistrez une erreur si (instance == null) {Debug.LogError ("Il n'y a pas de script SpecialEffects dans la scène"); return null; } 

 // Crée une explosion de pincement à la position spécifiée. ParticleSystem effect = Instantiate (instance.pinchExplosionEffect) as ParticleSystem; effect.transform.position = position; effet de retour; } 

 // Trail Effect public statique GameObject MakeTrail (position Vector3) {// Si ce script est désactivé, enregistrez une erreur si (instance == null) {Debug.LogError ("Il n'y a pas de script SpecialEffects dans la scène"); return null; } // Crée une nouvelle piste à la position définie GameObject trail = Instantiate (instance.trailsPrefab) as GameObject; trail.transform.position = position; sentier de retour; } 

Ajout du script à la scène

Vous voyez, ce n'était pas trop difficile, n'est-ce pas? Maintenant que nous avons ce script prêt, nous pouvons l'ajouter à la scène. Créez un nouvel objet de jeu vide, étiquetez-le en tant que scripts et faites glisser le script de votre dossier Scripts vers l'objet de jeu de scripts.

Affectez maintenant les variables à leurs préfabriqués respectifs en faisant glisser le préfabriqué du dossier Prefabs de la vue du projet vers les propriétés des scripts dans la fenêtre d'inspection. Voir la capture d'écran ci-dessus pour référence.

Étape 6: création et ajout d'un script de commandes tactiles

Création du script

Il est maintenant temps de programmer les commandes tactiles pour cette application. La fonction principale de cette application est de déclencher des effets lorsque l'écran est touché. Les trois gestes que nous utiliserons seront un tapotement, un glissement et une pincée pour zoomer. Vous pouvez également ajouter plus de gestes si vous le souhaitez, mais vous devrez le faire de votre propre gré.

Les effets que nous déclenchons varient en fonction du type d'entrée tactile (tapotement, balayage, pincement pour zoomer, etc.). Cela nous permettra de nous assurer que le bon geste est reconnu.

La méthode dans laquelle nous allons détecter ces gestes utilise la classe «Input» d'Unity, qui regroupe toutes les informations sur chaque type d'entrée dans un seul emplacement. Quelques exemples d'autres entrées sont le clavier, les contrôleurs de console ou le toucher.

Unity a une sous-classe spécifique appelée Input.touches et elle contient les événements pour les différents types de touches ainsi que leur état dans une certaine trame.

A Touch est un conteneur qui contient les informations sur les différents doigts, que nous examinerons lors de la programmation des commandes tactiles.

Le premier type de méthode tactile que nous allons implémenter est un pincement, puis un tapotement, puis un glissement. Une pincée est lorsque l'écran est touché avec deux doigts et déplacé vers l'extérieur ou vers l'intérieur. Un tap est lorsque l'écran est touché pendant une courte période (généralement une seconde). Cela revient à cliquer sur une souris. Un glissement est lorsque l'écran est touché avec un doigt et glissé le long de l'écran.

Créez un nouveau script dans votre dossier Scripts et nommez-le «TouchControls». Tapez ensuite le code suivant sous la fonction de mise à jour.

 en utilisant UnityEngine; using System.Collections.Generic; 

 classe publique TouchControls: MonoBehaviour {private Dictionary trails = new Dictionary (); tactile privé pinchFinger1, pinchFinger2; pincement ParticleSystem privéExplosion; 

 // Utilisez ceci pour l'initialisation void Start () {} // Update est appelé une fois par trame void Update () {// Ce sont les commandes tactiles 

 // Utilise une boucle pour rechercher tous les doigts // Contrôles pour pincer pour zoomer, ne fonctionne qu'avec 2 doigts // Si 2 doigts sont à l'écran si (Input.touchCount == 2) {// Attribuer ces 2 doigts à leurs propres variables var finger1 = Input.GetTouch (0); var finger2 = Input.GetTouch (1); 

 if (finger1.phase == TouchPhase.Began && finger2.phase == TouchPhase.Began) {this.pinchFinger1 = finger1; this.pinchFinger2 = finger2; } 

 // Lorsque les doigts ont bougé, mettez à jour le script vers le nouvel emplacement si (finger1.phase == TouchPhase.Moved || finger2.phase == TouchPhase.Moved) {float baseDistance = Vector2.Distance (this.pinchFinger1.position, this.pinchFinger2.position); float currentDistance = Vector2.Distance (finger1.position, finger2.position); 

 // Purcent float currentDistancePurcent = currentDistance / baseDistance; 

 // Crée l'effet entre les doigts s'il n'existe pas actuellement if (pinchExplosion == null) {Vector3 finger1Position = Camera.main.ScreenToWorldPoint (this.pinchFinger1.position); Vector3 finger2Position = Camera.main.ScreenToWorldPoint (this.pinchFinger2.position); 

 // Recherche le centre entre les 2 doigts Vector3 pinchExplosionPosition = Vector3.Lerp (finger1Position, finger2Position, 0.5f); pinchExplosion = SpecialEffects.MakePinchExplosion (pinchExplosionPosition); } 

 // Prend l'échelle de base et l'augmente ou la diminue pinchExplosion.transform.localScale = Vector3.one * (currentDistancePurcent * 1.5f); }} 

 else {// Si le pincement a été libéré if (pinchExplosion! = null) {// Créer des explosions pour (int i = 0; i <10; i ++) {var explosion = SpecialEffects.MakeExplosion (pinchExplosion.transform.position); explosion.transform.localScale = pinchExplosion.transform.localScale; } 

 // Destroy Pinch Explosion Effect Destroy (pinchExplosion.gameObject); } 

 // Effet tap // Vérifie tous les doigts (int i = 0; i <Input.touchCount; i ++) {Touch touch = Input.GetTouch (i); 

 // Un tapotement est un toucher rapide et relâchez si (touch.phase == TouchPhase.Ended && touch.tapCount == 1) {// Les touches sont des emplacements d'écran, cela les convertit en emplacements mondiaux Position Vector3 = Camera.main. ScreenToWorldPoint (touch.position); 

 // Crée l'effet SpecialEffects.MakeExplosion ((position)); } 

 else {// Contrôle le geste de balayage si (touch.phase == TouchPhase.Began) {// Stocke cette nouvelle valeur if (trails.ContainsKey (i) == false) {// Les touches sont des emplacements d'écran, cela les convertit dans les emplacements du monde Position Vector3 = Camera.main.ScreenToWorldPoint (touch.position); // S'assure que la trace est visible position.z = 0; 

 // Crée l'effet Trails GameObject trail = SpecialEffects.MakeTrail (position); 

 // Si la trace est toujours activée if (trail! = Null) {// Consigne la trace Debug.Log (trail); // Ajout de quelques sentiers supplémentaires.Add (i, trail); }}} 

 else if (touch.phase == TouchPhase.Moved) {// Déplace la piste if (trails.ContainsKey (i)) {// Tableau pour les pistes GameObject trail = trails [i]; 

 // Convertit les touches dans les emplacements du monde Camera.main.ScreenToWorldPoint (touch.position); Position Vector3 = Camera.main.ScreenToWorldPoint (touch.position); // S'assure que la trace est visible position.z = 0; 

 // Définit la position des traces sur la position du doigt trail.transform.position = position; }} 

 else if (touch.phase == TouchPhase.Ended) {// Efface toutes les traces visibles if (trails.ContainsKey (i)) {GameObject trail = trails [i]; 

 // Les fondus disparaissent des sentiers battus Destroy (trail, trail.GetComponent (). Time); sentiers.Retirer (i); }}}}}}} 

Pour la fonction Tap, nous récupérons l'emplacement de tous les doigts placés sur l'écran, que ce soit un doigt ou quatre, puis nous créons un effet d'explosion lorsque le doigt a été retiré de l'écran, dans la position où il était, avant la le doigt a été enlevé.

Pour la fonction Glisser, une nouvelle variable a été créée. Nous avons besoin de cette variable pour créer le lien entre un doigt et un Trail. Ce que fait le code:

Si une nouvelle touche a été créée, créez une nouvelle piste et liez-la au doigt via le dictionnaire.

Lorsque le doigt est déplacé, tant que le doigt est associé à une piste, la position de l'objet de jeu de piste est déplacée avec le doigt.

Lorsque le doigt est soulevé, la piste est détruite.

Pour la fonction Pincer, trois nouvelles variables supplémentaires ont été créées. Ces variables stockaient la première position des doigts, que nous avons ensuite utilisée pour calculer la différence entre la distance des doigts. Une variable pour l'effet d'explosion de pincement a également été créée afin que nous puissions la mettre à jour et la détruire.

La fonction Pinch était plus compliquée, car nous ne voulions pas qu'elle soit confondue avec autre chose.

Pour la fonction de pincement, si deux doigts sont détectés sur l'écran, un nouvel effet d'explosion de pincement est créé entre les deux positions. Après cela, le geste est déclaré comme un pincement. Si les doigts sont déplacés, l'objet de jeu Pinch Explosion est également déplacé et mis à l'échelle avec lui.

Une fois l'explosion de pincement terminée, ou si un doigt est soulevé de l'écran, il se transforme en explosion normale du robinet.

Ajout du script à la scène

Maintenant que le script de contrôles est terminé, ajoutez-le à la scène de la même manière que le script précédent, sinon cela ne fonctionnera pas.

C'est la principale programmation effectuée. Nous aurons encore besoin de faire un peu plus de programmation pour le Menu & HUD, mais ce sera beaucoup moins et plus facile à comprendre. Mais, avant de passer au menu, nous devons réellement tester l'application pour voir si elle fonctionne comme elle le devrait.

Étape 7: Test

Les tests sont cruciaux lors du développement de tout type de logiciel. Sans test, vous ne sauriez pas si tout fonctionne comme il se doit.

Idéalement, vous devriez tester dès que vous implémentez une nouvelle fonctionnalité, cependant, pour les besoins de ce tutoriel, nous testons après avoir implémenté la plupart des fonctionnalités.

Il existe plusieurs méthodes de test. Le plus efficace consiste à créer et à exécuter l'application sur un téléphone Android au fur et à mesure. Unity vous permet en fait de gérer cela facilement, à condition que les bons pilotes soient installés.

Avant de pouvoir réellement créer et tester l'application, vous devrez configurer quelques éléments. Accédez à Modifier> Paramètres du projet> Lecteur. En haut de la fenêtre Inspecteur, vous verrez «Nom de l'entreprise» et «Nom du produit». Modifiez-les comme vous le souhaitez. Développez ensuite l'onglet "Autres paramètres" si ce n'est pas déjà fait et allez dans "Identifiant du bundle". Remplacez-le par com.CompanyNameYouSet.ProductNameYouSet. Dans mon cas, le nom de mon entreprise est U et le nom de mon produit est Instructables, donc mon Bundle Identifier est com.U.Instructables. Si vous ne changez pas cela, vous ne pourrez pas réellement créer l'application pour Android.

Si les pilotes sont installés, allez simplement dans Paramètres de construction dans le menu Fichier. Cliquez ensuite sur «Ajouter des scènes ouvertes». Il doit ajouter la «scène principale» à la liste et lui donner le numéro «0». Une fois cela fait, assurez-vous que votre plate-forme sélectionnée est Android et que votre téléphone est connecté à votre ordinateur, puis cliquez sur «Build and Run». Unity commencera à créer votre application, cependant, avant de pouvoir terminer la construction, il faudra l'emplacement de votre SDK Android. Pour trouver cet emplacement, ouvrez Android Studio> Configurer les paramètres> Gestionnaire de SDK, puis recherchez en haut «Emplacement du SDK Android». Il s'agit de l'emplacement vers lequel vous devez pointer Unity. Une fois qu'Unity sait où se trouve le SDK, il continuera à créer votre application. Une fois que l'application a terminé la construction, elle s'exécute automatiquement sur votre téléphone. Vous êtes ensuite libre de jouer avec l'application et de profiter de votre travail acharné. Essayez tous les gestes pour vous assurer qu'ils fonctionnent tous.

Une autre méthode simple de test serait de cliquer sur "Build" au lieu de "Build and Run" puis de choisir un emplacement pour enregistrer le .apk (l'extension de fichier Android pour ses applications). Une fois ce fichier enregistré et créé, vous devrez le transférer dans la mémoire de votre téléphone et l'installer manuellement sur votre téléphone. Cette méthode permet d'envoyer votre application à d'autres personnes si vous le souhaitez.

Une autre façon de tester est via l'éditeur Unity. En appuyant sur le bouton Lecture en haut de l'écran au milieu, Unity créera et exécutera votre application / jeu. Cela vous évite d'avoir à utiliser votre téléphone pour des tests mineurs. Cependant, si vous souhaitez utiliser cette méthode pour tester votre jeu sur Android, vous devrez télécharger Unity Remote 4 depuis le Google Play Store ou l'iOS App Store. La télécommande Unity vous permet de tester votre jeu dans Unity, sans avoir à créer une version complète à chaque fois. Cela fait gagner beaucoup de temps. Une chose à mentionner est que cela réduit la qualité des graphiques sur votre téléphone. Mais c'est nécessaire. Il fait toujours un bon travail pour vous montrer à quoi ressemblera votre application / jeu sur votre téléphone. Si vous construisez pour PC (Windows), vous pouvez tester le jeu dans l'éditeur sans outils supplémentaires. Assurez-vous de quitter le mode Play dans Unity après avoir testé votre jeu car toutes les modifications apportées à tous les composants sont annulées lorsque vous quittez le mode Play.

Ces méthodes sont les plus efficaces lorsqu'il s'agit de tester votre jeu, car vous pouvez réellement voir si votre code fonctionne comme il se doit. Il existe cependant d'autres méthodes que vous pouvez également utiliser, ces méthodes sont pour Microsoft Visual Studio, qui est l'IDE que j'utilise, mais elles devraient également être synonymes d'autres IDE.

Une méthode est les points d'arrêt. Supposons que vous écriviez du code, puis que vous tombiez sur une erreur. Vous ne savez pas exactement où votre code va mal, mais vous avez une idée générale. Vous ajouteriez donc des points d'arrêt au-dessus, en dessous et sur le code défectueux. Les points d'arrêt arrêteront le programme lorsqu'il atteindra le point d'arrêt et vous donneront des informations sur le programme jusqu'à ce point d'arrêt.

Pour créer un point d'arrêt, recherchez la ligne où vous pensez que votre code va mal et cliquez sur la première marge à gauche. Ce devrait être une couleur plus claire que la page principale. Un point rouge devrait apparaître et si vous survolez le point rouge, il vous indiquera l'emplacement du point d'arrêt. Voir la capture d'écran pour référence.

Dans la capture d'écran, j'ai utilisé la ligne "if (explosionEffect == null" comme erreur. Une fois que vous avez le point d'arrêt, toujours dans Visual Studio, cliquez sur Déboguer> Démarrer le débogage ou appuyez sur F5 sur le clavier. Cela exécutera le programme à l'intérieur Unity et liez-le à VS et au bas de la fenêtre VS une barre rouge apparaîtra disant "Prêt".

Allez maintenant dans Unity et cliquez sur l'icône de lecture. Cela exécutera l'application / le jeu jusqu'au point d'arrêt, auquel cas il vous ramènera à la fenêtre VS avec des informations sur la façon dont le programme s'exécute jusqu'au point d'arrêt. Si votre jeu / application fonctionne correctement jusqu'au point d'arrêt, cette ligne n'est pas celle avec l'erreur. Si, cependant, votre programme génère une erreur avant le point d'arrêt ou ne s'exécute pas du tout, il peut s'agir de cette ligne ou des lignes au-dessus. Afin de trouver la ligne erronée, vous devrez continuer à ajouter des points d'arrêt jusqu'à ce que vous l'ayez localisée. La méthode la plus rapide consiste à ajouter plusieurs points d'arrêt à la fois au lieu d'un. C'est un très bon moyen de tester et vous permet d'être plus précis.

Une fois vos tests terminés, appuyez sur Maj + F5 pour terminer le débogage dans VS ou revenez au menu Déboguer et cliquez sur «Arrêter le débogage». Cela arrêtera alors le débogage et permettra au projet Unity de jouer normalement.

Lors des tests, assurez-vous d'utiliser une combinaison de ces méthodes plutôt qu'une seule car cela vous permettra de localiser exactement où vous vous êtes trompé.

Faites également attention à l'orthographe et à la syntaxe, les langages de programmation peuvent être assez impitoyables, et C # est l'un de ces langages. Si vous épelez quelque chose de mal, vous obtiendrez une erreur, et il sera difficile de localiser cette erreur car ni VS ni Unity ne rendent compte des fautes d'orthographe. J'ai passé des heures à essayer de corriger un bogue, seulement pour découvrir que j'avais mal orthographié une fonction ou une variable. Vérifier l'orthographe et la syntaxe au fur et à mesure est une bonne habitude à prendre car cela vous fera gagner des heures de débogage. Si vous arrivez au point où vous avez quadruple vérifié votre code et que vous ne parvenez toujours pas à comprendre ce qui ne va pas, demandez à quelqu'un d'autre de regarder votre code. Idéalement, vous voudriez un autre programmeur ou quelqu'un qui a au moins des connaissances en programmation, mais si vous n'avez personne qui connaît la programmation, demandez à quelqu'un qui est avec vous au moment de l'examiner. Dites-leur de rechercher spécifiquement les fautes d'orthographe, car ils pourraient les détecter quand vous ne le pouvez pas.

Essayez de ne pas être trop frustré si vous faites une faute d'orthographe et cela vous prend du temps pour la trouver. Ça arrive à tout le monde. C'est l'une des joies d'être programmeur.

Maintenant que nous avons couvert les tests, nous pouvons passer au menu & HUD.

Étape 8: Création du menu principal et du HUD

La création d'un menu / HUD pour votre application est en fait plutôt cruciale. Le menu principal donne au joueur des informations sur votre application et lui permet généralement de contrôler certains aspects de l'application. Pour ce didacticiel, nous n'apprendrons pas à programmer le menu afin que le lecteur puisse modifier les paramètres car il n'y a rien à modifier pour le lecteur (il n'y a pas de son, de musique, etc.) J'envisage d'ajouter des effets sonores et éventuellement de la musique, mais celles-ci seront incluses dans un tutoriel ultérieur. Le menu principal que nous allons créer sera plutôt basique mais toujours esthétique. Nous aurons un titre et trois boutons (Play, Help & Exit.) Le bouton Play vous amènera simplement à la scène principale, le bouton Help vous amènera à un panneau avec le fichier d'aide dessus et le bouton Exit quittera simplement le jeu. Je vais vous montrer deux façons d'implémenter le bouton Quitter, la première méthode sera un peu plus simple.

Vous pouvez utiliser n'importe quelle police, image d'arrière-plan, etc. que vous souhaitez, à condition qu'elle corresponde au thème du jeu. Assurez-vous également que vos ressources pour votre jeu sont libres de droits ou peuvent être utilisées commercialement si vous prévoyez de le publier sur une boutique d'applications, sinon vous pourriez rencontrer des problèmes juridiques. Pour ce tutoriel, j'utiliserai cette image de la région du Centre Galactique:

//bit.ly/29eP2jB

Et ces polices:

//www.dafont.com/fineliner-script.font

//www.dafont.com/post-it-penscript.font

Les polices sont attachées en bas de cette étape et l'image est en haut si vous souhaitez utiliser ces actifs pour votre application.

Une fois que vous avez téléchargé les polices et les images que vous souhaitez utiliser, importez-les dans votre projet Unity dans leurs dossiers respectifs (les polices vont dans le dossier Fonts et l'image va dans le dossier Menu.)

Création du menu

Afin de créer le menu, nous devons créer une nouvelle scène. Appuyez sur Ctrl + N ou allez dans Fichier> Nouvelle scène. Enregistrez-le en tant que menu ou menu principal.

Maintenant que nous avons notre scène, nous devons ajouter un canevas. Ce canevas nous permet d'utiliser toutes les fonctionnalités de l'interface utilisateur dont nous avons besoin. Considérez-le comme une superposition qui a toujours la taille exacte de votre écran.

Pour créer un canevas, faites un clic droit dans la hiérarchie> UI> Canvas. Dans la fenêtre Inspecteur du canevas, assurez-vous que le mode de rendu est défini sur Espace d'écran - Superposition et cochez l'option Pixel Perfect. Sous le composant Canvas Scaler, changez le mode de mise à l'échelle de Constant Pixel Size en Scale With Screen Size. Cela permet à tous les composants du canevas d'augmenter ou de diminuer si la résolution de l'écran augmente ou diminue. Modifiez la résolution de référence à la résolution de l'écran de votre téléphone en mode paysage (le mien est 1920 x 1080) et modifiez la valeur de correspondance de 0 à 0, 5. Cela garantira que les composants sont mis à l'échelle également en largeur et en hauteur.

Vous devez maintenant modifier votre vue de jeu pour qu'elle corresponde à la résolution de référence de votre canevas. Pour ce faire, cliquez sur l'onglet Jeu en haut, il devrait avoir une icône de Pacman à sa gauche. Si vous ne le voyez pas, allez dans Fenêtre> Jeu, ou appuyez sur Ctrl + 2. Regardez en haut à gauche de la fenêtre du jeu et vous devriez voir une liste déroulante disant Aspect libre. Clique dessus. En bas, il devrait y avoir une icône Plus, cliquez dessus et changez le type de rapport d'aspect en résolution fixe. Étiquetez-le selon la résolution d'écran de votre téléphone (la mienne est 1080p) et modifiez la largeur et la hauteur pour qu'elles correspondent à la résolution souhaitée. Cela vous permettra de mettre à l'échelle vos composants afin qu'ils s'affichent correctement sur votre téléphone. Si vous le gardiez sur Free Aspect, il serait difficile de faire évoluer correctement vos composants.

Créez un panneau (de la même manière que vous avez créé le canevas, mais cette fois, choisissez le panneau à la place). Si votre canevas est déjà sélectionné, le panneau devrait automatiquement devenir un enfant du canevas.

Dans Unity, les enfants et les parents sont extrêmement importants. Un enfant est un sous-ensemble du parent, il hérite de certaines qualités du parent. Pour faire la différence entre un enfant et un parent: un parent aura une flèche à gauche de son nom sur laquelle vous pouvez cliquer pour afficher ou masquer les enfants.

Pour créer un enfant, vous devez simplement cliquer avec le bouton droit sur un objet dans la hiérarchie, puis créer votre objet enfant à partir du menu qui apparaît ou vous pouvez faire glisser un objet sur un autre pour en faire un enfant de cet objet. Dans la capture d'écran ci-dessus, j'ai créé un objet de jeu vide et l'ai fait glisser sur le canevas pour faire de l'objet de jeu vide un enfant du canevas. Ceci est extrêmement utile et parfois critique. Par exemple, si vous avez créé un panneau en dehors du canevas (si le panneau était un parent) et que vous vouliez le mettre à l'échelle à la même taille que le canevas, vous devez connaître les dimensions du canevas, puis définir manuellement le les dimensions du panneau doivent être les mêmes. Cependant, si le panneau était un enfant de la toile, vous pouvez simplement le mettre à l'échelle en utilisant les ancres (que j'expliquerai un peu). Si vous avez créé le panneau pour être, par défaut un enfant du canevas, le panneau serait automatiquement mis à l'échelle pour le canevas. Il y a aussi le léger problème de tous les éléments de l'interface utilisateur qui ne sont pas visibles à moins qu'ils ne soient tous des enfants du canevas. Les parents / enfants sont également utiles pour l'organisation de la Hiérarchie, que je reviendrai également bientôt.

Maintenant que nous avons ce panneau, nous pouvons configurer l'image d'arrière-plan. Avant de faire cela, nous devons les nommer de manière appropriée, changer le nom du canevas dans la hiérarchie en canevas de menu et changer le nom du panneau en image d'arrière-plan. Maintenant, cliquez sur le panneau Image d'arrière-plan et regardez la fenêtre Inspecteur. Il devrait y avoir un composant Image (Script) attaché. Recherchez l'image source. Pour changer cette image, faites glisser et déposez l'image téléchargée de la fenêtre de votre projet vers la boîte ou cliquez sur le symbole d'un cercle avec un petit point au milieu. Cela devrait ouvrir une autre fenêtre intitulée Sélectionner Sprite. Dans cette fenêtre, vous pouvez ensuite choisir votre arrière-plan. Si vous ne voyez pas votre image, assurez-vous que le type d'image est défini en tant que Sprite (2D et UI).

Une fois que vous avez sélectionné votre arrière-plan, vous devrez augmenter l'alpha, pour ce faire, cliquez sur la boîte de couleur et en bas il y aura une boîte de curseur étiquetée A. Faites-la glisser vers la droite jusqu'à la fin de la section blanche et sa valeur est fixée à 255. Vous pouvez également teinter l'image d'une certaine couleur à partir de cette même fenêtre si vous le souhaitez.

Pour configurer le titre, créez un objet texte en tant qu'enfant de l'image d'arrière-plan. Renommez-le en titre. Changez la couleur du texte en blanc et assurez-vous que tous les objets de jeu de texte suivants que vous créez sont également blancs. Dans la section Texte, remplacez-le par Nouveau texte par ce que vous voulez que votre titre soit (dans ce cas, Instructables) et changez la police en votre police préférée (j'utiliserai la police Postit-Penscript). Sous l'en-tête Paragraphe, changez l'alignement comme vous le souhaitez, je vais centrer mon texte sur les axes vertical et horizontal. Ensuite, cliquez sur Meilleur ajustement et changez la taille maximale pour celle qui correspond le mieux à votre police. Ma police est assez fine, je vais donc utiliser 90 comme taille maximale. Assurez-vous de cliquer sur l'option Best Fit pour chaque objet de jeu de texte que vous créez.

Ensuite, regardez en haut à droite sous l'en-tête Rect Transform et vous devriez voir une boîte avec des lignes et du texte en haut et sur les côtés gauche de la boîte. Il devrait indiquer le centre en haut et le milieu à gauche. Cliquez sur cette case, maintenez Alt et Shift et cliquez sur l'icône au-dessus de l'icône du milieu / centre. Vérifiez la capture d'écran pour référence. Maintenant, si vous fermez la boîte, il devrait indiquer le centre en haut et en haut à gauche et votre texte doit être centré vers le haut. Il s'agit de l'ancre et elle est extrêmement utile lors de l'organisation des objets de jeu. Maintenez la touche Alt enfoncée pour définir la position de l'objet sur le nouveau point d'ancrage et maintenez la touche Maj enfoncée pour définir le pivot. Il vous évite d'avoir à définir manuellement l'emplacement des objets.

Si vous regardez à droite de la case Rect Transform, vous devriez voir un tas de nombres. Ce sont les dimensions et l'emplacement de l'objet. Ceux sur lesquels vous souhaitez vous concentrer sont les cases: Pos X, Pos Y, Width & Height. La largeur et la hauteur sont explicites. Le Pos X déplace l'objet horizontalement et le Pos Y le déplace verticalement. Cependant, ces cases changeront en fonction de l'ancre que vous utilisez. Si vous utilisez l'ancrage extensible uniforme, la position X et Y changera en droite, gauche en haut et en bas, ce qui fait la même chose, mais cela vous permet plus de contrôle. Vous pouvez soit faire glisser le long de l'étiquette de ces cases pour déplacer l'objet, saisir les nombres manuellement ou utiliser les outils Unity pour les déplacer. Changez le Pos Y de 0 à -10. Cela lui donnera 10 pixels d'espace à partir du haut de l'image d'arrière-plan, ce qui la rendra un peu plus propre.

Cliquez sur Ajouter un composant et ajoutez une ombre et un contour. Augmentez l'alpha des deux à 255. Cela le fera ressortir davantage sur le fond. Assurez-vous d'ajouter un composant Ombre et contour à chaque objet de jeu de texte que vous créez.

Maintenant que nous avons notre expérience, il est temps de configurer les boutons. Créez un objet de jeu vide en tant qu'enfant du panneau d'image d'arrière-plan et appelez-le Gestionnaire de disposition des boutons. Dans la fenêtre Inspecteur de cet objet de jeu vide, cliquez sur Ajouter un composant et recherchez le groupe de disposition verticale et ajoutez-le à l'objet. Cet objet de jeu gardera le placement des boutons cohérent. Changez l'ancre en Stretch Uniform (c'est en bas à droite) et changez la position et pivotez avec. Le Gestionnaire de disposition des boutons devrait maintenant occuper tout l'écran. Faites-le glisser du haut vers le bas jusqu'à ce qu'il occupe 3 cases de la grille et faites-le glisser de la droite jusqu'à ce qu'il occupe deux cases de la grille. Si vous ne pouvez pas voir la grille, regardez en haut de la fenêtre de la scène où il est écrit Gizmos. Cliquez dessus, puis cliquez sur Afficher la grille.

Créez maintenant un autre objet de jeu de texte en tant qu'enfant de l'image d'arrière-plan et configurez-le comme vous le souhaitez. Marquez-le Start. Si vous utilisez plusieurs polices, utilisez votre deuxième police pour le bouton et conservez la première police pour vos titres uniquement. J'utiliserai la police Fineliner_Script pour mes boutons. Vous pouvez créer les boutons de n'importe quelle taille à condition qu'ils soient clairement visibles. Une bonne règle consiste à réduire la taille du bouton de 10 ou 20 pixels par rapport au titre, donc si le titre est défini sur 90, vous devez définir la taille du bouton sur 80 ou 70. Je définirai la taille de mon bouton sur 70 Modifiez le texte en début et configurez l'alignement à votre guise. Ajoutez-y un composant Button et changez les couleurs surlignées et pressées en vos couleurs préférées, assurez-vous que la couleur pressée est plus sombre que celle surlignée. Je mettrai mon surligné en bleu clair et la couleur pressée sur un bleu plus foncé. Maintenant, ajoutez-y un composant Shadow et Outline et augmentez l'Alpha au maximum.

Dupliquez ce bouton deux fois (en cliquant avec le bouton droit sur le bouton et en sélectionnant Dupliquer ou en cliquant sur le bouton et en appuyant sur Ctrl + D) pour vous retrouver avec trois boutons au total, appelez l'un d'eux Aide et l'autre Quitter. Modifiez le texte de ces derniers pour refléter leurs étiquettes. Faites-en des enfants du Layout Manager.

Créez un panneau, appelez-le panneau d'aide et définissez l'image source pour être la même que l'image d'arrière-plan. Il doit déjà avoir la bonne taille. Augmentez l'alpha au maximum. Dupliquez le titre et faites-en un enfant du panneau d'aide. Remplacez le nom de l'objet de jeu par le titre du panneau d'aide et le texte par le panneau d'aide. Il devrait déjà être au bon endroit.

Dupliquez l'un des boutons et renommez-le Back. Faites-en un enfant du panneau d'aide, puis changez le texte du bouton en arrière. Réglez l'ancrage, la position et le pivotement en bas à gauche et changez la position X en 10.

Créez un autre objet de jeu de texte en tant qu'enfant du panneau d'aide, étiquetez-le corps de texte d'aide et définissez son ancre sur Stretch Uniform. Modifiez la zone supérieure de 0 à 110. Modifiez les zones gauche, droite et inférieure à 10. Configurez la police, utilisez la même police que les boutons. Modifiez la taille maximale à 80. Centrez le texte sur les deux axes. Copiez et collez ensuite le texte suivant dans la zone de texte:

Cette application vous permet de créer divers effets sur votre téléphone. Taper sur l'écran créera une explosion, pincer l'écran créera une plus grande explosion et faire glisser l'écran créera une trace.

Ou créez votre propre texte d'aide.

Allez maintenant dans Fichier> Paramètres de construction> Ajouter des scènes ouvertes. Votre scène de menu doit maintenant être ajoutée. Faites glisser votre scène de menu vers le haut de façon à ce que son numéro soit 0 et la scène principale à 1. Si vous ne le faites pas, vous ne pourrez pas afficher votre menu lors de la création de l'application, ni pour charger la scène principale lorsque vous cliquez sur Démarrer.

Maintenant que nous avons configuré le menu, nous pouvons passer à sa programmation pour qu'il fasse réellement quelque chose.

Programmation du menu

Créez un nouveau script et appelez-le Menu. Tapez ensuite le code suivant:

 en utilisant UnityEngine; // Cet espace de noms est requis pour utiliser tout composant d'interface utilisateur utilisant UnityEngine.UI; // Cet espace de noms est requis pour utiliser le SceneManager à l'aide de UnityEngine.SceneManagement; using System.Collections; public class Menu: MonoBehaviour {// Ce sont tous les boutons // ------------------------------- public Button start; aide du bouton public; sortie bouton publique; bouton arrière public; // ------------------------------- // Ceci est le panneau d'aide public GameObject helpPanel; // ------------------------------- // Utilisez ceci pour l'initialisation void Start () {// Désactive le panneau helpPanel .SetActive (false); } // Update est appelé une fois par image void Update () {} // Fonction pour le bouton Démarrer, charge la scène principale publique void StartPress () {SceneManager.LoadScene (1); } // Fonction pour le bouton Aide, active le panneau d'aide public void HelpPress () {helpPanel.SetActive (true); } // Fonction pour le bouton Quitter, quitte l'application publique void ExitPress () {Application.Quit (); } // Fonction pour le bouton Retour, désactive le panneau d'aide public void BackPress () {helpPanel.SetActive (false); }} 

Faites glisser ce script sur le canevas de menu, puis faites défiler vers le bas dans la fenêtre d'inspection. Tu aurais dû:

Début

Aidez-moi

Sortie

Retour

Panneau d'aide

Faites glisser les objets de jeu appropriés vers leurs champs respectifs. Voir la capture d'écran ci-dessus si vous n'êtes pas sûr.

Maintenant Ctrl cliquez sur les boutons Démarrer, Aide, Quitter et Retour et faites défiler jusqu'au composant Bouton (Script). Au bas de ce composant se trouve une liste vide qui indique On Click (). Cliquez sur le symbole Plus. Faites maintenant glisser l'objet de jeu Menu Canvas vers le champ qui indique Aucun (objet). La liste déroulante Aucune fonction doit maintenant être active.

Cliquez sur le bouton Démarrer, puis cliquez sur le menu déroulant Aucune fonction et allez au bas de la liste où il est dit Menu. Cliquez ensuite sur StartPress (). Il devrait maintenant indiquer Menu. StartPress dans la liste déroulante. Faites de même pour les boutons Aide, Quitter et Retour, mais assurez-vous de sélectionner la fonction Presse appropriée pour eux. Le bouton Aide doit avoir HelpPress, le bouton Quitter ExitPress et le bouton Retour BackPress. Maintenant, cliquez sur l'icône Lecture et testez-la, cliquez sur le bouton Aide et voyez si le panneau d'aide se charge. En cliquant sur le bouton Quitter, vous ne ferez rien sauf si vous avez créé l'application pour Android. Vous devrez tester le bouton Quitter de votre téléphone. Cliquer sur le bouton Lecture devrait vous amener à la scène principale.

Le moment est peut-être venu de tester votre application sur votre téléphone, alors construisez-la et exécutez-la et assurez-vous que votre menu est pleinement fonctionnel.

Comme je l'ai mentionné précédemment, il existe plusieurs méthodes pour créer la fonction de sortie. Je viens de vous montrer le moyen le plus simple. Ceci est la deuxième méthode.

Créez un autre panneau en tant qu'enfant de l'image d'arrière-plan et appelez-le Quitter le panneau. Définissez la couleur d'arrière-plan pour qu'elle corresponde à l'arrière-plan afin qu'elle semble se fondre (j'ai choisi un bleu foncé) et définissez le haut et le bas sur 450 et les côtés droit et gauche sur 760. Cela centrera la boîte sur l'écran.

Dupliquez le titre et faites-en un enfant du panneau de sortie. Diminuez un peu la taille du texte pour qu'il soit visible mais ne prenne pas trop de place. Assurez-vous qu'il est centré vers le haut.

Dupliquez le bouton Lecture deux fois, créez les deux enfants en double du panneau de sortie et changez l'ancre, la position et le pivot de l'un des boutons en bas à gauche. Changez l'autre en bas à droite.

Modifiez le nom du bouton en bas à droite sur Oui et faites de même avec le texte. Remplacez celui en bas à gauche par Non (nom et texte).

Ouvrez votre script de menu et ajoutez 2 boutons sous le bouton précédent et un GameObject sous le panneau d'aide en utilisant le code ci-dessous:

 Bouton public oui; Bouton public non; 

 public GameObject exitPanel; 

Ajoutez le code suivant dans la fonction de démarrage, sous helpPanel.SetActive (false); ligne:

 exitPanel.SetActive (false); 

Modifiez la fonction ExitPress de

 Application.Quit (); 

à

 exitPanel.SetActive (true); 

Ensuite, faites défiler jusqu'au bas du script et sous la fonction BackPress () ajoutez le code suivant:

 public void YesPress () {Application.Quit (); } public void NoPress () {exitPanel.SetActive (false); } 

Enfin, revenez à Unity, cliquez sur le bouton Oui et changez sa fonction de StartPress () en YesPress () et changez le bouton Non en NoPress (). Assurez-vous également d'affecter les nouvelles variables publiques dans le script Menu Canvas (cliquez sur Menu Canvas et faites glisser les boutons et le panneau vers leurs champs respectifs). Maintenant, appuyez sur Lecture et testez le bouton Quitter, il devrait charger le panneau de sortie et le fermer lorsque vous appuyez sur le bouton Non. Comme vous pouvez le voir, cette méthode est légèrement plus longue mais offre une protection au cas où le joueur clique accidentellement sur le bouton Quitter. N'hésitez pas à utiliser la méthode que vous choisissez.

Nous passons maintenant à la dernière étape, la création du HUD, qui est extrêmement basique et se compose d'un bouton. Je pourrais ajouter un autre tutoriel couvrant un HUD plus étendu (avec un curseur de santé, un compteur de score et un menu de pause réel) mais pour l'instant, cela suffira.

Création et programmation du HUD

Revenez à votre scène principale et créez un nouveau canevas. Étiquetez-le HUD Canvas et configurez-le de la même manière que le menu principal.

Ajoutez un objet de jeu de texte en tant qu'enfant du canevas, appelez-le Retour au menu principal et configurez les polices, la taille et l'alignement à votre convenance. Vous pouvez également faire de l'un des boutons du menu principal un préfabriqué, puis le faire glisser sur votre canevas. Une fois que vous avez configuré le bouton, modifiez son ancre, sa position et son pivot en bas à gauche. Créez un nouveau script appelé HUD et saisissez le code suivant:

 en utilisant UnityEngine; // Cet espace de noms est requis pour utiliser tout composant d'interface utilisateur utilisant UnityEngine.UI; // Cet espace de noms est requis pour utiliser le SceneManager à l'aide de UnityEngine.SceneManagement; using System.Collections; classe publique HUD: MonoBehaviour {// Button public Button backToMainMenu; // Utilisez ceci pour l'initialisation void Start () {} // Update est appelé une fois par image void Update () {} // Fonction pour le bouton BackToMainMenu, charge la scène de menu public void BackToMainMenuPress () {SceneManager.LoadScene (0); }} 

Faites glisser ce script sur le canevas HUD, configurez le script de la même manière que le menu principal (en faisant glisser l'objet de jeu Retour au menu principal dans le champ Retour au menu principal). Configurez ensuite le bouton en faisant glisser le canevas HUD dans le champ On Click (). Choisissez la fonction BackToMainMenuPress et testez le bouton en cliquant sur l'icône Lecture et voyez si cela vous ramène au menu principal.

Pièces jointes

• 
  
  Télécharger Fineliner_Script.ttf

• 
  
  Postit-Penscript.otf Télécharger

Étape 9: organisation de la hiérarchie

Rappelez-vous comment j'ai dit que la création d'objets de jeu vides vous aiderait à organiser la hiérarchie? Eh bien, vous avez déjà fait cela en utilisant des enfants et des parents.

Cependant, la scène principale est encore un peu désorganisée. Revenez à la scène principale et créez un objet de jeu vide nommé Effets. Faites glisser toutes les explosions et les objets du jeu de pistes vers ce script d'effets. Faites ensuite glisser cet objet de jeu d'effets sous les scripts. La caméra principale et le système d'événements peuvent rester tels qu'ils sont.

Utilisez ce système pour organiser tout projet que vous créez. Tout objet du même type peut passer sous son propre objet de jeu vide (par exemple, plusieurs ennemis peuvent être les enfants d'un objet de jeu ennemi, plusieurs caméras - objet de jeu de caméras et ainsi de suite.) Cela gardera votre hiérarchie en ordre et vous empêchera d'obtenir confus si vous créez beaucoup d'objets de jeu

Étape 10: Conclusion

Phew. C'était tout le voyage. Mais nous avons finalement atteint la fin (vous en êtes probablement tous heureux.) Mais maintenant, vous avez une application entièrement fonctionnelle que vous pouvez montrer à vos amis et améliorer. Vous devriez être fier, comme mentionné précédemment, c'était un tutoriel plus avancé. Alors prenez un moment et profitez de votre création.

J'espère que ce tutoriel a été une aide. If you get stuck on anything, a good habit to get in to is searching Google for your error, then typing in Unity after it. Because Unity is so widely used, there is a lot of documentation available and there will most likely be at least one person who has had the same issue as you.

If you're not sure about any of the programming functions (void Update, void Start, public void etc.) then search for the function along with unity c# and check the official Unity documentation.

If you can't find an answer to your issues, you can leave a comment and i'll do my best to help you resolve the error.

If there is something you think I could add or if you want to learn how to program an actual game, feel free to leave a comment.

Thanks for taking the time to read this tutorial. Until next time!