Les Mots-clés du Script

Tableaux
Types de données
Opérateurs
Constantes
Comparaisons if, else
while
function
struct
enum
import
export
noloopcheck

Tableaux

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;

int sante[50];

Voici un exemple d'utilisation du tableau :

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

Types de données

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!");
}

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

Opérateurs

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.

Opérateur  Description              Exemple

  !    INVERSE                    if (!a) 
  *    Multiplier                 a = b * c;
  /    Diviser                    a = b / c;
  %    Reste                      a = b % c;
  +    Additionner                a = b + c;
  -    Soustraire                 a = b - c;
  <<   Bitwise Left Shift         a = b << c;
       (utilisateurs avancés) 
  >>   Bitwise Right Shift        a = b >> c;
       (utilisateurs avancés) 
  &    ET binaire                 a = b & c;
       (utilisateurs avancés) 
  |    OU binaire                 a = b | c;
       (utilisateurs) 
  ^    OU exclusif binaire        a = b ^ c;
       (utilisateurs avancés) 
  ==   Est égal à                 if (a == b)
  !=   N'est pas égal à           if (a != b)
  >    Plus grand que             if (a > b)
  <    Plus petit que             if (a < b)
  >=   Plus grand ou égal à       if (a >= b)
  <=   Plus petit ou égal à       if (a <= b)
  &&   ET logique                 if (a && b)
  ||   OU logique                 if (a || b)

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 ((!a) && (b < 4))

Constantes

Nom	Description
DEBUG	Retourne une valeur positive si le jeu a été compilé pour le debug mode, sinon retourne une valeur nulle
STRICT	Retourne une valeur positive si l'option "Obliger le script orienté-objet" est cochée, sinon retourne une valeur nulle
LRPRECEDENCE	Retourne une valeur positive si l'option "Priorité d'opérateurs de gauche à droite" est cochée, sinon retourne une valeur nulle
AGS_NEW_STRINGS	Retourne une valeur positive si la version d'AGS est supérieure ou égale à 2.71 et permet les objets new-strings, sinon retourne une valeur nulle.
AGS_MAX_CHARACTERS	Retourne le nombre maximum de personnages
AGS_MAX_INV_ITEMS	Retourne le nombre maximum d'objets dans l'inventaire
AGS_MAX_GUIS	Retourne le nombre maximum de GUI
AGS_MAX_VIEWS	Retourne le nombre maximum de vues
AGS_MAX_LOOPS_PER_VIEW	Retourne le nombre maximum de boucles dans une vue
AGS_MAX_FRAMES_PER_LOOP	Retourne le nombre maximum de frames dans une boucle
AGS_MAX_OBJECTS	Retourne le nombre maximum d'objets par pièce
AGS_MAX_HOTSPOTS	Retourne le nombre maximum de hotspots par pière
AGS_MAX_REGIONS	Retourne le nombre maximum de régions par pièce

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

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

int charJibbles[AGS_MAX_CHARACTERS];

Comparaisons if, else

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.");
}

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

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

Par exemple :

while (character[EGO].Moving) {
  Wait(1);
}

function

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);
}

AddInvAndPlaySound(8);

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);

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

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;

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

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

// 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";

enum

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
}

enum faireTrucOption {
  CuireGateau,
  LaverLinge
};

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

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.

import

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);

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 : Pour le moment vous ne pouvez pas importer de variables string. A la place, vous pouvez utiliser les strings globales.

export

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;

noloopcheck

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++;
  }
}