La fumée et les miroirs des bons comptes à rebours, 2e partie

Ce que vous allez créer

La dernière fois, nous avons examiné les comptes à rebours dans les jeux, leur configuration et les éléments que vous pouvez utiliser pour les rendre plus attrayants. Il y a beaucoup plus que ce qui va dans un seul article, bien que!

Cela continuera à partir de la partie 1, c'est pourquoi nous commencerons au numéro sept..

Prêt? Allons-y!

7: Avoir une vitesse constante différente

C'est un truc simple qui ne nécessite même pas de mentir au joueur. Vous dites simplement "quand le temps imparti est écoulé" et affichez un compte à rebours. Ce que vous ne mentionnez pas est le unité qui est montré.

Si vous affichez un "10", le joueur aura intuitivement l’impression que cela prend 10 secondes, mais le nombre peut diminuer plus lentement que le nombre de secondes. Si vous modifiez la valeur avec un 0.5 multiplicateur, par exemple, il s'épuise après 20 secondes au lieu de juste dix.

Vous pouvez voir comment cela fonctionne dans mon jeu Ludum-Dare, Toutes les dix secondes un chaton se noie.

Une minuterie dans Toutes les dix secondes, un chaton se noie. La minuterie est suffisamment lente pour donner au joueur une bonne quantité de temps tout en apparaissant très bas

Le thème de la confiture a nécessité que 10 secondes sont utilisés, mais 10 secondes réelles sont beaucoup trop peu de temps pour accomplir quelque chose de significatif.

8: Adapter la vitesse de lecture pendant le jeu

Cela fonctionne aussi mieux si les unités de temps ne sont pas mentionnées et si le joueur a juste une idée approximative de "jusqu'à ce que cela se produise"..

Si vous avez une série de panneaux qui s'allument pour indiquer la progression du chronomètre, vous n'avez pas besoin de les activer au même rythme. En fait, cela deviendra plus intense si les premiers éléments s’allument rapidement et que les derniers ont plus de temps entre eux. Dans le feu de l'action, le joueur ne s'en rendra pas compte et vivra une expérience beaucoup plus intense..

Cela ne devrait pas être utilisé avec les unités de temps réelles, car les joueurs pourraient se sentir trompés et mentis. Ne pas briser la confiance du joueur dans votre système.

Cela peut être vu dans un niveau de Starfox 64, où le joueur doit défendre une position contre un navire géant qui approche.

Minimap dans Starfox 64. Le vaisseau-mère attaquant (le cercle noir) se déplace vers la base au milieu, donnant au joueur un compte à rebours indiquant le temps qu'il lui reste pour le détruire.

Au premier coup d'œil, vous avez une idée approximative du temps qu'il reste, mais le navire lui-même semble se déplacer à des vitesses différentes et non en ligne droite..

La minuterie est essentiellement adaptée à la volée, dont le processus est caché derrière de la fumée et des miroirs.

9: Utiliser des sons

Les comptes à rebours ne doivent pas être purement optiques! Un bip toutes les quelques secondes améliorera grandement l'immersion.

Une fois que vous avez cela, vous pouvez également adapter la fréquence une fois un certain temps écoulé. Si le bip retentit toutes les cinq secondes, au cours des 30 dernières secondes du chronomètre, le joueur en sera informé sans avoir à regarder le nombre et à calculer mentalement le temps restant..

De même, il est utile que le personnage commente la progression. Avoir quelqu'un dire "Nous sommes à mi-chemin fait!" vous fournit une information bien cadrée, beaucoup plus facile à comprendre que l’analyser à partir d’une lecture.

10: Utiliser les visuels de mise à l'échelle

Cela fonctionne très bien lorsque le compteur approche de sa fin. Chaque fois qu'une autre seconde est écoulée, augmentez la taille du compteur pendant une demi-seconde.

En plus de la couleur et du son, cela le rendra beaucoup plus juteux.

11: Faire quelque chose quand il atteint zéro

Assurez-vous qu'une minuterie ne devienne jamais négative - cela va dérouter beaucoup de gens et sembler être un bug, car les minuteries buggées et mal créées ont tendance à le faire..

Avoir le flash serait une bonne idée, car il souligne à nouveau le point d'être épuisé.

Si vous avez un chronomètre positif, il est amusant de le laisser continuer à fonctionner et de l'utiliser comme un score élevé. Le jeu Dagues du diable fait une chose similaire, où l'objectif principal est "Survivre à 500 secondes".

Gameplay à partir de Dagues du diable

Quoi ne pas faire qui briserait la confiance du joueur

Une fois que les règles du chronomètre ont été établies, elles devraient rester grossièrement cohérent, plus on laisse une marge de manœuvre moins un minuteur est exact. La question principale devrait être: "Comment cette règle cachée profite-t-elle à l'expérience?"

