Gestion Temps

Tu trouveras sur cette page :

Calculer le temps

Time.deltaTime

Il s’agit du temps écoulé depuis la dernière image. Logiquement, plus le nombre d’images par seconde sera grand, et plus ce temps sera petit.

A quoi deltaTime peut bien servir?

Supposons que le joueur se déplace à une certaine vitesse à chaque image, il sera forcément bien plus rapide pour les ordinateurs qui sont plus puissants et tournent à 60 images par seconde, en comparaison à un ordinateur moins puissant qui tourne à 15 images par seconde. Nous, on préfère que tous les joueurs se déplacent à la même vitesse peu importe le nombre de fps! 

Pour éviter que la vitesse du joueur dépende de la puissance de l’ordinateur, on va utiliser Time.deltaTime. Comme il s’agit du temps écoulé depuis la dernière image. Plus le nombre d’images par seconde sera grand, et plus ce temps sera petit. On peut donc l’utiliser pour uniformiser la vitesse: 

transform.Translate(direction * vitesse * Time.deltaTime)

Ici, direction est un vecteur vers lequel se diriger et vitesse est un float qui définit la vitesse qu’on veut donner au joueur.

Creer des timers

Script de Timer

Avec un simple script on peut créer des timers ultra facilement et ré-utilisable dans n’importe quel autre script!
Il suffit de mettre ce script ci sur un objet du niveau (unique, un objet qui sert de gestionnaire de temps) et c’est parti!

On peut utiliser ainsi ce script pour créer des temps d’attentes, des chronomètres qui déclenches des choses quand ils se finissent, etc.

using UnityEngine;
using System;
using System.Collections.Generic;

public class Timers : MonoBehaviour
{
    // Liste qui contient tous les timers actifs
    public static List<Timer> timers = new List<Timer>();

    private void Update() {
        // Boucle pour retirer les timers terminés
        foreach (Timer timer in timers) {
            timer.Update(Time.deltaTime);//met é jour les timers
            if (timer.fini)
                timers.Remove(timer);
                break; //pour eviter un message d'erreur dans la liste
        }
    }

    // fonction pour démarrer un nouveau timer, peut etre utilisée depuis n'importe quel script avec ce code:
    // Timers.StartTimer(TEMPS ICI, FONCTION ICI);
    public static void StartTimer(float duree, Action action) {
        timers.Add(new Timer(duree, action));
    }

    // Classe interne qui représente un timer individuel
    public class Timer
    {
        private float duree;      // Durée totale du timer
        private float tempsecoule;   // Temps écoulé depuis le démarrage du timer
        private Action action;     // Action é exécuter lorsque le timer se termine
        public bool fini;// Indique si le timer est terminé

        public Timer(float duration, Action callback) { //quand on génére un timer, on copie les chiffres donnés dans ses propres propriétés
            this.duree = duration;
            this.action = callback;
            tempsecoule = 0f;
            fini = false;
        }
        //et on fait tourner le timer
        public void Update(float deltaTime) {
            if (fini)
                return;
            tempsecoule += deltaTime;
            //si il est fini, il lance l'action qui é été attaché
            if (tempsecoule >= duree) {
                action?.Invoke();
                fini = true;
            }
        }
    }
}

BouclierTimer (Désactiver un Pouvoir après un laps de temps)

Dans cet exemple, je vais ramasser un objet bonus qui active un Pouvoir limité dans le temps. 

En premier lieu je crée l’objet bonus sur la scène à ramasser. Je vais lui donner un tag, un box collider (avec IsTrigge cocher). Je vais également créer mon pouvoir. Dans mon cas, il s’agira d’un bouclier. Je crée mon bouclier un 2D Object > Sprite > Cercle entant qu’enfant de mon Héros, par défaut je vais le rendre Inactif au le début du jeu. 

Je vais maintenant créer un nouveau script à donner au Héros. On va commencer par ramasser le bonus et activer le Pouvoir


public string cible; // à renseigner dans l’inspector
    public GameObject Pouvoir; // glisser l’objet Pouvoir

    private void OnTriggerEnter2D(Collider2D collision)
    {
        if(collision.tag == cible)
        {
            Destroy(collision.gameObject); //détruire le bonus
            Pouvoir.SetActive(true); // activer le pouvoir
        }  
    }

    public void ArretPouvoir(){
        Pouvoir.SetActive(false); // desactiver le pouvoir
        }

Puis on crée le chrono qui arrive à Zero et arretera le pouvoir:

Timers.StartTimer(5f, ArretPouvoir);

Et pour finir on va désactiver le Pouvoir au démarrage du jeu et donner du temps au chrono

public string cible; // à renseigner dans l’inspector
    public GameObject Pouvoir; // glisser l’objet Pouvoir

    private void Start()
    {
   Pouvoir.SetActive(false); // inactiver le pouvoir
   chrono = Timer; // attribuer le temps définir au chrono
    }

    private void OnTriggerEnter2D(Collider2D collision)
    {
        if(collision.tag == cible)
        {
            Destroy(collision.gameObject); //détruire le bonus
            Pouvoir.SetActive(true); // activer le pouvoir
            Timers.StartTimer(5f, ArretPouvoir);
        }  
    }

    public void ArretPouvoir(){
        Pouvoir.SetActive(false); // desactiver le pouvoir
        }

Si il s’agit d’un bouclier n’oublies pas de lui donner Circle Collider 2D et le Script qui Détruit les cibles !

Chronomètre

Tu peux retrouver une autre version du chronomètre, avec les scripts à copier-coller, si tu préfère les tutoriels écrit plutôt que les vidéos ci-dessous:

