Les structures de codes

Les conditions
La structure switch
La boucle Do/Until
La boucle While
La boucle For
Les boucles ForEach

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

1) Les conditions

if: si
else: sinon
==: égal
!=: inégal
~=: approximativement égal
&&: et
||: ou
<: inférieur
>: supérieur
<=: inférieur ou égal
>=: supérieur ou égal

Exemple avec if:

var() bool bMyBool;

function Test()
{
    if(bMyBool) // mon code
    else // mon autre code
}

// ou

function Test()
{
    if(bMyBool)
    {
        // mon code plusieurs lignes
    }
    else // mon autre code
}

// ou

function Test()
{
    if(bMyBool)
    {
        // mon code sur plusieurs lignes
    }
    else
    {
        // sinon mon autre code sur plusieurs lignes
    }
}

Note:
Si il s'agit d'une bool inutile de faire if(Activated == True), if(Activated) suffit pour dire quelle est vrai.

Exemple avec if, Else, ||:

var() bool bMyBool, bOtherBool;

function Test()
{
    if((bMyBool) || (bOtherBool))
        // mon code
    else
        // sinon mon autre code
}

Si bMyBool est vrai ou si bOtherBool est vrai, mon code s'enclenche, sinon sa serra mon autre code qui s'enclenchera.

Note:
N'oubliez pas les parentèses a chaque fois, et comme il y a plusieurs options on en met 2 au début et 2 a la fin (pour refermer).

Exemple avec if, &&, ==, || et else:

var() bool bMyBool, bOtherBool;
var() int MyNumber;

function Test()
{
    if((bMyBool)
    && (MyNumber == 10)
    || (bOtherBool == False))
    {
        // mon code
    }
    else
        // sinon mon autre code
}

Si bMyBool est vrai et que MyNumber = 10, c'est ok mon code s'enclenche sinon sa serra mon autre code qui s'enclenchera.
Si bMyBool est faux ou que MyNumber n'est pas égal a 10 (car là avec && il faut les deux), l'UnrealEngine vérifie donc la 3ème conditions, ou si bOtherBool est faux ça fonctionne aussi et mon code s'enclenche.

Exemple avec if, <=, >=:

var() int MyNumber;

function Test()
{
    if((MyNumber >= 5)
    && (MyNumber <= 10))
        // mon code
}

Si MyNumber est égal ou plus grand que 5 et égal ou plus petit que 10, mon code s'enclenche.

Exemple avec if, >=, &&, <=, ||:

var() bool bMyBool;
var() float MyNumber;

function Test()
{
    if((MyNumber > 12.75)
    && (MyNumber < 27.125)
    || (bMyBool))
    {
        // mes codesur plusieurs lignes
    }
}

Si MyNumber est plus grand que 12.75 et plus petit que 27.125, ou (l'UnrealEngine ne vérifira la 3ème condition que si les 2 premières sont fausses) si bMyBool est vrai mon code s'enclenchent.

Top

2) La structure switch

La structure Switch permet de faire plusieurs case avec éventuellement différentes options. Supporte les nombres (byte, float, int) et les enum (aussi les bool, mais c'est inutile).

break : Signale la fin des paramètres d'une case (ce mot clef permet aussi de stopé une boucle)
case * : * = Valeur de la case.
default : La case par default, utilisé si aucune case correspond a la valeur courante.

Exemple avec une valeur byte:

var() byte Options;

function Test()
{
    switch(Options)
    {
        case 0:
        // mon code si Options = 0
        break;

        case 1:
        // mon code si Options = 1
        break;

        case 5:
        // mon code si Options = 5
        break;
    }
}

Suivant la valeur de Options, un passage de code se déclenche(nt).

Exemple avec une valeur d'enum:

var() enum _Difficulty { D_Easy, D_Normal, D_Hard } Difficulty;

function Test()
{
    switch(Difficulty)
    {
        case D_Easy:
        // mon code si Difficulty = D_Easy
        break;

        case D_Normal:
        // mon code si Difficulty = D_Normal
        break;

        case D_Hard:
        // mon code si Difficulty = D_Hard
        break;
    }
}

Autre exemple avec Default:

var() byte Options;

function Test()
{
    switch(Options)
    {
        case 0:
        case 1:
        case 2:
        // mon code si Options = 0, 1 ou 2
        break;

        default:
        // mon code si Options = aucune des cases définient
        break;
    }
}

Dans cet exemple, on voit la possibilité d'arriver au même résultat avec différente valeurs. (fonctionne aussi pour un enum)
Si la valeur d'Options n'est pas la même qu'une des case spécifié, sa serra mon code de la case Default qui se déclenche(nt).

Top

3) La boucle Do/Until

Fait tourner une boucle jusqu'a atteindre la condition until.

Exemple:

function Test()
{
    local int i;

    do
    {
        Log("Test de la boucle DO: i = "$i);
        i = i + 1;
    }
    until(i == 3);
}

