La gestion du temps

1. Quoi utiliser?
2. Function Timer()
3. Function Tick()
4. Function lantente Sleep()
5. Variable Level.TimeSeconds

Créé le 10/11/2002
Dernière mise à jour le 10/11/2003

1) Quoi utiliser?

- Pour une gestion du temps a intervalle régulier, opter pour la function Timer().
- Pour une gestion trés rapide du temps, utiliser la function Tick().
- Pour une gestion du temps avec des attentes, utiliser dans un label d'un état la function lantente Sleep().
- Pour une muti gestion du temps, utiliser la variable Level.TimeSecond.

La plus pars du temps on se débrouille avec Timer(), sinon pour la grande précision (même multiple) on utilise Level.TimeSecond dans un Tick().

Top

2) Function Timer()

La function Timer() est désactivé par défault, on utilise la function SetTimer() pour l'enclencher.

Exemple:

var int Timed;


function PostBeginPlay()
{
    Super.PostBeginPlay();

    SetTimer(1.0, TRUE);
}


function Timer()
{
    Timed++;
    Log("Timer(): appellé "$Timed$"fois !");
}

La function SetTimer() a 2 paramètres:
- Le premier indique le delay avant chaque appel de la Timer(), j'ai mis 1 point 0 pour montré que c'est bien un nombre flottant, on peut donc mettre 2.5 par exemple.
- Le second indique si on met ce delay en boucle, sinon avec False, Timer() serra appellé qu'une seule fois, donc faire SetTimer(0, FALSE); pour stoper la boucle.

Exemple pour démarré aussitôt le Timer():

...
function PostBeginPlay()
{
    Super.PostBeginPlay();

    SetTimer(1.0, TRUE);
    Timer();
}
...

Il suffit d'appellé le Timer() comme s'il s'agissait d'une autre function.
Bien sur, ne pas faire un tel appel dans Timer() lui même!
Sachez qu'il ne faut jamais appellé une function a l'intérieur d'elle même, pour ne pas avoir un critical error.

Exemple pour stoper le Timer aprés 10 secondes:

...
function Timer()
{
    if(++Timed >= 10)
    {
        Log("Timer(): appellé pour la dernière fois !");
        SetTimer(0, FALSE);
    }
    else Log("Timer(): appellé "$Timed$"fois !");

    // mon code
}

On vois ici qu'on peut faire une incrémentation (une décrémentation fonctionneré aussi) d'un nombre a l'intérieur même d'une condition, à faire juste avant la variable en question.
Le reste se passe de commentaire, si ce n'est que si par exemple on aurrait voulu stoper le code avant d'arriver au reste de la function, on peut mettre return; juste aprés avoir stoper la boucle avec SetTimer().

Top

3) Function Tick()

La function Tick() est contrairement au Timer() active dés le départ.
Essayer au maximum d'utiliser Timer() plutot que Tick(), qui est trés rapide, est qu'on pas pas souvent besoin de cette vitesse.

Voici un exemple pour bien voir sa vitesse:

var float Ticked;


function Tick(float DeltaTime)
{
    Ticked += DeltaTime;
    Log("Test de Tick(): "$Ticked);
}

Avec ca, ne rester pas 2 heures dans le jeu car le log aurra énormément grossi avec toutes ces notes.

Exemples pour le stoper:

...
function StopTick()
{
    Disable('Tick'); // "Enable('Tick');" pour reactiver
    Log("StopTick(): désactivé");
}


// ou en l'ignorant dans un état


function StopTick()
{
    GoToState('NoTick');
}


state NoTick
{
    ignores Tick;

    Begin:
    Log("NoTick.Begin: Tick() ignoré");
}

- Dans le premier exemple, il faudra penser le ré-activé si on veut le re-utilisé.
- Dans le second exemple, il faudra sortir ou changer de l'état si on veut le re-utilisé.

Pour plus d'infos sur les états et labels, voir ce tutorial.

Note:
Cette function est appellé par l'UnrealEngine avec son TickAllActors();

Top

4) Function lantente Sleep()

Comme Sleep() est une function lantente, on ne peut qu'y accéder dans un label d'un état.

Exemple:

state test
{
    Begin:
    // mon code
    Sleep(1);
    // mon code
    Sleep(2.5);
    // mon code
}

Dans cet exemple, la seconde parti de mon code serra éxécuté aprés une seconde d'attente.
La 3ème partie aprés une autre attente mais de 2,5 secondes cette fois-ci, soit une attente réelle de 3,5 secondes avant l'éxécution de la 3ème partie de mon code.

Note:
Voir aussi ce tutorial.

Top

5) Variable Level.TimeSeconds

La variable flottante Level.TimeSecond est le temps total écoulé depuis le lancement de la map.
On l'utilise dans la function Timer() ou Tick() pour géré plusieurs délais en même temps, ce qui est obligé pour énormément de passage d'IA.

Exemple avec Tick(), comme on peut faire exactement pareil avec Timer() en moins précis:

var float FirstTime;  // gérera un delai de 2 secondes d'intervalle
var float SecondTime; // gèrera un delai de 7.25 secondes d'intervalle


function PostBeginPlay()
{
    Super.PostBeginPlay();

    FirstTime = Level.TimeSecond;
    SecondTime = Level.TimeSecond;
}


function Tick(float DeltaTime)
{
    if((Level.TimeSeconds - FirstTime) > 2)
    {
        FirstTime = Level.TimeSecond;
        // mon code éxécuté chaque 2 secondes
    }

    if((Level.TimeSeconds - SecondTime) > 7.25)
    {
        SecondTime = Level.TimeSecond;
        // mon code éxécuté chaque 7.25 secondes
    }
}

Dans cet exemple, on gère avec une précision maximale, 2 delais différent.
Voir l'exemple qui suit pour peut-être mieux comprendre.

Exemple d'une autre façon:

...
function PostBeginPlay()
{
    Super.PostBeginPlay();

    FirstTime = Level.TimeSecond + 2;
    SecondTime = Level.TimeSecond + 7.25;
}


function Tick(float DeltaTime)
{
    if(Level.TimeSeconds > FirstTime)
    {
        FirstTime = Level.TimeSecond + 2;
        // mon code éxécuté chaque 2 secondes
    }

    if(Level.TimeSeconds > SecondTime)
    {
        SecondTime = Level.TimeSecond + 7.25;
        // mon code éxécuté chaque 7.25 secondes
    }
}

Cet exemple a l'air un peu plus facile, c'est juste que si on veut changé un délai il faudra faire 2 modifications alors que dans le premier exemple qu'une.

Note:
Si c'est pour gérer de grands delais avec une précision de 1 seconde prés au maximum, mieux vaut faire pareil dans un Timer() en boucle de une seconde, ca utilisera moins de ressources.

Top