data_type nom [ dimension ];

Les tableaux vous permettes de créer facilement plusieurs variables d'un même type. Par exemple, supposez que vous vouliez une variable santé pour chaque personnage dans le jeu. Une façon de déclarer les différentes variables serait :

int egoSante;
int mechantSante;
int hommealepeeSante;

mais le désordre arrive rapidement et il est difficile manipuler les variables puisque vous utilisez du code différent pour changer chacune. Vous pourriez donc plutôt faire comme ceci :

int sante[50];

Cette exemple déclare 50 variables int, toutes nommées sante.

Vous accédez à chaque variables séparément par son index (le numéro dans les crochets). Les index commencent de 0, donc dans ce cas le tableau sante est numéroté de 0 à 49. Si vous essayez d'accéder à un index invalide, votre jeu s'interrompera en affichant une erreur.

Voici un exemple d'utilisation du tableau :

sante[3] = 50;
sante[4] = 100;
sante[player.ID] = 10;

ceci définit la variable Santé 3 à 50, Santé 4 à 100, et la variable Santé dont l'index correspond au nombre ID du personnage joueur à 10.

Voir aussi : Tableaux dynamiques

Type Description

Vous aurez normalement recours aux types de données int et String. Les types plus petits sont utiles uniquement pour conserver la mémoire dans les cas où vous créez un nombre énorme de variables.

Pour déclarer une variable, tapez son type suivi par son nom, et enfin un point-virgule. Par exemple :

int ma_variable;

déclare une variable de 4 octets qui contiendra un entier, appelée ma_variable

ATTENTION : Lorsque vous utilisez le type de données float, vous pourriez penser que les opérateurs == et != ne fonctionnent pas correctement. Par exemple :

float resultat = 2.0 * 3.0;
if (resultat == 6.0) {
Display("Le résultat est 6!");
}

ne fonctionnera pas toujours. Cela est dû à la nature même des variables décimales, et la solution est de coder comme cela :

float resultat = 2.0 * 3.0;
if ((resultat > 5.99) && (resultat < 6.01)) {
Display("Le résultat est 6!");
}

La façon de stocker les nombres décimaux fait que 6 peut en fait être stocké comme 6.000001 ou 5.999999 ; cela est commun à tous les langages de programmation, alors soyez juste attentif à ce point si vous utilisez des décimaux dans vos calculs.

L'interprétateur de script AGS supporte les opérateurs suivants dans les conditions. Ils sont listés ici en ordre de priorité de traitement, le premier évalué étant tout en haut de la liste.

ATTENTION : En utilisant des opérateurs de même priorité, AGS les évaluera pas défaut de droite à gauche. Donc l'expression a = 5 - 1 - 2; sera évaluée comme a = 5 - (4 - 2); ce qui ne correspond pas à ce à quoi vous vous attendez. Utilisez toujours les parenthèses pour coder clairement.

L'option de “priorité d'opérateurs de gauche à droite” dans le panneau des Options Générales vous permet de contrôler ce comportement.

if (!a && b < 4)

ce qui exécutera le bloc 'if' si a vaut 0 et si b est plus petit que 4.

Cependant, il est toujours bon d'utiliser des parenthèses pour grouper les expression. Il est bien plus lisible d'écrire le script plus haut comme ceci :

if ¹⁾

Les macros prédéfinis suivant sont disponibles pour vos scripts :

Vous pouvez vérifier si un macro retourne une valeur ou non en utilisant les mots-clés #ifdef et #ifndef :

#ifndef STRICT
// compilera la commande MoveCharacter si le script n'utilise pas le style orienté-objet
MoveCharacter(EGO, 30, 40);
#endif
#ifdef DEBUG
// affichera le message seulement lorsque le jeu sera compilé pour le degub mode
Display("Informations pour le debugging");
#endif

Il existe également un mot-clé #error qui vous permet de stopper la compilation du script :

#ifndef AGS_NEW_STRINGS
#error Ce script recquiert une version égale ou supérieure à 2.71
#endif

Les autres constantes (AGS_MAX_*) sont utiles si vous écrivez du code qui soit portable sur différentes versions d'AGS, de façon à pouvoir récupérer les limites de la version d'AGS de l'utilisateur. Par exemple, si vous vouliez stocker des informations supplémentaires sur tous les objets d'inventaire, vous pourriez faire :

int poidsInventaire[AGS_MAX_INV_ITEMS];

Pour obtenir le nombre d'éléments actuels dans le jeu plutôt que les limites d'AGS, utilisez les propriétés du style Game.CharacterCount.

Si vous écrivez un module de script, vous pourriez avoir besoin de vérifier quelle version d'AGS utilise l'utilisateur de votre module.

A cet effet, il y a l'option suivante :

#ifver 2.72
// faire choses pour la 2.72 et plus récentes
#endif
#ifnver 2.72
// faire choses pour la 2.71 et plus anciennes
#endif

