Share
Dans ce didacticiel, nous présenterons le jeu avec un gameplay plus complexe avec une variété de micros différents à collecter, certains gênant le joueur et d'autres fournissant des accélérateurs de vitesse..
Nous allons également introduire un compte à rebours complet avec un HUD affichant à la fois le score et le temps restant, ainsi que la fonctionnalité préférée de tous - les particules!
Notre mini-jeu comportera plusieurs types de micros que l'utilisateur pourra collecter. Le type 1 incrémente simplement le score, le type 2 ajoute ou soustrait un score aléatoire et le type 3 accélère ou ralentit le joueur. Pour que ce soit plus intéressant, les micros changeront aléatoirement pendant que le joueur joue..
La première étape consiste à créer un nouveau script définissant le type de collecte de chaque instance..
Ouvrez votre projet de la dernière fois ou téléchargez le code source ci-dessus; Dans la fenêtre du projet, cliquez avec le bouton droit de la souris sur le dossier Scripts et sélectionnez Créer -> JavaScript. renommez-le.
Nous allons maintenant ajouter ce nouveau script en tant que composant de notre préfabriqué de collecte. Sélectionnez donc le 'pickup-prefab' dans le dossier Prefabs et faites glisser le script de collecte sur la fenêtre Inspecteur (ou sur le 'pickup-prefab' lui-même)..
Chaque instance de collecte qui est générée présentera ce nouveau script qui déterminera son type de collecte et diverses autres propriétés. Définissons maintenant ces types.
Lorsque le ramassage est créé, nous allons décider au hasard de quel type il s'agit, ajoutez donc le code suivant au script de ramassage:
// variable pour contenir le type public var type: int; function Awake () // définit un type aléatoire pour commencer SwapType (); function SwapType () // génère un nombre aléatoire compris entre 1 et 10 var random: float = Random.Range (1,10); // définit le type if (random <= 5) // 50% for type 1 type = 1; else if (random <= 8) // 30% for type 2 type = 2; else // 20% for type 3 type = 3;
Le bloc de code ci-dessus définit un "type" de variable qui, lors de l'initialisation du script, prend une valeur aléatoire de 1 (capture de points standard), 2 (prise de jeu par points) ou 3 (mise sous tension rapide) pour définir le type de ramasser.
Nous générons le nombre aléatoire à l'aide de Random.Range (…), puis utilisons une série d'instructions if pour augmenter la probabilité qu'il s'agisse d'une prise de point standard (type = 1) et que, par conséquent, les accélérations de vitesse sont plus rares..
Une fois instanciée, l’enlèvement restera actuellement du même type pendant toute sa durée de vie. Rendons-le un peu plus intéressant en le faisant changer de type après un nombre aléatoire de secondes.
Ajoutez les variables suivantes et la fonction Start () au script:
// temps min et max pour le changement de type public var minTypeChange: int = 10; public var maxTypeChange: int = 30; function Start () while (true) // attend X secondes pour obtenir WaitForSeconds (Random.Range (minTypeChange, maxTypeChange)); // définit un type aléatoire SwapType ();
Cela commence essentiellement par une boucle while qui fonctionnera indéfiniment puisque la condition testée est toujours vraie. La première partie de l'instruction utilise une instruction de rendement WaitForSeconds (…) pour créer un délai d'un nombre aléatoire de secondes, entre les valeurs minimale et maximale spécifiées, avant de permuter le type de collecte en appelant la fonction SwapType définie précédemment..
Le jeu devrait donc fonctionner comme prévu, mais le joueur n'a aucune idée du type de collecte qu'il collecte! Alors maintenant, égayons un peu notre pick-up pour distinguer les différents types. Nous utiliserons la fonctionnalité préférée de tout le monde…
Pour que le joueur puisse faire la différence entre les micros, nous allons ajouter différents systèmes de particules colorées au centre des micros..
Faites glisser une occurrence du préfabriqué dans la scène et concentrez-vous dessus en utilisant la touche F ou en double-cliquant dessus dans la hiérarchie. Ajoutez un système de particules en utilisant le menu du haut: GameObject -> Créer un autre -> Système de particules. Faites-en un enfant du pickup-prefab en le faisant glisser sur le pickup-prefab dans la hiérarchie; cliquez sur Continuer lorsque la boîte de dialogue ci-dessous vous avertit de la perte de la connexion préfabriquée.
Utilisez l'inspecteur pour positionner le système de particules sur (0, 0, 0) de sorte qu'il se trouve au centre du modèle de capteur, comme illustré ci-dessous..
Remarque: si vous avez sélectionné le système de particules ou l'un de ses parents, il émettra des particules dans la fenêtre de scène; sinon, il cessera d'émettre les particules jusqu'à ce qu'il soit sélectionné à nouveau.
Donc, vous devriez maintenant avoir votre premier système de particules positionné au centre de la collecte.
Les systèmes de particules dans Unity sont constitués de trois composants: un émetteur, un animateur et un moteur de rendu. Leurs noms sont assez explicites et chacune comporte une poignée de variables publiques que vous pouvez personnaliser, ce qui permet de produire toutes sortes d'effets visuels impressionnants..
Vous pouvez en savoir plus sur chacun d’entre eux sur les pages de référence des composants qui sont liées ci-dessus. Vous pouvez également trouver leurs pages de référence de script ici: Emitter, Animator and Renderer.
Actuellement, notre système de particules est assez ennuyeux, non? Sélectionnez le système de particules et dans l'inspecteur, ajustez le composant émetteur en fonction des valeurs ci-dessous:
Tout ce que nous avons fait est de modifier l’énergie des particules, affectant leur durée de vie, et de réduire l’ellipsoïde d'où elles sont émises. Vous devriez maintenant remarquer que les particules sont maintenant émises beaucoup plus étroitement les unes dans les autres. centre de la camionnette.
Associez maintenant le composant animateur de votre particule aux valeurs indiquées ci-dessous:
Les changements que nous avons apportés ici sont l'ajout d'une force aléatoire aux particules sur chaque axe, afin de les rendre plus naturelles, et une valeur de croissance de taille égale à 1 afin qu'elles grossissent avec le temps, comme indiqué ci-dessous..
C'est notre système de particules complet; nous allons ajuster les couleurs en utilisant notre script Pickup.
Enfin, pour mettre à jour le préfabriqué de prélèvement avec l'objet sélectionné dans la hiérarchie sélectionnée, cliquez sur le bouton Appliquer en haut de l'inspecteur. Vous pouvez ensuite supprimer la collecte de la hiérarchie.
Réglons maintenant notre script Pickup pour modifier la couleur des particules en fonction du type de collecte.
Comme vous l'avez peut-être remarqué dans les composants système des particules, une particule peut animer cinq couleurs différentes, chacune pouvant avoir une valeur de couleur et une valeur alpha (transparence)..
Si vous examinez la page Référence de script de l'animateur de particules et examinez de plus près la propriété colorAnimation, vous remarquerez qu'il s'agit d'un tableau d'objets couleur..
Introduisons maintenant une variable pour stocker le système de particules du capteur afin d’accéder à ses couleurs, et introduisons trois nouveaux tableaux (type datatyped to Couleur) à notre script Pickup. Allez-y et ajoutez le code suivant au script:
// les particules gameobject public var particules: GameObject; // couleurs pour chaque type de ramassage public var type1: Color []; public var type2: Color []; public var type3: Color [];
Enregistrez le script et sélectionnez à nouveau le préfabriqué dans la fenêtre de projet. Développez le préfabriqué pour afficher ses enfants et faites glisser le système de particules, qui est un enfant, dans la variable des nouvelles particules de Pickup Components..
Vous devriez également maintenant remarquer les trois nouveaux tableaux au sein de l'inspecteur; définissez chacune de leurs tailles à 5 comme ci-dessous car il s’agit du nombre de couleurs que les particules doivent animer.
Les couleurs sont actuellement toutes noires, ce qui n’est pas si excitant. Sélectionnez donc le premier élément de Type1, choisissez une couleur vive dans la palette de couleurs résultante (j’ai utilisé le vert ci-dessous) et définissez la valeur alpha (A) sur 50..
Répétez cette opération pour les couleurs restantes du type 1, augmentez ainsi la valeur alpha, puis revenez en arrière de façon à ce que les particules apparaissent et disparaissent en fondu. La valeur alpha de chaque couleur est représentée par la barre blanche au bas de la couleur, comme indiqué ci-dessus. . J'ai également choisi d'utiliser un vert légèrement plus foncé lorsque la particule s'estompe - vous pouvez bien sûr les colorer comme vous le souhaitez..
Répétez ce processus en utilisant différentes couleurs pour Type2 et Type3 comme ci-dessous.
Donc, ce sont nos couleurs créées. La dernière chose à faire est de les assigner au colorAnimation propriété de l'animateur du système de particules.
Comme il est mentionné dans le script colorAnimation Script Reference, il convient de noter que, lors de la modification des couleurs via du code, vous devez récupérer, modifier et réaffecter l'ensemble du tableau plutôt que des couleurs individuelles. Heureusement, nous pouvons simplement écraser les tableaux ColorAnimation actuels avec les nôtres, ce qui est agréable et facile..
Introduisez la variable suivante et remplacez la fonction Awake () actuelle par celle ci-dessous, qui récupère et stocke le composant ParticleAnimator de particules que nous pourrons utiliser plus tard..
// le composant animateur de particules private var particleAnimator: ParticleAnimator; function Awake () // récupère le composant animateur de particules à partir des particules particleAnimator = particules.GetComponent (ParticleAnimator); // définit un type aléatoire pour commencer SwapType ();
Enfin, écrasez la fonction SwapType () actuelle par la suivante:
function SwapType () // génère un nombre aléatoire compris entre 1 et 10 var random: float = Random.Range (1,10); // définit le type if (random <= 5) // 50% for type 1 type = 1; particleAnimator.colorAnimation = type1; else if (random <= 8) // 30% for type 2 type = 2; particleAnimator.colorAnimation = type2; else // // 20% for type 3 type = 3; particleAnimator.colorAnimation = type3;
Ceci introduit une ligne supplémentaire pour chaque condition de la si instruction, en affectant le tableau pertinent à la propriété colorAnimation de la variable particleAnimator. Travail accompli.
Si vous jouez maintenant au jeu, les bonus auront chacun des particules de couleur et il devrait y en avoir plus avec la couleur utilisée pour Type1 que Type2 ou Type3. Ils ont toujours l'air un peu ennuyeux, cependant, puisqu'ils sont statiques sur place; ajoutons rapidement un peu de rotation aléatoire à eux.
Ceci est un ajout simple mort, mais il rendra nos micros un peu plus intéressant.
Ajoutez les variables suivantes et Mettre à jour() fonction pour le script de collecte:
// vitesses de rotation min et max. public var minRotationSpeed: float = 0.5; public var maxRotationSpeed: float = 2.0; // vitesse de rotation calculée private var rotationSpeed: float; function Update () // fait pivoter le gameobject à chaque transformation.Rotate (rotationSpeed, rotationSpeed, 0); // fait pivoter les particules chaque image (afin qu'elles tournent deux fois plus vite que l'objet entier) particules.transform.Rotate (rotationSpeed, rotationSpeed, 0);
Puis écrasez le Éveillé() fonctionne avec ce qui suit, qui calcule la rotation aléatoire Speed lors de l’initialisation du script:
function Awake () // calcule une vitesse de rotation aléatoire rotationSpeed = Random.Range (minRotationSpeed, maxRotationSpeed); // récupère le composant animateur de particules à partir des particules particleAnimator = particules.GetComponent (ParticleAnimator); // définit un type aléatoire pour commencer SwapType ();
Si vous lancez à nouveau le jeu, les micros devraient tous tourner à des vitesses aléatoires! Il est temps de commencer à marquer!
Avant de construire notre interface, nous devons décider de la résolution de notre jeu et nous assurer que notre fenêtre de jeu est de cette résolution afin de pouvoir positionner avec précision les éléments de notre interface..
J'utilise les formats d'exportation WebPlayer par défaut (600 x 450) que vous pouvez modifier à l'aide du menu principal, Edition -> Paramètres du projet -> Lecteur. Vous pouvez également choisir la version du modèle WebPlayer que vous souhaitez utiliser..
Une fois que vous avez décidé de la résolution de votre jeu, vous devez définir la même taille pour votre fenêtre de jeu. Pour ce faire, utilisez le menu situé dans le coin supérieur gauche de la fenêtre de jeu indiquée ci-dessous.
Nous pouvons maintenant positionner avec précision nos éléments d'interface dans la fenêtre de jeu. Il est important de vous rappeler de les positionner tout en observant la fenêtre de jeu, PAS la fenêtre de scène..
Commençons maintenant à créer notre interface…
Avant de commencer à rédiger des scripts pour le scoring, nous construirons l'interface pour contenir le score en introduisant GUITextures (GUI = Graphical User Interface), qui constituera la partie statique de l'interface..
Téléchargez ce paquet contenant la police et la texture requises pour notre interface. La police utilisée s'appelle IrisUPC et est disponible ici. Double-cliquez sur le package pour en extraire le contenu, puis cliquez sur Importer pour importer tous les actifs lorsque vous y êtes invité par la fenêtre de dialogue Importer:
Vous aurez maintenant deux nouveaux dossiers dans votre fenêtre de projet: Polices et interface graphique..
Commençons maintenant à créer l'interface graphique de notre jeu. Tout d’abord, ajoutez un nouveau GameObject vide (à l’aide du menu principal), renommez-le en "GUI" et positionnez-le sur (0, 0, 0). Ce sera le conteneur de notre interface graphique afin que notre hiérarchie soit bien organisée.
Développez le dossier de l'interface graphique dans la fenêtre de projet, sélectionnez l'interface de jeu et, à l'aide du menu supérieur, ajoutez une GUITexture: GameObject -> Créer un autre -> GUITexture. Vous devriez maintenant avoir quelque chose de similaire à ci-dessous:
Donc, pour le moment, ce n'est pas trop grave car nous voulons aligner ce graphique avec le haut de l'écran..
Tout d'abord, modifions son encart en pixels dans l'Inspector afin que son point de pivot ne soit plus au centre, puis repositionnons-le en haut de l'écran. Sélectionnez l'interface de jeu et faites correspondre ses composants Transform et GUITexture à ceux indiqués ci-dessous:
Ce que nous avons fait ici a modifié la valeur Y d'insertion de pixels GUITexture en -64 (qui correspond à la hauteur de l'image), de sorte que son point de pivotement se trouve en haut de l'image. Désormais, lorsque vous définissez la valeur Y dans le composant de transformation sur 1, GUITexture s’aligne parfaitement avec le haut de l’écran; il y aurait sinon un écart de 32px.
Rappelles toi: Lors du positionnement d’éléments graphiques dans Unity, (0,0) est le coin inférieur gauche de l’écran et (1,1) le coin supérieur droit de l’écran..
Voilà donc pour notre GUITexture; il est temps d'ajouter le GUIText…
Avec les graphiques pour notre interface en place, il est maintenant temps d'introduire GUIText, qui affichera le score du joueur et le temps restant..
Développez le dossier Polices, sélectionnez UPCIL dans Iris, puis créez un GameObject GUIText en utilisant le menu du haut: GameObject -> Créer autre -> GUIText. Renommez le en txt-score et en faire un enfant de GUI.
Vous devriez maintenant avoir un petit texte disant «Texte graphique» au centre de l’écran en utilisant la police UPCIL. Remarque: lors de la création de GUIText, il est plus facile de sélectionner la police avant de créer GUIText que de la définir ultérieurement..
Dans l'inspecteur, faites correspondre les paramètres des composants Transform et GUIText avec ceux indiqués ci-dessous:
Le positionnement du composant de transformation ci-dessus alignera le GUIText comme indiqué ci-dessous avec la résolution 600 x 450 du WebPlayer. Si vous utilisez une résolution différente, vous devrez peut-être jouer avec les valeurs pour l'aligner correctement. Notez que, en réglant la valeur de l’axe Z sur 1, le GUIText se positionne devant le GUITexture.
Nous avons réglé le texte sur '888' car c'est le plus large qui soit. nous avons également modifié l'ancrage pour centrer le texte plutôt que de l'aligner à gauche. Enfin, nous avons élargi la taille de la police à 36:
Suivez maintenant à nouveau exactement les mêmes étapes - mais renommez le GUIText en txt-time - et réglez son composant de transformation sur les paramètres indiqués ci-dessous afin que vous obteniez quelque chose de similaire à l'image:
Voilà donc la construction de l'interface terminée, il est maintenant temps de tout relier.
Rouvrez le script PickupController et ajoutez les deux variables et fonction suivantes au script:
// textfield pour contenir la partition et la variable de partition private var textfield: GUIText; score de var privé: int; function UpdateScoreText () // met à jour textfield avec score textfield.text = score.ToString ();
Assez explicite ici. Deux variables, une pour suivre le score et une pour stocker le champ de texte dans lequel le score est affiché. UpdateScoreText () fonction définit le texte du champ de texte sur la valeur de chaîne de la variable de score à l'aide de la touche ToString () une fonction.
Avant d'appeler cette fonction, nous devons toutefois attribuer une valeur à notre champ de texte. Ajoutez le code suivant au Éveillé() une fonction:
Accentsconagua
textfield = GameObject.Find ("GUI / txt-score"). GetComponent (GUIText);
score = 0; UpdateScoreText (); Cela trouvera le GameObject 'txt-score' - en supposant que vous l'ayez placé dans votre hiérarchie comme demandé - et récupère son composant GUIText. La variable de score est ensuite définie sur 0 et UpdateScoreText () est appelé.
Actuellement, vous devriez obtenir un 0 à l'écran lorsque vous cliquez sur Lecture; cependant, il n’ya rien pour augmenter le score, alors remplacez le Recueilli (…) fonctionner avec celui ci-dessous:
function Collected (pickupCollected: GameObject) // récupère le nom de la collecte collectée et converti en int index var: int = parseInt (pickupCollected.name); // le ramassage a été détruit, remettez à nouveau l'index spawn disponible spawnIndexAvailableList [index] = true; // récupère l'état de ramassage de type var: int = pickupCollected.GetComponent (Pickup) .type; // met à jour le score en fonction du type de ramassage if (type == 1) score + = 2; // ajoute simplement 2 au score else if (type == 2) score + = Random.Range (-2, 5); // ajoute un score aléatoire entre -2 et 5 au score // met à jour le score UpdateScoreText (); // détruit le ramassage Destroy (pickupCollected); // attend un nombre aléatoire de secondes entre minimumSpawnDelayTime et maximumSpawnDelayTime, rendement WaitForSeconds (Random.Range (minimumSpawnDelayTime, maximumSpawnDelayTime)); // créer un nouveau ramassage SpawnPickup ();
Vous remarquerez que nous avons ajouté quelques lignes au centre de la fonction pour extraire la variable de type de la collecte collectée, puis incrémenter le score soit d'une valeur statique de 2 pour les collectes de type 1, soit d'une valeur aléatoire entre -2 et 5 pour les micros de types 2 et 3.
Le champ de texte est ensuite mis à jour une fois le score ajusté. Facile, droit?
Avant d’afficher la minuterie, l’un de nos capteurs peut influer sur la vitesse du lecteur..
Ouvrez le script PlayerController et ajoutez les variables suivantes:
// le composant PickupController du composant gameObject 'PickupSpawnPoints' private var characterMotor: CharacterMotor; // variables de vitesse public var minSpeed: int = 5; public var maxSpeed: int = 35; private var originalSpeed: int;
Maintenant remplacer le courant Éveillé() fonctionner avec ce qui suit:
function Awake () // récupère les PickupSpawnPoints gameObject var pickupSpawnPoints: GameObject = gameObject.Find ("PickupSpawnPoints"); // puis récupérez le composant PickupController du PickOpject PickupController ci-dessus gameObject pickupController = pickupSpawnPoints.GetComponent ("PickupController"); // récupère les joueurs CharacterMotor Component characterMotor = GetComponent (CharacterMotor); // récupère la vitesse originale du lecteur à partir de characterMotor originalSpeed = characterMotor.movement.maxForwardSpeed; Alors qu'est-ce qui a changé? Nous avons introduit un caractèreMoteur variable qui récupère le composant CharacterMotor du joueur où nous pouvons accéder à la vitesse du joueur. Nous avons également introduit plusieurs variables de vitesse pour suivre la vitesse d'origine et définir les valeurs de vitesse minimale et maximale..
C’est formidable jusqu’à présent, mais cela ne changera rien à notre jeu puisque nous ne conservons que la vitesse initiale. Nous devons le faire régler la vitesse lorsque le joueur entre en collision avec l'un des micros.
Remplace le OnControllerColliderHit (…) fonctionner avec le dessous:
function OnControllerColliderHit (hit: ControllerColliderHit) // si le joueur lance un enlèvement if (hit.gameObject.tag == "Pickup") // appelle la fonction Collected (…) du composant PickupController (script) et // passe le micro que nous avons sélectionné comme paramètre de la fonction pickupController.Collected (hit.gameObject); // si le ramassage est défini sur le type 3, ajustez la vitesse du lecteur if (hit.gameObject.GetComponent (Pickup) .type == 3) // arrêtez toutes les routines exécutant déjà StopCoroutine ("AdjustSpeed"); // crée un nouveau coroutine pour AdjustSpeed StartCoroutine ("AdjustSpeed"); Nous avons donc ajouté une instruction supplémentaire if qui teste si le type de collecte est égal à 3, ce qui ajustera ensuite la vitesse via le Ajuster la vitesse () une fonction. Allez-y et ajoutez le Ajuster la vitesse () fonction ci-dessous pour le script:
function AdjustSpeed () // récupère un nombre aléatoire compris entre 0 et 1 var rand: float = Random.Range (0.0, 1.0); si (rand <= 0.6) // 60% for speed boost characterMotor.movement.maxForwardSpeed = maxSpeed; else // 40% for slow down characterMotor.movement.maxForwardSpeed = minSpeed; // wait for 5-10 seconds before resetting the speed to the original speed yield WaitForSeconds(Random.Range(5,10)); characterMotor.movement.maxForwardSpeed = originalSpeed;
le Ajuster la vitesse () Cette fonction génère un nombre aléatoire, qui est ensuite utilisé pour décider d’accélérer ou de ralentir le lecteur. La fonction attend alors entre 5 et 10 secondes avant de réaffecter la vitesse initiale. Si vous jouez maintenant au jeu, tout devrait sembler fonctionner correctement.
Il y a un problème, cependant.
Si vous collectez un capteur de type 3, puis un autre capteur de type 3 avant que la vitesse d'origine ait été réinitialisée, la fonction est toujours en attente et la vitesse initiale sera réinitialisée bien plus tôt que prévu.
L'approche que nous allons utiliser pour résoudre ce problème consiste à utiliser StartCoroutine (…), en passant le nom de la fonction en tant que paramètre. Nous pourrons ensuite utiliser StopCoroutine (…), qui supprimera l'instruction de rendement WaitForSeconds (…) dans la fonction..
Remplacer l'appel à Ajuster la vitesse () dans le si déclaration avec le code suivant:
// arrête toutes les routines exécutant déjà StopCoroutine ("AdjustSpeed"); // crée un nouveau coroutine pour AdjustSpeed StartCoroutine ("AdjustSpeed"); Maintenant, lorsque vous lancez le jeu, il devrait fonctionner comme prévu si vous pouviez trouver rapidement deux micros de type 3 (si vous avez copié exactement ce qui précède, ils doivent être bleus).
Créer un compte à rebours dans Unity est assez simple! Créez un nouveau script appelé 'CountdownTimer' et ajoutez les variables suivantes et Éveillé() une fonction:
// le champ de texte pour mettre à jour l'heure en champ de texte var privé: GUIText; // variables de temps public var allowedTime: int = 90; private var currentTime = allowedTime; function Awake () // récupère le composant GUIText et définit le texte textfield = GetComponent (GUIText); UpdateTimerText (); // démarre la minuterie en cochant TimerTick ();
Tous assez simple jusqu'à présent; nous avons déclaré quelques variables et lorsque le script est initialisé, nous assignons au composant GUIText du GameObject que le script est un composant de la variable textfield.
Nous faisons ensuite deux appels de fonction à UpdateTimerText () et TimerTick (). Commençons par ajouter le UpdateTimerText () fonction ci-dessous à notre script:
function UpdateTimerText () // met à jour le champ de texte textfield.text = currentTime.ToString ();
C’est aussi très simple, convertir le heure actuelle variable dans une chaîne, puis mettre à jour le champ de texte avec cette chaîne. Ajoutons maintenant la fonctionnalité de minuterie à notre script avec le TimerTick () fonction ci-dessous:
function TimerTick () // alors qu'il reste des secondes tandis que (currentTime> 0) // attend 1 seconde de rendement WaitForSeconds (1); // réduire le temps currentTime--; UpdateTimerText (); // jeu terminé
Donc, il y a un peu plus de choses dans cette fonction mais c'est quand même assez simple; nous allons jeter un coup d'oeil…
Nous avons un tandis que boucle qui continue à boucler jusqu’à ce que le compteur de secondes atteigne 0 - c’est-à-dire que le jeu est terminé. Dans la boucle, nous utilisons le rendement WaitForSeconds (…) instruction pour arrêter l'exécution du script pendant 1 seconde. Lorsque le script recommence à s'exécuter, le heure actuelle la variable est réduite de 1 et le champ de texte est mis à jour en appelant UpdateTimerText ().
Depuis c'est un tandis que boucle, ce flux est répété jusqu'à ce que le heure actuelle est égal à 0, moment auquel le jeu est terminé et «Game Over» est imprimé sur la console.
Il reste une dernière chose à faire pour que cela fonctionne: il faut bien sûr ajouter le script CountdownTimer en tant que composant du GameObject 'txt-time', car sinon, il ne s'agit que d'un script inutilisé dans un dossier.!
Maintenant, lancez le jeu. Le compte à rebours devrait commencer à 90 et s'arrêter à 0. (Vous pourrez cependant continuer à courir après mais nous y remédierons dans le prochain tutoriel.)
J'espère que vous avez apprécié ce dernier tutoriel de Getting Started with Unity! Nous avons couvert GUITextures, GUIText, créer des comptes à rebours et tout le monde préféré - Particles! Dans la prochaine et dernière partie de cette série, nous ajouterons une intro et un écran de fin pour notre jeu. On se voit là-bas!
