Pages traduites Pages à traduire Pages en cours de traduction
A propos
 


Les Mots-clés du Script

Tableaux

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


Types de données

Type Description
char Donnée d'un seul octet, peut contenir une seule lettre ou un nombre allant de 0 à 255
short Un entier de 2 octets, peut contenir des nombres allant de -32 768 à 32 767
int Un entier de 4 octets, peut contenir des nombres allant de -2 147 489 648 à 2 147 483 647
String Contient une chaîne de caractères
float Un nombre décimal de 4 octets. En général supporte jusqu'à 6 chiffres après la virgule, mais varie selon la dimension du nombre contenu.
bool une variable qui vaut soit 'true' soit 'false'

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.


Opérateurs

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.

Opérateur Description Exemple
! INVERSE if (!a)
* Multiplication a = b * c;
/ Division a = b / c;
% Reste a = b % c;
+ Addition a = b + c;
- Soustraction 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 avancés)
^ OU exclusif binaire a = b ^ c;
(utilisateurs avancés)
== Correspond à if (a == b)
!= Ne correspond pas à if (a != b)
> Est strictement supérieur à if (a > b)
< Est strictement inférieur à if (a < b)
>= Est supérieur ou égal à if (a >= b)
<= Est inférieur ou égal à if (a b)
&& ET logique if (a && b)
|| OU logique if (a || b)
if (!a && b < 4)

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

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

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
STRICT_STRINGS Définie seulement si l'option “Enforce new-style strings” (”Forcer le nouveau style pour les chaînes de caractères”) est cochée
STRICT_AUDIO Définie seulement si l'option “Enforce new-style audio scripting” (”Forcer le nouveau style pour les scripts audios”) est cochée
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_SUPPORTS_IFVER Retourne une valeur positive si la version d'AGS est supérieure ou égale à 2.72 (support de #ifver), sinon retourne une valeur nulle.
AGS_MAX_INV_ITEMS Retourne le nombre maximum d'objets dans l'inventaire
AGS_MAX_CONTROLS_PER_GUI Retourne le nombre maximum de contrôles par GUI
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

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.


Vérification de la Version

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.


Comparaisons if, else

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

switch

switch ( expression ) {
[ case expression constante :
instructions
[ break; ] ]

[ default:

instructions
[ break; ] ]

}

Compatibilité: Supporté à partir de la version AGS 3.4.0

Calcule l'expression dans l'en-tête du switch, puis trouve un cas (case) avec une expression constante correspondant au résultat du calcul précédent, et exécute les instructions de ce cas. A partir de là, il ne tiendra plus compte de la correspondance avec les autres cas et exécutera toutes leurs instructions jusqu'à rencontrer la commande break  ou atteindre la fin du switch. Si le résultat de l'expression ne se trouve dans aucun des cas, il débutera avec la ligne par défaut (default) et exécutera toutes les autres instruction à partir de ce point, mais si aucune instructions par défaut n'est trouvée, le switch sera entièrement ignoré. Le switch peut avoir plusieurs déclarations de cas (case) mais une seule déclaration par défaut (default). Cependant, ils peuvent être disposés dans n’importe-quel ordre. Contrairement à de nombreux langages de programmation, AGS permet d'utiliser un résultat d'expression de tout type (entier, booléen, chaîne, pointeurs).

Exemple:

 switch (player)
 {
 case cEgo: Display("Bonjour je suis Ego, le personnage par défaut du jeu."); break;
 case cJohn: Display("Enchanté, je suis John, le personnage masculin."); break;
 case cMary: Display("Salut, je suis Mary, le personnage féminin."); break;
 default:
    Display("Je ne suis pas vraiment sûr du personnage contrôlé par le joueur, cela pourrait être un bug.");
    break;
 }


Exemple avec les cas “passe à travers”:

 switch (player)
 {
 case cJohn:
 case cMary:
    player.Say("J'aime les oranges.")
    break;
 case cEgo:
    player.Say("J'aime les pommes.");
 default:
    player.Say("Je voudrais quelques baies.");
 }