Notez que ce mot-clé n'a été ajoutée qu'à partir de la 2.72, vous ne pouvez donc pas utiliser les vérification #ifver si vous voulez faire une différence entre des versions plus récentes.

if ( condition ) { commandes1 } [ else { commande2 } ]

Si condition est vraie, alors commande1 est exécutée.

Si condition n'est pas vraie, et qu'il y a une case else, alors commande2 est exécutée à la place.

Par exemple:

if (GetGlobalInt(5) == 10) {
Display("Globalint 5 vaut 10.");
}
else {
Display("Globalint 5 ne vaut pas 10.");
}

Dans cet exemple, le premier message sera affiché si la valeur retournée par GetGlobalInt(5) vaut 10, et le deuxième message sera affiché si ce n'est pas le cas.

La comparaison if peut être insérée dans le else pour créer un effet “else if”. Par exemple :

if (GetGlobalInt(5) == 1) {
Display("Globalint 5 vaut 1.");
}
else if (GetGlobalInt(5) == 2) {
Display("Globalint 5 vaut 2.");
}
else {
Display("Globalint 5 ne vaut ni 1 ni 2.");
}

while ( condition ) { commandes }

Exécute les commandes en continu, tant que la condition est vraie.

Par exemple :

while (cEgo.Moving) {
Wait(1);
}

répètera la commande Wait(1); aussi longtemps que cEgo.Moving ne vaut pas zéro. Lorsque ça atteint une valeur nulle, la comparaison while passera à la fin de la boucle et s'arrêtera.

function nom ( [type1 param1, type2 param2, … ] )

Déclare une fonction personnelle dans votre script. Une fonction vous permet de définir une suite de commandes qui seront effectuées les unes après les autres lorsque vous appellerez la fonction, ce qui vous évite de devoir taper chaque fois ce code dans votre script.

Par exemple, admettons que vous vouliez souvent ajouter un objet à l'inventaire tout en jouant un son. Vous pourriez écrire chaque fois les deux commandes l'une après l'autre, ou définir une fonction qui s'en chargerait :

function AddInvAndPlaySound(int inventoryItem) {
player.AddInventory(inventory[inventoryItem]);
PlaySound(5);
}

ainsi, vous aurez simplement à appeler cette fonction ailleurs dans votre code :

AddInvAndPlaySound(8);

Pour ajouter l'objet 8 à votre inventaire tout en jouant le son 5.

En général, vous devrez placer vos fonctions dans votre script global. Vous devrez ensuite ajouter une ligne import dans votre script header pour permettre à la fonction d'être appelée par les scripts des pièces.

Paramètres optionnels

Vous pouvez créer un paramètre optionnel int si vous spécifiez une valeur par défaut que l'utilisateur ne sera pas obligé d'entrer. Pour cela, changez la déclaration import du script header comme cela :

import function FonctionTest(int trucs, int choses = 5);

ce qui déclare une fonction avec un paramètre obligatoire trucs, et un paramètre facultatif choses. S'il n'est pas spécifié de deuxième paramètre lorsque la fonction est appelée, la valeur par défaut de choses sera de 5.

NOTE : Pour utiliser un paramètre facultatif, vous devez obligatoirement placer une déclaration “import” pour la fonction dans le script header. Les valeurs par défaut ne peuvent pas être spécifiées dans la déclaration de la fonction elle-même.

struct nom {

Déclare une structure personnelle dans votre script. Les structures vous permettent de grouper des variables entre elles afin de rendre votre script plus structuré et plus lisible. Par exemple, supposez que vous vouliez stocker des informations à propos des armes que le joueur peut transporter. Vous pourriez déclarer les variables comme ça :

int epeeDommages;
int epeePrix;
String epeeNom;

mais ça devient rapidement ingérable et vous vous retrouvez avec un tas de variables à gérer. C'est là que les structures viennent à votre aide :

struct Arme {
int dommages;
int prix;
String nom;
};

Maintenant, vous pouvez déclarer une structure d'un seul coup, comme ceci :

Arme epee;
epee.dommages = 10;
epee.prix = 50;
epee.nom = "Epée fine";

Bien plus clair et mieux organisé. Vous pouvez aussi combiner les structures avec les tableaux:

// tout en haut du script
Arme armes[10];
// dans la fonction du script
armes[0].dommages = 10;
armes[0].prix = 50;
armes[0].nom = "Epée fine";
armes[1].dommages = 20;
armes[1].prix = 80;
armes[1].nom = "Dague empoisonnée";

Les structures sont essentielles si vous avez des données complexes à manipuler dans vos scripts.

Recommandé uniquement pour les utilisateurs avancés

enum nom { option1 [ = valeur1 ], option2 [ = valeur2 ], … };

Déclare un type d'énumération. Une énumération vous permet de grouper des options, dont une seule pourra être vraie à la fois – un peu comme le contenu d'une listbox.

Par exemple, si vous avez une fonction, faireTruc, qui permet de faire 3 opérations différentes, vous pourriez faire ceci :

function faireTruc(int param) {
if (param == 1) {
// faire quelque chose
}
else if (param == 2) {
// faire autre chose
}
// etc
}

mais c'est difficile à lire, et il est possible que vous oubliiez à quoi correspond 1 et 2 en appelant la fonction plus loin dans le script. C'est là que “enum” fait son entrée :

enum faireTrucOption {
CuireGateau,
LaverLinge
};

function faireTruc(faireTrucOption param) {
if (param == CuireGateau) {
// faire quelque chose
}
else if (param == LaverLinge) {
// faire autre chose
}
// etc
}

puis vous appelez la fonction comme ceci :

faireTruc(CuireGateau); 

la commande étant très explicite sur ce qu'elle fera.

Normalement, vous devriez placer les définitions enum dans votre script header.

Pour résumer, les énumérations ne sont pas une partie essentielle du codage et vous pouvez parfaitement vous en passer, mais il arrive qu'elles soient vraiment pratiques.

Il y a deux utilisations pour ce mot-clé.

1. Accéder aux membres de la structure courante

Lorsque vous créez des structures personnalisées, vous pouvez utiliser le mot-clé “this” dans les fonctions membres pour référer à la structure en question. Par exemple :

Supposez que vous ayez ceci dans l'en-tête de votre script :

struct MaStructure {
  int maValeur;
  