Lorsque vous ralentissez un chronomètre au cours des trois dernières secondes, la situation devient plus tendue et le joueur dispose de quelques secondes supplémentaires pour accomplir sa tâche. Le ralentir aléatoirement au milieu ou l'accélérer ne fera que briser la confiance du joueur dans vos règles..

Construisons-le

Cela va continuer avec le code de base du dernier tutoriel et le construire. Si vous ne l'avez pas encore vérifié, faites-le maintenant! Vous pouvez également télécharger la source finie en haut à droite de cet article..

Quand nous avons quitté notre minuterie pour la dernière fois, cela ressemblait à ceci:

Maintenant, de nouveaux ajouts vont le rendre plus intéressant. Nous allons continuer avec countdown.cs-script, qui devrait ressembler à ceci:

utiliser UnityEngine; using System.Collections; Classe publique Countdown: MonoBehaviour float timer = 60f; public AudioClip soundBlip; void Update () if (timer> 0f) timer - = Time.deltaTime;  else timer = 0f;  if (minuterie < 10f)  GetComponent() .color = Color.red;  else if (minuterie < 20f)  GetComponent() .color = Color.yellow;  GetComponent() .text = timer.ToString ("F2");  

Faites-le bip

Faisons en sorte que notre minuterie émette un bip chaque seconde pour que le joueur sache qu'il diminue même sans le regarder..

Tout d'abord, nous avons besoin d'une belle spot effet sonore. Vous pouvez trouver un fichier audio dans les fichiers source ou en créer un agréable à l'aide de l'outil gratuit BFXR. Une fois que vous en avez un, copiez-le dans votre dossier.

Ajoutez un composant AudioSource à votre objet de compte à rebours via Composant> Audio> AudioSource. Ajoutez cette variable au script de compte à rebours:

public AudioClip soundBlip;

Vous devez également affecter le fichier son au soundBlip variable:

Et ajoutez ce bloc à la Mettre à jour une fonction:

if (Mathf.Round (timer * 100) / 100% 1f == 0) GetComponent() .PlayOneShot (soundBlip); 

Ceci vérifiera si la minuterie est à la seconde marque complète et si c'est le cas, jouez le fichier son.

Le fonctionnement réel de ce code est un peu plus compliqué. Ce qu’il fait est d’abord de contourner le compteur à virgule flottante en deux décimales, puis de le diviser par 1 et de voir s’il reste un reste. Si le reste est égal à zéro, cela signifie que la minuterie a atteint une seconde complète et que le son blip peut être lu..

Si nous ne le faisons pas, le système risque de se déclencher beaucoup plus souvent, ce qui ne sera ni amusant ni propice à une bonne minuterie.

Vitesse différente

Cela ajoutera un multiplicateur qui réduira ou accélérera la vitesse du chronomètre. Ajoutez cette variable au début:

multiplicateur de flottement = 0.6f;

Maintenant, trouvez la ligne qui réduit le temps, c'est celle-ci:

timer - = Time.deltaTime;

Et adaptez-le pour ressembler à ceci:

minuteur - = multiplicateur Time.deltaTime *;

Si le multiplicateur est inférieur 1,0 la minuterie fonctionnera maintenant plus lentement, et si elle est au-dessus 1,0 ça va courir plus vite. Le mettre à 1,0 ne fera rien.

Essayez d'expérimenter pour trouver une bonne valeur! Je sens une vitesse légèrement inférieure, comme 0.85f, fera en sorte que le joueur sente le compte à rebours plus.

Ralentir quand bas

Maintenant que nous avons un composant multiplicateur, nous pouvons le changer en cours de partie.!

Accédez au bloc de code changeant de couleur:

si (minuterie < 10f)  GetComponent() .color = Color.red;  else if (minuterie < 20f)  GetComponent() .color = Color.yellow; 

Ici, nous avons déjà les conditions dans lesquelles un changement de vitesse de rotation serait approprié, nous pouvons donc simplement l'ajouter.!

si (minuterie < 10f)  GetComponent() .color = Color.red; multiplicateur = 0,6f;  else if (minuterie < 20f)  GetComponent() .color = Color.yellow; multiplicateur = 0.8f;  else multiplier = 1.0f; 

Lorsque le minuteur devient jaune à 20 secondes, il va maintenant cocher avec une vitesse de 80%. Une fois qu'il devient rouge, il passera à 60% de la vitesse normale. Sinon, il sera réglé à 100% de la vitesse.

Mise à l'échelle lorsque faible

Un autre excellent moyen de faire ressortir davantage une minuterie est de l'augmenter chaque seconde qui passe. Comme nous avons déjà du code qui se déclenche toutes les secondes, nous pouvons l’adapter davantage!