Gérer le délai

Tu aimerais pouvoir déclencher du code après un certain délai? Ce guide est fait pour toi! Tu apprendras comment créer un délai, répéter le chronomètre et inclure de l’aléatoire!

Délai simple

Voici un script d’exemple avec tous les éléments qui te permettront de créer un délai! 

public class NomDeTonScript : MonoBehaviour
{
    public float delaiMax;
    private float prochaineApparition;

    private void Start()
    {
        prochaineApparition = delaiMax;
    }

    private void Update()
    {
        if(Time.time > prochaineApparition)
        {
            // mets ton code ici!
        }
    }
}
Explication des variables
  • public float delaiMax – sert à définir le temps d’attente en secondes. Comme c’est une variable publique, tu peux le modifier depuis l’inspecteur. N’oublie pas de le changer dans l’inspecteur pour qu’il ne soit pas égal à zéro! (sinon il est inutile)
  • private float prochaineApparition – variable qui va stocker le moment (en secondes) qu’il faudra dépasser pour déclencher le code!
Explication du Start

Sert à initialiser le prochain temps d’apparition (en secondes) en fonction du délai indiqué dans l’inspecteur. 

Explication de l’Update

Time.time est la variable qui indique le temps passé depuis le début du jeu (en seconde). On vérifie si ce temps dépasse celui qu’on a fixé pour la prochaineApparition. Si c’est le cas, ça déclenche le code à l’intérieur de la condition!

Redémarrer le chronomètre

Tel quel, le script attend juste un délai pour faire ce qu’on lui demande. Cela serait bien de pouvoir redémarrer le chrono pour qu’il puisse exécuter ton code à intervalles réguliers! Imaginons par exemple que tu veuilles faire apparaître des obstacles toutes les deux secondes!
Ajoute à ton script une fonction qui permet de redémarrer le chrono. Tout ce que fait cette fonction est de répéter ce qu’on a déjà écrit dans la fonction Start.
private void RedemarrerLeChrono()
    {
        prochaineApparition = Time.time + delaiMax;
    }

D’ailleurs c’est pour cette raison que tu peux remplacer ce que tu as mis dans Start par un simple appel de la fonction RedemarrerLeChrono();

 private void Start()
    {
        RedemarrerLeChrono();
    }
private void Update()
    {
        if(Time.time > prochaineApparition)
        {
             RedemarrerLeChrono();
            // mets ton code ici!
        }
    }

Dans la fonction Update, tu vas appeler RedemarrerLeChrono() à chaque fois que la condition est remplie.

Cela aura pour effet de faire redémarrer le chronomètre à chaque fois que le délai est atteint. Le code que tu vas écrire à l’intérieur de la condition ne sera exécuté qu’à intervalles réguliers. 

Redémarrer le chronomètre dans un délai aléatoire

C’est très sympa d’avoir du code qui s’exécute régulièrement comme une horloge, mais c’est souvent plus faire d’ajouter de l’aléatoire dedans! Ne pas prévoir quand apparaîtra le prochain obstacle est bien plus amusant pour le joueur! Pour cela, rien de plus simple: il faut juste modifier la fonction RedemarrerLeChrono() en y intégrant un délai aléatoire.

private void RedemarrerLeChrono()
    {
        prochaineApparition = Time.time + Random.Range(0, delaiMax);
    }

BouclierTimer (Désactiver un Pouvoir après un laps de temps)

Dans cet exemple, je vais ramasser un objet bonus qui active un Pouvoir limité dans le temps. 

En premier lieu je crée l’objet bonus sur la scène à ramasser. Je vais lui donner un tag, un box collider (avec IsTrigge cocher). Je vais également créer mon pouvoir. Dans mon cas, il s’agira d’un bouclier. Je crée mon bouclier un 2D Object > Sprite > Cercle entant qu’enfant de mon Héros, par défaut je vais le rendre Inactif au le début du jeu. 

Je vais maintenant créer un nouveau script à donner au Héros. On va commencer par ramasser le bonus et activer le Pouvoir

Voici une petite vidéo qui t’explique cela en détail

    public string cible; // à renseigner dans l’inspector
    public GameObject Pouvoir; // glisser l’objet Pouvoir

    private void OnTriggerEnter2D(Collider2D collision)
    {
        if(collision.tag == cible)
        {
Destroy(collision.gameObject); //détruire le bonus
Pouvoir.SetActive(true); // activer le pouvoir
}
    }

Puis on crée le chrono qui arrive à Zéro arrêtera le pouvoir, Ainsi que définir le temps qu’on veut d’activation du pouvoir.

public int Timer = 10; // indiquer le temps désirer, par défaut à 10
private float chrono; // le chrono qui va diminuer 

Et on va commencer à retirer du temps au chrono dès que le Pouvoir est actif.

    void Update()
{
if (Pouvoir == true)
{
//chrono qui tourne
if (chrono > 0)
{
chrono -= Time.deltaTime; // on retire du temps au chrono
}
else
{ //quand chrono est fini, bouclier s’éteint
Pouvoir.SetActive(false);
chrono = Timer; // redonne du temps au chrono
 }
 }
}

Et pour finir on va désactiver le Pouvoir au démarrage du jeu et donner du temps au chrono

    private void Start()
    {
   Pouvoir.SetActive(false); // inactiver le pouvoir
   chrono = Timer; // attribuer le temps définir au chrono
    }

Si il s’agit d’un bouclier n’oublies pas de lui donner Circle Collider 2D et le Script qui Détruit les cibles !
Retour en haut