  import function MaMethode();
};

Vous pouvez alors mettre ceci dans le corps de votre script :

function MaStructure::MaMethode()
{
  this.maValeur = 5;
}

MaStructure::MaMethode informe AGS que vous définissez la fonction MaMethode qui appartient à la structure MaStructure (l'opérateur :: signifie “appartient à”).

Le code ci-dessus signifie que lorsque la fonction MaMethode est appelée, elle définir la variable maValeur à 5.

2. Déclarer des fonctions d'extension

Veuillez consulter la page des fonctions d'extension pour les détails.

import declaration ;

Déclare declaration en tant que variable ou fonction qui est externe au script courant, mais à laquelle le script doit accéder. Vous utilisez ceci pour permettre à vos scripts de pièce d'accéder à certaines parties de votre script global.

Par exemple :

import int compteur;
import function additionner_nombres (int, int);

Ceci importe la variable entière compteur et la fonction additionner_nombres depuis le script global pour permettre au script courant d'y accéder. Vous devriez normalement placer la déclaration “import” dans le script header pour que toutes les pièces puissent en bénéficier.

Pour importer une variable il faut que celle-ce soit exportée par le script global à l'aide du mot-clé export.

NOTES : Vous DEVEZ importer les variables externes avec le type correct. Si compteur a été déclarée comme short dans le script global, vous DEVEZ l'importer en tant que short ou alors votre jeu risque de planter.

NOTE : Vous ne pouvez pas importer les variables d'anciennes chaînes (cela ne s'applique pas aux nouvelles chaînes).

export variable [, variable … ] ;

Déclare que variable peut être exportée et que les autres scripts peuvent y accéder. Vous devez placer cette déclaration à la fin de votre script global. Vous pouvez exporter beaucoup de variable en une seule ligne.

Par exemple :

export ma_variable;
export compteur, force;

Ceci exporte trois variables - ma_variable, compteur et force.

function noloopcheck nom_fonction ( paramètres … ) {

Le mot-clé noloopcheck empêche le script de vérifier les boucles de la fonction spécifiée.

Normalement, si une boucle while s'exécute plus de 150 000 fois, AGS considérera que le script a eu un problème et fermera le jeu. Ceci est prévu pour vous assister puisque sans ça, le jeu “gèlerait” lorsque vous auriez mal codé une boucle.

Cependant, il existe quelques rares situations dans lesquelles vous aurez besoin d'une boucle s'exécute plusieurs milliers de fois (par exemple, si vous initialisez un très grand tableau). Dans ce cas, le mot-clé noloopcheck peut être utilisé pour empêcher AGS de mettre fin à votre script.

NOTE : Le mot-clé noloopcheck doit être placer entre “function” et le nom de la fonction. Si vous importez une fonction dans le script header, vous ne devez pas inclure le mot-clé “noloopcheck” dans la déclaration d'importation – c'est contenu uniquement dans la déclaration de la fonction elle-même.

NOTE : Si AGS vous annonce une erreur d'itérations dans le script, N'AJOUTEZ PAS systématiquement ce mot-clé pour résoudre le problème - la plupart du temps ça ne résoud rien, le problème viendra de votre code et utiliser ce mot-clé signifiera que le jeu devra geler plutôt que s'arrêter.

Par exemple :

function noloopcheck initialiser_tableau() {
char grostableau[200000];
int a = 0;
while (a < 200000) {
grostableau[a] = 1;
a++;
}
}

ici sans le mot-clé “noloopcheck”, AGS avorterait ce script.