Premièrement, nous avons besoin d’une fonction pour augmenter et diminuer la taille de notre affichage. Ajouter cette fonction:

private bool isBlinking = false; IEnumerator privé Blink () isBlinking = true; float startScale = transform.localScale.x; transform.localScale = Vector3.one * startScale * 1.4f; return return new WaitForSeconds (0.3f); transform.localScale = Vector3.one * startScale; isBlinking = false; 

C'est un IEnumerator, qui est un type de fonction pouvant contenir des commandes d'attente. Nous avons besoin de estBlinking variable pour vous assurer que nous ne l'appelons pas plusieurs fois.

Une fois lancé, il redimensionnera la taille de l’objet par un facteur de 1,4f, attendra 0,3 seconde, puis redimensionnera à la taille originale..

Nous l'appelons en utilisant ce code spécial:

if (Mathf.Round (timer * 100) / 100% 1f == 0) GetComponent() .PlayOneShot (soundBlip); si (minuterie < 10f)  if(!isBlinking)  StartCoroutine(Blink());   

Un IEnumerator doit être initié en appelant via StartCoroutine, sinon ça ne marchera pas.

Le bloc entier sera appelé quand une seconde passera. On pourra alors vérifier si le timer est suffisamment bas pour le faire clignoter..

Cligner des yeux à zéro

Faisons quelque chose quand le temps est écoulé. Le laisser rester à zéro peut être ennuyeux, alors faisons-le cligner des yeux.

D'abord, nous aurons besoin d'un autre IEnumerator une fonction:

private bool isZeroBlinking = false; IEnumerator privé ZeroBlink () isZeroBlinking = true; GetComponent() .enabled = false; return return new WaitForSeconds (1.5f); GetComponent() .enabled = true; return return new WaitForSeconds (1.5f); isZeroBlinking = false; 

Cela activera et désactivera la minuterie 1,5-deuxième intervalle. Déclenche le dans le bloc qui vérifie déjà si la minuterie est à zéro.

if (timer> 0f) timer - = Time.deltaTime * multiplicateur;  else timer = 0f; if (! isZeroBlinking) StartCoroutine (ZeroBlink ()); 

Avant de l'exécuter, nous devons désactiver le bip et le clignotement à zéro lui-même, sinon cela entraînerait des comportements.

Adaptez les conditions du bloc pour vérifier si une seconde s'est écoulée et pour vérifier si l'heure actuelle est supérieure à zéro:

if (Mathf.Round (timer * 100) / 100% 1f == 0 && timer> 0f) GetComponent() .PlayOneShot (soundBlip); si (minuterie < 10f && timer > 0f) if (! IsBlinking) StartCoroutine (Blink ()); 

Cela garantira un clignotement régulier et zéro clignotant sans interférer les uns avec les autres.

L'ensemble compte à rebours le script devrait ressembler à ceci:

utiliser UnityEngine; using System.Collections; Classe publique Countdown: MonoBehaviour float timer = 5f; multiplicateur de flottement = 0.6f; public AudioClip soundBlip; void Update () if (timer> 0f) timer - = Time.deltaTime * multiplicateur;  else timer = 0f; if (! isZeroBlinking) StartCoroutine (ZeroBlink ());  if (minuterie < 10f)  GetComponent() .color = Color.red; multiplicateur = 0,6f;  else if (minuterie < 20f)  GetComponent() .color = Color.yellow; multiplicateur = 0.8f;  else multiplier = 1.0f;  if (Mathf.Round (timer * 100) / 100% 1f == 0 && timer> 0f) GetComponent() .PlayOneShot (soundBlip); si (minuterie < 10f && timer > 0f) if (! IsBlinking) StartCoroutine (Blink ());  GetComponent() .text = timer.ToString ("F2");  private bool isBlinking = false; IEnumerator privé Blink () isBlinking = true; float startScale = transform.localScale.x; transform.localScale = Vector3.one * startScale * 1.4f; return return new WaitForSeconds (0.3f); transform.localScale = Vector3.one * startScale; isBlinking = false;  private bool isZeroBlinking = false; IEnumerator privé ZeroBlink () isZeroBlinking = true; GetComponent() .enabled = false; return return new WaitForSeconds (1.5f); GetComponent() .enabled = true; return return new WaitForSeconds (1.5f); isZeroBlinking = false;  

Cela fera le travail. Vous pouvez bien sûr le rendre plus élégant et combiner les commandes dans un code plus efficace.

Conclusion

Notre petit compte à rebours standard est devenu beaucoup plus intéressant et attrayant. Si vous le construisez une fois, vous pouvez l’utiliser et le brancher à n’importe quel projet, peu importe sa taille..

Maintenant, va le mettre dans un jeu!