Dans l'exemple ci-dessus les deux cas cJohn et cMary conduisent à l'instruction “J'aime les oranges”. cEgo dira “J'aime les pommes.” puis “Je voudrais quelques baies.”. S'il y avait d'autre joueurs contrôlables, non mentionnés dans ce switch, ils iront directement à la ligne par défaut.


while

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.


do...while

do {
instructions

} while ( expression );

Compatibilité: Supporté à partir de la version AGS 3.4.0

Tout comme la commande while les instructions sont exécutées en boucle tant que l'expression est vrai, mais ici l'expression n'est vérifiée qu'après la première exécution des instructions. Cela signifie que les instructions seront exécutées au moins une fois même si l'expression est fausse.

Par exemple:

 do {
    cEgo.Move(cEgo.x + 1, cEgo.y);
 }   
 while (IsKeyPressed(eKeyRightArrow));

Exécutera le script cEgo.Move (cEgo.x + 1, cEgo.y); une fois, puis continuera à l'exécuter en boucle tant que le joueur appuie sur la flèche de droite.


for

for ([initialisation]; [expression]; [itération]) {
instructions

}

Compatibilité: Supporté à partir de la version AGS 3.4.0

Cette commande est une boucle qui effectue d'abord les déclarations d'initialisation, puis exécute instructions à l'intérieur des parenthèses incurvées. Elle exécute ensuite les instructions d'itération et vérifie si l'expression est vraie ou non pour exécuter à nouveau ou non les instructions contenues dans la boucle.

L'initialisation est couramment utilisée pour déclarer des variables ou donner des valeurs à des variables existantes. Si une nouvelle variable est déclarée lors de l'initialisation - cette variable n'existera et ne pourra être utilisée qu'à l'intérieur de la boucle. L'étape d'itération est généralement destinée à sortir de la boucle en changeant la valeur de la variable.
Chaque partie dans l'en-tête de la commande ( l'initialisation, l'expression et l'itération ) - est facultative: il peut y avoir une commande sans initialisation, sans itération, ou même sans expression conditionnelle (dans ce cas, la boucle doit être brisée avec la commande break ou une déclaration return).

Par exemple:

 for (int i = 0; i < Game.CharacterCount; i++)
 {
    Display("Mon nom est%s", character[i].Name);
 }

Cherchera tous les personnages du jeu et affichera leurs noms.

Un autre exemple (remarquer l'absence d'initialisation et d'itération):

 for (; cEgo.x < 100;)
 {
     Wait(1);
 }

Attendra jusqu'à ce que le caractère cEgo dépasse la coordonnée x = 100.


break

break;

Compatibilité: Supporté à partir de la version AGS 3.4.0

La commande break termine l'exécution de la plupart des boucles (for, while, do...while) ou d'un switch. Le script continuera à partir de la prochaine ligne suivant la boucle ou le switch.

Par exemple:

 while (cEgo.Moving) {
    if (IsKeyPressed(eKeyEscape))
    break;
 
    Wait(1);
 }

Attendra tant que cEgo ne bouge pas. Si le joueur appuie sur la touche Échappement, la boucle se termine immédiatement.


continue

continue;

Compatibilité: Supporté à partir de la version AGS 3.4.0

La commande continue permet d'ignorer les instructions restantes d' une boucle en cours d’exécution et de retourner à la vérification des condition de la boucle pour la relancer ou la terminer. Si la boucle est du type for, l'itération est exécutée juste avant la vérification.
Par exemple:

 for (int i = 0; i < 100; i++)
 {
    //  les premières instructions à exécuter   
 
    if (i > 50)
    continue;
 
    //  des instructions supplémentaires à exécuter 
 }

Exécutera les premières instructions en boucle et les instructions supplémentaires seulement lorsque i est inférieur ou égal à 50.


function

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(InventoryItem* item) {
player.AddInventory(item);
aInventorySound.Play();
}

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

AddInvAndPlaySound(iKey);

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

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.


enum

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.


this

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

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

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.


noloopcheck

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 &lt; 200000) {
    grostableau[a] = 1;
    a++;
  }
}

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

 
mots-cles.txt · Dernière modification: 03/10/2016 18:08 par 78.250.249.129
 
Recent changes RSS feed Creative Commons License Donate Powered by PHP Valid XHTML 1.0 Valid CSS Driven by DokuWiki