Une expression est une expression mathématique qui peut contenir des nombres, des variables, des chaînes ou des fonctions GML ordinaires ainsi qu'un ou plusieurs opérateurs (comme ajouter, soustraire, multiplier, etc...). Les valeurs utilisées dans une expression peuvent être des nombres réels (par exemple 3.4 * 6), des nombres hexadécimaux commençant par un signe $ (par exemple $00FFAA | $88FFAA ), des chaînes entre guillemets doubles (par exemple "hello" + "world") ou plus compliquées expressions utilisant plusieurs opérateurs et valeurs.

Pour les expressions, les opérateurs suivants existent (par ordre de priorité):

Attribution (=)

= - Permet d'attribuer une valeur à une variable. Notez que ceci peut également être utilisé pour comparer des variables dans GameMaker Studio 2 et vous pouvez le voir dans des exemples et d'autres codes de peuples. Cependant, il s'agit d'un héritage des anciennes versions de GameMaker et vous devez utiliser les opérateurs == pour comparer et = pour assigner, comme indiqué dans ces exemples:

a = 12;
speed = 5;
val = (old_val + 5);

Combinaison (&&, ||, ^^)

&&, ||, ^^ (et, ou et xor) - Combine les valeurs booléennes pour donner vrai ou faux. Si l'un des exemples suivants se résout à true alors le code serait exécuté:

if (a == b && c == d) {do something...}// and
if (a == b || c ==d) {do something...}// or
if (a == b ^^ c == d) {do something...} // xor

En comparant (<, <=, ==,! =,>,> =)

<, <=, ==,! =,>,> = - Ce sont des comparaisons et ne peuvent donner qu'un true ou false result (où true peut également être interprété comme 1, et false comme 0). Exemples d'utilisation:

if (a < b) {do something...}
if (a != b) {do something...}

Bitwise (|, &, ^, <<, >>)

|, &, ^, <<, >>: Vous pouvez effectuer des opérations au niveau du bit avec ceux-ci, où | = bit à bit ou, & = bitwise et, ^ = bit à bit xor, << = décalage à gauche, >> = décalage à droite. Exemples d'utilisation:

x = (x & $ffffffe0) + 32;
if (y ^ $1f) > 0 {do something...};

Vous pouvez trouver des informations supplémentaires sur la façon d'utiliser les opérateurs au niveau du bit et ce qu'ils font à partir de la section: Opérateurs bit à bit.

Arithmétique (+, -, *, /)

+, -, *, / - Ajouter, soustraire, multiplier et diviser. Exemples d'utilisation:

c = a * b;
str = a + "world";

Incrément / Décrément (++, -)

++, - - Ajouter ou soustraire un à une valeur. Il est à noter que placer ceci avant ou après la valeur à ajouter ou à soustraire aura des résultats légèrement différents. Par exemple:

• ++ a incrémente la variable et renvoie la valeur incrémentée.
• a ++ va incrémenter la variable mais retourner la valeur avant qu'elle ne soit incrémentée.

Par conséquent, si vous avez quelque chose comme ceci:

var a = 1;
show_debug_message(string(a++));
show_debug_message(string(++a));

La sortie de débogage serait 1 et 3. Voici quelques exemples d'utilisation:

for (var i = 0; i < 10; i++;) {do something...};
if hit == true score--;

Remarque: sur les plates-formes cible du compilateur YoYo (celles marquées (YYC)), ces expressions sont évaluées de gauche à droite, tandis que sur toutes les autres plates-formes cibles, elles sont évaluées de droite à gauche, ce qui signifie que:

val = max(num, ++num, num++);

donnera des résultats différents en fonction de la plate-forme.

Division et Modulo (div,%, mod)

div, mod (%) - Division et modulo, où div vous donne le montant qu'une valeur peut être divisée en produisant seulement un quotient entier, alors que mod ne vous donne que le reste d'une division. Exemples d'utilisation:

secs = time mod 60;
time_str = string(time div 60);

Unaire (!, -, ~)

En outre, les opérateurs unaires suivants existent:

• !: booléen "pas", donc !true == false
• -: annule la prochaine valeur réelle ou entière (non valide pour les chaînes ou les booléens)
• ~: annule la valeur suivante au niveau du bit

En tant que valeurs dans toutes les expressions, vous pouvez utiliser des nombres, des variables ou des fonctions qui renvoient une valeur, et des sous-expressions peuvent également être placées entre parenthèses. Tous les opérateurs fonctionnent avec des valeurs réelles, mais les comparaisons fonctionnent également pour les chaînes et les chaînes "+" concaténent les chaînes.

Ordre des opérations

Lorsque vous effectuez plusieurs opérations dans une seule expression, il est très important d'utiliser brackets () pour séparer l'ordre d'opération, car différentes plates-formes peuvent les exécuter différemment sinon explicitement. Par exemple, considérez le code suivant:

a = b == c || d;

Les différents compilateurs cibles effectueront les opérations dans des ordres différents puisqu'ils ne sont pas explicitement montrés, donnant lieu à des résultats "bizarres" auxquels vous ne pouvez pas vous attendre lorsque vous jouez à votre jeu. pour éviter cela, utilisez le signe () pour séparer les parties, comme ceci:

a = (b == c || d); //better
a = ((b == c) || d); //best

Voici quelques exemples finaux des différentes expressions:

{
x = 23;
colour = $FFAA00;
str = "hello world";
y += 5;
x *= y;
x = y << 2;
x = 23 * ((2 + 4) / sin(y));
str = "hello" + "world";
b = (x < 5) && !(x==2 || x==4);
}

Accesseurs

Il existe également des raccourcis d'expression appelés accesseurs à utiliser avec certaines structures de données et tableaux, qui vous permettent d'ajouter ou de remplacer des données dans ces formats rapidement et facilement et sans utiliser d'appel de fonction. Pour plus de détails, veuillez consulter la page suivante:

1. Accesseurs