Ca donne les messages suivant dans le log: (System\UnrealGame.log)
Test de la boucle DO: i = 0
Test de la boucle DO: i = 1
Test de la boucle DO: i = 2

Note:
Si on ne mais pas la condition until la boucle tourne indéfiniment.

Top

4) La boucle While

Fait tourner une boucle tant que la condition while est vrai.

Exemple:

function Test()
{
    local int i;

    while(i < 3)
    {
        Log("Test de la boucle WHILE: i = "$i);
        i = i + 1;
    }
}

Ca donne les messages suivant dans le log: (System\UnrealGame.log)
Test de la boucle WHILE: i = 0
Test de la boucle WHILE: i = 1
Test de la boucle WHILE: i = 2

Top

5) La boucle For

Les paramètres de For:

La valeur de départ.
La condition qui stope la boucle si elle est fausse.
L'incrémentation de la boucle avec ++ (-- pour une décrémentation).

function Test()
{
    local int i;

    for(i==0; i<3; i++)
        Log("Test de la boucle FOR: i = "$i);
}

Ca donne les messages suivant dans le log: (System\UnrealGame.log)
Test de la boucle FOR: i = 0
Test de la boucle FOR: i = 1
Test de la boucle FOR: i = 2

6) Les boucles ForEach

Les boucles ForEach (traduire: pour chaque) sont à utiliser juste avant une des functions spéciales qui vont suivrent, renvoi dans sa boucle tous les actors d'un certain type.

Note importante:
Pour ce type de boucle qui sont la plus pars lente, c'est vraiment déconseillé de s'en servir dans un Tick() par exemple.

final iterator function AllActors(class<actor> BaseClass, out actor Actor, optional name MatchTag);
Lent, renvoi tous les actors.
class<actor> BaseClass: Le type d'actor a renvoyé.
out actor Actor: Les actors trouvé sont renvoyé par cette variable.
optional name MatchTag: Optionnel, ajoute a la condition de renvoi (en plus du type d'actor BaseClass donc), renvoi les actors que si son Tag = cette variable.

Exemple:

function ListActors()
{
    local Actor A;

    ForEach AllActors(class'Actor', A)
    {
        if(A != None)
        {
            Log(A.name);
        }
    }
}

Dans cet exemple, la function ListActors notera dans le log, tous les acteurs de la map.

final iterator function DynamicActors(class<actor> BaseClass, out actor Actor, optional name MatchTag);
Relativement lent mais meilleur que AllActors(), renvoi tous les actors non-statique.

final iterator function TouchingActors(class<actor> BaseClass, out actor Actor);
Rapide, renvoi tous les actors touchéent par l'actor courant.
Note: Utilisé dans l'exemple de script pour UT2003 Regen Volume.

final iterator function TraceActors(class<actor> BaseClass, out actor Actor, out vector HitLoc, out vector HitNorm, vector End, optional vector Start, optional vector Extent);
Assez rapide (comme toute function de tracer), renvoi tous les actors toucher par cette ligne.
out vector HitLoc: Renvoi l'endroit où un actor est trouvé
out vector HitNorm: Renvoi le type d'orientation au contact de l'actor toucher.
vector End: L'endroit ou s'arrête le tracer. (la direction donc)
optional vector Start: Optionel, indique un nouveau point de départ du tracer, par default c'est la location de l'actor courant.
optional vector Extent: Optionel, ?.
Note: cette function est aussi utilisable sans ForEach.

final iterator function RadiusActors(class<actor> BaseClass, out actor Actor, float Radius, optional vector Loc);
Lent comme AllActors() il est donc conseillé d'utiliser plutot CollidingActors() ou VisibleCollidingActors(), renvoi tous les actors dans un rayon donné.
float radius: Rayon dans lequel les actors sont renvoyé
optional vector Loc: Optionel, le rayon pars de cette variable, par default la rayon par de l'actor courant.

final iterator function VisibleActors(class<actor> BaseClass, out actor Actor, optional float Radius, optional vector Loc);
Lent comme AllActors(), renvoi tous les actors qui ont une collision-entre-actor (bCollideActors = True) dans un rayon donné comme avec RadiusActors().

final iterator function VisibleCollidingActors(class<actor> BaseClass, out actor Actor, float Radius, optional vector Loc, optional bool bIgnoreHidden);
Beaucoup plus rapide que AllActors(), renvoi tous les actors visible (bHidden = False) et avec une collision-entre-actors (bCollideActors = True) dans un rayon donné.
optional bool bIgnoreHidden: Optionel, permet d'ignorer les actors visible, mettre False ou utiliser plutot CollidingActors().

final iterator function CollidingActors(class<actor> BaseClass, out actor Actor, float Radius, optional vector Loc);
Beaucoup plus rapide que AllActors() surtout pour un petit rayon d'utilisation, renvoi tous les actors qui ont une collision-entre-actors (bCollideActors = True) dans un rayon donné.

Top