[[ags|{{:contents.gif}}]] [[scripting|{{:up.gif}}]] [[types_predefinis|{{:back.gif}}]] [[audiochannel|{{:forward.gif}}]] ---- =====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) | Cet ordre de priorité vous permet de prévoir l'évaluation de telles expressions : 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|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 [[mots-cles#break|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 [[mots-cles#while|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 [[mots-cles#break|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// ([[mots-cles#for|for]], [[mots-cles#while|while]], [[mots-cles#do...while|do...while]]) ou d'un [[mots-cles#switch|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 [[mots-cles#for|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 [[#struct|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 [[#export|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 < 200000) { grostableau[a] = 1; a++; } } ici sans le mot-clé "noloopcheck", AGS avorterait ce script.\\ \\ {{tag>français}}