ags

Adventure Game Studio 3.2.1

par Chris Jones

Bienvenue sur Adventure Game Studio ! Cette nouvelle version du Manuel d'Aide devrait vous aider mieux à vous en sortir avec AGS. Enjoy !

Table des matières

  • Notes sur la version française du manuel
  • Copyright et termes d'utilisation
  • Introduction
  • Le moteur
  • Tutoriel
  • Autres fonctionnalités
  • Scripting
  • Références
  • Questions Fréquemment Posées (FAQ)
  • Passer à AGS 3.0
  • Passer à AGS 3.1
  • Passer à AGS 3.2
  • Utilisation anonyme d'informations
  • Contacter l'auteur
  • Crédits


notes_sur_la_version_francaise_du_manuel

Table des matières
    • Notes sur la version française du manuel
      • Avertissements sur la traduction
      • Traduction des termes techniques

Notes sur la version française du manuel

Le présent manuel est rédigé en quasi-totalité en langue française. Il s'agit d'une traduction du manuel original, rédigé en anglais.

Avertissements sur la traduction

Cette traduction a été initiée en 2008 et concernait le manuel d'aide de la version 2.71 d'AGS. La traduction a été mise à jour au fur et à mesure. Toutefois, il est possible que certaines reliques n'aient pas été corrigées.

Cette traduction est l’œuvre d'amateurs bénévoles, dont ce n'est pas le métier. Elle exploite l'organisation du wiki. Aussi, la multiplicité des traducteurs peut amener à une légère inconsistance dans l'utilisation des termes, bien qu'il y ait eu un travail de remise en forme final.

Traduction des termes techniques

AGS manipule de nombreux éléments récurrents comme les personnages, les interfaces, les objets, etc. accessibles depuis l'éditeur via des onglets dont le texte est en langue anglaise dans la version originale du logiciel. C'est pourquoi la traduction de termes comme Character, Hotspot, Room ou encore Walkable Area a soulevé des questions. Les laisser tels quels semblait entrer en contradiction avec l'idée de passer d'une langue à une autre, les traduire semblait entrer en contradiction avec l'idée de faciliter la compréhension vis-à-vis de l'interface couramment utilisée.

C'est pourquoi vous rencontrerez la plupart du temps une traduction du terme, accompagnée du terme original entre parenthèses (ou inversement). Dans la suite d'un paragraphe toutefois, un seul des deux termes pourra être conservé.

Voici une liste des correspondances terminologiques principalement employées dans cette traduction du manuel :

  • Array : Tableau
  • Blocking script : Bloquant l'exécution
  • Character : Personnage
  • Clip (Audio) : Séquence
  • Drawing Surface : Surface de dessin
  • Frame : Image
  • GUI : Interface
  • Hotspot : Zone interactive
  • Inventory Item : Objet d'inventaire
  • Loop (dans une vue) : Séquence (d'animation)
  • Object : Objet
  • Overlay : Calque
  • Plugin : Greffon
  • Room : Pièce
  • Speech : Discours, Dialogue
  • Sprite : Image
  • String : Chaîne de caractères
  • View : Vue
  • Voice (speech) : Doublage
  • Walkable Area : Zone de déplacement
  • Walkbehind Area : Zone de plan intermédiaire

Le titre des sous-sections de la section Scripting concernant des éléments du script propose leur traduction courante entre parenthèses.

Section créée le 11 octobre 2012, mise à jour le 11 octobre 2012.

Adresse web du projet wiki : http://admin.no.uchi.free.fr/dokuwiki-2008-05-05/


copyright_et_termes_d_utilisation

Table des matières
    • Copyright et termes d'utilisation
      • Version originale
      • Version traduite

Copyright et termes d'utilisation

Version originale

Copyright © 1999-2010 Chris Jones.
THE SOFTWARE IS PROVIDED 'AS-IS' AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
IN NO EVENT SHALL CHRIS JONES BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
NO MONEY WHATSOEVER MAY BE CHARGED FOR ADVENTURE GAME STUDIO UNLESS EXPRESS WRITTEN PERMISSION IS GIVEN BY THE AUTHOR. IF YOU PAID FOR THIS, THE SELLER IS BREACHING THE TERMS OF DISTRIBUTION OF THIS APPLICATION.
AGS is an adventure game creation system. As such, it is provided to you in good faith by the author. Chris Jones cannot be held responsible for the contents of any works created with AGS, including but not limited to any which infringe on copyright, are libellous or contain offensive material. Please use AGS responsibly.
AGS allows user-made “Plugins” to be incorporated into games created by the system. These Plugins can access all standard Windows functionality and are therefore not protected from system functions as the scripting language is. Chris Jones cannot be held responsible for any Plugins for AGS which you use in your game. Any problems with the Plugin should be addressed to its author.
Anything you distribute which has been created with AGS MUST retain the Version resources unaltered in order to display the AGS version and copyright in the Version tab of the EXE properties.
Please note that this is the only evidence that remains that your game was created with AGS - I do not place any splash screens or copyright messages in your game, and leaving the version tab is all I ask.
TrueType font display uses ALFont by Javier Gonzalez and the Freetype project. Distributed under the terms of the Freetype Project license.
OGG Vorbis player is alogg by Javier Gonzalez, using the Ogg Vorbis decoder, which is available from http://www.xiph.org/ . Copyright © 2002, Xiph.org Foundation
OGG Theora player is APEG by Chris Robinson, using the Ogg Theora decoder, which is Copyright (C) 2002-2008 Xiph.Org Foundation and contributors.
MP3 player is almp3 v2.0.4, by Javier Gonzalez and the MPG123 team. It uses the mpg123 MP3 decoder, and again is distributed under the terms of the GNU Lesser General Public License version 2.1.
Copyright information on the various other modules AGS uses can be found in the credits section.
Pentium is a trademark of Intel corporation. Windows is a trademark or registered trademark of Microsoft corp.

Version traduite

Copyright © 1999-2010 Chris Jones.
LE LOGICIEL EST FOURNI 'EN L'ETAT' ET VIENT SANS GARANTIE D'AUCUNE SORTE, EXPRIMEE, SOUS-ENTENDUE OU AUTRE, INCLUANT SANS LIMITATION TOUT GARANTIE DE COMMERCIALISATION OU DE COMPAIBILITE POUR UN USAGE PARTICULIER.
CHRIS JONES NE SAURAIT ETRE TENU POUR RESPONSABLE D'EVENTUELS DOMMAGES SPECIAUX, ACCIDENTELS, INDIRECTS OU CONSECUTIFS, NI DANS AUCUN DOMMAGE RESULTANT DE LA PERTE D'UTILISATION, DE DONNEES OU DE PROFITS, INFORME OU NON DES DOMMAGES POSSIBLES, NI SUR LA BASE D'AUCUNE THEORIE D'ASSURANCE, QUI INTERVIENDRAIT SUITE OU EN RAPPORT A L'UTILISATION OU AUX PERFORMANCES DU LOGICIEL.
ADVENTURE GAME STUDIO N'OFFRE AUCUNE LEGITIMITE POUR EXIGER UN RETOUR MONETAIRE A MOINS QU'UNE PERMISSION ECRITE EXPLICITE SOIT DONNEE PAR L'AUTEUR. SI VOUS AVEZ PAYE POUR CE LOGICIEL, LE VENDEUR CONTREVIENT AUX TERMES DE DIFFUSION DE CETTE APPLICATION.
AGS est un système de création de jeu d'aventure. En tant que tel, il vous est proposé en toute bonne foi par son auteur. Chris Jones ne peut pas être tenu pour responsable pour le contenu des projets réalisés avec AGS, y compris (mais non limité à) ceux qui portent atteinte aux droits d'auteur, sont diffamatoires ou présentent un contenu offensant. Veuillez utilisez AGS de façon responsable.
AGS permet d'incorporer des “Plugins” réalisés par ses utilisateurs dans les jeux créés par le système. Ces Plugins peuvent accéder aux fonctionnalités standard de Windows et peuvent ainsi accéder aux fonctions du système tout comme le langage de script. Chris Jones ne saurait être tenu pour responsable pour aucun Plugin pour AGS que vous utilisez dans votre jeu. Tout problème avec un Plugin devrait être adressé directement à son auteur.
Tout ce que vous diffusé qui a été créé avec AGS DOIT utiliser les versions originales des ressources afin d'afficher la version d'AGS et son copyright dans l'onglet Version des propriétés du fichier EXE.
Veuillez remarquer que ceci est la seule information restante que votre jeu a été créé avec AGS - je n'insère aucun écran d'avertissement ou de message de copyright dans votre jeu, et laisser l'onglet Version est tout ce que je demande.
L'affichage de police TrueType utilise ALFont par Javier Gonzalez et le projet Freetype. Diffusée sous les termes de la licence du projet Freetype.
Le lecteur OGG Vorbis est alogg par Javier Gonzalez, qui utilise le décodeur Ogg Vorbis, lequel est disponible à http://www.xiph.org/ . Copyright © 2002, Xiph.org Foundation
Le lecteur OGG Theora est APEG par Chris Robinson et utilise le décodeur Ogg Theora, qui est sous Copyright (C) 2002-2008 Fondation Xiph.Org et contributeurs.
Le lecteur MP3 est almp3 v2.0.4, par Javier Gonzalez et l'équipe MPG123. Il utilise le décodeur mpg123 MP3, et est à nouveau distribué sous les termes de la licence GNU Lesser General Public License version 2.1.
Les information sur les copyrights d'utilisation des autres différents modules d'AGS peuvent être trouvées dans la section Crédits.
Pentium est une marque déposée de Intel corporation. Windows est une marque déposée ou enregistrée de Microsoft corp.

,


Introduction

Adventure Game Studio
Copyright 1999-2010 Chris Jones

Bienvenue sur AGS !
Adventure Game Studio vous permet de créer votre propre jeu d'aventure point-and-click comme les anciens classiques Sierra ou Lucasarts, mais offre aussi des outils modernes comme la musique digitale et l'alpha-blending.
AGS est basé sur un environnement intuitif, où vous pouvez travailler sur tous les aspects de votre jeu, ainsi qu'ajouter du script pour intégrer des événements au jeu. Faire un jeu n'a jamais été aussi productif !
Pour commencer, lisez le tutoriel.

Configuration Requise


configuration_requise

Pour exécuter l'Éditeur, vous devez disposer d'un PC tournant sous Windows, possédant au minimum 128 Mo de RAM ainsi que le Framework .NET 2.0 d'installé (les jeux que vous créerez N'auront PAS besoin du framework).

Tous les jeux que vous créez nécessiteront au minimum :

  • Un processeur Pentium ou supérieur
  • 64 Mo RAM
  • Windows 98, ME, 2000, XP ou Vista avec DirectX 5 ou supérieur
  • Cartes video et son compatibles DirectX

Selon la résolution du jeu et sa profondeur de couleurs, il se peut qu'il demande une configuration plus développée. Le processeur requis varie selon ces critères :

  • 320×200, 256-couleurs : Tout système Pentium
  • 640×400, 256-couleurs : 266 Mhz ou supérieur
  • 800×600, 256-couleurs : 500 Mhz ou supérieur recommandé
  • 320×200, 16-bit couleurs : 233 Mhz ou supérieur
  • 640×400, 16-bit couleurs : 500 Mhz minimum, plus rapide si le jeu utilise des objets larges
  • 800×600, 16-bit couleurs : 600 Mhz minimum, plus rapide si le jeu utilise des objets larges
  • 320×200, 32-bit couleurs : 300 Mhz ou supérieur
  • 640×400, 32-bit couleurs : 700 Mhz minimum, plus rapide si le jeu utilise des objets larges
  • 800×600, 32-bit couleurs : 900 Mhz minimum, plus rapide si le jeu utilise des objets larges

Ces nécessités ne constituent toutefois pas une science exacte - la vitesse de jeu dépend de beaucoup d'éléments, par exemple le nombre d'objets/personnages affichés à l'écran, si de la musique est jouée ou non, la complexité de vos scripts, et bien d'autres. La meilleure façon de déterminer la configuration minimale requise par votre jeu est de le tester sur des ordinateurs proposant des configurations différentes.


le_moteur

Le moteur (également appelé “l'interpréteur”) est ce qui permet d'exécuter votre jeu et ce que le joueur va utiliser.
Si vous utilisez l'interface par défaut, alors vous utilisez le bouton droit de la souris pour passer en boucle les 'modes' disponibles de la souris, et le bouton gauche pour utiliser le mode courant aux coordonnées où se trouve votre souris. Vous pouvez également passer la souris en haut de l'écran pour faire apparaître une barre d'icônes où vous pouvez directement sélectionner un mode. Pour stopper le moteur, appuyez sur Ctrl+Q. Vous pouvez sauvegarder votre avancement en utilisant F5 et le restaurer en utilisant F7.
Ces contrôles-là fonctionnent avec les réglages par défaut ; cependant, vous pouvez personnaliser votre jeu pour utiliser une interface et des touches de raccourcis différentes.

Le jeu de démonstration

Choix du pilote graphique

Configuration du moteur


le_jeu_de_demonstration

Le jeu de démonstration

La première chose que vous voudrez probablement faire sera d'exécuter le jeu de démonstration. Ce jeu essayera de vous montrer ce dont AGS est capable.

Pour exécuter la démonstration, choisissez “Open the Demo Game” (“Ouvrir le jeu de démonstration”), option du dossier AGS dans votre menu Démarrer. Si vous cherchez les fichiers, ils sont placés dans le dossier All Users Application Data (ceci par soucis de compatibilité avec les nouveaux filtres de sécurité de Windows Vista).

NOTEZ : le jeu de démonstration est actuellement en cours de développement. Divers secteurs sont non finis ou non implémentés.


choix_du_pilote_graphique

AGS propose deux pilotes graphiques différents sous Winwows – DirectDraw et Direct3D.

DirectDraw est le pilote graphique “classique” pour les logiciels, celui qu'AGS a toujours utilisé depuis sa version initiale pour Windows. Il convient parfaitement pour les jeux simples qui n'utilisent pas beaucoup de sprites larges, de teinte ou de canal alpha. Il est également rapide pour la manipulation des surfaces de dessin (DrawingSurfaces).

Direct3D est un pilote graphique nouveau, accélérateur matériel. Il utilise Direct3D 9.0 pour l'affichage du jeu dans un environnement matériel totalement accéléré. Cela signifie que le jeu tournera bien plus rapidement si vous utilisez des options comme les canaux alpha ou la teinte, dont l'application est plutôt lente en mode logiciel. Cependant, effectuer des opérations sur les surfaces de dessin (DrawingSurfaces) avec DirectED peut s'avérer plutôt lent, et le pilote ne marche pas avec toutes les cartes graphiques.

Peu importe le pilote graphique que vous utilisez par défaut, le joueur pourra toujours exéctuer le programme de configuration (Setup) et choisir d'utiliser l'autre pilote s'il rencontre des problèmes sur son PC.

Système Requis

DirectDraw: tout PC disposant de Windows avec DirectX 5 ou plus récent Direct3D: tout PC disposant de Windows avec DirectX 9.0 et une carte graphique compatible DirectX 8.1 et plus récent (correspond à la plupart des cartes produites depuis 2003).

Si vous obtenez le message d'erreur “Graphics card does not support Pixel Shader 1.4” (”Votre carte graphique ne supporte pas Pixel Shader 1.4”) au démarrage, cela signifie que votre carte graphique est trop vieille pour utiliser le pilote Direct3D. Vous devriez donc plutôt choisir le pilote DirectDraw.

Voir aussi : System.HardwareAcceleration


configuration_du_moteur

Le programme de configuration (Setup) du moteur permet au joueur de personnaliser certaines options de jeu.

Tout d'abord, il peut changer la résolution du jeu. S'il le fait, tous les graphismes de votre jeu sera automatiquement redimensionnés en conséquence. C'est une option qui peut permettre au joueur de démarrer le jeu même si son système ne permet pas de le faire à la résolution par défaut, pour une raison quelconque.

Le joueur peut aussi choisir d'exécuter le jeu dans une fenêtre sur le bureau plutôt qu'en plein écran. Toutefois, cela aura des conséquences sur les performances. Il est donc préférence de toujours laisser en plein écran.

L'option “Use 85 Hz display” (“Utiliser l'affichage en 85Hz) définit le rafraîchissement de l'écran à une fréquence de 85Hz lors de l'exécution du jeu, ce qui élimine les scintillements. Cependant, cela ne marche pas sur tous les moniteurs, et aucunement sur les écrans plats, c'est pourquoi l'option est désactivée par défaut.

L'option “Force alternate letterbox resolution” (“Forcer la résolution alternative”) est seulement disponible dans les modes 320×200 et 640×400, et permet l'exécution réelle en 320×240 ou 640×480, affichant des bandes noires au-dessus et sous la zone de jeu. Ceci est pertinent pour les ordinateurs qui ne supportent plus les résolutions 320×200 ou 640×400, mais qui supportent ces versions adaptées.

“Smooth scaled sprites” (“Lisser les graphismes redimensionnés”) appliquera une opération d'anti-aliasing sur les personnages subissant un zoom, de façon à donner un aspect plus lisse au redimensionnement. Cela peut toutefois ralentir le jeu, l'option est donc désactivée par défaut.

Enfin, l'option “Downgrade 32-bit graphics to 16-bit” (“Abaisser les graphismes 32-bit vers du 16-bit”) n'est disponible que pour les jeux 32-bit. Cela permet aux gens qui disposent de PCs plus lents de pouvoir jouer en 16-bit à la place, de façon à améliorer les performanceS. S'ils utilisent cette option, la qualité graphique sera réduite, mais cela devrait au moins leur permettre de jouer à une vitesse décente.


Tutoriel

Cette introduction à AGS vous guide à travers la création d'un jeu simple.

Débuter

Configurer le jeu

Propriétés avancées des pièces


debuter

Débuter

Le tutoriel a été mis à jour pour AGS 3.0. Suivez les liens ci-dessous pour le consulter (en anglais).

Tutoriel, Partie 1 - Créer le jeu

Tutoriel, Partie 2 - Créer votre première pièce

Tutoriel, Partie 3 - Zones interactives (Hotspots) et événements

Tutoriel, Partie 4 - Objets

Tutoriel, Partie 5 - Gérer l'inventaire

Tutoriel, Partie 6 - Utiliser vos propres graphismes

Tutoriel, Partie 7 - Animations et scènes cinématiques (cutscenes)

Tutoriel, Partie 8 - Conversations

Tutoriel, Partie 9 - Curseurs et polices

Pour la dernière version des tutoriels, vérifiez régulièrement le site d'AGS.


configurer_le_jeu

Table des matières
    • Configurer le jeu
      • La profondeur de couleurs
      • Inventaire
      • Importer ses propres ressources graphiques
      • Séquences d'introduction
      • Animations
      • Les personnages
      • Conversations
      • Options du Jeu
      • Curseurs
      • Polices

Configurer le jeu

Maintenant que vous savez comment créer une scène, il est temps de paramétrer les options du jeu. Cela inclut les objets d'inventaire, les images de graphismes (sprites), le gestionnaire de couleurs et tout ce qui ne dépend pas d'une scène.

La profondeur de couleurs

La première chose que vous avez besoin de faire une fois que vous avez créé votre nouveau jeu est de décider si vous voulez utiliser une profondeur de couleur de 8-bit (palette basique) ou de 16-bit (haute qualité). Si vous optez pour le 16 bits, vous pouvez toujours utiliser des décors et des images en 256 couleurs si vous le désirez, mais le moteur de jeu fonctionnera seulement avec une résolution de 16-bit , sujet à un léger ralentissement.

Sinon si vous optez pour le 8-bit (notamment parce qu'il tourne plus vite), vous devez assigner cette profondeur de couleur. Tout simplement parce que les images et les scènes importées se réfèrent à la profondeur de couleur que vous aurez choisi. Vous NE POUVEZ PAS utiliser de ressources graphiques en haute qualité quand vous réaliser un jeu en 256 couleurs.

Pour choisir la profondeur de couleur de votre jeu, ouvrez l'onglet General Settings et sélectionnez la profondeur de couleur (Colour Depth) situé proche du haut de la liste.

Maintenant, ouvrez l'onglet “Coulours”. Ici vous apercevrez la palette des 256 couleurs rangée sur une grille. La plupart des emplacements sont marqués d'un “X” - ce sont les emplacement réservés pour les décors, et ils sont différents pour chaque scène. Les autres emplacements sont autorisés pour le jeu. Ce sont des couleurs fixes qui permettent de configurer toutes les options de couleurs comme la couleur de texte d'un personnage , qui doit être affiché sur plus d'un écran pour fonctionner.

Si vous le souhaitez, vous pouvez créer d'autres couleurs pour le décor. Pour permuter le rôle d'un emplacement de couleur, sélectionnez cet emplacement puis sélectionnez Gamewide ou Background dans l'option CoulourType.

NOTE IMPORTANTE: Vous devez confirgurer la profondeur de couleur avant de commencer à créer votre jeu - si vous changez plus tard, vous devrez réimporter toutes les images et tous les décors.

Vous pouvez sélectionner plusieurs emplacement à la fois en cliquant dans un premier tant sur un emplacement, puis tout en maintenant la touche Shift enfoncée, sélectionnez le dernière emplacement de votre sélection multiple. Vous pouvez alors permuter le rôle de tous ces emplacements en une seule fois.

Pour exporter la palette de couleur, faite clic-droit sur un emplacement puis Export to file… , enregistrer votre image au format .PAL ou .BMP. Vous pourrez alors importer votre palette pour un autre jeu si vous le désirez. Si vous exporter au format .BMP, une capture d'écran de la palette de l'éditeur sera enregistrée comme une image. Cela vous permet de consulter toutes les couleurs de la palette si besoin est.

L'option “Replace palette from file…” remplace la palette par le fichier au format .PAL ou .BMP que vous aurez choisi. Les fichiers .PAL standards de 768 bytes peuvent être lu, la palette de ressources SCI (renommé au format .PAL) et les fichiers au format JASC PSP.

Inventaire

La plupart des jeux d'aventure mette en place un système d'inventaire au joueur pour qu'il porte plusieurs objets, qui peuvent alors servir à résoudre certaines énigmes. Adventure Game Studio intègre ce système de manière facile et intuitive.

Chaque objet d'inventaire dont le joueur peut porter à n'importe quel moment durant le jeu est listé sous l'onglet “Inventory items”. Ici, chaque objet possède un numéro et un nom de script que vous pourrez utiliser dans les scripts pour identifier l'objet. Pour créer un nouvel objet, cliquez-droit sur l'onglet “Inventory items”.

Double-cliquez sur un objet pour l'éditer. Sur la gauche vous voyez l'image de l'objet lorsqu'il est dans la fenêtre de l'inventaire d'une interface (Inventory Window). Pour changer d'image, sélectionnez la propriété “Image” puis cliquez sur le bouton ”…”.

La dernière chose à faire avec les objets est de définir leurs événements : que se passe-t-il quand le joueur les manipule dans la fenêtre de l'inventaire. Cliquez sur le bouton “Events” (l'éclair jaune sur le dessus de la grille des propriétés), cela vous amène à une liste similaire à celle des hotspots. Les interactions disponibles sont décris dans la section correspondante.

NOTE: Chaque personnage dans le jeu a son propre inventaire. Cela signifie que si vous voulez créer un jeu comme Day of the Tenctacle, où le joueur peut contrôler trois personnages différents, chaque personnage possèdera ses propres objets.

Vous avez deux choix en ce qui concerne l'affichage des inventaires aux joueurs – une fenêtre d'inventaire préfabriquée pour les débutants, et la possibilté de créer un inventaire personnalisé quand vous êtes prêt à faire le votre.

L'option d'affichage par défaut est la fenêtre d'inventaire à la Sierra, qui apparaît en cliquant sur l'icône de l'inventaire sur la barre d'icônes. Vous pouvez aussi avoir l'objet actif affiché dans son propre bouton toujours dans la barre d'icône en créant un bouton sur le GUI et en lui donnant comme texte (INV) qui étend l'image de l'objet à la taille du bouton, ou (INVNS) qui dessine l'image de l'objet directement sur le bouton sans le redimensionner. Et enfin, (INVSHR), probablement la meilleure option, qui dessinera l'objet dans sa taille actuelle si elle est appropriée, ou qui la rétrécie si ce n'est pas le cas.

L'autre option est de faire un inventaire personnalisé. Pour l'utiliser, vous aurez besoin de modifier le GUI pour l'ajouter, je vous l'expliquerai donc plus tard. Tant que vous débutez avec AGS, il est recommandé d'utiliser la fenêtre d'inventaire de Sierra qui vous est fourni.

Finalement, vous avez peut être remarqué dans l'onglet General Settings (rubrique Inventory) que vous pouvez ajouter une croix permettant de définir le point d'interaction de l'objet. Cela permet au joueur de voir facilement où le clic avec l'objet fera effet. Vous pouvez entrer la couleur du point du centre et aussi les 4 pixels aux alentours.

Importer ses propres ressources graphiques

Précédemment, lorsque vous avez sélectionné l'image d'un objet dans le tutoriel, vous avez probablement remarqué que la plupart des ressources graphiques disponibles ne sont pas très belles. Ce n'est pas un problème, dans la mesure où vous pouvez importer vos propres graphismes en utilisant le gestionnaire d'images.

Allez dans l'onglet Sprites (Images) de l'éditeur. Ici, vous verrez la panoplie d'images complète du jeu. Il y a deux méthodes pour importer vos ressources graphiques - soit en remplaçant une image déjà importée par la vôtre, ou en lui créant un nouvel emplacement.

Pour remplacer une image existante, cliquez-droit sur son emplacement puis sur “Replace sprite from file” (Remplacer l'image par le fichier…). Pour importer sur un nouvel emplacement, cliquez-droit sur le fond blanc de la fenêtre et cliquez sur “Import new sprite” (Importer une nouvelle image).

L'image que vous importez doit avoir la même profondeur de couleur que celle de votre jeu (c'est-à-dire que si vous utilisez des décors de haute qualité, vos images doivent être de haute qualité, et vice versa). AGS essayera de convertir l'image si possible, mais si votre jeu est en 256 couleurs, le résultat de la mise à niveau d'une image en haute qualité peut être pauvre.

Ensuite, la fenêtre d'importation d'images apparaît. Ici, vous devez décider quelle portion de l'image devra être importée. Pour cela, cliquez-droit et en maintenant le clic enfoncé, faites un rectangle jaune de sélection. Une fois satisfait, faites un clic gauche pour importer cette dernière. D'autre part, vous pouvez aussi importer l'image entière en cliquant sur le bouton “Import whole image” (Importer l'image entière).

NOTE (en 256 couleurs uniquement) : Vous trouverez certainement que les images que vous aurez importées dans le gestionnaire ont un aspect graphique étrange. C'est dû au fait que les images ont seulement été allouées en mémoire avec, par défaut, Les 41 premières couleurs de la palette graphique (voir La profondeur de couleurs), et donc vos images ont été représentées avec ces quelques couleurs seulement. Si vous trouvez que trop de vos images sont étranges, vous pouvez augmenter le nombre de couleurs assignées aux images, aux dépends de celles des décors (voir la section citée plus haut). Si votre image est utilisée seulement dans une seule scène alors vous pouvez encore utiliser l'option “Use background palette” (Utiliser la palette du décor), qui recalculera votre image avec la palette de la pièce actuelle, donnant de meilleures résultats. Notez que, cependant, si vous le faites, et que vous utilisez l'image sur un autre écran, ses couleurs vont très probablement se dégrader. Pour utiliser la palette de la pièce, cochez la case “Use background palette” (Utiliser la palette du décor). Veillez à désactiver cette option avant d'importer d'autres images.

NOTE: la couleur de transparence utilisée par AGS est l'indice 0 de la palette (pour des images en 256 couleurs) et la couleur rose (255,0,255) pour la haute qualité. Sur les images que vous aurez importées, n'importe quel pixel de ces couleurs respectives sera transparent.

Vous pouvez classer vos images importées dans des répertoires. Cela évite d'avoir une liste trop longue. Par défaut, le gestionnaire affiche le répertoire principal (Main), contenant quelques graphismes et un sous-répertoire appelé “Defaults”. Les répertoires fonctionnent comme ceux de Windows. Cliquez-droit sur un dossier de l'arbre pour le renommer ou pour en générer plusieurs sous-répertoires.

Vous pouvez supprimer un répertoire en cliquant-droit dessus et en choisissant l'option “Delete” (Supprimer) ; notez bien que toutes les ressources y figurant seront également supprimées .

* NOTE: quelques personnes ont rencontré des problèmes quand ils importaient à partir du presse-papier (copier-coller), en effet les couleurs des images étaient inversées (le rouge devient bleu, le bleu devient rouge, etc.) quand elles étaient sous Windows en 24 bits ou 32 bits. Si cela vous arrive, il y a deux solutions : (a) configurez la profondeur de couleurs de votre bureau en 16 bits et relancez AGS, ou (b) importez vos images à partir de fichiers plutôt qu'avec le presse-papier.

Importer des images de même taille

Vous avez peut être remarqué une case appelée “Tiled sprite import” (Import d'images en mosaïque). Certaines personnes trouvent cela utile pour importer beaucoup d'images d'animation de personnage en une fois.

Tout d'abord pour que cela fonctionne, toutes vos images-cases doivent être réunies dans un seul fichier image, alignées dans le bon ordre et de même dimension. Puis, utilisez l'option “Import from file” (Importer à partir d'un fichier…) et importez le fichier image qui comporte toutes les cases, comme d'habitude. Cochez la case “Tiled sprite import” (Import d'images en mosaïque) et sélectionnez la case supérieure gauche.

Quand vous faites un clic gauche, le rectangle de sélection deviendra vide et vous pourrez alors définir avec la souris combien il y a d'images à importer - elles seront toutes entourées d'un rectangle de sélection. Une fois que vous avez le bon compte, cliquez-gauche de nouveau et elles seront toutes importées.

Images avec canal alpha

AGS gère le canal alpha des images si votre jeu est en 32 bits. Dans ce cas, vous devez importez une image au format PNG avec le canal alpha intégré (vous ne pouvez pas coller l'image à partir du presse-papier).

Une fois importée, AGS vous demandera si vous souhaitez utiliser le canal alpha ou pas. Si vous répondez Oui, alors l'image sera dessinée avec le canal alpha dans le jeu si elle est utilisée comme image de personnage, objet, curseur ou GUI.

Notez que si vous utilisez le canal alpha, toutes les propriétés de transparence que vous aurez affectées (comme Character.Transparency, Object.Transparency, GUI.Transparency) seront ignorées.

NOTE: Actuellement, il n'est pas possible d'appliquer l'anti-crénelage (anti-alias) à ces images, donc si vous avez l'option Anti Alias Sprites (Anti-Crénelage des Images) d'activée dans les options de l'installateur, elle ne sera pas appliquée sur les personnages.

Séquences d'introduction

Vous pouvez facilement ajouter un générique, un final et des cinématiques à votre jeu. Ils n'ont pas d'implémentation directe dans le logiciel, mais en utilisant les animations et des commandes script vous pouvez créer quasiment tout ce que vous voulez.

Généralement, le jeu démarre dans la pièce 1. Ce numéro correspond à la pièce de départ du personnage joueur. Pour le changer, ouvrez ce personnage depuis l'onglet Character de l'éditeur, et changez le numéro de StartingRoom (pièce de départ) de la grille des propriétés.

Conseil : cette possibilité de changer de pièce de départ est utile surtout quand vous testez votre jeu - vous pouvez assignez n'importe quelle pièce de départ en fonction du point à partir duquel vous désirez tester, sans vous obliger à refaire toute la progression du jeu jusqu'à ce point.

Les cinématiques sont crées en utilisant les commandes de script d'animation basiques, telles que Character.Walk (Personnage.Marche), Object.SetView (Objet.AssignerVue), et bien d'autres. Je vous conseillerais de laisser cela de côté jusqu'à ce que vous soyez plus à l'aise avec AGS, et que vous ayez plus d'expérience à propos de l'utilisation de ces fonctions.

Animations

Dans la plupart des jeux vous verrez des animations, comme un drapeau qui flotte dans la brise ou le joueur qui se penche pour ramasser quelque chose. Le terme “animation” se réfère à la possibilité de changer d'apparence, et de position, aux objets.

Les animations sont crées dans AGS en utilisant des Views (Vues). Une “vue” est un ensemble d'une ou de plusieurs “séquences”. Une séquence est, elle, un ensemble de frames (images) qui, assemblées les unes après les autres, donne un effet de mouvement. Chaque frame (image) de la séquence peut posséder une image et une vitesse (définissant le temps pour passer à la frame suivante).

Allez dans l'onglet “Views”, cliquez-droit dessus puis sélectionnez “New view” pour créer une nouvelle vue vierge. Double-cliquez dessus pour l'ouvrir. Chaque séquence est affichée horizontalement avec leur numéro sur le côté gauche, les frames se défilent vers la droite. Pour ajouter une frame, cliquez sur le bouton gris “New frame”. Pour supprimer une frame, cliquez-droit dessus.

Pour changer l'image d'une frame, double-cliquez-gauche dessus. La fenêtre de la liste des images s'affichera (vous devez vous souvenir de la sélection graphique d'objet) où vous pouvez choisir l'image que vous voulez utiliser pour cette frame.

Notez que pour les animations de marche, la première frame de chaque séquence est réservée pour la frame où le personnage est statique (donc il ne marche pas), et quand il se mettra à marcher son cycle s'effectuera à partir de la deuxième frame qui la suit.

Quand une frame est sélectionnée, la grille des propriétés se mettra à jour avec les informations de la frame. Une de ces propriétés est appelée “Delay” (Durée), qui représente la vitesse relative de la frame. Plus ce nombre est grand, plus la frame s'affichera longtemps (l'animation sera donc plus lente). Quand l'animation s'exécute, une vitesse d'animation globale est affectée, donc la vitesse réelle de la frame équivaut à : vitesse_globale + vitesse_frame . Notez que vous pouvez utiliser des valeurs négatives pour la durée de la frame pour la rendre particulièrement rapide, par exemple l'affecter à -3 signifie que la frame s'affichera à peine à chaque fois.

La vitesse d'animation dépend du taux de rafraîchissement du jeu (c'est-à-dire qu'une vitesse d'animation de 4 affichera la frame pendant 4 rafraîchissements - à 40 fps (images par seconde), cela équivaut à 0.1 seconde).

La propriété “Sound” vous permet d'entrer un numéro de son qui sera jouée quand la frame correspondante sera visible à l'écran. C'est spécialement utile pour les sons de pas d'un personnage.

Vous pouvez lancer des animations en utilisant des commandes scripts d'animation, qui seront expliqués en détail plus tard. Rapidement, pour animer un objet, vous devez avant tout affecter la view (vue) de l'objet au numéro de la view correspondante (utilisez la commande Objet.SetView), et après utilisez la commande Objet.Animate pour démarrer l'animation.

Les personnages

Un personnage est similaire à un objet, à part qu'il peut changer de scène, contenir son propre inventaire, et prendre part dans des conversations (voir plus tard). Il peut aussi avoir ses propres vitesse d'animations personnalisées et vitesse de mouvement.

Allez dans l'onglet “Characters” (Personnages) dans l'arbre principal. Vous lui verrez en dessous une liste de tous les personnages dans le jeu. Pour créer un nouveau personnage, cliquez-droit sur l'onglet “Characters” et choisissez l'option “New character” (Nouveau personnage).

Vous verrez qu'il y a beaucoup d'options que vous pouvez paramétrer pour chaque personnage. La plus remarquable est le bouton “Make this the player character” (Rendre le personnage joueur), qui vous permet de changer quel personnage le joueur contrôlera au début du jeu. Quand le jeu démarre, la première scène qui se chargera sera la scène de départ du personnage joueur.

Le reste des options sont placées ailleurs dans la grille des propriétés sur la droite. Voici la description de quelques-unes d'elles :

L'option “UseRoomAreaScaling” (Utiliser la zone d'ajustement des scènes) vous permet de spécifier si ce personnage sera étendu ou racourci dans les zones d'ajustement de l'écran. Vous devirez désactiver cette option si vous avez un personnage qui reste toujours au même plan dans la scèn ; ou que vous voulez que les images à l'écran soit de même taille que celles que vous avez importées, même s'il est dans une zone ajustée.

L'option “Clickable” (cliquable) dit à AGS si vous voulez que le joueur puisse cliquer sur le personnage. Si l'option est activée, et bien le personnage sera interactif, comme dans les jeux de Sierra. S'il elle n'est pas activée dans ce cas le personnage fonctionne dans le même style que les jeux Lucasarts - si vous déplacer le curseur sur le personnage ou que vous cliquer dessus en mode “regarder”, “parler”, etc, le jeu ignorera le personnage et agira sur ce qui se trouve derrière lui.

Pour assigner dans quelle room le personnage se trouve au début du jeu, changez le propriété “StartingRoom” (Scène de départ). Vous pouvez modifier la position du personnage dans ladite scène en utilisant les propriétés “StartX” et “StartY” (X de départ | Y de départ) pour indiquer les coordonnées X et Y qu'il doit avoir. Ces coordonnées définissent où le point du milieu de ses pieds doit être placée.

La “NormalView” (Vue normale) indique la vue du personnage quand il est normal. Vous devez créer une vue dans l'onglet Animations, et cette vue doit avoir soit 4, soit 8 séquences. Si vous utilisez 4 séquences, et bien quand il marchera diagonallement les images de la direction cardinale la plus proche seront utilisées. Chaque séquence est utilisée pour chaque direction du personnage, de la manière suivant :

 Séquence 0 - marche vers le bas
 Séquence 1 - marche vers la gauche
 Séquence 2 - marche vers la droite
 Séquence 3 - marche vers le haut
 Séquence 4 - marche diagonale vers le bas-droite
 Séquence 5 - marche diagonale vers le haut-droite
 Séquence 6 - marche diagonale vers le bas-gauche
 Séquence 7 - marche diagonale vers le haut-gauche

Pour changer la vitesse à laquelle le personnage s'anime, modifiez la cellule Animation Speed (Vitesse d'Animation). Ici, un petit nombre signifie une animation plus rapide. Notez que cela N'AFFECTE PAS la vitesse de déplacement quand le personnage marche.

NOTE Le première image de chaque séquence représente l'image où le personnage est fixe. Quand il marche, le jeu déroulera son cycle à partir de la deuxième à chaque fois.

L'option “MovementSpeed” vous permet de paramétrer la vitesse de déplacement du personnage quand il marche. Ici, un plus grand nombre signifie qu'il marchera plus vite. Si vous estimez que la vitesse de mouvement à 1 est encore trop rapide, vous pouvez utilisez des valeurs négatives (ex: -3) qui le feront marcher encore moins vite. Plus bas vous irez, plus le déplacement sera lent.

L'option “SpeechColor” (Couleur des messages)

Conversations

Alors que les vieux jeux de Sierra étaient principalement basés sur l'action et non sur les dialogues, les jeux de Lucasarts ont pris le chemin opposé.

Si vous voulez créer un jeu avec des dialogues où le joueur peut choisir parmi une liste de thèmes à aborder, c'est désormais possible avec le nouvel Éditeur de Dialogues (Dialog Editor). Rendez-vous dans le nœud “Dialogs”.

Les dialogues sont formés de Topics (Thèmes). Un “topic” est une liste de choix accessibles au joueur. Vous pouvez introduire jusqu'à 30 choix dans un topic. Cependant, il n'est pas nécessaire que la totalité d'entre eux soit accessible au joueur au début du jeu - vous pouvez n'activer certaines options dans la conversation que lorsque le joueur aura dit ou effectué certaines choses. Par exemple, lorsque vous parlez à l'homme dans le jeu de démonstration, la première option est simplement “Hi” (”Salut”). Mais une fois ceci dit, une nouvelle option devient disponible.

L'Éditeur de Dialogues s'explique plus ou moins de lui-même. Double cliquez sur un topic pour ouvrir sa fenêtre. Vous verrez une liste d'options pour ce thème sur la gauche, et le script du dialogue sur la droite. Chaque option possède deux cases à cocher sur sa droite :

  • La colonne “Show” (”Montrer”) spécifie si l'option est disponible pour le joueur au début du jeu.
  • La colonne “Say” (”Dire”) définit si le personnage prononce l'option lorsque le joueur clique dessus. Cette option est activée par défaut, mais si vous voulez que l'option décrive l'action du joueur plutôt que ce qu'il dira, vous pourrez décocher cette colonne pour ce dialogue.

Script des dialogues Vous contrôlez ce qui arrive lorsque le joueur choisit une option en édiant le script sur la droite. On l'appelle le script des dialogues (dialog script), et c'est une version simplifiée du code de script classique, adapté aux conversations.

À la création d'un sujet de conversation, tout ce que vous verrez dans le script seront des numéros de lignes précédés du signe '@'. Dans le script des dialogues, ces signes symbolisent le point de départ du script pour chaque option. Par exemple, lorsque le joueur clique sur l'option 3, le script débutera à la ligne à la ligne suivant ”@3”. Il y a aussi un point de départ spécial, appelé ”@S”. C'est l'endroit où démarre la conversation, avant que le joueur puisse effectuer quelque choix. Vous pouvez vous en servir pour afficher un message comme “Bonjour” par exemple.

Pour afficher un discours, vous débutez la ligne avec le NOM DE SCRIPT du personnage (pas le nom complet), suivi d'une virgule puis un espace et enfin ce que vous voulez que ce personnage dise. Par exemple, si le nom de script du personnage principal est EGO, vous écrirez :

ego: "Je suis très heureux aujourd'hui car c'est mon anniversaire."

Le nom de script du personnage est utilisé par le système pour choisir quelle couleur utiliser pour le texte.

IMPORTANT : Ne recopiez PAS le 'c' qui débute le nom de script du personnage dans ces scripts.

Vous pouvez aussi utiliser le nom de personnage spécial “narrator”, qui affichera le texte dans une fenêtre dédiée plutôt que comme un discours simple ; de même que le raccourci “player”, qui fera parler le personnage joueur - ce qui est utile si vous ne savez pas quel personnage le joueur est en train de contrôler lorsqu'il participe à la conversation.

Si vous utilisez simplement ”…” comme texte à faire dire aux personnages, le jeu marquera une brève pause comme s'ils s'arrêtaient pour penser, rien ne sera affiché.

Pour signaler la fin d'un script pour une option, insérez une commande “return” à la dernière ligne de l'option. Par exemple,

@1
ego: "Salut. Comment ça va ?"
narrator: L'homme vous regarde dans les yeux
autrehomme: ...
autrehomme: "Je vais bien."
return

“return” indique à AGS de revenir à l'affichage des choix pour le joueur. Si vous utilisez “stop” au lieu de “return”, alors la conversation est interrompue. Vous pouvez aussi utiliser les commandes “goto-dialog” (aller au dialogue) ou “goto-previous” (aller au précédent), qui interrompent le script de dialogue en cours et qui transfèrent le contrôle au nouveau dialogue.

NOTE: NE PAS placer d'espace ou de tabulations devant ces lignes. Si vous le faites, cela signifie qu'AGS devrait interpréter ces lignes comme des commandes de script classiques plutôt que comme des commandes de script de style dialogue. Les commandes de dialogue existantes sont :

  • goto-dialog X
Passe au sujet X, et affiche la liste des choix pour ce sujet.
  • goto-previous
Retourne au sujet à partir duquel vous êtes arrivé au sujet en cours. Si
le dialogue a commencé avec le sujet en cours, alors la conversation est interrompue.
  • option-off X
Désactive l'option X du sujet en cours, ce qui signifie qu'elle ne sera plus affichée
dans la liste des choix la prochaine fois.
  • option-off-forever X
Désactive l'option X de façon permanente. Elle ne sera plus jamais affichée, pas même
si une commande "option-on" est utilisée.
  • option-on X
Active l'option X pour le sujet en cours, l'incluant dans la prochaine liste des choix
affichée au joueur.
  • return
Interrompt le script et retourne à la liste des choix.
  • stop
Cesse la conversation et retourne au jeu.

Pour voir un exemple de script de dialogue, chargez le jeu de démonstration dans l'éditeur et regardez le script du sujet 0.

Utiliser des commandes de script dans les dialogues

Il arrivera souvent que les commandes plus haut soient insuffisante pour ce que vous voudrez faire dans les dialogues. Vous pourriez par exemple vouloir donner un objet d'inventaire au joueur ou modifier son score.
AGS vous permet désormais d'insérer des commandes de script classiques dans votre script de dialogue, en indentant ces lignes avec des espaces ou des tabulations. Par exemple :

@1
ego: "Bonjour. Comment ça va ?"
narrator: L'homme vous regarde dans les yeux.
  player.AddInventory(iClef);
  Display("L'homme vous remet une clef.");
autrehomme: "Je vais bien."
return

Ici, vous voyez que des commandes de dialogue sont utilisées, mais une paire de commandes de script classiques a aussi été insérée aux lignes indentées.
À l'intérieur des scripts de dialogue, le mot-clé this vous permet de manipuler le dialogue en cours.
Si vous voulez conditionner l'interruption d'un script de dialogue, vous pouvez utiliser les expressions spéciales RUN_DIALOG_GOTO_PREVIOUS, RUN_DIALOG_RETURN et RUN_DIALOG_STOP_DIALOG à l'intérieur d'un bloc de script normal. Par exemple :

@1
ego: "Bonjour. Comment ça va ?"
narrator: L'homme vous regarde dans les yeux.
  if (player.HasInventory(iClef)) {
    player.Say("En fait, il vaudrait mieux que j'y aille.");
    return RUN_DIALOG_STOP_DIALOG;
  }
otherman: "Voici une clef pour vous."
  player.AddInventory(iClef);
return

Analyseur de texte

Dans l'éditeur de dialogue, vous pourrez remarquer que la grille présente une option appelée “ShowTextParser” (“MontrerAnalyseurTexte”). Si vous l'activez, alors une zone de saisie sera affichée sous les options du dialogue durant le jeu, permettant au joueur d'entrer son propre texte.

S'il tape quelque chose dedans, alors la fonction de script globale dialog_request sera exécutée, avec pour paramètre le numéro du sujet de dialogue ainsi que la chaîne de caractères que le joueur a entrée.

AGS applique automatiquement la commande ParseText sur le texte entré avant d'appeler dialog_request, vous pouvez donc utiliser la commande Said() pour traiter le texte. Voir la section L'analyseur de texte pour plus d'informations.

Options du Jeu

L'onglet Game Settings (Réglages du Jeu) contient une liste de toutes les différentes options globales que vous pouvez configurer pour votre jeu.

Notez que certaines choses listées ici sont expliquées plus loin dans la documentation, alors si vous ne comprenez pas un des éléments de cette liste, vous pouvez y revenir plus tard.

La plupart des ces options peuvent à nouveau être modifiées durant le jeu grâce à la commande SetGameOption.

  • Debug Mode - définit si les touches de débogage sont activée ou non. Lorsque le mode de débogage est activé, vous pouvez appuyer sur Ctrl-X pour vous téléporter dans n'importe quelle pièce, sur Ctrl-S pour obtenir tous les objets d'inventaire, sur Ctrl-A pour afficher les zones de déplacement libre à l'écran, et sur Ctrl-D pour afficher les statistiques de la pièce en cours. Lorsque ce mode est désactivé, ces touches n'ont aucun effet. Consultez la section Options de débogage pour plus de détails.
  • Play sound on score (Jouer un son lorsque le joueur gagne des points) - définit si un effet sonore doit être joué lorsque le score du joueur augmente. Si oui, vous pouvez définir un nombre x de façon à ce que le fichier SOUNDx.WAV (ou SOUNDx.MP3) soit joué.
  • Walk to hotspot in Look mode (Marcher jusqu'à la zone d'interaction en mode Observer) - définit si le personnage marchera jusqu'aux zones d'interactions lorsque le joueur clique dessus en mode LookAt (Observer). En temps normal, il marche avec Use (Utiliser), Speak (Parler) et Use-inv (Utiliser l'inventaire).
  • Dialog options on GUI (Options des dialogues avec GUI) - définit comment les options du joueur lors d'un dialogue sont affichées. Si cette option n'est pas cochée, lors des conversations les options seront affichées en bas de l'écran. Si vous la cochez, les options seront à la place affichées sur le GUI que vous aurez spécifié.
  • Use “anti-glide” mode (Utiliser le mode anti-glisse) - vous aurez peut-être remarqué que lorsque les personnages se déplacent, ils peuvent parfois donner l'impression de glisser, particulièrement si vous avez défini une vitesse d'animation lente. Lorsque le mode anti-glisse est activé, la position du personnage n'est mise à jour que lors d'un changement d'image dans l'animation. Vous devriez augmenter la vitesse de marche de vos personnages lorsque vous utilisez cette option.
  • Text windows use GUI (Fenêtres de texte avec GUI) - vous permet de personnaliser l'apparence des fenêtres de texte standards, en utilisant le GUI spécifié. Consultez cette page pour plus d'informations.
  • Pixel gap between options (Espace entre chaque option) - définit l'espace qui sépare chaque option proposée au joueur dans une conversation. Normalement cela vaut 0, ce qui signifie que les options sont directement les unes sous les autres. Donner la valeur 1 ou 2 peut rendre l'affichage des options moins serré ; c'est une question de goût personnel.
  • Skip Speech (Passer le discours) - définit comment et si le joueur peut passer les discours dans le jeu. Vous pouvez permettre de les passer à l'aide de la souris (mouse) et/ou du clavier (keyboard) ou ne pas le permettre (neither).
  • When interface disabled (Lorsque l'interface est désactivée) - définit ce qui se passe avec les boutons sur vos GUI lorsque l'interface du jeu est désactivée (durant une cinématique par exemple).
  • Always display text as speech (Toujours afficher le texte comme un discours) - si vous sélectionnez cette option, tous les textes normaux du jeu seront affichés au-dessus de la tête du personnage principal comme s'il parlait, globalement comme dans les jeux Lucasarts. Si vous désactivez cette option, alors le texte normal apparaîtra dans une fenêtre dédiée, comme dans les jeux Sierra.
  • Speech style (Style des dialogues) - dans le style de dialogues par défaut Lucasarts, lorsqu'un personnage parle, le texte est affiché au-dessus de sa tête dans le jeu et l'animation de dialogue du personnage est enclenchée. Cependant, si vous définissez cette option pour utiliser le style Sierra, alors le numéro de la vue est utilisé pour afficher un portrait animé séparément dans le coin supérieur gauche de l'écran, le texte s'affichant à sa droite. Ce rendu est similaire à celui des jeux Space Quest 5, King's Quest 6 et autres Sierra. Vous pouvez aussi choisir une autre option, “Sierra-style with background” (Style Sierra avec arrière-plan), qui a le même effet sauf qu'une fenêtre d'arrière-plan est dessinée derrière le texte pour le rendre plus facile à lire. “Whole Screen” (Tout l'écran) affiche un portrait en plein écran, comme c'est le cas dans QFG4.
  • Speech portrait side (Côté du portrait) - si vous utilisez le style de dialogues Sierra, cela détermine si les portraits seront affichés à gauche ou à droite de l'écran. Le réglage “alternate” (alterner) a pour effet de changer le côté chaque fois qu'un nouveau personnage parle, et l'option “Based on X position” (Basé sur la position horizontale) choisit le côté en fonction de la proximité du personnage avec le bord de l'écran correspondant.
  • Room transition style (Transition de changement de pièce) - détermine le type de transition pour l'écran qui sera utilisé lorsque le joueur change de pièce. Plusieurs options sont disponibles.
  • Save screenshots in save games (Captures d'écran comme sauvegardes) - sauvegarde une mini capture d'écran de la position actuelle du joueur dans le fichier de sauvegarde. Cela créera des fichiers de sauvegarde plus lourds, mais vous permettra aussi d'utiliser un aperçu dans votre GUI de sauvegarde/chargement.
  • Enforce object-based scripting (Force le script orienté objet) - configure le compilateur en mode strict : il n'acceptera pas les commandes dans l'ancien style (avant AGS 2.7). Il vaut mieux garder cette option car vous ne devriez plus utiliser ces vieilles commandes. Toutefois, il peut parfois s'avérer utile d'autoriser l'ancien style pour des soucis de compatibilité avec un ancien module.
  • Left-to-right operator precedence (Évaluation des opérateurs de gauche à droite ) - si vous activez cette option, alors les opérateurs de force égale seront évalués de gauche à droite. Par exemple, 5 - 4 - 3 peut être interprété comme (5 - 4) - 3 ou comme 5 - (4 - 3), conduisant à des résultats différents. Vous devriez toujours utiliser des parenthèses pour clarifier ce genre d'expressions, de façon à ne pas dépendre de la force des opérateurs.
  • Pixel-perfect click detection (Détection de clics au pixel près) - normalement lorsque le joueur clique avec sa souris, AGS vérifie simplement si le curseur se trouve dans la zone rectangulaire de chaque personnage et objet à l'écran. Cependant, si vous activez cette option, alors AGS vérifiera en plus si le curseur se trouve bien sur un pixel appartenant réellement à un élément ou s'il se trouve dans une zone transparente de son image. Si cette option est activée et que le joueur clique sur un pixel transparent, c'est l'événement correspondant à l'élément qui se trouve derrière qui sera exécuté à la place.
  • Don't automatically move character in Walk mode (Ne pas déplacer le personnage automatiquement en mode Marche) - normalement, lorsque vous cliquez en mode Marcher, le personnage principal se rendra où vous avez cliqué. Cependant, si vous voulez créer un jeu à la première personne, et donc sans personnage principal, sélectionner cette option vous permettra d'utiliser le mode Marche pour d'autres choses. Avec cette option, les événements “Character stands on hotspot” (Le personnage se trouve sur la zone d'intercation) sont déclenchés par un clic en mode Marche sur la zone.
  • Use letterbox (320×240 / 640×480) resolution (Utiliser une résolution 16/9) - cette option n'est disponible que si votre jeu est en 320×200 ou 640×400 et forcera AGS à exécuter le jeu en 320×240 ou 640×480 à la place. Un “effet 16/9” sera appliqué à l'écran - c'est-à-dire qu'il y aura des bordures noires en haut en en bas. Vous pourriez vouloir utiliser cette option s'il vous est essentiel que les pixels aient un aspect bien carré.
  • Don't use inventory graphics as cursors (Ne pas utiliser les images d'inventaire comme curseurs) - normalement, lorsque vous sélectionnez un objet d'inventaire, son image sert comme curseur pour la souris. Cependant, si vous voulez créer un jeu dans le style Lucasarts (où le curseur d'inventaire est toujours une simple croix), activez cette option et le curseur restera inchangé.
  • Don't scale up fonts at 640×400 (Ne pas agrandir les polices en 640×400) - normalement, si le joueur est en résolution 640×400, alors les polices seront agrandies en conséquence. Toutefois, si vous avez directement conçu vos polices pour cette résolution, activez cette option pour éviter qu'elles soient déformées.
  • Resources split every Mb (Fragmenter les ressources en fichiers de X Mb) - consultez cette page pour plus d'information.
  • Characters turn before walking (Les personnages se retournent avant de marcher) - avec cette option, avant que le personnage commence tout déplacement, il se tournera s'il y a lieu dans la direction vers laquelle il se dirige en utilisant les images d'animation disponibles, plutôt que commencer directement sa marche dans une direction opposée.
  • Override built-in inventory window click handling (Clics sur fenêtre d'inventaire personnalisés) - AGS traite de façon interne les contrôles GUI des fenêtres d'inventaire, un clic droit aura pour effet d'observer l'objet tandis qu'un clic gauche le sélectionnera si le curseur est en mode Interaction. Cependant, si vous activez cette option, cliquer sur un objet dans la fenêtre d'inventaire appellera la fonction on_mouse_click avec eMouseLeftInv, eMouseMiddleInv ou eMouseRightInv, ce qui vous permettra de gérer vous-même. Vous pouvez utiliser la variable game.inv_activated pour savoir sur quel objet le joueur a cliqué.
  • Enable mouse wheel support (Prise en charge de la molette) - avec cette option, on_mouse_click pourra être appelée avec les valeurs eMouseWheelNorth et eMouseWheelSouth, ce qui correspond au défilement nord ou sud, respectivement, de la molette de la souris.
    NOTE : Certaines souris n'ont pas de molette, et le moteur DOS ne gère pas du tout les molettes. Ainsi, votre jeu ne devrait jamais exiger d'utiliser la molette pour être jouable - vous devriez simplement l'inclure comme option supplémentaire.
  • Number dialog options (Numéroter les options des dialogues) - place un numéro devant chaque option affichée dans les dialogues. Par exemple,
    1. Bonjour !
    2. Au revoir
    Ceci permet au joueur de savoir visuellement à quelle option correspond les touches de clavier, ainsi qu'à séparer les options si vous n'utilisez pas de puce.
  • Dialog options go upwards on GUI (Options de dialogue upwards sur les GUI) - normalement, si vous sélectionnez un GUI non fenêtre textuelle pour afficher vos options de dialogue, celles-ci sont affichées du premier plan vers le fond. Si vous sélectionnez cette option toutefois, elles seront affichées depuis le fond vers le premier plan du GUI.
  • Crossfade music tracks (Enchaînement des musiques en fondu) - ceci effectue des transitions en fondu entre les pistes musicales d'arrière-plan. Vous pouvez sélectionner une vitesse de fondu dans la liste. Cette options présente quelques désavantages - tout d'abord elle ralenti sensiblement le jeu, puisqu'AGS doit décoder deux fichiers musicaux à la foix. Ensuite, elle ne marche que pour les fichers OGG, MP3 et WAV. Vous ne pouvez pas fondre des musiques MIDI, XM, MOD, S3M ou IT.
  • Anti-alias TTF fonts (Polices TTF anti-crénelage) - avec cette option, les polices TTF de votre jeu seront affichées de façon anti-crénelée (anti-alias). Cela améliore leur aspect, mais présente deux contreparties - tout d'abord l'anti-crénelage est significativement plus lent qu'un affichage classique, vous pourrez donc vouloir permettre au joueur de désactiver cette option. Ensuite, l'anti-crénelage ne fonctionne que pour les jeux en hautes couleurs (dans les jeux en 256 couleurs, l'affichage sera brouillé et illisible).
    NOTES : l'anti-crénelage n'est actuellement pas appliqué pour le discours dans le style lucastars pour raisons techniques.
  • Thought uses bubble GUI (Utiliser tel GUI pour les pensées) - détermine quel GUI - fenêtre textuelle sera utilisé(e) pour afficher les pensées avec la commande Think.
  • Characters turn to face direction (Les personnages pivotent pour se retourner) - avec cette option, lorsqu'un personnage regarde dans une nouvelle direction suite à une commande Character.FaceLocation ou Character.FaceCharacter, il effectuera un retournement visible en utilisant les séquences définies. Si cette option n'est pas activée, il fera instantanément face à la nouvelle direction.
  • Write game text backwards (Affichage textuel inversé) - les textes du jeu seront affiché de droite à gauche, les retour à la ligne renvoyant à la droite et les derniers mots étant affichés en premier. Cette option est utile pour des langues comme l'arabe ou l'hébreu.
  • Display multiple inventory items multiple times (Copies d'objets d'inventaires affichées) - normalement, si le joueur possède deux exemplaires d'un objet d'inventaire, un seul sera visible dans la fenêtre d'inventaire. Si vous activez cette option cependant, autant de copies de l'objet seront affichées que le nombre d'exemplaires qu'en possède le joueur. Utile pour les inventaires de style RPG.
  • Save games folder name (Nom du dossier de sauvegarde) - si vous laissez le champ blanc, alors les sauvegardes seront stockées dans le dossier où le jeu est installé. Ceci n'est pas une bonne idée, car différentes utilisateurs d'un même ordinateur partageront les mêmes sauvegardes, et Windows Vista dissuade l'écriture dans le dossier Program Files. Entrez plutôt un nom de dossier de façon à ce qu'AGS le crée automatiquement dans le dossier Parties Sauvegardes (Saved Games, Vista) ou Mes Documents (My Documents, XP et précédentes distributions), et y place les fichiers de sauvegarde.

Voir aussi : Sauvegardes enrichies

Voir aussi : Explorateur de Jeux Windows

Curseurs

L'onglet Cursors (Curseurs) de l'éditeur présente les différents modes de curseur disponibles dans le jeu. Chaque mode de curseur déclenche une action différente dans le jeu. Double-cliquez pour explorer.

L'option ”StandardMode” dans la grille des propriétés indique à AGS qu'il a affaire à un mode de curseur 'normal' - c'est-à-dire que ce curseur déclenchera un événement sur tout objet sur lequel l'utilisateur cliquera, comme d'habitude. Ce mode s'applique aux modes standards Walk (Marcher), Look (Regarder), Interact (Interagir) et Talk (Parler), mais vous pouvez aussi créer d'atres modes standards. Ne cochez pas cette option pour le mode Use Inventory (Utiliser l'inventaire), puisque ce mode est un mode spécial.

L'option “Animate” (”Animer”) vous permet d'indiquer que le curseur de la souris sera animé à l'écran. Choisissez un numéro de vue (view) et le curseur s'animera en utilisant la première séquence (loop) de cette vue. Vous pouvez ne le faire s'animer qu'au survol d'un élément (zone d'interaction, objet et personnage) en activant l'option “AnimateOnlyOnHotspots” (”AnimerSeulementSurZonesInteractives”).

La case “AnimateOnlyWhenMoving” (”AnimerSeulementAuDeplacement”) vous permet de proposer un curseur dans le style QFG4, où le curseur n'est animé que lorsque le joueur le déplace.

Trois modes de curseur ont un sens intrinsèque pour AGS :

  • Mode 4 (Use Inventory - Utiliser l'Inventaire) . Ce mode est spécial car c'est le jeu qui choisit de l'utiliser ou non, selon que le joueur a sélectionné un objet d'inventaire ou non.
  • Mode 6 (Pointer - Pointeur) . Ce curseur est utilisant lorsqu'un dialogue modal est affiché (c'est-à-dire un GUI qui met le jeu en pause). Normalement ce pointeur est une flèche standard.
  • Mode 7 (Wait - Attendre) . Ce curseur est utilisé lorsque le joueur ne peut pas contrôler l'action, par exemple durant une séquence cinématique que vous aurez scriptée. Si vous voulez que le curseur disparaisse complètement durant ces phases, comme dans les jeux LucasArts, importez simplement une image vierge pour le graphisme (sprite) du curseur d'attente.

En ce qui concerne les modes standards,

  • Le mode 0 fera marcher le joueur jusqu'au point où se trouvait le curseur lors du clic.
  • Les modes 1, 2, 3, 5, 8 et 9 exécuteront l'événement nommé comme le mode du curseur.

Polices

AGS est fourni avec quelques polices (fonts) par défaut, mais vous pouvez les remplacer pour ajouter les vôtres. Vous pouvez utiliser les polices de format TrueType (TTF) et SCI (le format de police de Sierra).

Les polices SCI peuvent être créées de deux façons :

  • Extraire la police depuis un jeu Sierra, en utilisant le programme SCI Decoder disponible sur Internet.
  • Créer votre propre police et la sauver en format SCI à l'aide du programme SCI Graphic Studio.

Des polices sont également disponibles sur le site web d'AGS.

Notez que l'affichage des polices SCI est plus rapide que celui des polices TTF, pouvant ainsi accélérer l'exécution de votre jeu. Il vaut donc mieux utiliser des polices SCI si vous le pouvez.

Allez dans le nœud “Fonts” (Polices) dans l'arbre principal. Vous verrez alors la liste des polices actuellement utilisées. Vous pouvez créer une nouvelle police en effectuant un clic droit sur le nœud “Fonts” puis en choisissant “New font” (Nouvelle police). Pour remplacer une police déjà en place, ouvrez-la et appuyez sur le bouton “Import over this font” (Importez par-dessus cette police).

Les polices peuvent être surlignées. Dans un style de discours LucasArts, le surlignage est indispensable afin d'éviter que la couleur du texte ne le rende illisible sur certains arrière-plans. Pour surligner une police, vous pouvez soit définir l'option OutlineStyle à “Automatic” de façon à ce que AGS le fasse automatiquement pour vous, ou vous pouvez utiliser un bloc de police spécifique comme police de surlignage (elle sera alors affichée sous la police principale).

NOTE : Si vous allez dans votre dossier Fonts sur Windows, vous ne pourrez pas les sélectionner pour les importer puisque double-cliquer dessus les ouvrira avec le visualiseur de polices Windows. Malheureusement, il n'y a rien que je puisse faire à cela, vous devez donc soit entrer le nom du fichier manuellement, soit copier la police dans un autre dossier et l'importer à partir de ce dernier.

NOTE : La police 0 est utilisée pour afficher le texte normal, et la police 1 est utilisée pour afficher les dialogues. Pour utiliser des polices additionnelles, vous pouvez définir les propriétés Game.NormalFont et Game.SpeechFont dans votre script.

,


proprietes_avancees_des_pieces

Table des matières
    • Propriétés avancées des pièces
      • Mise à l'échelle des personnages
      • Défilement (Scrolling)
      • Importer un fichier en tant que masque de zone de déplacement (walkable area mask)
      • Arrière-plans Animés
      • Effets d'éclairage

Propriétés avancées des pièces

Cette section décrit des choses sensiblement plus avancées que vous pouvez faire avec les pièces.

Mise à l'échelle des personnages

AGS supporte la mise à l'échelle des personnages, où le personnage peut sembler diminuer de taille lorsqu'il s'éloigne de l'écran. La mise à l'échelle des personnages est une propriété des zones de déplacement (walkable areas) d'une pièce.

Si vous avez plusieurs couleurs de disponibles pour les zones de déplacement, c'est afin de vous permettre de définir un niveau de zoom pour chaque couleur, qui définit la taille du personnage lorsqu'il se trouve sur cette zone. Par défaut, toutes les zones de déplacement correspondent à 100%, c'est-à-dire la taille normale. Cependant, vous pouvez modifier cela en utilisant dans le mode “Walkable Areas” et définir par exemple une zone de 10% (un dixième de la taille) et une de 200% (taille double).

La mise à l'échelle peut affecter tous les personnages et objets du jeu. Pour les personnages, ce sera le cas par défaut mais vous pouvez la désactiver pour chacun en modifiant l'option “UseRoomAreaScaling” (”UtiliserMiseALEchelle”) dans les propriétés du personnage.

Pour les objects, la mise à l'échelle est désactivée par défaut mais vous pouvez créer un objet spécifique susceptible aux niveaux de zoom en modifiant là encore son option “UseRoomAreaScaling”.

Si vous activez l'option “UseContinuousSclaing” (”UtiliserZoomProgressif”), alors plutôt que sépcifier simplement un niveau de zoom sur toute la zone de déplacement, vous spécifiez un niveau maximum et un niveau minimum de zoom. Cela spécifie les zooms au haut et au bas de la zone de déplacement. A l'exécution du jeu, AGS calculera ces valeurs de façon à ce que le personnage soit progressivement redimensionné pour aller de la première valeur à la seconde lorsqu'il se déplace vers le haut ou vers le bas de l'écran.

Défilement (Scrolling)

Il est facile de créer des pièces à défilement (scrolling) comme celles des jeux Lucasarts comme Monkey Island ™ ou Day of the Tentacle.

Por cela, importez simplement un arrière-plan plus large que la résolution de votre jeu. Par exemple, dans un jeu en 320×200, 500×200 est une bonne taille pour une pièce dans le style Lucasarts.

C'est tout ce que vous avez à faire. Définissez les zones de déplacements, d'interaction et autres, normalement, puis sauvegardez la pièce. L'écran défilera automatiquement de façon à suivre le personnage principal dans ses déplacements.

La commande de script SetViewport vous permet de faire manuellement défiler la pièce si vous ne voulez pas qu'elle suivre le personnage.

Importer un fichier en tant que masque de zone de déplacement (walkable area mask)

AGS propose de pouvoir utiliser un fichier externe BMP ou PNG à utiliser comme masque de zone de déplacement (walkable area), d'interaction (hotspot) ou superposée (walk-behin area). Si vous n'aimez pas la façon dont vous avez à les dessiner dans l'éditeur AGS, vous pouvez les dessiner à partir d'un autre programme puis les importer. Ceci est pratique si vous convertissez un jeu que vous développiez avec un autre logiciel de création de jeu vers AGS.

Pour utiliser cette option, cliquez sur le bouton “Import Mask” (”Importer Masque”) (dans la barre d'outils) dans le mode pertinent de l'éditeur de zone. Il y a quelques restrictions sur le dessin contenu dans le fichier : il doit être exactement à la même taille que la scène d'arrière-plan, et doit être en 16 couleurs (4-bits) ou 256 couleurs (8-bits). De cette façon, la couleurs 0 sur le fichier bitmap signifie la transparence et les couleurs 1 à 15 sont utilisées comme les numéros respectifs des zones superposées/de déplacement/d'interaction.

IMPORTANT : N'utilisez PAS de numéro de couleur au-dessus de 15 dans le masque bitmap. N'utilisez que les couleurs indexées de 0 à 15 sur la palette.

Arrière-plans Animés

Si vous voulez beaucoup d'animations à l'écran, vous serez confrontés à deux problèmes si vous tentez de le faire en utilisant des objets :

  • Le nombre d'objets par pièce est limité, vous ne pourrez donc peut-être pas

animer tout ce que vous voulez de cette façon.

  • Les objets ralentissent le jeu - plus il y a d'objets à l'écran, moins le jeu

tourne vite.

La solution à ces problèmes est d'utiliser un arrière-plan animé.

Voilà comment ça fonctionne : Chaque pièce peut avoir de 1 à 5 arrière-plans. Normalement, chaque pièce a un seul arrière-plan. Cependant, vous pouvez importer jusqu'à 4 arrière-plans supplémentaires pour chaque pièce, et si vous le faites alors le jeu les passera en boucle, donnant un effet d'animation.

Cela apporte deux avantages principaux : vous pouvez animer l'écran entier, et cela ne ralentit pas du tout le jeu vu le fonctionnement du moteur.

Pour importer un second arrière-plan pour une pièce, chargez la pièce dans l'éditeur, affichez la liste “Main background” (”Arrière-plan principal”), et choisissez l'option “Import new background” (”Importer un nouvel arrière-plan”). Choisissez le fichier qui contient l'arrière-plan que vous voulez et c'est bon.

Pour supprimer un arrière-plan, sélectionnez-le puis cliquez sur le bouton “Delete” (”Supprimer”).

Vous pouvez définir la vitesse d'animation des arrière-plans en ajustant l'option “BackgroundAnimationDelay” (”DelaiAnimationArrierePlan”) dans la grille des propriétés de la pièce. Vaut 5 par défaut, ce qui correspond à un changement d'arrière-plan tous les 5 cycles.

NOTE : Tous les arrière-plans doivent être de la même taille.

NOTE : (en 256 couleurs seulement) Les images d'arrière-plan possèdent chacune leur palette (à moins que vous ne sélectionniez “Share palette with main background” – ”Partager la palette de l'arrière-plan principal” – avant d'importer). Cela signifie que lorsque l'image permute dans le jeu, la palette sera réinitialisée - ainsi vous ne pouvez pas utiliser d'effets spéciaux sur la plaette comme CyclePalette ou SetPalRGC dans les pièces avec un arrière-plan animé.

Effets d'éclairage

Vous pouvez contrôler la brillance de vos personnages, à l'aide du réglage “LightLevel” (”NiveauLuminosité”) pour les Regions des pièces.

Elle vaut 100% par défau, mais vous pouvez la modifier de 0% à 200%. Ce nombre correspond au niveau de luminosité sur la zone de déplacement (walkable area) courante. De plus petits nombres signifient plus sombre, 0% rendant ainsi le tout noir et 200% très brillant.

Cette option peut être utile si, par exemple, vous avez un réverbère sur votre écran et si le personnage doit s'éclairer lorsqu'il marche dessous, ou si un mur prive un personnage de lumière et qu'il doit alors s'assombrir.

Vous pouvez aussi utiliser une teinte de couleur pour la région. Si vous sélectionnez cela, alors vous pouvez entrer des valeurs Rouge (Red), Vert (Green) et Bleu (Blue) allant de 0 à 255, qui définissent la teinte que vous voulez que la zone prenne. Le réglage Amount (Quantité) détermine dans quelle mesure les personnages seront teintés, et vaut de 0 à 100.

NOTE : Les niveaux de lumière ne fonctionnent que si le graphisme du personnage est à la même profondeur de couleurs que l'arrière-plan (c-à-d un personnage en 256 couleurs dans un jeu hautes couleurs ne sera pas affecté).

NOTE : Dans un jeu 256 couleurs, seules les zones assombrissantes (niveau de lumière < 100%) fonctionneront. Aussi, selon la palette de la pièce, la qualité de l'assombrissement variera dans un jeu 256 couleurs.

NOTE : Les niveaux de lumière affectent les personnages et les objets, selon le réglage de “UseRoomAreaLighting” (”UtiliserEclairageZonesPiece”) de chacun. Ils n'affectent pas les calques ou les images d'arrière-plan.


autres_fonctionnalites

Autres fonctionnalités

Cette section décrit les caractéristiques d'AGS non couverts par le tutoriel.

Musique et son

Editer les GUI

Diffuser votre jeu

Faire une copie de sauvegarde de votre jeu

L'analyseur de texte

Traductions

Les variables Globales

Propriétés Personnalisées

Greffons

Synchronisation des lèvres

Modèles de jeu

Options de débogage

Auto-numérotation des fichiers de doublage

Intégration dans Windows

Intégration de la gestion des versions


musique_et_son

Le son et la musique représentent un aspect essentiel de l'expérience vidéoludique, et AGS 3.2 offre désormais un système audio remanié qui vous donne un contrôle total sur la partie audio de votre jeu.

Formats des fichiers

AGS sait lire les types de fichiers audio suivants : OGG, MP3, MIDI, WAV (décompressé), MOD, XM, IT, S3M et VOC.

La seule limitation à ceci est qu'AGS n'est capable de lire qu'un seul fichier MIDI à la fois. Si vous essayez de jouer deux fichiers MIDI simultanément, le premier sera coupé lorsque le second commencera à être lu.

Si vous n'avez jamais entendu parler de OGG auparavant, il s'agit d'un format de musique digital, similaire au MP3, mais qui propose une meilleure compression pour une qualité supérieure. Plus important, il s'agit d'un format totalement libre, vous n'avez donc besoin de payer aucune royalty ou autorisation pour l'utiliser. Pour plus d'information et des logiciels vous permetant d'encoder votre musique au format OGG, visitez http://www.vorbis.org/

Audio dans l'éditeur

Inspectez la branche “Audio” dans l'arborescence du projet. Vous y trouverez des nœuds nommés “Speech” (”Doublage”), “Types” et deux dossiers nommés “Music” et “Sounds” (“Musique” et “Sons”).

Doublage vocal

Pour le moment, les fichiers de doublage vocal ne se gèrent pas directement dans l'éditeur. Consultez la page d'aide Doublage pour en savoir plus sur cette fonctionnalité.

Types Audio

Les Types Audio vous permettent de regrouper les types similaires de fichiers audio. On distinguera communément les Musiques et les Sons, les Musiques étant généralement jouées une à la fois alors que vous pouvez vouloir jouer plusieurs effets sonores simultanément.

Double-cliques sur un Type Audio pour l'ouvrir ; ses propriétés s'affichent dans la grille des propriétés. Le réglage “MaxChannels” vous permet de définir combien de séquences audio de ce type peuvent être jouées à la fois. Le réglage “VolumeReductionWhenSpeechPlaying” vous permet de réduire automatiquement le volume de ces séquences audio lorsque du dialogue est joué, afin que le joueur puisse entendre plus facilement les voix que la musique.

Les réglages par défaut vous conviendront sans doute et vous n'aurez pas besoin de les changer dans la plupart des jeux.

Importer des fichiers audio

La question majeure maintenant – comment ajouter du son et de la musique dans votre jeu ? Eh bien, si vous faites un clic droit sur les dossiers “Sound” (Son) ou “Music” (Musique) (ou tout autre dossiers que vous créez), vous verrez une option “Add Audio Files” (Ajouter Fichiers Audio).

Sélectionnez cette option et une fenêtre s'affichera pour que vous sélectionniez les fichiers audio à importer. Une fois importés, des noms de script leur seront assignés automatiquement.

Double-cliquez sur un fichier audio dans l'arbre du projet pour ouvrir une fenêtre qui vous permettra de l'écouter ainsi que de modifier ses propriétés dans la grille des propriétés.

Jouer du son dans le jeu

Le script pour jouer une séquence audio dans le jeu est très simple. Par exemple :

aExplosion.Play();

jouera la séquence audio appelée aExplosion.

Priorités des canaux

AGS possède actuellement un système audio à 8 canaux, ce qui signifie que jusqu'à 8 sons peuvent être joués à la fois. Avec les réglages par défaut pour les Types Audio, un canal est réservé au doublage, un à la musique et un pour les sons ambiants ; ce qui vous en laisse 5 disponibles pour les effets sonores.

Si vous essayez de jouer une séquence audio et qu'il n'y a aucun canal de disponible, alors un canal occupé sera libéré et la séquence qu'il jouait sera remplacée par la nouvelle. Cependant, cela n'aura lieu que si la nouvelle séquence audio a une priorité égale ou supérieure à celle du son en cours de lecture.

La priorité vous permet ainsi de décider quelles séquences audio sont plus importantes que les autres. Par exemple, vous pourriez définir un son de pas avec une priorité basse et un son de porte qui s'ouvre avec une priorité haute. Cela peut être défini au niveau du dossier dans l'éditeur, mais aussi en changeant les propriétés d'une séquence audio individuelle (qui hérite par défaut de la priorité du dossier qui la contient).

Parfois vous pourriez ne pas vouloir que la priorité du son soit définie dans l'éditeur – vous pourriez vouloir la définir dans le script lorsque vous lancez la séquence. C'est pourquoi la commande Play présente un paramètre optionnel qui vous permet de spécifier explicitement la priorité, par exemple :

aExplosion.Play(eAudioPriorityLow);

jouera la séquence aExplosion avec une priorité basse.

Déplacement et contrôle du volume

Alors, comment manipule-t-on un son en cours de lecture ? Eh bien, il n'existe aucune méthode Audio Clip (Séquence Audio) à cet effet car vous pourriez vouloir jouer deux copies du même son à la fois, et alors AGS ne saurait pas auquel vous voulez accéder. C'est là que les Canaux Audio viennent à votre rescousse.

Lorsque vous utilisez la commande Play(), AGS retourne un élément AudioChannel* représentant le canal sur lequel le son est joué. Vous pouvez le garder en mémoire dans une variable globale et y accéder plus tard. Par exemple :

AudioChannel* canal = aExplosion.Play();
canal.Volume = 20;

Ceci lancera la séquence aExplosion et définira son volume à 20%.

Utiliser les Canaux Audio

Supposez que vous vouliez lancer un son maintenant et changer son volume ou son équilibrage plus tard. Comment feriez-vous ? Eh bien il vous faudrait garder l'élément AudioChannel sous le coude, de façon à pouvoir y accéder à nouveau plus tard. La façon la plus simple de le faire est de créer une Variable Globale ; si vous ouvrez l'éditeur de Variables Globales (Global Variables), vous pouvez créer une nouvelle variable AudioChannel* (appelons-la longSonOrageux). Ensuite, lorsque vous lancez le son vous procédez comme suit :

longSonOrageux = aExplosion.Play();

plus tard, ailleurs dans le script, vous pouvez changer le volume comme cela :

if (longSonOrageux != null)
{
  longSonOrageux.Volume = 20;
}

Notez la vérification (différent de null) ici – cela pour s'assurer que le jeu ne crashera pas si le son n'est pas en cours de lecture (il pourrait être terminé ou pas encore lancé).

Volume général

Il existe une propriété System.Volume qui contrôle le volume général du jeu, que vous pouvez utiliser comme une sorte de contrôle du volume par curseur pour le joueur. Le volume de chaque son est déterminé relativement à ce volume général.

Conclusion

Le nouveau système audio d'AGS vous donne plus de contrôle sur l'aspect audio de votre jeu. Consultez les sections suivantes pour une liste complète des commandes supportées :

Commandes AudioClip,
Commandes AudioChannel,
Doublage,
Le dossier AudioCache

Doublage

AGS vous permet d'associer une ligne de dialogue à un fichier son, afin de proposer un jeu “parlant”. Supposons que vous ayez un script de dialogue commençant comme cela :

ego: "Salut, tu vas bien ?"
david: "Très bien."

En temps normal ces lignes s'affichent textuellement au-dessus des têtes des personnages. Cependant, vous pouvez ajouter le caractère spécial '&' pour signaler qu'un fichier audio devrait également être lancé. Le nom du fichier correspondra aux quatre premières lettres du nom de script (script name) du personnage suivies d'un nombre d'identification. Par exemple,

ego: &10 "Salut, tu vas bien ?"
david: &7 "Très bien."

Cela lancera le fichier EGO10.WAV à l'affichage de la première ligne, puis le fichier DAVI7.WAV à l'affichage de la seconde. Lorsqu'une ligne de texte est associée à un fichier voix, le texte affiché à l'écran ne sera effacé que lorsque la lecture du fichier audio sera terminée. Si le joueur l'interrompt en cliquant ou en pressant une touche, le texte ainsi que la voix seront stoppés. Ces fichiers audio doivent être placés dans le sous-répertoire “Speech” du dossier du jeu.

Vous pouvez aussi utiliser cette option avec la commande Say.

cEgo.Say("&10 Salut, tu vas bien ?");
cDavid.Say("&7 Très bien.");

NOTE : Vous pouvez utiliser les formats de fichiers WAV, OGG et MP3.

NOTE: Vous ne pouvez pas utiliser des nombres supérieurs à 9999. Cela signifie que vous pouvez utiliser des fichiers de EGO1.OGG jusqu'à EGO9999.OGG, mais vous ne pouvez pas utiliser EGO10000.OGG ou supérieur.

Les fichiers vocaux sont compilés dans un fichier nommé SPEECH.VOX, à l'écart du reste des données de votre jeu de façon à ce que vous puissiez le proposer comme une option supplémentaire à télécharger. Sans ce fichier, le jeu fonctionnera normalement, sans discours vocal.

Voir aussi : fonction SetVoiceMode.

Le dossier AudioCache

Si vous importez des fichiers audio dans AGS, vous remarquerez probablement qu'un dossier, nommé AudioCache, commence à se remplir de fichiers dans votre répertoire de jeu. De quoi s'agit-il et pourquoi est-ce là ?

Eh bien lorsque vous importez un élément audio dans AGS, cela peut se faire à partir de n'importe quel support – votre disque dur, mais aussi une clé USB ou un CD. Il n'est pas raisonnable qu'AGS aille chercher à cet endroit à chaque fois, puisque vous êtes susceptible de retirer la clé USB ou de supprimer ses fichiers.

Ainsi, lorsque vous importez un fichier audio dans AGS, celui-ci en crée une copie dans le dossier AudioCache. AGS se souvient aussi d'où provient le fichier, et lorsque vous compilez votre jeu, il vérifiera si le fichier du dossier d'origine a été mis à jour – et il copiera la version la plus récente dans AudioCache si c'est le cas.

Mais si le fichier source n'existe plus, votre jeu pourra continuer à être compilé sans soucis puisqu'AGS possède sa propre copie.

Ceci permet à AGS de coller à un de ses principes de base, selon lequel tous les fichiers dont vous avez besoin pour compiler votre jeu se trouvent dans son dossier même. De cette façon, en faisant une copie de sauvegarde du dossier de votre jeu, vous savez que vous êtes en totale sécurité même si le pire se produit.

,


editer_les_guis

Table des matières
    • Editer les GUI
      • Boutons de GUI
      • Texte d'interface
      • Fenêtres de texte personnalisées
      • Inventaire personnalisé
      • Barres de défilement
      • Zones de saisie
      • Listes

Editer les GUI

L'interface du jeu repose sur différents GUI. Chaque GUI est une région rectangulaire de l'écran qui est dessiné par-dessus l'arrière-plan. Chacun peut être défini comme :

  • toujours affiché (par exemple la ligne statut dans les jeux Sierra)
  • s'affichant lorsque la souris arrive à un certain endroit (ex : barre d'icône Sierra)
  • s'affichant suite à une commande de script seulement

L'interface par défaut est constituée de deux GUI - la ligne de statut et la barre d'icônes.

Allez à l'onglet “GUIs” de l'arborescence principale. Tous les GUI du jeu y sont listés – double-cliquez pour en éditer un. Pour en créer un nouveau, faites un clic droit sur le noeud “GUIs” et choisissez “New GUI” (”Nouveau GUI”).

Une fois que vous avez ouvert un GUI, vous verrez le GUI lui-même dans la fenêtre princpale, et ses réglages peuvent être modifiées dans la grille Properties (Propriétés). Ceci vous permet de changer la couleur ou l'image d'arrière-plan, et de définir la position ou la taille du GUI parmi d'autres choses.

La propriété “Visibility” (”Visibilité”) vous permet de définir quand le GUI sera affiché. Vaut “Normal” par défaut, ce qui signifie que le GUI sera initialement visible, bien qu'il puisse être caché si vous utilisez une commande GUI.Visible=false dans game_start.

L'option “Popup modal” signifie que le GUI sera initialement caché et doit être activé par une commande de script. Avec cette option, le jeu se mettra en pause lorsque le GUI sera affiché, et durant ce temps les fonctions on_mouse_click et on_key_press ne seront pas exécutées.

L'option “Mouse YPos” (”Position Y de la Souris”) signifie que le GUI n'apparaît que lorsque la position verticale de la souris se déplace au-dessus de la coordonnée Y définie dans l'option “Popup-YP”.

“Persistent” est similaire à “Normal”, sauf que ce GUI ne sera pas effacé lors d'une cutscene même si vous avez choisi “GUIs turn off when disabled” (”Les GUI s'effacent lorsqu'ils ne sont pas actifs”) dans les réglages généraux. Pratique si vous voulez que la plupart de vos GUI s'effacent, sauf une ligne de statut ou autre.

Le réglage “Z-Order” (”Couche Z”) vous permet de définir dans quel ordre les GUI sont dessinés - c'est-à-dire lorsque deux GUI se chevauchent, lequel sera dessiné par-dessus. Le réglage Z-Order est un nombre arbitraire entre 0 et 1000. AGS dessine les GUI dans l'ordre, du plus petit nombre à l'arrière-plan jusqu'au plus grand nombre au premier plan.

La réglage “Clickable” vous permet de définir si le GUI et ses boutons réagissent aux clics de souris. Ceci est activé par défaut, mais si vous le désactivez et que le joueur clique sur le GUI, le jeu traitera le clic comme s'il avait cliqué sous le GUI, sur ce qu'il y a vraiment dans la pièce. Utile pour des GUI transparents quie ne sont utilisés que pour afficher de l'information.

Vous remarquerez que les GUI ont des noms. Ils peuvent être utilisés dans le script de la même façon que les noms de personnage. Par exemple, si un GUI a le nom “gBarreIcones”, vous pouvez utiliser les scripts comme ça :

gBarreIcones.Visible = true;

Boutons de GUI

Pour proposer une interface interactives, vous utiliserez les boutons.

Pour ajouter une bouton, cliquez sur le bouton “Add button” (”Ajouter bouton”) dans la barre d'outils, puis dessinez un rectangle sur le GUI avec la souris. Vous le verrez s'afficher comme un bouton textuel, rempli du texte “New button” (”Nouveau bouton”). Remarquez que la fenêtre Properties (Propriétés) affiche désormais les propriétés de votre nouveau bouton plutôt que celles du GUI.

En utilisant la fenêtre des propriétés, vous pouvez définir une image pour le bouton plutôt que du texte, et vous pouvez aussi définir d'autres attributs assez clairs. Vous définissez ce qui se passe lorsque le joueur clique sur le bouton en utilisant l'attribut “Click Action” (”Action de Clic”). Il peut valoir “Run Script” (”Exécuter Script”) (par défaut), mais aussi “Set mode” (”Définir mode”), qui change le mode de curseur pour le mode spécifié dans la propriété “New mode number” (”Numéro du nouveau mode”).

Pour supprimer un bouton, faites un clic droit dessus et choisissez Delete (Supprimer).

Texte d'interface

Vous pouvez facilement afficher du texte statique sur votre interface. Par exemple, les interface dans le style Sierra affichent le score dans la barre de statut.

Pour afficher du texte dans un GUI, vous aurez besoin d'une étiquette (label). Cliquez sur le bouton “Add label” (”Ajouter étiquette”) dans la barre d'outils, puis tracez un rectangle comme vous l'avez fait pour le bouton. Vous pouvez changer le texte affiché dans l'étiquette en éditant la propriété “Text”. Remarquez que le texte s'adapte automatiquement pour entrer dans le rectangle que vous avez tracé.

En plus du texte normal que vous pouvez entrer dans une étiquette, vous pouvez ajouter certains mot-clés spéciaux qui permettent au texte de changer de valeur durant le jeu. Les mot-clés suivants seront remplacés par les valeurs pertinentes dans le jeu :

 @GAMENAME@    Le nom du jeu, spécifié dans l'onglet Game Settings (Réglages du Jeu)
 @OVERHOTSPOT@ Le nom de la zone d'interaction (hotspot) sur laquelle se trouve le curseur
 @SCORE@       Le score actuel du joueur
 @SCORETEXT@   Le texte "Score: X of XX" ("Score : X sur XX") rempli avec les nombres correspondants
 @TOTALSCORE@  Le score maximum possible, défini dans l'onglet Game Settings (Réglages du Jeu)

Exemple : Vous avez @SCORE@ points sur @TOTALSCORE@.

La fenêtre de propriétés vous permet aussi d'aligner le texte à gauche, à droite ou au centre, ainsi que de modifier la couleur et la police utilisées.

Fenêtres de texte personnalisées

Si vous voulez ajouter une touche personnelle aux fenêtres de texte blanches qui affichent tous les messages durant le jeu, vous pouvez créer une bordure à l'aide de l'éditeur de GUI. Faites un clic droit sur le noeud “GUIs”, et choisissez “New Text Window GUI” (”Nouveau GUI fenêtre de texte”).

L'élément sera redimensionné à environ 1/4 de l'écran, et vous verrez 8 images - une dans chaque coin et une de chaque côté. Ce sont les images de bordure. Vous changez les images des coins de façon normale.

Dans le jeu, les images des coins seront placées aux coins respectifs de la fenêtre de texte, et les images de côtés seront répétées tout le long du bord de la fenêtre. Pour informer le jeu que vous utilisez votre style personnalisé de fenêtre textuelle, allez dans l'onglet General Settings, et cochez “Text windows use GUI” (”Les fenêtres de texte utilisent un GUI”). Ensuite, entrez le numéro du GUI que vous voulez utiliser.

Vous pouvez aussi définir une image d'arrière-plan pour la fenêtre de textes. Dans l'éditeur de GUI, définissez simplement une image d'arrière-plan pour l'élément GUI. L'image que vous spécifiez ne sera ni étirée ni affichée en mosaïque dans le jeu ; toutefois elle sera rognée pour entrer dans la fenêtre. Vous devriez utilise une image d'au moins 250×80 pixels pour vous assurer qu'elle rempli entièrement la fenêtre.

Pour définir la couleur du texte dans la fenêtre, définissez simplement la couleur de premier plan (Foreground Colour) du GUI et ce sera celle utilisée pour afficher le texte des messages.

Inventaire personnalisé

Une autre option que vous pouvez avoir remarquée dans l'éditeur GUI est le bouton “Add Inventory” (”Ajouter Inventaire”). Ceci vous permet de tracer un rectangle qui affichera l'inventaire en cours du joueur, de la façon que le font les jeux Lucasarts. Pour pouvoir faire défiler la fenêtre d'inventaire, vous aurez besoin de boutons Haut et Bas, et d'y attribuer des scripts qui appellent les fonctions adéquates comme InvWindow.ScrollUp et InvWindow.ScrollDown.

Pour voir la liste complète des commandes disponibles pour les fenêtres d'inventaire, consultez la section Fonctions et propriétés des inventaires.

Barres de défilement

Vous pouvez désormais ajouter des barres de défilement (sliders) à vos GUI. Ceci vous permet d'offrir une interface élégante au joueur pour qu'il puisse régler des aspects comme le volume ou la vitesse du jeu à l'aide d'un curseur. Pour ajouter une barre de défilement, cliquez sur le bouton “Add slider” et tracez un rectangle comme vous le feriez pour un bouton. Vous pouvez aussi redimensionner la barre en glissant le coin inférieur droit de la même façon que pour un bouton.

Les barres de défilement peuvent être verticales ou horizontales. La direction dans laquelle elles sont tracées est automatiquement calculée selon la dimension du cadre - si elle est plus large que haute, vous aurez une barre horizontale, sinon vous en aurez une verticale.

Dans les propriétés des barres de défilement, vous pouvez définir un minimum, un maximum et une valeur courante pour le curseur. En jeu, l'utilisateur pourra le faire glisser de MIN à MAX, le curseur étant initialement positionné à VALUE. Pour les barres de défilements horizontales, MIN est à gauche et MAX à droite, pour les verticales, MAX est en haut et MIN est en bas.

Lorsque le joueur déplace le curseur dans la barre, l'événement OnChange est appelé. Cela signifie que s'ils le déplacent continuellement de haut en bas, l'événement sera appelé sans discontinuer.

Votre script peut récupérer la valeur du curseur à l'aide de la propriété Slider.Value.

Zones de saisie

Une zone de saisie (Text Box) est un outil simple qui permet au joueur de passer des informations à votre jeu. L'ajout d'une zone de saisie se fait comme l'ajout de tout autre élément de GUI.

Si une zone de saisie est affichée dans un GUI, lorsque le joueur pressera une touche (une lettre, la touche Entrée, la touche de correction) elle sera dirigée vers la zone de saisie plutôt que passer à la fonction on_key_press. Lorsque le joueur appuie sur Entrée (Return) dans la zone de saisie, l'événement OnActivate est appelé. Vous pouvez alors utiliser la propriété TextBox.Text pour récupérer ce qui a été tapé.

Listes

Les listes vous permettent d'ajouter une liste de lignes à votre GUI. Cela peut être utile pour afficher une boîte de sauvegarde/chargement, permettant au joueur de choisir diverses options.

Vous utilisez les fonctions ListBox pour manipuler les listes - par exemple, ListBox.AddItem pour ajouter une ligne, ou ListBox.SelectedIndex pour récupérer la sélection actuelle.

L'événement OnSelectionChanged est déclenché lorsque le joueur clique sur une ligne dans la liste. Vous pouvez l'ignorez si vous n'en avez pas l'utilité.

,


diffuser_votre_jeu

Table des matières
      • Diffuser votre jeu
      • Icône personnalisée
      • Diviser les fichiers ressource

Diffuser votre jeu

Lorsque choisissez l'option “Build EXE” (Construire EXE) dans l'editeur, un sous-répertoire “Compiled” (”Compilé”) est créé dans le dossier de votre jeu, qui contiendra tous les fichiers nécessaires à la distribution de votre jeu. Basiquement, ce sera simplement l'exécutable de votre jeu et le programme de configuration (setup), mais vous pouvez aussi avoir les fichiers des ressources audio et vocales (MUSIC.VOX et SPEECH.VOX) ; et si vous avez choisi de diviser les fichiers ressource, vous aurez aussi plusieurs fichiers nommés “game.001”, “game.002”, etc.

Ainsi, lorsque vous voulez mettre votre jeu sur internet, zippez simplement les fichiers du dossier Compiled, et allez-y !

NOTE : Il n'est pas possible de charger le fichier exe depuis l'éditeur AGS. Cela signifie deux choses lorsque vous n'avez accès qu'au fichier EXE : (1) les autres personnes ne peuvent pas éditer les données de votre jeu, et (2) vous ne le pouvez pas non plus. Gardez toujours une copie des autres fichiers produits (*.CRM, GAME.AGS, etc) puisque ce sont ceux que l'éditeur requiert pour charger votre jeu afin de l'éditer.

ASTUCE : Vous pouvez créer un écran de style “Chargement…” à afficher lorsque votre jeu démarre. Pour cela, sauvez simplement l'image avec PRELOAD.PCX comme nom (elle doit être dans la même résolution et à la même profondeur de couleurs que le jeu) dans le dossier du jeu, et compilez le jeu. Elle s'affichera ensuite lorsque le jeu se charge.

NOTE : Puisqu'AGS utilise du code sous licence, votre documentation doit citer ce qui suit :

L'affichage des polices TrueType utilise la police ALFont par Javier Gonzalez et le projet Freetype. Diffusé sous les termes de la licence du projet FreeType.

Le lecteur OGG est alogg par Javier Gonzalez, et utilise le décodeur Ogg Vorbis, qui est disponible sur http://www.xiph.org/ Copyright © 2002-2008, Xiph.org Foundation

Le lecteur MP3 est almp3, par Javier Gonzalez et l'équipe FreeAmp. Il utilise le décodeur mpg123 MP3, et est distribué sous les termes de la licence GNU Lesser General Public License version 2.1.

Vous devriez aussi inclure tous les fichiers license_* du répertoire DOCS dans votre jeu.

IMPORTANT : Si vous avez l'intention de gagner de l'argent avec votre jeu, que ce soit un shareware ou un jeu commercial, il est impératif que vous lisiez la page Legal Information sur le site d'AGS, actuellement à l'adresse http://www.bigbluecup.com/aclegal.htm

NOTE : Le fichier AUDIO.VOX contient les séquences audios que vous avez notées comme ”InSeperateVox” (”distribuées séparément”) dans l'éditeur. Cela vous permet de proposer un fichier audio à télécharger optionnellement, si votre jeu utilise beaucoup de fichiers sonores ou si vous ne voulez pas que le joueur soit obligé de les télécharger.

Icône personnalisée
Diviser les fichiers ressource

Icône personnalisée

Si vous le désirez, vous pouvez utiliser votre propre icône personnalisée lorsque vous compilez le fichier EXE Windows. Pour cela, placez simplement votre icône dans le dossier de votre jeu, et renommez-la USER.ICO. Puis, chargez l'éditeur et sauvez le jeu.

AGS n'est capable de compiler votre icône personnalisée que si vous exécutez l'éditeur sur Windows 2000, XP ou Vista. Si vous utilisez Windows 98 alors votre jeu sera compilé avec l'icône AGS standard.

NOTE : L'icône doit être un véritable fichier Windows .ICO, pas simplement un fichier BMP renommé. Les éditeurs d'icône, comme AX-Icons depuis http://www.axialis.com, feront la conversion pour vous.

Vous pouvez aussi avoir une icône personnalisée pour le programme de configuration (Setup) généré. Pour cela, créez votre icône comme décrit plus haut mais nommez-la setup.ico dans le dossier du jeu.

Diviser les fichiers ressource

Certaines personnes ont trouvé que lorsque leur jeu devenait lourd, le seul fichier EXE était lent à cause des vérifications anti-virus sur l'intégralité du fichier. AGS prévoit une option pour diviser les fichiers ressource en parties plus petites pour éviter cela. Dans l'onglet General Settings (Réglages Généraux) vous remarquerez une option “Split resource files into X Mb sized chunks” (”Diviser les fichiers ressource en parties de X Mb”).

Si vous la cochez, alors entrez un nombre comme 1 ou 2, puis sauvez le jeu, alors les données du jeu seront séparées en parties de cete taille, nommées GAME.001, GAME.002, etc.

Quelques ressources sont tout de même compilées dans le fichier EXE mais toutes les pièces seront placées dans d'autres fichiers. Si vous utilisez cette option, vous devrez diffuser le fichier EXE de votre jeu plus les fichiers GAME.00N.


faire_une_copie_de_sauvegarde_de_votre_jeu

Vous voudrez sans doute sauvegarder vos fichiers de jeu, et cela doit être fait régulièrement au cours du développement de votre jeu. Mais quels sont les fichiers que vous devez sauvegarder ?

Au moment de faire une copie de sauvegarde (back up), assurez-vous que vous copiez TOUS les fichiers listés ci-dessous :

  • GAME.AGF - c'est le principal fichier de données de votre jeu, il contient la quasi-totalité des paramètres du jeu. Sans ça, votre jeu est perdu.
  • ACSPRSET.SPR - c'est le fichier des “sprites” (images) de votre jeu, il contient toutes les “sprites” (images) du “sprite manager” (gestionnaire d'images).
  • ROOM*.CRM - tous les ROOM*.CRM sont les fichier de vos “rooms” (pièces), et bien sûr sans l'un d'entre eux vous ne serez plus en mesure d'aller dans la pièce concernée.
  • *.ASC, *.ASH - ce sont tous vos fichiers script, qui contiennent tous les scripts que vous avez écrit.
  • *.TRS - fichiers source des traductions. Ils contiennent toutes les traductions que vous avez faites.
  • AGSFNT*.TTF, AGSFNT*.WFN - Ces fichiers contiennent toutes les polices (fonts) que vous avez importées.

Pensez également à sauvegarder les sons, musiques et fichiers vidéo que vous utilisez.


l_analyseur_de_texte

L'analyseur de texte

Vous pouvez désormais utiliser un analyseur de texte dans vos jeux, comme le faisaient les plus anciens jeux Sierra. Dans l'éditeur, allez dans le panneau “Text parser” (Analyseur de texte). Là, vous verrez une courte liste de mots qui vous sont fournis. Chaque mot a un nombre à côté de lui.

Basiquement, vous ajoutez le mot que vous voulez utiliser par un clic droit sur la liste, et sélectionnez “Add word” (ajouter mot). Toutefois, le véritable intérêt de l'analyseur est sa capacité à reconnaître des synonymes - lorsque deux mots signifient la même chose. Par exemple, si vous voulez que le joueur tape “look at fence” (regarder la clôture), il pourrait taper à la place “look at wall” (regarder le mur), si c'est sa façon de voir le dessin. Où un anglais taperait ”colour” , un américain tapera peut-être ”color”, les deux devraient avoir le même effet.

Pour ajouter un synonyme à un mot existant, sélectionnez le mot. Faites un clic droit dessus et choisissez “Add synonym” (ajouter synonyme). Vous remarquerez que le nouveau mot donne le même nombre que l'ancien. Tous les mots avec le même nombre sont considérés comme identiques par l'analyseur.

Vous remarquerez que la liste fournie a beaucoup de mots avec le numéro 0. Il s'agit d'un numéro spécial, qui indique que l'analyseur doit ignorer complètement le mot. Dans notre exemple précédent, le joueur devait taper “look at the fence”, “look at fence”, ou juste “look fence”. En ajoutant des mot comme “at” et “the” dans la liste à ignorer, ils sont enlevés automatiquement des entrées tapées par l'utilisateur. Pour ajouter de nouveaux mots à ignorer, il suffit de les ajouter comme synonymes.

Comment utiliser l'analyseur de texte ? Eh bien vous aurez besoin d'une zone de saisie (Fonctions et propriétés des zones de saisie de GUI (Text Box)) dans un GUI quelque part pour permettre au joueur d'entrer du texte, ou vous pouvez simplement utiliser la commande InputBox (mais elle présente une longueur de ligne assez restreinte).

Lorsque l'utilisateur a entré son texte (vous le détecterez certainement par le déclenchement de l'événement associé à la TextBox), appelez la fonction Parser.ParseText pour dire à AGS quelle chaîne de texte utiliser dans les commandes suivantes. Vous pourrez ensuite simplement utiliser la commande Said pour tester ce que le joueur a entré.

Tapez la phrase entière (SANS mettre les mots ignorés), et AGS la comparera à ce que l'utilisateur a entré, en considérant tous les synonymes comme équivalents. Par exemple (en supposant que notre TextBox est appelée “txtUserInput”) :

  String input = txtUserInput.Text;
  Parser.ParseText(input);
  if (Parser.Said("regarder barrière")) {
    Display("C'est une vieille barrière en bois.");
  }
  if (Parser.Said("manger pomme")) {
    Display("Vous adoreriez, mais vous n'en avez pas.");
  }

Il y a deux mots spéciaux que vous pouvez utiliser avec la commande Said. “anyword” (n'importe quel mot) correspondra à n'importe quel mot que l'utilisateur entrera. Par exemple, Said(“jeter anyword”) fera correspondre “jeter dague”, ou “jeter ordure”. “rol” (raccourci pour Rest-of-Line – Reste-de-la-Ligne) fera correspondre au reste de ce que l'utilisateur a entré. Ainsi, vous pourrez faire :

if (Parser.Said("tuer rol")) {
  Display("Vous n'êtes pas quelqu'un de violent.");
}

Ainsi, si le joueur essaie de tuer quoique ce soit, il obtiendra toujours la même réponse.

Parfois, vous désirerez peut-être accepter deux mots différents, qui ne sont pas synonymes, comme désignant la même chose. Par exemple, les mots “prendre” et “manger” ont habituellement des sens totalement différents, vous ne voudrez donc pas en faire des synonymes. Toutefois, si le joueur possède une pillule contre les maux de crâne, par exemple, alors “prendre la pillule” et “manger la pillule” pourraient être tous les deux valides. C'est ici que la virgule ”,” devient pertinente : si vous incluez une virgule dans le texte, tous les synonymes et les mots séparés par la virgule correspondront. Ainsi :

if (Parser.Said("manger,prendre pillule"))

correspondra à “manger” ou “prendre” et à tous leurs synonymes suivis de pillule ou d'un de ses synonymes.

Une autre tâche fréquente avec un analyseur est de vérifier des mots facultatifs - par exemple, s'il y a une un mur de briques à l'écran, vous voudrez que le joueur puisse entrer “regarder mur” et “regarder mur de briques”. Bien que cela puisse être réalisé par le test de deux commandes Said, AGS propose une façon plus simple. Vous pouvez utiliser les [crochets] pour signifier un mot optionnel. Ainsi :

if (Parser.Said("regarder mur [de brique]"))

correspondra à “regarder mur” et “regarder mur de brique”.

Tout ça est très bien, mais les objets avec lesquels vous interagissez dépendent de la pièce où vous vous trouvez - par exemple, dans une pièce il peut y avoir un arbre auquel le joueur devrait pouvoir faire référence avec “regarder arbre”, ou autre. Définir tout cela dans votre script global serait très contraignant et peu lisible. Utilisez alors la fonction CallRoomScript. Ainsi, vous pouvez faire comme suit :

  Parser.ParseText(input);
  String badWord = Parser.SaidUnknownWord();
  if (badWord != null)
    Display("Vous ne pouvez pas utiliser '%s' dans ce jeu.", badWord);
  else if (Parser.Said("manger pomme")) {
    Display("Vous adoreriez, mais vous n'en avez pas.");
  }
  ... // autres commandes du jeu
  else
    CallRoomScript (1);

Alors, le script de la pièce peut voir ce que le joueur peut faire dans la pièce actuelle. Voir la description de CallRoomScript pour plus d'information.

,


Traductions

Maintenant AGS rend plus facile les traductions de vos jeux. Clic-droit sur “Translations” (Traductions), et choisissez “New translation” (nouvelle traduction). Une fois que vous l'avez nommée, AGS vous demandera si vous voulez remplir le fichier maintenant. Dites YES (OUI).

La création de la traduction écrit toutes les lignes de texte du jeu dans un fichier - “no script sources”, ou se trouvent seulement les textes affichables dans la jeu. Le fichier génère chaque ligne de texte, séparée par une ligne vide.

Vous pouvez maintenant donner ce fichier à vos traducteurs. Ils ne doivent remplir que les lignes vides correspondant au texte en anglais au dessus (important : Ne pas remplacer les lignes originales en anglais par la traduction) ** . Si une ligne est laissée en blanc, elle ne sera simplement pas traduite.

Une fois la traduction finie, clic-droit sur traduction et choisir “Compile”. Elle sera convertie en un fichier compilation de traduction (.TRA) dans le dossier Compiled (compilé), il pourra être utilisé avec le moteur de jeu.

Exécutez le programme d'installation du jeu, et sélectionnez la traduction de la liste déroulante. Ensuite, exécutez le jeu, et tout le texte devrait être traduit.

NOTE : Avec les polices (fonts) SCI, seuls 128 caractères sont disponibles, ainsi certains caractères pour une traduction non-anglaise ne seront pas disponibles. Vous devrez d'utiliser des caractères de remplacement, ou envisager d'utiliser les polices (fonts) TTF pour les applications internationales. Cependant, gardez à l'esprit que le rendu des TTF ralentit le moteur.

Alors que la plupart du texte est traduit automatiquement, il y a certains cas dans lesquels ce n'est pas possible. C'est le cas quand un script utilise des fonctions comme “Append” pour construire une chaîne de caractères, ou “CompareTo” pour vérifier certaines entrées de l'utilisateur. Dans ces cas, vous pouvez utiliser la fonction GetTranslation pour que cela marche.

Vous aurez également remarqué l'option “Update” (Mise à jour) lorsque vous faites un clic-droit sur “Translations” (traductions). Ceci est utile si vous avez une version traduite de votre jeu et vous souhaitez mettre à jour le jeu en ajoutant quelque chose. Une fois que vous avez mis à jour votre jeu, exécutez l'option “Update Translation” (Mise à jour traduction) et le fichier de traduction que vous sélectionnerez accueillera toutes les choses que vous auriez changé – vous pouvez alors demander à votre traducteur de traduire ces lignes.

,


les_variables_globales

Le panneau variables Globales vous permet d'ajouter facilement des variables à vos jeux qui sont accessibles depuis tous votre code.

Dans les versions précédentes d'AGS, déclarer une variable globale dans le code demandait sa définition dans 3 endroits diférents, avec des clauses d'import et d'export aux bon endroits. Maintenant, ce processus est très simplifié avec le nouvel éditeur de variables globales.

Quand utiliser une variable globale?

Utilisez une variable globale lorsque vous avez besoin de stoquer des informations auxquelles vous voulez acceder depuis differents codes. Par exemple, si vous voulez stoquer la santé du joueur et que vous voulez y acceder de partout dans votre code, alors utilisez une variable globale.

Si vous avez besoin de stoquer des informations localement (par exemple, un drapeau (flag) “porte ouverte” qui s'applique à une pièce particulière) alors vous devez déclarer une variable à la main au début du code de cette pièce.

Qu'en est il des GlobalInts et des Variables Grpahiques?

Les GlobalInts et les variables graphiques étaient des moyens de fournir des variables globales dans les versions précédentes d'AGS. Ces variables sont maintenant obsolètes et sont remplacées par le nouveau système de variables globales.

Et ça marche comment?

L'éditeur de variables globales s'exlique de lui même. Pour ajouter une variable, clickez droit et choisissez “Add” (ajouter). Donnez lui un nom, un type et une valeur initiale. La plupart du temps, vous utiliserez les types int (entier) et String (chaine de carractères) . En option, vous pouvez aussi mettre une valeur par défaut.

Ensuite, dans votre code, utiliser juste la variable par le nom que vous lui avez donné. Simple, non? Par exemple , si vous avez ajouté une variable globale de type int appellée “myVariable”, alors dans votre code, vous ferez :

if (myVariable == 3)
{
  myVariable = 4;
}

ou

Display("myVariable: %d", myVariable);\\ \\

C'est tout! Utilisez les comme n'importe quelle autre variable déclarée dans votre code.

Notez que certains des types disponibles sont des instances de pointeurs gérés, comme “GUI”, “DynamicSprite” et “Character”. Celles-ci sont pour les utilisateurs avancés. Si vous créez une de ces variables , vous ne pouvez pas mettre de valeur par défaut et elles seront initialisées à null . Vous devrez initialiser le pointeur dans votre code pour qu'il pointe vers quelque chose avant de les utiliser.

,


proprietes_personnalisees

Propriétés Personnalisées

Que sont les propriétés personnalisées ?

Supponsons que vous créiez un jeu dans le style Lucasarts, et que vous vouliez que tous vos hotspots aient un événement par défaut (donc si le joueur clique droit sur une fenêtre, par exemple, “Ouvrir” sera l'action par défaut, mais s'il clique sur un crayon, “Ramasser” sera celle par défaut.)

Pour faire cela, il vous faudrait manifestement scripter beaucoup de lignes de code afin de changer le mode par défaut de chaque objet différent.

Mais grâce aux Propriétés Personnalisées, vous pouvez définir des “Événements par défaut”, par exemple, et les utiliser ensuite simplement dans le script global afin de tout faire correspondre correctement.

Comment les utiliser ?

Vous remarquerez que les personnages, les objets, les hotspots, les pièces et les objets d'inventaire ont tous une option “Properties” (Propriétés) dans leur grille de propriétés. Sélectionnez-la et cliquez sur le bouton ”…“

Lorsque vous n'avez encore défini aucune propriétés personnalisée, une fenêtre vide apparaîtra, cliquez alors sur le bouton “Edit Schema”. Ceci affichera l'Éditeur de Schéma, où vous pouvez créer les différentes propriétés que vous voulez pour votre jeu. Pour commencez, vous voyez une liste vide, faîtes donc un clic droit dessus et choisissez “Add property” (Ajouter propriété).

Dans la fenêtre “Add Property”, vous pouvez régler différentes options concernant la nouvelle propriété :

  • Name - Nom : ceci est le nom par lequel vous accéderez à la propriété

à partir du script. Celui-ci ne peut être modifié après la création de la propriété.

  • Description - cette option est faite pour une meilleure compréhension, et

son texte sera affiché dans l'éditeur de propriétés personnalisées lorsque vous éditerez la propriété.

  • Type - ceci définit quel type de propriété vous voulez. “Boolean” (booléenne)

est associé à une case à cocher (qui retournera 0 – non cochée – ou 1 – cochée – au script), “Number” (nombre) correspond à une boîte d'édition textuelle où vous pouvez entrer une valeur numérique, et “Text” (texte) vous donne une boîte d'édition plus large dans laquelle vous entrez un texte sous forme de chaîne de caractères (String).

  • Default value - Valeur par défaut : cette option spécifie quelle sera la valeur par

défaut de la propriété, lorsque vous aurez un élément dont cette propriété n'est pas définie.

Par exemple, ajoutez une nouvelle propriété booléenne (”Boolean”). Fermez l'éditeur de schéma, puis cliquez à nouveau sur le bouton “Properties”. Vous obtiendrez alors une fenêtre présentant une case à cocher ainsi que le texte descriptif que vous avez entré. Vous pouvez cliquer sur le bouton “Edit schema” pour retourner à l'éditeur de schéma si vous le désirez.

Tous les types d'éléments du jeu partagent le même schéma. Cela signifie que si vous créez une propriété “Action” dans l'éditeur de schéma pour un hotspot, celle-ci apparaîtra également dans la fenêtre de propriétés pour les personnages, les objets et autres.

Obtenir les valeurs dans le script

Pour accéder à ces propriétés depuis le script, il existe des fonctions spécifiques. Voyez leurs descriptions pour savoir comment elles fonctionnent :

Character.GetProperty, Character.GetTextProperty

Hotspot.GetProperty, Hotspot.GetTextProperty

InventoryItem.GetProperty, InventoryItem.GetTextProperty

Object.GetProperty, Object.GetTextProperty

GetRoomProperty, Room.GetTextProperty

Les valeurs des propriétés personnalisées ne peuvent pour le moment pas être définies dans le script – elles ne sont disponibles qu'en lecture seule lors de l'exécution du jeu.


Greffons

AGS supporte les greffons (plugins) écrits par les utilisateurs afin de fournir des fonctionnalités à votre jeu qu'AGS lui-même ne prend pas en charge.

Le guide des développeurs de greffons est disponible dans la section “Resources” du site web d'AGS.

Les greffons sont des fichiers en DLL avec un nom en AGS*.DLL, par exemple agscircle.dll peut être un greffon fournissant une fonction script DrawCircled (dessiner des cercles).

Comment utiliser un greffon

Alors, vous avez téléchargé un greffon pour AGS. Que faire avec ? Eh bien, tout d'abord lire le fichier README (lisez moi) que l'auteur du greffon a inclus. Mais pour que le greffon fonctionne, vous devez faire ce qui suit :

1. Placez une copie du greffon dans le dossier “AGSEDIT” (pas le dossier de votre jeu).

2. Lancez AGS, et chargez votre jeu. Allez à la section Plugins (Greffons). Ouvrez-le, et vous devriez voir tous les greffons disponibles énumérés. Pour en utiliser un dans votre jeu, faites un clic droit et choisissez “Use plugin” (”Utiliser greffon”). Le développeur du greffon doit fournir des instructions sur ce qui reste à faire. Enregistrez votre jeu pour que AGS se souvienne que vous souhaitez utiliser le greffon.


synchronisation_des_levres

Synchronisation des lèvres

Si vous le voulez, AGS peut essayer de “lire” les parole en texte. Aller dans le panneau “Lip Sync” (Synchronisation des lèvres) de l'éditeur.

Normalement, quand un personnage parle, AGS lance simplement votre animation “de parole” du début à la fin, et cela en boucle. Cependant, synchroniser les lèvres vous permet d'être plus intelligent en spécifiant à une image (frame) d'aller avec diverses lettres et sons. Alors, quand le personnage parlera, AGS montrera l'image désignée pour le mot que dit actuellement le personnage.

Dans l'éditeur “Lip Sync”(Synchronisation des lèvres), vous avez 20 boites de texte, une pour chaque image de la boucle “paroles”. Dans chaque boite, vous pouvez entrer toutes les lettres qui pourront faire afficher cette image. Les combinaisons de lettres comme 'th' et 'ch' peuvent aussi être utilisées - AGS trouvera des correspondances à chaque part du texte parlé à la plus longue phrase possible dans l'éditeur de “lip sync”(Synchronisation des lèvres).

Séparez les lettres par un simple “slashes”. Par exemple,

3  R/S/Th/G

Ça veut dire que la frame 3 (image 3) de l'animation du personnage qui parle est montrée quand les lettres R, S, Th or G sont dites.

La boite “Default frame for unlisted characters”(image par défaut pour mot non listé) vous permet de définir quelle image est utilisée quand le mot n'est listé dans aucune des boites .

Synchronisation des lèvres pour les voix

AGS supporte la synchronisation des lèvres pour les voix d'une animation de discour. Si vous activez cette fonctionnalité, vous ne pourrez pas utiliser la synchronisation des lèvres standard pour les lignes non vocales.

NOTE: Il s'agit là d'une caractéristique non officielle et elle n'est pas actuellement prise en charge. A utiliser à vos propres risques

NOTE: L'option de synchronisation des voix est seulement supportée par les paroles de style Sierra.

Pour faire cela, vous devez télécharger cette application “PAMELA”:

http://www-personal.monash.edu.au/~myless/catnap/pamela/

Installez l'élément “Pamela” de sorte qu'il y ait seulement 10 choix disponibles (ou autant d'images parole que vous avez). Après, dans le panneau “Lip Sync”(Synchronisation des lèvres) d'AGS, changez le type de propriété en “Voice”(voix). Entrez l'élément “Pamela” dans la boite de texte pour créer l'association entre l'élément code “Pamela” et le numéro d'image AGS.

Par exemple, entrer “AY0” dans la boite de l'image 0, “E” dans “frame 1”(image 1), et ainsi de suite - correspondant à la façon dont il est mis en place dans “Pamela”. Pour plusieurs éléments qui lancent la même frame (image), séparez avec un slash – Par exemple, “AY0/AY1” permet à ces deux évènements de correspondre à l'image spécifiée.

Utilisez l'application “Pamela” sur chacune des lignes de votre discours, et sauvegardez votre projet dans un fichier “Pamela”(.pam), nommez le comme le discours.

Par exemple, le projet “pamela” pour EGO46.OGG sera nommé EGO46.PAM, placé dans le dossier Speech(paroles) de votre jeu.

Lorsque vous construirez le jeu, ce fichier .pam sera compilé dans speech.vox(paroles) et sera utilisé pour synchroniser l'animation des paroles pendant le jeu.

NOTE: La synchronisation des voix ne fonctionne pas bien avec les fichiers MP3. Il est rigoureusement recommandé d'utiliser des OGG ou des WAV pour les parole.

,


modeles_de_jeu

Modèles de jeu

Quand vous choisissez “Start a new game” (Commencer un nouveau jeu) dans la boîte de dialogue initial “Welcome to AGS” (Bienvenue sur AGS), une fenêtre apparaît avec plusieurs templates (modèles) sur lesquels vous pouvez baser votre jeu.

AGS possède quelques templates standards, mais vous pouvez aussi créer le vôtre.

Si vous avez téléchargé un modèle de jeu sur Internet, vous devriez voir un fichier avec une extension .AGT. Cette extension correspond aux modèles AGS, copiez simplement ce fichier dans le dossier “Templates” du répertoire de l'éditeur d'AGS.

Créer votre propre modèle

Un template (modèle) de jeu est tout simplement une archive contenant tous les fichiers source du jeu, qui sont ensuite extraits dans un nouveau dossier lorsque l'utilisateur crée un nouveau jeu. C'est comme si vous faisiez un ZIP de votre dossier de jeu et que vous l'envoyiez à un ami - sauf que cette manière est beaucoup plus professionnelle.

Pour créer un modèle (template), créez tout d'abord un jeu comme d'habitude dans l'éditeur. Une fois que vous avez tout mis en place comme vous le souhaitez, sélectionnez dans le menu File (Fichier) “Make template from this game” (Faire un modèle de ce jeu). On vous demandera un nom pour le modèle (template) (celui-ci apparaîtra sous l'icône dans la boite de dialogue “Start New Game” (commencer un nouveau jeu)), et cela compilera un modèle (template) pour vous.

Le modèle de jeu (template) créera les fichiers suivants dans votre dossier de jeu : les fichiers sources du jeu (GAME.AGF, ACSPRSET.SPR), tous les fichiers scripts et rooms (pièces), tous les fichiers sons et musiques, toutes les polices (fonts), les icônes du jeu, et les fichiers *.TXT (pour vous autoriser à inclure un “README.TXT” (lisez-moi.TXT) ou autres).

Si vous ajoutez un fichier template.ico dans le dossier de votre jeu quand vous faites le modèle (template), il sera utilisé pour l'icône dans la boîte de dialogue “Start New Game” (commencer un nouveau jeu). Sinon, l'icône sera prise à partir de “user.ico” (si présent), ou sinon il prendra l'icône par défaut d'AGS.

Vous pouvez aussi ajouter un fichier “template.txt” dans le dossier de votre jeu. Si vous faites cela, son contenu sera affiché à l'utilisateur dans une boîte de message après avoir créé un nouveau jeu basé sur le modèle. Vous pouvez utiliser ceci pour expliquer brièvement les principaux aspects du modèle, ou pour dire aux utilisateurs de lire votre fichier README.TXT (lisez-moi.TXT). Ce fichier doit être assez petit - l'ensemble de son contenu nécessite de s'inscrire dans une boîte de message standard.

NOTE: Ne faites pas simplement un template (modèle) une fois le jeu presque fini. Si vous voulez faire un template (modèle), vous devez commencer un jeu à partir de zéro et faire vos modifications - l'utilisateur ne voudra probablement pas d'un jeu presque terminé quand il utilisera votre template (modèle).

,


options_de_debogage

Options de débogage

Cela arrive aux meilleurs d'entre nous - vous travaillez joyeusement votre jeu, lorsque soudain quelque chose déraille. La nature du problème n'est pas toujours évidente.

AGS prévoit quelques outils pour essayer de vous aider à remédier à ces difficultés. Selon votre problème, les options suivantes peuvent vous aider. Si malgré cela, celui-ci persiste, vous pouvez bien sûr demander de l'aide sur les forums de la communauté.

Il existe deux types différents de débogages, qui s'activent de façons différentes. Le débogueur de script est activé uniquement lorsque vous utilisez F5 pour tester votre jeu ; les commandes Debug() quant à elles ne sont activées que si l'option “Enable debug mode” est définie dans les réglages de votre jeu. N'oubliez donc pas, au moment de distribuer votre jeu, de la décocher afin qu'aucun joueur ne puisse tricher.

1. Le débogueur de script

Lorsque vous utiliserez l'option Run (F5) pour lancer le jeu, le débogueur sera automatiquement lancé. Celui-ci vous permet de mettre le jeu en pause pour le suivre ligne par ligne.

Il y a deux façons d'utiliser cette option :

* Appuyez sur Arrêt défil (SCROLL LOCK) lorsque le jeu est en cours. Celui-ci s'arrêtera dès la prochaine ligne de script à exécuter.

* Placez un repère dans votre script. Il faut cliquer sur une ligne du code dans l'éditeur de script, puis presser F9. Ensuite, lorsque le jeu arrivera à cette ligne de code, il se mettra automatiquement en pause.

NOTE : L'éditeur vous permet de placer un repère sur toute ligne du script. Cependant, pour que cela fonctionne correctement, il doit être placé sur une ligne qui contient effectivement du code (et non une ligne “blanche”).

Une fois que le script est en suspens, vous pouvez utiliser le bouton “Step Into” (F11) pour parcourir les lignes de code, une par une. Pour reprendre le cours du jeu, utilisez le bouton Run (F5).

NOTE : Le Débogueur de Script n'est pas supporté par Windows 98 et Windows ME. Si vous utilisez ces versions de Windows, nous ne pouvons que vous conseiller de passer aux versions XP ou Vista pour profiter de cet outil.

2. La commande Debug()

Il existe une commande de script, Debug, que vous pouvez utiliser dans votre script pour vous aider à découvrir des problèmes. La configuration par défaut active certaines touches pour les différentes options - en particulier, Ctrl+X vous permet de vous téléporter dans une autre pièce, Ctrl+A vous montre les zones de déplacement libre à l'écran et Ctrl+S vous donne tous les objets d'inventaire.

Vous pouvez aussi utiliser la commande Debug pour assigner une touche qui vous permettra d'activer et désactiver l'affichage du FPS. (FPS signifie “Frames Per Second”, en français “Image Par Seconde”, ce qui vous permet de voir la vitesse de votre jeu et de repérer tout ralentissement.

Cette commande ne fonctionne que si le Debug Mode est activé dans les réglages du jeu.

3. Informations sur la pièce actuelle

Appuyer sur Ctrl+D affiche des informations sur la pièce où se trouve le joueur. Cela vous informe sur le numéro de la pièce, suivi de l'état de tous les objets dans la pièce. Après cela, une autre fenêtre textuelle vous indique tous les personnages qui sont dans la pièce et diverses informations à leur propos.

Cette commande ne fonctionne que si le Debug Mode est activé dans les réglages du jeu.


auto-numerotation_des_fichiers_de_doublage

Auto-numérotation des fichiers de doublage

Si vous avez déjà fait votre jeu, et que vous décidez que vous voulez un “voice pack”(pack de voix) pour aller avec, la pensée du fait d'ajouter manuellement les numéros de chaque ligne de parole dans le jeu est assez redoutable. Mais n'ayez pas peur, c'est la qu'interviens le “Auto-number Speech Files”(Auto-numérotation des fichiers de paroles).

Si vous sélectionnez cette option, l'éditeur passera par toutes les lignes discours dans le jeu et ajoute “a&amp;NUM” à leurs débuts. Un résumé des résultats est écrit dans un fichier appelé “SPEECHREF.TXT” dans le fichier du jeu, de sorte que vous pouvez facilement voir de quel fichier il s'agissait lors de l'enregistrement des paroles.

Les types de message auto-numéroter sont. Si l'un des messages a déjà un numéro de parole(speech), il sera écrasé:

  • room - les messages à afficher en tant que parole(speech)dans la room
  • dialog messages script
  • dialog options (si “Say”(dire) est sélectionner comme option)
  • commande “say”(dire) dans le scripts
,


integration_a_windows

Table des matières
    • Intégration dans Windows
      • Sauvegardes Enrichies
      • Explorateur de Jeux Windows

Intégration dans Windows

AGS a la capacité de s'intégrer à Windows de deux façons. Premièrement, il peut être configuré pour lancer les jeux directement à partir de l'explorateur lorsque le joueur double-clique ; deuxièmement, dans Windows Vista, AGS peut s'intégrer avec la fonction “Game Explorer” (”Explorateur de Jeux”).

Sauvegardes Enrichies

En option, AGS peut être configuré de façon à ce que vous puissiez double-cliquer sur un fichier de sauvegarde pour lancer directement le jeu et continuer depuis l'endroit où vous l'avez quitté.

Mise en place

Pour activer cette option, ouvrez le panneau des “General Settings” (”Réglages Généraux”), et trouvez la section “Saved Games” (”Jeux Sauvegardés”). Là, il y a une option appelée “Enhanced Save Games” (”Enrichir les Sauvegardes”). Si vous l'activez, AGS permettra l'intégration avec Windows Explorer.

Pour que ça marche, vous devez définir l'option “Save Game File Extension” (”Extension des Fichiers de Sauvegarde”) à une extension de fichier. Cela correspond à la façon dont Windows va identifier les sauvegardes de jeu, et vous devez soumettre une extension de 5 a 20 lettres (Exemple : “DemoQuestSave” serait une bonne extension pour Demo Quest).

En modifiant ces paramètres, les noms des fichiers des parties sauvegardées pour votre jeu vont être modifiés, et donc vous pouvez perdre l'accès à toutes les sauvegardes du jeu.

Options supplémentaires dans Windows Vista/7

Si vous jouez sous Windows Vista/7, alors cette fonctionnalité vous permettra également de voir la description et la capture d'écran de la sauvegarde (si activée) dans la fenêtre de prévisualisation d'Explorer :

Enregistrer les jeux avec des captures d'écran intégrées sous Vista/7

Activer l'intégration

Une fois que vous avez compilé le jeu, l'intégration ne sera pas activée immédiatement. Si vous voulez bénéficier de cette option, vous devez distribuer votre jeu dans un installateur plutôt qu'un fichier zip, parce qu'il y a une étape supplémentaire, à exécuter après l'installation afin de mettre en place cette association.

Dans votre installateur, vous devez lancer l'exécutable de votre jeu avec le paramètre ”-registergame”. En faisant cela, AGS va créer les associations nécessaires dans Explorer pour que la fonctionnalité marche. Si cela marche, aucun message ne s'affichera.

Vous pouvez manuellement tester cela en créant un raccourci vers l'EXE de votre jeu, et en le modifiant pour ajouter ”-registergame” a la fin de la ligne de commande. Après, lancez le raccourci et l'association sera créée pour vous.

Pour la désinstaller, lancez l'EXE du jeu encore une fois mais avec le paramètre ”-unregistergame”. Cela fera qu'AGS effacera cette association du système.

Support multi-plateforme

Windows: Oui
MS-DOS: Non
Linux: Non
MacOS: Non

Explorateur de Jeux Windows

Windows Vista et Windows 7 ont une fonction appelée ”Explorateur de Jeux” (“Game Explorer”), qui est un dossier spécial dans le menu Démarrer (Start) qui liste tous les jeux installés sur le système et donne des raccourcis facilement accessibles pour y jouer.

AGS est maintenant capable d'ajouter votre jeu à cette liste. Toutefois, pour ce faire, vous aurez besoin de distribuer votre jeu en utilisant un installateur plutôt qu'un simple fichier zip, car vous devez dire à AGS d'ajouter le jeu à la liste lors de installation.

Le menu Game (Jeux) qui lance l'Explorateur de Jeux (Game Explorer)

Activation du support de l'Explorateur de Jeux

Ouvrez le panneau “General Settings” (”Réglages Généraux”) dans l'éditeur AGS. Si vous descendez en bas de la liste, vous trouverez une option nommée “Windows Vista Game Explorer” (Explorateur de Jeux Windows). Le principal paramètre est appelé “Enable Game Explorer intégration” (Activer l'Intégration dans l'Explorateur de Jeux), et est désactivé par défaut. Mettez-le sur ”True” (Oui) pour ajouter votre jeu à l'Explorateur de Jeux. Cela n'aura aucun effet sous Windows XP et les versions précédentes.

Paramètres de l'Explorateur de Jeux

Le reste des paramètres vous permet de configurer les différentes options que l'Explorateur de Jeux peut afficher. Developer Website (Site web du développeur) doit être une URL commençant par “http://”, et Version doit être un numéro a trois point (ex: 1.0.0.0).

Windows Experience Index (Indice de Performance Windows) est un score que Vista/7 donne à chaque ordinateur en fonction de ses performances pour exécuter le jeu. 1 est le plus bas score, et 5 le plus haut. Ce champ vous permet de spécifier le minimum requis pour jouer à votre jeu (c'est généralement 1 pour les jeux AGS, sauf si vous avez une haute résolution et beaucoup d'animations).

Parties sauvegardées

Si vous avez cocher la propriété Save games folder name (Nom du dossier de sauvegarde) dans la section “Saved Games” (Parties Sauvegardées) , alors l'Explorateur de Jeux fournira une option au clic-droit pour ouvrir directement le dossier de sauvegardes de jeu. Ce n'est utile que si vous activez également “Enhanced Save Games” (Sauvegardes enrichies).

Contrôle Parental

AGS n'est pas actuellement en mesure de prendre en charge le contrôle parental de Vista/7, car Vista/7 demande que le jeu soit signé numériquement pour que cela fonctionne. Les signatures numériques vous obligent à acheter un certificat émanant d'une autorité telles que Verisign, cela n'est donc pas supporté à l'heure actuelle. Votre jeu sera classé comme “Unrated” (Non évalué) par Vista/7.

Jaquette

L'Explorateur de Jeux peut afficher une icône haute résolution pour votre jeu, plutôt qu'une icône standard. Pour cela, placez un fichier “GameExplorer.png” dans le fichier de votre jeu, et recompilez l'EXE. De préférence une image PNG, pas plus large que 256 x 256 pixels :

Mon jeu (“Chris Kwest”) dans le l'Explorateur de Jeux

Ajout du jeu à l'Explorateur de Jeux

Afin d'ajouter le jeu a la liste de l'Explorateur de Jeux, vous devez lancer l'exécutable du jeu avec le paramètre spécial ”-registergame”. Après, AGS ajoutera le jeu à l'Explorateur de Jeux et quittera. Si cela marche, il n'affichera aucun message.

Par conséquent, lors de votre installation, une fois tous les fichiers installés, vous avez une étape qui consiste à lancer l'EXE avec ces paramètres. Il ne se passera rien sous Windows XP et les versions précédentes.

Pour retirer votre jeu de la liste de l'Explorateur de Jeux, lancez l'EXE encore une fois mais avec le paramètre ”-unregistergame”. Cela dira à AGS d'enlever le jeu de la liste.

NOTE: Si vous avez activé les deux options “Enhanced Save Games” (Sauvegardes Enrichies) et “Game Explorer Integration” (Intégration dans l'Explorateur de Jeux), alors les commandes ”-registergame” et ”-unregistergame” installeront/désactiveront ces deux fonctionnalités à la fois.

Support multi-plateformes

Windows: Vista et 7 seulement
MS-DOS: Non
Linux: Non
MacOS: Non


integration_de_la_gestion_des_versions

Intégration de la gestion des versions

L'éditeur AGS supporte l'intégration de systèmes de gestion des versions comme SourceSafe et Perforce.

Qu'est-ce qu'un système de gestion des versions ?

Un système de gestion des versions vous permet de facilement conserver des copies des vieilles versions de vos fichiers, alors si vous cassez quelque chose vous pouvez regarder en arrière et voir à quoi ressemblait votre script dans la version précédente.

AGS ne propose pas cette fonctionnalité par lui-même, mais il est capable de s'intégrer à des applications de gestion des versions comme SourceSafe et Perforce afin de vous permettre de de vérifier facilement les modifications.

Quels logiciels sont pris en charge ?

AGS supporte tous les systèmes de gestion des versions qui peuvent intégrer “Visual Studio” (on les appelle les interfaces MSCCI). Beaucoup de systèmes de gestion des versions sont très lourds et conçus pour être utilisés par de grandes équipes, mais il y a de plus petits systèmes disponibles comme SourceSafe et qui marchent mieux sur un ordinateur particulier.

Comment les utiliser ?

Si vous avez installé un système de gestion des versions pour AGS, une option supplémentaire “Add to source control” (Ajouter au gestionnaire de versions”) apparaîtra dans le menu “File” (Fichier). Utilisez-la pour ajouter votre jeu au gestionnaire de versions et ensuite chaque fois qu'AGS tentera de modifier un fichier, il vous invitera à vérifier si nécessaire.

Vous pouvez vérifier les fichiers à l'aide de l'option “Show Pending Checkins” (Voir les vérifications en attente), celle-ci apparaîtra dans le menu “File” (Fichier) dès que vous aurez ajouté votre jeu au gestionnaire de versions.

Quel fichiers AGS renseigne-t-il au gestionnaire de versions ?

AGS passe actuellement le principal fichier du jeu et vos scripts, pièces, polices et traductions au gestionnaire de versions. En option, vous pouvez inclure les sons, musiques et images (Sprites) en changeant le paramètre dans le panneau “General Settings” (Réglages Généraux).


Scripting

Le système de scripting d'AGS vous permet d'écrire un mini-programme, vous offrant un contrôle important sur le jeu.

Tutoriel de Scripting, partie 1

Tutoriel de Scripting, partie 2

Migrer vers AGS 2.7

Migrer vers AGS 2.71

Les pointeurs dans AGS

Appeler des fonctions globales depuis vos scripts locaux

L'entête des scripts

La syntaxe des chaînes de caractères (String)

Les fichiers scripts (modules)

Comprendre le blocage des scripts

Tableaux Dynamiques

Fonctions d'extension

Variables du jeu

Fonctions prédéfinies du script global

Fonction repeatedly_execute (_always)

Affichage personnalisé des options de dialogue

Liste des types prédéfinis

Liste des mots-clés du langage

AudioChannel (canaux audios) : fonctions et propriétés

AudioClip (séquences audios) : fonctions et propriétés

Character (Personnage) : fonctions et propriétés

DateTime (Temps) : fonctions et propriétés

Dialog (dialogues) : fonctions et propriétés

DialogOptionsRenderingInfo (affichage personnalisé des options de dialogues) : fonctions et propriétés

DrawingSurface (zones graphiques) : fonctions et propriétés

DynamicSprite (images dynamiques) : fonctions et propriétés

File (fichiers) : fonctions et propriétés

Game/Global (jeu/général) : fonctions

GUI (Interfaces) : fonctions et propriétés

GUI control (éléments d'interface) : fonctions et propriétés

GUI Button (boutons) : fonctions et propriétés

GUI InvWindow (zones d'inventaires) : fonctions et propriétés

GUI Label (zones de texte) : fonctions et propriétés

GUI ListBox (listes) : fonctions et propriétés

GUI Slider (ascenseur) : propriétés

GUI TextBox (zones de saisie) : fonctions et propriétés

Hotspot (zones d'interaction) : fonctions et propriétés

InventoryItem (objets d'inventaire) : fonctions et propriétés

Maths : fonctions et propriétés

Mouse (souris) : fonctions et propriétés

Multimedia : fonctions

Object (objets) : fonctions et propriétés

Overlay (calques) : fonctions et propriétés

Palette : fonctions

Parser (Analyseur de texte) : fonctions

Region : fonctions et propriétés

Room (pièces) : fonctions

Screen (écran) : fonctions

String (chaînes de caractères) : fonctions

System : fonctions et propriétés

Speech (discours) : fonctions

ViewFrame (séquences d'animation) : fonctions et propriétés

SCUMM_VERBCOIN_GUI : fonctions


tutoriel_de_scripting_partie_1

Table des matières
    • Tutoriel de Scripting, partie 1
      • Les bases
      • Les commandes expliquées
      • Instances
      • Séquences de commandes
      • Récapitulatif
      • Variables
      • Fonctions qui retournent une valeur
      • Raccourcis communs
      • Conclusion

Tutoriel de Scripting, partie 1

Dans AGS, toutes les interactions de votre jeu sont traitées à l'aide des scripts. Les scripts sont donc une partie essentielle de la création d'un jeu vidéo, il est donc temps de comprendre comment les utiliser.

Les bases

Bien, nous allons commencer avec quelque chose de vraiment très simple — afficher un message au joueur quand celui-ci clique avec le curseur Observer sur une zone interactive (hotspot). En admettant que vous ayez fait le tutoriel principal d'AGS, vous devriez déjà avoir créé un script ressemblant à ça :

function hDoor_Look()
{
  Display("C'est vraiment une porte large et menaçante !");
}

Jetons un œil sur les détails. ”function” dit à AGS que ce qui suit est un bloc de code qui se lancera quand un événement se produira. ”hDoor_Look” est le nom de cet événement. Les parenthèses vides ( ) annoncent à AGS que cette fonction ne prend aucun paramètres (nous reviendrons là-dessus plus tard). Enfin, les crochets { et } définissent quand ce bloc de code démarre et se termine. Tout ce que vous mettez entre { et } sera lancé quand l'événement se déclenchera.

Display est le nom de la commande que nous allons lancer. Alors, dans les parenthèses nous allons mettre les paramètres pour cette commande. Les paramètres sont des informations dont la commande a besoin pour démarrer — dans ce cas, elle a besoin du message que nous voulons afficher. Enfin nous allons terminer la ligne avec une point-virgule. On utilise le point-virgule pour dire à AGS que c'est la fin de la commande. Tout ce que vous mettrez après ce point virgule deviendra une commande séparée, et pour que le script reste propre et lisible, il est conventionnel de revenir à la ligne.

Il est important de mentionner ici que les lignes qui commencent avec double-slash "//" sont des commentaires - AGS les ignore, elles seront seulement utiles pour vous aider a savoir ce que fait le script. Vous pouvez ajouter des commentaires à votre script simplement en commençant la ligne avec le symbole //.

Les commandes expliquées

Chacune des commandes que vous pouvez utiliser dans un script est aussi appelé une fonction. Toutes les commandes disponibles sont listées dans la partie Scripting du manuel, qui vous expliquera aussi comment les utiliser.

Nous voulons afficher un message pour le joueur, donc nous utiliserons la fonction Display. Regardons de plus près la définition que nous donne le manuel :

Display (string message, …)
Displays a message to the screen. It will be displayed in the standard message box, and centred in the middle of the screen. (description continues…)

Traduction :

Display (chaine de caractère, …)
Affiche un message à l'écran. Il sera affiché dans une boîte de messages standard, et centré au milieu de l'écran.

(la description continue…)

Le point clé ici c'est la partie de la première ligne a l'intérieur des parenthèses. Elle est appelée aussi la liste des paramètres et définit quels paramètres vous donnez à la fonction. Un paramètre est une information que la fonction utilise pour savoir quoi faire ou non.

Chaque paramètre est listé, séparé par des virgules. Voici quelques types de paramètres :

* string nom

Ce paramètre est une une chaîne de caractères (string). Cela signifie que pour ce paramètre, vous fournirez un texte entre guillemets.
Par exemple, “Mon texte”.
nom est le nom par lequel le paramètre sera référencé dans la description de la fonction, ce n'est pas pertinent pour écrire votre script.

* int nom

Ce paramètre est un nombre entier, c'est-à-dire une valeur numérique. Ce qui veut dire que le paramètre sera un nombre, par exemple 65.

* CHARID

Ce paramètre est le nom de script d'un personnage. Vous devez fournir le nom de script d'un des personnage du jeu.

* InventoryItem*

Ce paramètre est un objet d'inventaire. Vous avez besoin de fournir l'objet d'inventaire que vous voulez utiliser.

* …

Ce paramètre est facultatif, et peut correspondre à n'importe quel type. Pas besoin de fournir quelque chose en particulier, mais si vous voulez le faire, la description de la fonction vous informera sur le type de valeur qu'il faut utiliser.

Donc, nous savons que notre fonction Display a besoin d'un attribut de type String (chaîne de caractères) et d'un paramètre optionnel. La description va nous expliquer que le paramètre optionnel est utilisé pour des choses avancées comme afficher différentes valeurs variables dans le message, nous pouvons donc l'ignorer pour le moment.

Pour faire que notre script appelle la fonction, nous entrons son nom, puis les paramètres entre parenthèses, et enfin le point virgule.

Cette syntaxe est très importante, si l'on oublie les parenthèses par exemple, le script ne compilera pas. Aussi, notez que l'on ne DOIT PAS écrire le type de paramètre (Comme “string” ou “int”). On a donc cette ligne dans notre script :

Display("C'est vraiment une porte large et menaçante !");

Nous avons déjà fait ça dans le tutoriel principal, mais nous venons d'examiner ça plus de détails, vous devriez comprendre à présent pourquoi nous avons procédé de cette manière.

Instances

Le langage du script AGS est orienté objet. Ce qui veut dire que énormément de commandes sont sur quelque chose dans le jeu. Vous devriez ne pas confondre orienté objet avec les objets des pièces, ce sont deux choses totalement différentes. Il y a une instance de script (script instance) pour chaque personnage dans le jeu, un pour chaque objet dans une pièce, un pour chaque zone d'interaction (hotspot) et ainsi de suite.

Le nom par lequel vous avez accès à l'instance dans le script est donné dans l'éditeur comme un attribut : le Script Name (Nom de Script). Par exemple, le nom de script de notre personnage principal est cEgo, alors son instance sera désigné par cEgo.

Pour effectuer une commande sur quelque chose, vous écrirez le nom de script suivi par un point, suivi par le nom de la commande. Quand vous taperez le point, l'éditeur AGS va automatiquement afficher une liste des commandes disponibles dans une fenêtre surgissante (pop-up) :

L'éditeur de script s'auto-complète.

Vous devrez alors choisir la commande appropriée, et placer tout paramètre dans les parenthèses, comme nous avons vu dans la commande Display. Par exemple :

cEgo.AddInventory(iClef);

Ceci ajoutera la clef dans l'inventaire de personnage EGO. Si vous regardez dans le manuel concernant la fonction AddInventory, vous trouverez qu'elle prend deux paramètres : un Objet d'Inventaire (InventoryItem*) et un entier optionnel (optional int). L'InventoryItem* signifie que vous avez besoin de fournir le nom du script de l'Objet d'Inventaire ; c'est quelque chose que vous pouvez voir/définir dans l'éditeur de script.

L'optional int signifie quant à lui que vous pouvez ajouter le paramètre supplémentaire si vous le voulez, mais que vous n'y êtes pas obligé. Dans le cas où vous le faîtes, il sert à spécifier où exactement dans la liste de l'inventaire du personnage, l'objet devrait être ajouté ; cela ne nous concerne pas ici.

De la même façon qu'il existe des instances pour chaque personnage comme cEgo, il y a une instance spéciale nommée player. Elle correspond toujours au personnage actuellement dirigé par le joueur, donc si vous voulez exécuter une commande sur le personnage joueur (ce qui est particulièrement utile dans les jeux où le joueur peut diriger plusieurs personnages) alors vous utilisez l'instance player pour faire ça.

Séquences de commandes

Supposons que nous voulions que le joueur récupère une affiche rose quand il regarde une zone interactive (hostpot) particulière, avec un message qui s'affiche. En supposant que nous ayons un objet d'inventaire qui soit une affiche dont le nom de script est iAffiche (voir dans le tutoriel principal comment faire ça), le script nous permet d'effectuer ces deux actions très facilement.

Notre script final ressemblera à ça :

Display("C'est vraiment une porte large et menaçante !");
cEgo.AddInventory(iPoster);

Notons que le système de script est sensible à la casse, donc écrire par exemple addinventory(iposter) ne marchera pas.

L'action dans le script s'exécutera de haut en bas dans l'ordre par lequel vous avez écrit les commandes, donc écrire quelque chose comme :

Display("Pourquoi la poule traverse-t-elle la route ?");
Display("Parce qu'elle s'ennuit.");

Cela voudra dire que le joueur lira les messages dans l'ordre tel que vous l'avez spécifié.

Récapitulatif

Donc, rappelez-vous de ces points cruciaux :

  • Les chaînes de caractères sont entre guillemets.
  • Le point-virgule après avoir fermé les parenthèses sur chaque ligne.
  • Le script est sensible à la casse.
  • Pour utiliser une commande basée sur une instance, écrivez le nom du script suivi d'un point, suivi par le nom de la commande.
  • L'instance player correspond au personnage dirigé par le joueur.

Variables

Les scripts dans AGS peuvent utiliser les variables. Une variable est dans une zone de stockage mémoire qui contient une valeur, que vous pouvez vérifier et changer avec votre script.

Pour déclarer une variable, vous devez écrire le type de la variable, suivi par le nom de la variable, et enfin d'un point-virgule. Le type peut être “int” (entier), “String” (Notez la lettre capitale S) ou “float” (décimale), et le nom peut être ce que vous voulez — c'est ce que vous utiliserez pour référer à la variable plus tard. Par exemple :

int myCounter;

Le nom de la variable peut uniquement contenir les lettres de A à Z, de a à z et la barre underscore : _

Vous avez besoin de déclarer une variable avant de pouvoir l'utiliser, pour que le compilateur sache quel type de données vous pouvez stocker dans une variable si elle est impliquée dans une erreur.

Initialement, votre variable vaudra 0. Vous pouvez cependant facultativement l'initier avec une dans la déclaration, comme ceci :

int myCounter = 5;

la varible prendra comme valeur initiale 5.

La portée d'une Variable

Un effet indésirable du script dans sa tentative d'émuler le langage 'C' concerne la portée des variables. Pour faire court, cela signifie que vous avez besoin de placer les définitions de vos variables EN DEHORS de tous les événements, sinon leurs valeurs seront réinitalisées à chaque nouvel appel de la fonction.

Donc pour déclarer une variable utilisée par un script d'une interaction de la pièce, vous avez besoin de placer la définition au-dessus du corps de la fonction principale. Cela doit ressembler à ça :

// fichier du script de le pièce
int myCounter;

//(autres scripts événements)//

function hDoor_Look()
{
  Display("C'est vraiment une porte large et menaçante !");
}

//(suite du fichier)//

Aucune commande de script ne peut être utilisée hors des fonctions (sinon AGS ne les lira pas et ne les fera pas fonctionner !) — seules les déclarations de variables y sont autorisées.

Changer les variables

Vous pouvez changer la valeur d'une variable facilement dans un script - écrivez simplement le nom de la variable, le signe égal, puis la nouvelle valeur, suivie par un point virgule. Ainsi :

myCounter = 10;

la variable changera pour une valeur de 10.

Vous pouvez aussi ajouter et soustraire une variable en utilisant les opérateurs += et -=. Ainsi, pour ajouter 3 à la valeur de la variable myCOunter, faites comme ceci :

myCounter += 3;

Vérifier les variables

Manifestement, nous avons besoin d'une manière pour connaître les valeurs contenues dans nos variables, autrement ça serait inutile. Nous allons donc utiliser les expressions conditionnelles, introduites par le mot-clé if. Une condition ressemble à cela :

if (myCounter == 5)
{
  myCounter = 0;
}

Ce qui veut dire que si myCounter contient la valeur 5, alors le script à l'intérieur des crochets { } sera exécuté (lequel va changer la valeur de myCounter pour zéro).

Si myCounter n'est pas égal à 5, le script à l'intérieur des crochets ne s'exécutera pas et le déroulement de l'exécution passera à la suite, après le }.

Notez le double-égal dans la condition. Dans une expression conditionnelle, vous devez TOUJOURS utiliser un opérateur double-égal, lequel comparera les deux valeurs. Si vous utilisez un simple égal, vous modifierez la valeur de la variable à la place, ce qui donnera d'étrange résultats.

Le == est appelé un opérateur, parce qu'il effectue une opération entre deux valeurs. Voici les principaux opérateurs disponibles :

  • ==

compare les deux valeurs, et exécute le code si les deux valeurs sont les mêmes.

  • !=

compare les deux valeurs, et exécute le code si les deux valeurs ne sont pas les mêmes.

  • <

compare les deux valeurs, et exécute le code si la valeur de gauche est inférieure à celle de droite.

  • >

compare les deux valeurs, et exécute le code si la valeur de gauche est supérieure à celle de droite.

  • <=

compare les deux valeurs, et exécute le code si la valeur de gauche est inférieure ou égale à celle de droite.

  • >=

compare les deux valeurs, et exécute le code si la valeur de gauche est supérieure ou égale à celle de droite.

Un peu de pratique

Maintenant, faisons quelque chose d'utile avec notre variable. Supposons que nous voulions avoir un message différent à chaque fois que le joueur regarde une zone interactive (hotspot). La première fois, il regarde et cela va la décrire, et s'il regarde à nouveau, il aura un message différent décrivant quelque chose plus en détail. Notre code ressemblera à quelque chose comme ça :

if (myCounter == 0)
{
  Display("Vous voyez une bibliothèque.");
}
if (myCounter == 1)
{
  Display("Regardons de plus près, vous voyez un livre nommé Hamlet.");
}
if (myCounter == 2)
{
  Display("Il y a aussi un livre nommé Harry Potter.");
}
if (myCounter == 3)
{
  Display("Il n'y a rien de plus qui soit intéressant là dedans...");
}
if (myCounter &lt; 3)
{
  myCounter += 1;
}

myCounter débute initié à 0, donc la première fois que le script sera appelé, il lancera la première commande Display, mais pas les autres. Puis, comme 0 est inférieur à 3, il va ajouter à myCounter la valeur de 1 (dernière expression conditionnelle), et ainsi 0+1 = 1 ; myCounter vaut donc à présent 1.

Un fois que le joueur aura vu tous les messages (myCounter == 3), il n'y a plus de valeur à ajouter, donc si le joueur clique à nouveau, il observera à nouveau le dernier message.

Se faciliter la vie grâce aux variables globales

Parfois, vous voudrez peut-être placer une variable de sorte qu'elle soit partagée entre le script d'une pièce et votre script global. Il y a deux manières de faire cela — vous pouvez exporter la variable du script global et l'importer dans l'entête du script, mais c'est trop avancé pour ce tutoriel. Une façon plus facile est d'utiliser une des 300 GlobalInts — les variables globales —, lesquelles doivent utiliser les fonctions SetGlobalInt et GetGlobalInt pour y avoir accès. Voir les descriptions sur le manuel pour plus d'explications.

Fonctions qui retournent une valeur

Quand on lit les descriptions des fonctions dans le manuel, vous noterez que quelques unes retournent une valeur. Par exemple,

IsGamePaused ()
//Retourne 1 si le jeu est actuellement en pause, ou 0 autrement.

Vous pouvez les utiliser comme si vous utilisiez une valeur littérale comme “9”. Par exemple, vous pouvez faire :

// Mettre une valeur retour dans notre variable
myCounter = IsGamePaused();

(OU)

// Tester la valeur retour directement
if (IsGamePaused() == 0)
{
  myCounter += 5;
}

N'oubliez pas les parenthèses ().

Raccourcis communs

Le système de script a quelques raccourcis pratiques pour des tâches communes que vous vous retrouverez souvent à faire régulièrement.

Premièrement, les opérateurs ++ et – incrémentent et décrémentent la variable de 1, respectivement. Donc, la dernière partie de notre précédent script peut être écrit :

if (myCounter < 3)
{
  myCounter++;
}

Aussi, les crochets { } sont seulement nécessaires si vous avez plus d'une commande à l'intérieur. Si nous n'avons qu'une seule commande, la ligne “myCounter++;” dans notre exemple précédent, nous pouvons alors supprimer les crochets { } complètement et présenter la condition de cette manière :

if (myCounter < 3)
  myCounter++;

Toutefois, cela peut mener à des erreurs dans le script difficilement repérables, je vous conseille donc d'utiliser les crochets juste pour être sûr.

Enfin, si vous voulez tester pour voir si la valeur d'une variable est à 0 ou non, vous pouvez juste écrire ceci :

if (myCounter)
  Display("la variable myCounter n'est pas égale à zéro");

équivalent à:

if (myCounter != 0)
  Display("la variable myCounter n'est pas égale à zéro");

Conclusion

Nous avons couvert les bases, donc vous devriez maintenant être capable d'écrire votre propre script. Il y a encore beaucoup d'autre choses que le système peut faire, mais ce que vous venez de voir devrait vous suffire pour commencer.

Quand vous vous sentirez prêt, n'hésitez pas à débuter le chapitre 2 de ce tutoriel, pour apprendre les boucles, les conditions multiples et créer vos propres fonctions. Tutoriel de Scripting, partie 2

Enjoy AGS!

Page créée le 6 Juin 2002; mise à jour le 19 Août 2007. Copyright © 2002-2007 Chris Jones.


tutoriel_de_scripting_partie_2

Table des matières
    • Tutoriel de Scripting, partie 2
      • Récapitulatif
      • Les Boucles
      • Conditions multiples
      • Expression 'OU'
      • Faire une chose ou une autre
      • Votre propre fonction
      • Notre propre fonction
      • Retourner une valeur
      • Utiliser les fonctions dans les script d'une pièce
      • Conclusions

Tutoriel de Scripting, partie 2

Récapitulatif

Dans la première partie du tutoriel, nous avons survolé les bases du scripting : comment écrire un simple script ; utiliser des variables et des expressions conditionnelles. Vous savez donc à présent utiliser toutes les fonctions internes à AGS et écrire un script à peu près comme il faut. Bon, c'est quoi la suite ?

Les Boucles

Vous serez sans doute confronté a une séquence de commandes qui devra être exécutée plus d'une fois d'affilée. Dans AGS, il faut utiliser la commande while. Le format est virtuellement le même que pour la commande if:

int compteur = 1;
while (compteur &lt; 10) {
  compteur ++;
}

Cela veut dire que le corps de la déclaration de while sera répété aussi longtemps que la condition entre parenthèses sera vrai. Dans l'exemple, le compteur démarre à 1, la boucle s'enclenchera 9 fois, jusqu'à cette dixième fois, où le compteur vaudra 10, et clôturera la boucle.

NOTE :

Faites tout de même attention avec les boucles — il est possible de faire planter votre jeu en utilisant une boucle mal écrite — nommée la boucle infinie. Regardez :

int compteur = 1;
while (compteur &gt; 0) {
  compteur ++;
}

Ici, la variable compteur débute à 1, donc la boucle va démarrer. Puis, cette valeur va s'incrémenter de 1, et donc valoir 2. Comme la valeur est toujours au dessus de 0, la boucle va recommencer. Cette boucle particulière va donc recommencer encore et encore — bref, elle tournera à l'infini tant que la valeur compteur ne sera pas inférieure à 1, et votre jeu se soldera par un arrêt brutal.

Conditions multiples

À plusieurs occasions, vous ne pourrez pas décider quoi faire en vous basant uniquement sur une seule variable — dans le cas où il y aurait une combinaisons de choses que vous voulez considérer.

Par exemple, supposons que vous vouliez afficher un message si le joueur a deux objets spécifiques dans l'inventaire. Vous devriez alors appliquer une condition multiple, et déclarer deux if à l'intérieur l'un de l'autre :

if (player.HasInventory(iPremierObjet))
{
  if (player.HasInventory(iDeuxiemeObjet))
  {
  Display ("Vous avez les deux objets !");
  }
}

Toutefois, cela peut devenir lourd et compliqué si vous avez plein de conditions et ça ne fera pas très propre. Alors AGS vous permet d'opter pour cette méthode :

if ((player.HasInventory(iPremierObjet)) && (player.HasInventory(iDeuxiemeObjet)))
{
  Display ("Vous avez les deux objets !");
}

Cela est rendu plus clair avec l'aide de l'opérateur && . Notez que vous avez besoin d'une parenthèse supplémentaire pour contenir l'ensemble de l'expression. Chaque partie de l'expression va à l'intérieur d'une parenthèse, comme d'habitude, et sont jointes avec le symbole de l'opérateur &&.

Vous pouvez étendre cette technique à autant de conditions que vous le voulez. Par exemple, cela va afficher un message si la variable Porte_ouverte est vraie, et si la variable script timer est entre 5 et 10.

if ((Porte_ouverte == true) && (timer > 5) && (timer < 10))
{
  Display ("Tout fonctionne comme prévu.");
}

Expression 'OU'

Parfois, vous vous retrouverez dans la situation où vous voulez demander si une condition ou une autre est vraie. Par exemple, vous proposez de laisser au joueur le choix d'ouvrir une porte avec la clef ou avec l'aide d'une tronçonneuse.

if ((player.HasInventory(iClef)) || (player.HasInventory(iTronconneuse)))
{
  player.ChangeRoom(10);
}

L'opérateur ici est la double barre verticale de concaténation || (Windows : Alt Gr + 6 ; Mac : Alt + Maj + L).

Cela marche exactement de la même manière que l'opérateur &&, sauf qu'il n'exécutera le code que lorsqu'une des deux conditions (ou bien les deux à la fois) est vraie.

Faire une chose ou une autre

Parfois, vous voulez que le script fasse une certaine action si une valeur est fixée, et une autre action si elle ne l'est pas. Initialement vous penseriez faire ça :

if (timer == 5) {
  // faire quelque chose
}
if (timer != 5) {
  // faire quelque chose d'autre
}

Ca devrait marcher — toutefois, il y a une méthode plus simple, en utilisant la commande else :

if (timer == 5) {
  // faire quelque chose
}
else {
  // faire quelque chose d'autre
}

Ceci vous permet de modifier la variable à l'intérieur du premier bloc de code, sans affecter quoi que ce soit du second bloc, qu'il fonctionne ou non. Vous pouvez faire autant de tests que vous voulez en utilisant la commande else if. Alors la partie complète du code devrait se présenter comme cela :

if (timer == 5) {
  // faire quelque chose
}
else if (timer == 6) {
  // faire quelque chose d'autre
}
else {
  // faire ça si c'est ni 5 ni 6.
}

Votre propre fonction

Vous avez probablement remarqué que dans le manuel, il est mention des fonctions comme repeatedly_execute, ou on_event, et que vous pouvez les ajouter à vos scripts pour faire des trucs cools. Mais vous vous demandez sans doute comment cela fonctionne exactement.

Rappelez vous que dans la première partie, nous avons découvert les paramètres des focntions et que ceux-là peuvent être de type int, string, etc. Et bien, vous pouvez écrire ces fonctions comme cela :

function dialog_request(int param)
{
  // contenu de la fonction ici
}

Vous commencez donc avec le mot-clé function, puis suivi par le nom de la fonction, et après une parenthèse pour y ajouter les types des paramètres suivis de leur nom. Pour chaque paramètre que vous voulez, vous avez besoin d'écrire son type (int ou string), suivi par le nom par lequel il sera connu à l'intérieur de la fonction. Ce nom peut être ce que vous voulez — c'est comme nommer une variable.

Il y a quelques fonctions fixées, comme dialog_request et on_event, lesquelles font parti d'AGS et dont vous DEVEZ utiliser le nom et le nombre de paramètres corrects. Toutefois, vous pouvez aussi ajouter vos propres fonctions en les nommant comme vous voulez, et avoir autant de paramètres que nécessaire.

Ces fonctions sont aussi utiles si vous avez un bloc de code dont vous avez besoin à deux endroits différents — le mettre dans une fonction à la place vous évitera de copier/coller et si vous modifiez votre fonction, tous les autres scripts reliés seront mis à jour.

Pour appeler votre fonction n'importe où dans le script, faites exactement comme avec une fonction interne à AGS : écrivez juste le nom, les paramètres et le point virgule.

Je pense que des exemples seront les bienvenus. Avant tout, regardons une fonction établie ; on_event :

function on_event (EventType evenement, int donnees)
{
  if (evenement == eEventGotScore)
  {
    if (donnees == 5)
    {
      aSonSpecialScore.Play();
    }
    Display("Vous avez %d points!", donnees);
  }
}

Avec ce script, où qu'en soit le score du joueur, un message l'affichera. De plus, si le joueur obtient 5 points d'un coup, la fonction lancera une séquence audio aSonSpecialScore. Comme vous pouvez le voir, vous utilisez les paramètres de la fonction comme n'importe quelle autre variable.

Notre propre fonction

Maintenant, supposons que nous avons une animation spéciale d'un personnage en train de faire une danse, et nous voulons être capable de la jouer à partir de plusieurs endroits dans le scripts. De loin, la voie la plus facile serait de faire ça dans une fonction :

function faire_danser()
{
  cEgo.LockView(10);
  cEgo.Animate(2, 5);
  cEgo.UnlockView();
}

Cette fonction attribue la vue 10 au personnage, lance la séquence numéro 2 de l'animation, attend qu'elle finisse et retourne à la vue initiale.

Astuce : Si vous vous demandez où placer vos fonctions, ouvrez le global script et écrivez-les tout en haut. La fonction doit être en dehors de toutes les autres fonctions.

Maintenant, n'importe où dans le script global, quand vous voulez que le personnage danse, faites juste :

faire_danser();

Retourner une valeur

Vous avez peut-être remarqué que dans quelques fonctions internes à AGS, comme IsGamePaused, cela retourne une valeur dans le script. Vous pouvez faire ça dans vos propres fonctions, en utilisant la commande return. Donc :

function ajouter(int a, int b)
{
  int resultat;
  resultat = a + b;
  return resultat;
}

Cette fonction ajoute les deux nombres ensemble et retourne le résultat (une fonction inutile en pratique puisque l'opérateur + fait la même chose, mais elle illustre bien l'utilité du return). Ainsi, ailleurs dans votre script, vous pouvez écrire :

total = ajouter(5, 10);

par exemple, et total vaudra 15.

Utiliser les fonctions dans les script d'une pièce

Vous avez sans doute remarqué que quand vous ajoutez votre propre fonction dans le script global, vous pouvez très bien l'appeler de n'importe où depuis dans le script global, mais tenter de l'appeler dans le script d'une pièce déclenche une erreur d'analyse. Le manuel explique comment résoudre ça en utilisant L'entête des scripts.

Conclusions

Nous avons survolé quelques sujets plus avancés du script. Je suis sûr qu'il y a plein de trucs que j'ai oublié de mentionner, alors n'hésitez pas à commenter sur les forums.

Page créée le 7 juin 2002 ; mise à jour le 19 août 2007. Copyright © 2002-2007 Chris Jones.


migrer_vers_ags_2.7

Le langage de script d'AGS 2.7 a drastiquement changé par rapport à celui des versions précédentes. Beaucoup de commandes sont devenues orientées objet , ce qui présente plusieurs avantages par rapport à l'approche précédente. Cette page tentera de vous présenter les nouvelles méthodes et d'en expliquer les avantages.

Tout d'abord, pour que vous vous fassiez une idée des changements, voici un exemple de certaines commandes dans l'ancien style, et leurs équivalents :

AnimateObjectEx(0,2,0,0,0,1);
ListBoxAdd(3, 5, "Nouvel objet");

devient :

oCascade.Animate(2, 0, eOnce, eForwards, eBlock);
lstTest.AddItem("Nouvel objet");

Rien qu'en regardant cet exemple les avantages devraient être évidents ; l'apprentissage du script est plus intuitif, il est plus facile à lire (il n'y a plus à trouver ce que signifient les chiffres dans la fonction AnimateObjectEx), et ainsi vous êtes moins à même de faire des erreurs en l'utilisant. Les contrôles de GUI ont désormais des noms ce qui s'approche du style de GUI dans Visual Basic, et vous n'avez plus à vous rappeler les numéros de chacun de vos contrôles.

La fonction de l'éditeur d'auto-complétion du script a été significativement améliorée pour vous aider. Vous verrez en commencer à tester que l'auto-complétion s'affiche plus souvent et ne liste que les commandes pertinentes grâce au scripting orienté objet.

Cela signifie-t-il alors que je dois jeter tous mes anciens scripts ?

Non, ben sûr que non ! Cette nouvelle version est totalement rétro-compatible, ainsi tous vos anciens scripts continueront de fonctionner normalement. Toutefois, lorsque vous écrivez de nouveaux scripts, il est fortement recommander d'utiliser les nouvelles commandes orientées objet.

D'accord, alors euh… qu'est-ce qui a changé exactement ?

La syntaxe du langage de script n'a pas changé du tout (la façon dont vous utilisez les point-virgules, les accolades, etc.). Ceci est comme avant, mais avec quelques ajouts. Le plus significatif concerne les commandes qui sont désormais appelées sur quelque chose . Par exemple, l'ancienne commande :

StopMoving(EGO);

Au premier regard, il n'est pas facile de dire ce que fait StopMoving. Cela stoppe-t-il le déplacement d'un personnage, d'un objet, ou le mouvement de l'écran ? Ce n'est pas intuitif. Désormais, plutôt que passer le personnage comme un paramètre de cette fonction, vous appelez véritablement la fonction sur le personnage. De cette façon :

character[EGO].StopMoving();

Désormais, il est parfaitement clair que c'est le personnage EGO que nous voulons stopper.

Imaginez que vous vous demandiez quelle commande appeler sur un personnage. Avant, c'était difficile à dire, mais maintenant si vous tapez character[EGO]. dans l'éditeur de script, l'auto-complétion affichera une liste de toutes les fonctions et propriétés disponibles pour les personnages.

Je dois donc taper character[EGO] à chaque fois ? Quelle plaie !

Pas si vite ! La plupart des nouvelles commandes orientées objet peuvent être appelées de deux façons – soit depuis un tableau comme nous venons de voir, mais aussi depuis ce qui s'appelle le Script O-Name du personnage. C'est un raccourci qui vous permet d'accéder directement aux éléments, et pour les personnages cela correspond au nom de script précédé de “c”. Ainsi, pour cet exemples nous aurions :

cEgo.StopMoving();

Cette ligne a le même effet que celle avec character[EGO] que nous avons utilisée plus haut.

De plus, la variable player correspond désormais touours au personnage joueur en cours, c'est donc très pratique. Dans un jeu à plusieurs personnages, ce que vous écriviez ressemblait à ça :

StopMoving(GetPlayerCharacter());

Cela peut désormais se faire ainsi :

player.StopMoving();

Hmm, je vois… donc qu'est-ce qui a été objectivé exactement ?

Acutellement, les éléments orientés objet suivant sont utilisables :

Tableau global | Exemple de O-Name
character[] | cEgo
object[] | oPorte
hotspot[] | hArbre
gui[] | gInventaire
inventory[] | iAfficheRose
region[] | (aucun)

Les contrôles GUI sont géré assez différemment. Ils ont tous un nom de script, et on y accède directement grâce à eux. Par exemple, si vous donnez à une list box le nom de script “lstSaves”, alors vous utiliserez “lstSaves.” pour y accéder. Il n'y a pas de tableau global pour les contrôles de GUI.

Comment je trouve les nouveaux équivalents des anciennes fonctions ?

L'index du fichier d'aide a été mis à jour pour vous rediriger automatiquement vers les nouvelles commandes. Ouvrez juste le fichier d'aide, allez à l'index et tapez le nom de l'ancienne commande, et cela affichera le nouvel équivalent orienté objet (s'il existe).

Quelles commandes n'ont pas été changées ?

Les commandes qui n'agissent pas sur quelque chose en particulier (et qui n'auraient donc pas vraiment profité de l'orientation objet) ont été épargnées. Par exemple, SaveGameSlot, QuitGame et autres n'ont pas changé par rapport aux anciennes versions.

C'est quoi ces trucs “eBlock” ?

AGS supporte désormais les types énumérés . Basiquement, dans les situations où vous devez choisir dans une liste d'options possibles, un type énuméré (ou enum ) est désormais introduit. Précédemment, vous aviez des commandes avec des descriptions comme :

“Passez 1 si vous voulez que la fonction bloque, 0 si vous ne le voulez pas.”.

Cela faisait beaucoup de 1 et de 0 dans les appels de fonctions, ce qui rendait la lecture difficile. Maintenant, chaque numéro est plutôt représenté par un mot facile à se souvenir (comme eBlock et eNoBlock). Encore mieux, lorsque vous appelez une fonction qui utiliser un paramètre enum, l'auto-complétion affiche automatiquement une liste d'options parmi lesquels choisir.

Voyez la description du mot-clé enum pour des informations sur la façon d'en créer.

Alors je dois passer toutes ces choses comme eBlock chaque fois que j'appelle la fonction ?

Non ! Beaucoup de fonctions supportent désormais les paramètres optionnels , où les options les plus courantes sont sélectionnées automatiquement. Si vous consulter l'aide pour une fonction comme la commande de personnage Animate, vous verrez que certains paramètres sont définis comme “optionnels”. Cela signifie que vous n'avez pas à les spécifier ; si vous ne le faites pas, l'option qui sera choisie par défaut est décrite dans l'aide pour cette commande.

Quoi d'autre est nouveau ?

Eh bien, la version 2.7 introduit le type de données float , AGS supporte donc finalement les calculs décimaux dans vos scripts. De plus, pour les codeurs plus avancés, vous pouvez créer vos propres fonctions membres (incluant les protégées – protected – et les statiques) afin d'écrire des scripts plus propres que si vous aviez un tas de fonctions globales.

Aussi, l'éditeur de script détecte maintenant plus efficacement vos erreurs. Il se peut que des scripts qui se compilaient sans soucis avant ne fonctionnent plus sur la 2.7. Normalement, le message d'erreur devrait vous signaler directement le problème.

Y a-t-il autre chose à quoi je dois me préparer ?

A cause des nouveaux ajouts, le langage de script a davantage de mots réservés qu'avant. Par exemple, des mots comme “gui”, “object” et “hotspot” sont désormais réservés (puisqu'ils sont utiliser pour accéder aux tableaux globaux). Si votre script utilise des variables qui portent ces noms, il y aura désormais conflit. Vous devrez changer les noms de ces variables pour pouvoir compiler.

Aussi, le langage de script supporte désormais les pointeurs . Vu que c'est un sujet assez complexe, il y a une page séparée qui leur est consacrée.

Eh bien, ça fait beaucoup. Par où je commence ?

Je vous recommanderais d'essayer d'écrire votre prochain script de la nouvelle façon. Chaque fois que vous êtes sur le point d'utiliser une commande de l'ancien style, regarder simplement dans le manuel pour trouver son nouvel équivalent.

Une fois que vous serez habitué au nouveau système, je suis sûr que vous concéderez que c'est une amélioration significative par rapport à l'ancien système de script et vous commencerez à profiter des avantages d'un codage plus rapide et plus intuitif.

Comme toujours, s'il y a quelque chose qui vous tracasse véritablement, postez sur les Forums AGS et nous essayer de vous aider au mieux !

Amusez-vous bien, CJ

Suite : Les pointeurs dans AGS


pointeurs

Table des matières
    • Les Pointeurs dans AGS
      • Les Pointeurs pour les débutants
      • Les Pointeurs pour ceux qui connaissent Java ou C#
      • Les Pointeurs pour ceux qui connaissent C ou C++

Les Pointeurs dans AGS

Diverses commandes dans le nouveau langage de script nécessiteront que vous utilisiez des pointeurs. Cette section a été divisée en trois parties séparées pour vous expliquer les pointeurs en fonction de votre expérience précédente en programmation. – sélectionnez un des liens ci-dessous :

Les Pointeurs pour les débutants

Les pointeurs peuvent être d'apparence décourageante, et dans des langages comme le C ou le C++, ils le sont ; mais AGS essaye de rendre les choses aussi simples que possible.

Simplement, un pointeur est une variable qui pointe vers quelque chose d'un type particulier. Par exemple, un pointeur personnage (Character ) va pointer vers un personnage. Quel est l'intéret de tout cela, me direz vous ? Et bien, regardons en arrière AGS 2.62. Si vous vouliez référencer un hotspot particulier, vous deviez vous rappeler son numéro. Si vous vouliez basculer un objet sur On, vous deviez aussi vous rappeler son numéro. Et puisque vous pouviez par erreur utiliser un numéro d'objet là où vous vouliez un numéro de hotspot, des erreurs pouvaient arriver facilement et ça devenait plutôt embrouillé.

C'est là que les pointeurs interviennent. Ils vous permettent de vous débarrasser de l'utilisation de numéros pour identifier les éléments et en même temps ils fournissent une vérification de type évitant ainsi d'utiliser un hotspot là où vous pensiez utiliser un objet.

Regardons un exemple. Si vous vouliez écrire une chaîne de caractères dans un fichier en 2.62, vous feriez ceci :

int handle = FileOpen("temp.txt", FILE_WRITE);
FileWrite(handle, "Test !");
FileClose(handle);

Plutot simple ; mais si vous vouliez ouvrir le fichier à un endroit et l'écrire à un autre ? Vous deviez avoir recours à une variable globale, puis vous rappeler que ce nombre est un identifiant de fichier et non un identifiant de hotspot ou autre. Maintenant , en 2.7 ce code devient :

File *fichier = File.Open("temp.txt", eFileWrite);
fichier.WriteString("Test !");
fichier.Close();

Simple, n'est-ce pas ? La seule partie “confuse” est de s'habituer à déclarer la variable en File* au lieu de int ; mais vous vous y ferez rapidement et tous les exemples dans la documentation vous pointeront dans la bonne direction.

Regardons un autre exemple. Supposons que vous vouliez une variable contenant le hotspot que la souris survole. En 2.62, vous pourriez avoir un code comme ceci :

// haut du global script
int sourisSurvoleHotspot;

// repeatedly_execute
sourisSurvoleHotspot = GetHotspotAt(mouse.x, mouse.y);

Comment faire en 2.7 ? Simplement :

// haut du global script
Hotspot *sourisSurvoleHotspot;

// repeatedly_execute
sourisSurvoleHotspot = Hotspot.GetAtScreenXY(mouse.x, mouse.y);

Mais attendez, et si vous vouliez savoir si la souris survole votre hotspot porte (disons le hotspot 2). En 2.62 vous feriez :

if (mouseOverHotspot == 2) {
  Display("La souris est sur la porte");
}

Mais ça devient vite confus, parce que si vous changez le numéro d'hotspot de la porte, que se passe-t-il ? Vous devriez alors vous rappeler de changer tous les 2 en 3 dans votre code. En 2.7, vous feriez seulement ceci (en supposant que votre Hotspot a un script du nom de hPorte) :

if (mouseOverHotspot == hPorte) {
  Display("La souris est sur la porte");
}

Si vous êtes un fan des nombres pour d'étranges raisons, vous pouvez toujours faire ceci :

if (mouseOverHotspot == hotspot[2]) {
  Display("La souris est sur la porte");
}

Donc, ceci conclut notre introduction aux pointeurs. J'espère que vous avez compris ce qu'ils sont et à quoi ils servent. Si vous avez des questions, n'hésitez pas à les poser sur notre forum technique.

Les Pointeurs pour ceux qui connaissent Java ou C#

Les pointeurs AGS fonctionnent comme les variables objet en Java et C#. La différence principale est que les pointeurs AGS sont déclarés comme en C avec une astérisque (*) pour représenter le pointeur. Donc :

Hotspot *hs;

va déclarer une variable hs qui pointe sur un hotspot. Cela serait équivalent au code suivant en Java ou C# :

Hotspot hs ;

Dans AGS, les pointeurs sont utilisés pour pointer vers différents types prédéfinis comme les Hotspots, les éléments d'inventaire, les personnages, ainsi de suite. Comme AGS n'a pas de mot-clé new il n'est pas possible de créer des pointeurs vers des types de structures personnalisées.

Vous utilisez les pointeurs comme en Java ou en C#. Diverses méthodes statiques d'AGS retournent des pointeurs vers une instance (par exemple, File.Open, Hotspot.GetAtScreenXY, ainsi de suite). Vous pouvez sauver ce pointeur dans une variable pointeur puis appeler ces méthodes comme en Jave ou C#. Les exemples suivants sont tous valides :

File *leFichier = File.Open("test.dat", eFileWrite);
if (leFichier == null) Display("C'est null !");
File *fichier2 = leFichier;
if (leFichier == fichier2) Display("Ce sont les mêmes fichiers !");
leFichier = null;
fichier2.WriteInt(10);
fichier2.Close();

Si vous essayez d'appeler une méthode sur un pointeur null, une erreur va se produire (comme en Java ou en C#, vous auriez une exception).

La gestion de mémoire des pointeurs dans AGS est automatique – la mémoire est libérée quand il n'y a plus de variables pointant vers l'instance. Cependant, si vous avez une variable pointeur globale, il est conseillé d'initialiser ce pointeur à null quand vous n'en avez plus besoin pour libérer la mémoire.

Les Pointeurs pour ceux qui connaissent C ou C++

Les pointeurs dans AGS sont basés sur la syntaxe C/C++, ils sont donc déclarés avec une astérisque ( * ). Cependant, dans AGS, les pointeurs sont utilisés pour pointer vers différents types prédéfinis, mais il n'est pas possible de créer des pointeurs vers des types de structures personnalisées.

Les membres des pointeurs sont accessibles avec l'opérateur point ( . ) et non avec -> , l'opérateur C. Parce qu'AGS ne supporte pas les pointeurs vers des pointeurs et autres, il n'y a pas besoin d'un séparateur spécifique.

Dans AGS, la gestion de mémoire des pointeurs est faite automatiquement sur la base d'un comptage par référence (sur le même principe que COM), il n'y a donc pas de mot-clé new ou delete . Quand un objet n'est plus référencé par aucune variable de pointeur, il est libéré. Pour cette raison, si vous avez une variable pointeur globale, il est conseillé d'initialiser ce pointeur à null quand vous n'en avez plus besoin pour libérer la mémoire.

Les pointeurs AGS sont fortement typés et vous ne pouvez pas les passer d'un type à l'autre comme vous le feriez en C ou C++. AGS vous autorisera uniquement à comparer ou à assigner des pointeurs du même type ou du même type de base. Il existe un mot clé spécial null auquel tous les pointeurs peuvent être assignés ou comparés, vous indiquant qu'ils ne sont plus assignés.

Parce qu'il n'y a pas de mot clé new , vous ne pouvez pas créer d'instances d'objets, par contre ils sont retournés par des membres statiques de fonctions comme File.Open et Hotspot.GetAtScreenXY. Regardez les exemples de ces fonctions pour comprendre comment les utiliser.


migrer_vers_ags_2.71

AGS 2.71 ajoute un support simple des chaînes de caractères dans le langage de script. Les chaînes ont longtemps été pénibles à utiliser dans AGS, mais ce problème est finalement résolu avec la version 2.71.

Il existe un nouveau type String (avec un 'S' majuscule). Ces nouvelles chaînes se comportent comme les chaînes en Java/C# en cela que vous pouvez facilement les manipuler et leur donner des valeurs.

Par exemple, dans les versions 2.7 et précédentes, vous deviez faire comme cela :

string texte;
StrCopy(texte, "Voici mon texte");

avec la version 2.71, vous pouvez maintenant faire :

String texte = "Voici mon texte";

De plus, les opérateurs == et != peuvent être utilisés pour comparer l'égalité des chaînes (équivaut à utiliser StrComp mais bien plus intuitif). Un intérêt supplémentaire est qu'il n'est plus nécessaire d'utiliser GetText() et SetText() – à la place, vous pouvez simplement utiliser la propriété Text.

Toutes les anciennes fonctions qui prenaient un paramètre “tampon de chaîne” (”string buffer”) ont désormais été remplacées par de nouvelles qui retournent une chaîne. Les propriétés des chaînes peuvent s'utiliser comme n'importe quelle propriété. Ainsi :

lblLabel.Text = "Salut";
String buttonValue = btnOK.Text;

ou autre.

NOTE : Certaines des nouvelles fonctions ont été implémentées dans les objets Game – par exemple, la nouvelle fonction GameSaveSlotDescription doit être appelée ainsi :

String description = Game.GetSaveSlotDescription(10);

Ceci fait partie d'une migration générale vers des fonctions orientées objet, mais méfiez vous des confusions possibles. Le manuel vous renseignera sur les fonctions qui le requièrent.

Plutôt qu'utiliser les vieilles fonctions comme StrCat et StrContains, vous pouvez maintenant appeler les fonctions directement sur les chaînes :

String texte = "Salut";
texte = texte.Append(" tout le monde");

signifie que texte contient désormais “Salut tout le monde”. Notez texte = dans cette expression. Les fonctions comme Append retourneront une version modifiée de la chaîne, elles ne changeront pas véritablement l'originale. Ainsi, pour mettre à jour la variable texte vous devez lui assigner le résultat.

Rétro-compatibilité

Afin de maintenir la rétro-compatibilité, un nouveau mot-clé “const” a été ajouté. Celui-ci s'applique seulement aux vieilles chaînes, et vous permet de les incorporer aux nouvelles. Le nouveau type de chaînes (String) peut être passé aux fonctions qui attendent une ancienne chaîne constante (”const string”) (ce qui signifie qu'il ne sera pas permis de changer le contenu de la chaîne), mais ne peuvent pas être passées à une fonction qui attend une chaîne (string) simple (puisque son contenu peut être modifié par la fonction).

Les fonctions personnelles que vous aviez définies et qui prenaient une chaîne comme paramètres ne fonctionneront donc peut-être plus. Si c'est le cas, changez l'ancien paramètre “string” pour “const string” et le problème devrait être résolu.

Toutes mes excuses pour le désagrément, mais c'est le seul moyen de permettre aux nouvelles chaînes d'interagir sans soucis avec les anciennes.


appeler_des_fonctions_globales_depuis_vos_scripts_locaux

Vous pouvez maintenant appeler vos fonctions de script global directement à partir de votre room. Ca signifie que si vous avez un script que vous souhaitez utiliser en réponse à différents événements au cours du jeu, vous pouvez appeler à partir de votre script de room plutôt que de dupliquer le code.

Pour utiliser une fonction globale, ouvrir le header de script principal (GlobalScript.ash), et ajoutez une ligne semblable à la suivante:

import function my_function_name (parameters);

Ou my_function_name est le nom de la fonction script globale, et parameters est une liste contenant Seulement les types de paramètres qu'il faut. Par exemple, si vous aviez dans votre script global:

function do_animation (int anim_number) {

alors vous écrivez:

import function do_animation (int);

Pour utiliser la fonction, il vous suffit de l'appeler normalement dans votre script, par exemple:

do_animation (3);

Vous pouvez aussi retourner une valeur à l'appelant en utilisant le mot clé “return” , et le script en place l'utilise de la même façon qu'il le fait avec les fonctions internes. Par exemple, la fin de votre fonction de script global pourrait être:

return 51;

Alors le script local serait :

int value = do_animation(3);
,


l_entete_des_scripts

L'entête des scripts

Cela vous permet d'inclure les mêmes informations dans tous vos scripts. Par exemple, si vous avez une fonction globale que vous souhaitez utiliser dans toutes vos pièces, vous pouvez ajouter sa définition d'importation à l'en-tête de fichier.

Ne placez directement aucune fonction dans cet en-tête, parce que si vous le faites vous aurez besoin de re-compiler tous les scripts à chaque fois que vous modifierez la fonction. Au lieu de cela, placez vos fonctions dans votre script global et placez juste une ligne d'importation dans le fichier d'en-tête pour permettre à d'autres scripts d'y accéder.


la_syntaxe_des_chaines_de_caracteres

Syntaxe des chaînes de caractères (String)

Il vous arrivera souvent, dans votre jeu, d'avoir besoin de créer une chaîne basée sur les valeurs des variables, et des fonctions comme Display (Afficher) et String.Format vous permettent de le faire.

AGS utilise un format de style printf pour les arguments (utilisé par le langage C). Cela signifie que vous devez utiliser des caractères spéciaux pour insérer la valeur d'une variable. Ces caractères spéciaux commencent par un signe pour-cent ( % ), puis vous spécifiez le type de variable. Le type de variables que vous pouvez afficher sont listés en-dessous.

Les codes speciaux que vous pouvez utiliser sont :

Code | Description
%d | Entier (pour afficher une variable de type entier ou short)
%0Xd | Entier de X chiffres (précédé du nombre de zéros nécessaires)
%s | Chaîne de caractères (pour afficher une variable de type string )
%c | Caractère (affiche le caractère ASCII correspondant à la valeur )
%f | Nombre décimal (pour afficher une variable de type float )
%.Xf | Nombre décimal à X décimales
%% | Affiche le caractère %
[ | Insère une nouvelle ligne dans le message

Quelques exemples:

int vie = 42;
float deuxPi = Maths.Pi * 2.0;
String message = "Une chaîne de caractères";

Display("Un texte sans variable.");
Display("Le sens de la vie est %d.", vie);
Display("Le sens de la vie en trois chiffres est %03d.", vie);
Display("Deux fois Pi vaut %f.", deuxPi);
Display("Le message dit : %s.", message);

vont afficher :

Un texte sans varible.
Le sens de la vie est 42.
Le sens de la vie en trois chiffres est 042.
Deux fois Pi vaut 6.283186.
Le message dit : Une chaîne de caractères.

Vous pouvez afficher autant de variables que vous le souhaitez en une seule ligne :

int vie = 42;
float deuxPi = Maths.Pi * 2.0;

Display("La vie vaut %d, 2 x Pi = %f, et mon dîner est %s.", vie, deuxPi, "terrible");

mais, faites bien attention à bien fournir le bon nombre de variables correspondant avec les balises que vous utilisez dans le texte. Si vous ne fournissez pas assez variables, le jeu va planter.


les_fichiers_scripts

Les fichiers scripts (modules)

Si vous travaillez sur un assez grand jeu, vous verrez que votre script global peut rapidement devenir assez gros et lourd. AGS vous permet de créer des scripts supplémentaires (anciennement connue sous le nom de modules de script) afin de fractionner votre code et facilement importer des scripts écrits par d'autres personnes.

Le script global principal doit encore contenir toutes les fonctions d'événements (les scripts correspondant à Look At Character, Interact With Inventory, etc.) et de tous les éléments de GUI (btnSave_Click, etc.)

Mais si vous avez des fonctions personnalisées, vous pouvez les mettre dans un script séparé afin de diviser votre code. Les scripts ont l'avantage qu'ils peuvent être facilement exportés et importés, si vous voulez partager une partie de votre code avec d'autres personnes, ou même seulement la déplacer d'un jeu à l'autre.

Les scripts pour le jeu peut être vu dans le noeud “Scripts” dans l'arbre du projet. Chaque script a son propre entête, qui est l'endroit où vous placez le import de ce script pour permettre au reste de votre jeu d'accéder à ses fonctionnalités.

L'ordre des scripts est important. Un script ne peut utiliser des fonctionnalités d'autres des scripts qui viennent avant dans la liste, de sorte que l'option Monter et Descendre vous permettent pour définir l'ordre. Le script global est toujours en bas afin qu'il puisse accéder à tous les autres scripts, et les cripts des rooms ont automatiquement accès à tous les scripts.

À titre d'exemple, supposons que vous voulez avoir une fonction spéciale AddNumbers dans un module. Vous alles créer un nouveau script, puis mettre dans son fichier d'en-tête (. ASH):

import function AddNumbers(int a, int b);

Puis, dans le fichier de script (. ASC), vous pouvez mettre:

function AddNumbers(int a, int b) {
  return a + b;
}

C'est le principe de base derrière l'utilisation de plusieurs scripts!

Fonctions speciales

Est-ce que ces script rajoutés peuvent utiliser des fonctions comme game_start et repeatedly_execute ? Eh bien, oui et non. Ils peuvent contenir les fonctions suivantes, et ils seront appelés au bon moment juste avant les fonction de script globales :

  • function game_start()
  • function on_event(EventType event, int data)
  • function on_key_press(eKeyCode keycode)
  • function on_mouse_click(MouseButton button)
  • function repeatedly_execute()
  • function repeatedly_execute_always()

Toutes les autre fonction spéciales , comme dialog_request, seront seulement appelées dans le script global même si elles existent dans un autre script. Si vous avez besoin d'autres scripts pour utiliser ces fonctionnalités , vous pouvez créer une fonction personnalisée et l'appeler depuis votre script global.

La commande ClaimEvent est utilisée pour on_key_press, on_mouse_click et on_event. L'appeler empêche d'appeler ces fonctions dans le reste des scripts (y compris les scripts globaux)

,


comprendre_le_blocage_des_scripts

Vous verrez certaines commandes listées comme “bloquant l'exécution”, où l'exécution du script est bloquée jusqu'à ce que la commande soit accomplie. Mais qu'est-ce que cela signifie, exactement?

Afin de mieux comprendre cela, nous avons besoin d'explorer un peu plus la façon dont le moteur de script AGS fonctionne. Dans un jeu AGS, il y a trois fils (threads) de script qui peuvent être en cours d'exécution à la fois. Pensez à un fil comme un mini-processeur qui exécute vos scripts.

Au début du jeu, les fils sont tous en attente (ils n'exécutent aucun script) :

Maintenant, au fur et à mesure que vos scripts doivent être exécutés, AGS va essayer de les exécuter sur le fil approprié (fil de la pièce pour les scripts locaux , et fil global pour les scripts globaux).

Donc, lors de la première boucle du jeu votre script global repeatedly_execute va etre exécuté.

et une fois l'exécution finie, le fil redevient passif à nouveau.

Mais supposons que dans votre repeatedly_execute, vous appeliez la commande Say. Say (ou DisplaySpeech dans les anciennes versions) est une commande bloquant l'exécution et ne se termine que quand le personnage a fini de parler.

Le fil global est maintenant bloqué , attendant que le personnage ait fini de parler. Cela signifie qu'aucun de vos scripts globaux tels que repeatedly_execute, on_event ou on_key_press ne va être exécuté tant que le personnage parle. Le fil est bloqué.

AGS empile jusqu'à 5 fonctions pour les exécuter sur ce fil dès qu'il se libère ; mais si vous avez énormement de choses en cours, il est possible de louper des évènements tels que on_event ou des appuis sur le clavier si votre script est bloqué longtemps.

Regardons la situation la plus commune dans laquelle se pose un problème. Supposons que se déclenche l'événement Look at inventory item (Regarder l'objet d'inventaire) qui exécute un code pour afficher un message.
Supposons aussi que vous ayez du code à la fin de votre fonction on_mouse_click pour que le personnage reste sur place après avoir exécuté les événements de la fonction on_mouse_click.
Vous allez découvrir que le code à la fin de on_mouse_click est en fait appelé avant l'événement correspondant à l'inventaire. Regardons pourquoi :

Rappelez vous qu'AGS n'exécute pas les événements automatiquement. Plutôt, la fonction on_mouse_click gére le clic de la souris et appelle ProcessClick pour exécuter les événements appropriées. Ce faisant, AGS remarque que l'événement Look At Item (Regarder l'Objet d'Inventaire) de la clé est associé à une fonction.
Mais, oh non ! les scripts des objets d'inventaire sont dans le script global et le fil global est bloqué à cause de l'appel de on_mouse_click. Donc, le script appelé lors de l'événement avec l'objet d'inventaire est ajouté à la pile du fil et on_mouse_click finit de s'exécuter. Le script d'événement avec l'inventaire suivra après.

Vous pourriez penser que cela signifie que les événements avec les objets et les zones interactives (hotspots) peuvent s'exécuter à l'intérieur de on_mouse_click, vu qu'ils utilisent le fil de la pièce, comme ceci :

Cependant, ce n'est pas le cas. C'est toujours le fil global qui apelle ProcessClick, donc le script de la pièce va en fait être exécuté sur le fil global quand celui-ci sera libéré.

Finalement, nous arrivons au fil No-Block. Ce fil est uniquement utilisé pour exécuter la fonction repeatedly_execute_always. Parce que repeatedly_execute_always n'est autorisée à exécuter aucune fonction bloquante, ceci garantit que ce fil ne sera jamais bloqué et tournera toujours, même si les autres fils sont bloqués.

J'espère que cela aide à expliquer les blocages de scripts dans AGS. Si ce n'est pas clair, parlez-en sur le forum technique.

,


les_tableaux_dynamiques

Tableaux Dynamiques

Supposons que vous vouliez écrire un script que les gens puissent utiliser dans leurs jeux. Vous voulez stocker la Santé de chaque personnage du jeu, mais vous ne savez pas combien de personnages il y aura au final. Que faire ?

Les Tableaux Dynamiques sont justement faits pour ça. Vous pouvez déclarer un tableau comme ceci :

int SantePerso[];

dans votre fichier script. La notation spécial informe AGS que vous ne savez pas encore la largeur que fera le tableau. Désormais, avant d'utiliser le tableau, vous pouvez faire ceci (probablement dans game_start) :

SantePerso = new int[Game.CharacterCount];

Si vous oubliez cette commande new, vous aurez une Erreur Null Pointer lorsque vous tenterez d'accéder au tableau. Vous pouvez changer la taille d'un tableau simplement en utilisant à nouveau la commande new en passant une taille différente ; mais cela effacera le contenu du tableau en cours.

Pour le moment, les tableaux dynamiques peuvent être créés comme variables globales et locales, mais vous ne pouvez pas les intégrer dans une structure. De plus, vous pouvez créer des tableaux dynamiques de types basiques (int, char, etc.) et de types structures intégrées (String, Character, etc.) mais pas encore de type de structures personnalisées.


fonctions_d_extension

Fonctions d'extension

Supposez que vous vouliez ajouter une nouvelle fonction aux personnages, “Crier”, qui les ferait criter “AARRRGGGHHH”. Puisque l'objet Character est prédéfini dans AGS, vous n'avez pas la simple possibilité de lui ajouter une fonction.

C'est pour cela qu'existent les Fonctions d'Extension. Voici un exemple :

function Crier(this Character*)
{
this.Say("AAAAARRRRGGGGHHHHHH!!!!");
}

Ce code ajoute une nouvelle fonction “Crier” à l'objet Character, de façon à ce que, dans votre code, vous puissiez l'appeler ainsi :

player.Crier();
cEgo.Crier();

et ainsi de suite.

Où je le mets ce code ?

Dans l'entête de votre script, vous mettez :

import function Crier(this Character*);

et vous définissez la fonction dans le fichier script. Cela vous permettra alors de l'utiliser dans les autres scripts.


variables_globales_du_jeu

Variables du jeu

Les variables suivantes sont accessibles depuis votre script. Elles vous permettent de paramétrer le moteur lors de l'exécution.

Les noms en gras sont des variables en lecture seule et ne doivent PAS être modifiées dans le script.

Toutes les variables suivantes sont des variables entières (int).

game.abort_key | Le numéro de touche pour Arrêter le jeu (Abort Game), qui vous permet de quitter même si votre script bloque. Vaut 324 (Alt+X) par défaut.
game.ambient_sounds_persist | Si 0 (par défaut), les sons ambiants cessent à tout changement de pièce. Passez à 1 pour dire à AGS de laisser jouer les sons ambiants après un changement de pièce.
game.anim_background_speed | La vitesse d'animation de l'arrière-plan de la pièce en cours - même valeurs que dans l'éditeur.
game.auto_use_walkto_points | 1 par défaut ; donnez la valeur 0 pour qu'AGS cesse d'utiliser automatiquement les points de destination (walk-to points) des zones interactives (hotspots).
game.bgspeech_game_speed | Si 0 (par défaut), la durée d'affichage des discours d'arrière-plan ne dépendra pas de la vitesse du jeu. Si 1, alors la durée d'affichage sera relative à la vitesse du jeu.
game.bgspeech_stay_on_display | Si 0 (par défat), les discours d'arrière-plan sont effacés dès qu'une commande Say survient ; si 1, ce n'est pas le cas.
game.close_mouth_end_speech_time | L'animation de discours, après l'effacement du texte correpondant, s'arrêtera après ce nombre de cycles de jeu. Vaut 10 par défaut. Aucun effet en mode voix.
game.debug_mode | Définit si le debug mode est activé (1) ou non (0).
game.dialog_options_x | Écart horizontal (x) entre les options des dialogues de GUI et les bordures.
game.dialog_options_y | Écart vertical (y) entre les options des dialogues de GUI et les bordures.
game.disable_antialiasing | Donnez la valeur 1 pour désacter le lissage des personnages redimensionnés, indépendamment du choix de l'utilisateur dans Setup. Vaut 0 par défaut.
game.following_room_timer | Le temps après lequel le personnage suivant apparaît dans la pièce, 150 par défaut (plus la valeur est haute, plus le délai est long).
game.keep_screen_during_instant_transition | En temps normal, la transition instantannée obscurcit l'écran dans les modes de couleur 8-bit, pour éviter d'étranges effets sur la palette. Toutefois, vous pouvez donner la valeur 1 à ce paramètre pour que ce ne soit pas le cas.
game.inv_activated | Le numéro d'objet d'inventaire sur lequel le joueur a cliqué pour la dernière fois. Utile pour unhandled_event.
game.inventory_greys_out | Donnez la valeur 1 pour que l'interface d'inventaire se grise lorsque la désactivation des GUI correspond à “GUIs Grey Out” (”Les GUI se grisent”)
game.lipsync_speed | Similaire à game.TextReadingSpeed, mais ceci détermine à quelle vitesse le texte est 'lu' par le mouvement des lèvres. Vous ne devriez pas le mettre plus bas que text_speed, sinon la lecture s'achèvera dès que le texte sera coupé. Vaut 15 par défaut.
game.max_dialogoption_width | Largeur maxium pour les cadres des options de dialogue basées sur les fenêtre texte (textwindow-based dialog options box). Vaut 180 par défaut.
game.min_dialogoption_width | Largeur mainimum pour les cadres des options de dialogue basées sur les fenêtre texte (textwindow-based dialog options box). Vaut 0 par défaut.
game.narrator_speech | L'ID du personnage à utiliser pour la voix associée à la commande Display(). Est par défaut associé au personnage principal. Vous pouvez aussi utiliser NARRATOR qui utilise le préfixe 'NARR' - personnage narrateur spécial.
game.no_textbg_when_voice | Normalement, 0. Si vaut 1, et que le style de discours Sierra-style avec arrière-plan (Sierra-style With Background) est en cours d'utilisation, changera pour le style Sierra (sans arrière-plan) si une ligne de discours oral est présente.
game.read_dialog_option_color | -1 par défaut. Vous pouvez donner un numéro de couleur, auquel cas les options de dialogue que le joueur a sélectionnées seront affichées dans cette couleur.
game.roomscript_finished | La fonction on_call a été entièrement exécutée (Voir CallRoomScript)
game.score | Le score du joueur. Pour modifier le score, utilisez la fonction GiveScore
game.score_sound | L'effet sonore à jouer lorsque le joueur gagne des points, initialement défini dans l'éditeur.
game.screenshot_height | La hauteur des captures d'écran. La dimension la plus large est (320×200) (plein écran), ce qui donne la meilleure qualité mais aussi un poids de fichier lourd. Vaut 160×100 par défaut.
game.screenshot_width | La largeur des captures d'écran.
game.show_single_dialog_option | Si 1, lorsqu'une seule option de dialogue est valable, la montre malgré tout. Vaut 0 par défaut.
game.sierra_inv_color | La couleur d'arrière-plan des inventaires de style Sierra.
game.skip_display | La manière dont les messages Display() sont passés ; les valeurs possibles sont celles de SetSkipSpeech (vaut 3 par défaut).
game.skip_speech_specific_key | 0 par défaut. Vous pouvez définir une valeur de touche, auquel cas seule cette touche peut passer le texte.
game.speech_bubble_width | La largeur maximum de la fenêtre de texte de pensée (100 par défaut).
game.speech_text_align | L'alignement du texte de discours dans le style Lucasarts. Les valeurs possibles sont celles de game.text_align. Vaut eAlignCentre par défaut.
game.speech_text_gui | Le numéro de la fenêtre de texte GUI utilisée pour les discours style sierra.
game.text_align | L'alignement du texte dans les cadres de message et dans le discours style Sierra : eAlignLeft : le texte est aligné à gauche du cadre (par défaut) eAlignCentre : le texte est centré dans le cadre eAlignRight : le texte est aligné à droite du cadre Ces options n'ont pas d'effet dans le style Lucasarts, qui centre systématiquement.
game.text_shadow_color | La couleur utilisée pour l'ombre du texte de discours (16 par défaut).
game.top_bar_XXXX | Personnalisation de DisplayTopBar, voir le lien pour plus de détails
game.total_score | Le score maximum possible, initialement défini dans l'éditeur.
game.used_mode | Le mode de curseur (Cursor) utilisé lors du dernier clic (à utiliser avec les événements “any click” (”n'importe quel clic”) pour savoir le mode qui a été utilisé)
mouse.x | Coordonnée X de la souris lors du dernier cycle de jeu (résolution 320)
mouse.y | Coordonnée Y de la souris lors du dernier cycle de jeu (résolution 200)
palette[BLOC].r | Le composant rouge (0-63) du BLOC de la palette.
palette[BLOC].g | Le composant vert (0-63) du BLOC de la palette.
palette[BLOC].b | Le composant bleu (0-63) du BLOC de la palette.
player.[x,y,name,…] | Correspond au personnage joueur en cours.
,


fonctions_globales_predefinies

Table des matières
    • Fonctions prédéfinies du script global
      • dialog_request
      • game_start
      • interface_click
      • on_event
      • on_key_press
      • on_mouse_click
      • repeatedly_execute
      • repeatedly_execute_always
      • unhandled_event

Fonctions prédéfinies du script global

Dans le fichier principal du script global, certaines fonctions sont automatiquement ajoutées lorsque vous créez un jeu. Ce sont les événements globaux, dont les fonctions sont appelées lorsqu'un événement particulier survient. Il y a aussi certains autres événements dont vous pouvez ajouter les fonctions si vous le voulez.

Les fonctions possibles sont :

dialog_request

dialog_request (int parametre)
Appelée lorsqu'une ligne “run-script” d'un script de dialogue est exécutée. PARAMETRE correspond au nombre qui suit “run-script” sur la ligne qui a appelé la fonction.

game_start

game_start ()
Appelée au démarrage du jeu, avant que la première pièce ne soit chargée. Vous pouvez l'utiliser pour définir les positions de départ des personnages, pour (dés)activer des GUIs, …
Vous ne pouvez pas jouer d'animation ou quoique ce soit qui suppose que la pièce soit chargée .

interface_click

interface_click (int interface, int bouton)
(Désormais oboslète) Appelée lorsque le joueur clique sur un bouton d'un GUI dont l'action est définie comme “Run script”. INTERFACE est le numéro du GUI cliqué. BOUTON est le numéro du bouton dans ce GUI.

on_event

on_event (EventType evenenemnt, int DATA)
Appelée lorsque certains événements du jeu surviennent. La valeur de DATA dépend de l'événement. Ceci vous permet de vérifier ou de mettre à jour des choses chaque fois qu'un joueur fait quelque chose, indépendamment de la pièce où il se trouve. Les valeurs possibles pour EVENEMENT sont :
eEventEnterRoomBeforeFadein
         appelé juste avant l'événement Player Enters Room ("Joueur Entre dans la Pièce")
         DATA = numéro de la nouvelle pièce
eEventLeaveRoom
         appelé juste après l'événement Player Leaves Room ("Joueur Quitte la Pièce")
         DATA = nuémro de la pièce quittée
eEventGotScore
         appelé lorsque le score du joueur change
         DATA = nombre de points obtenus
eEventGUIMouseDown
         appelé lorsqu'un bouton de souris est pressé sur un GUI
         DATA = numéro du GUI
eEventGUIMouseUp
         appelé lorsqu'un bouton de souris est relâché sur un GUI
         DATA = numéro du GUI
eEventAddInventory
         appelé lorsque le joueur obtient un nouvel objet d'inventaire
         DATA = numéro de l'objet d'inventaire obtenu
eEventLoseInventory
         appelé lorsque le joueur perd un objet d'inventaire
         DATA = numéro de l'objet d'inventaire perdu
eEventRestoreGame
         appelé juste après le chargement d'une partie sauvegardée
         DATA = numéro du bloc de sauvegarde

on_key_press

on_key_press (eKeyCode touche)
Appelée lorsque l'utilisateur appuie sur une touche. TOUCHE correspond à la valeur ASCII de la touche. La liste des valeurs est dressée dans cette section.

NOTE : Cet événement peut aussi être géré par les scripts individuels de pièce. Si vous ajoutez la définitions de cette fonction à vos script de pièce de la même façon que dans le script global, le script de la pièce sera déclenché avant et interceptera la pression de touche en premier, puis décidera de la passer au script global ou non. Consulter la fonction ClaimEvent pour plus de détails.

on_mouse_click

on_mouse_click (MouseButton bouton)
Appelée lorsque le joueur clique avec un bouton de la souris. BOUTON vaut soit LEFT soit RIGHT soit MIDDLE, selon le bouton qui a servi au clic. Les variables globales “mouse.x” et “mouse.y” contiennent la position de la souris.
Si 'Handle inventory clicks in script' ('Gérer les clics d'inventaire dans le script') est activée dans les options du jeu, cette fonction peut aussi être appelée avec eMouseLeftInv, eMouseMiddleInv ou eMouseRightInv, ce qui signifie qu'un clic a eu lieu sur un objet d'inventaire avec le bouton gauche, central ou droit respectivement.
Si 'Enable mouse wheel support' ('Autoriser le support de la molette') est activée, cette fonction peut aussi être appelée avec eMouseWheelNorth ou eMouseWheelSouth, ce qui indique que l'utilisateur a respectivement tourné la molette vers le haut ou vers le bas.

NOTE : Cet événement peut aussi être géré par les scripts individuels de pièce. Si vous ajoutez la définition de cette fonction à vos script de pièce de la même façon que dans le script global, le script de la pièce sera déclenché avant et interceptera le clic en premier, puis décidera de le passer au script global ou non. Consulter la fonction ClaimEvent pour plus de détails.

repeatedly_execute

repeatedly_execute()
Appelée à chaque cycle de jeu (normalement 40 fois par seconde).
Voir cette page d'aide pour plus de détails.

repeatedly_execute_always

repeatedly_execute_always()
Appelée à chaque cycle de jeu, même lorsqu'une routine bloquante (par exemple, un discours ou une cutscene) est en cours. Vous ne pouvez pas appeler de fonction bloquante dans cette fonction.
Voyez cette page d'aide pour plus de détails.

unhandled_event

unhandled_event (int quoi, int type)
Appelée lorsqu'un événements est déclenché, mais qu'il n'est pas proposé d'y associer une fonction dans la liste des événements (Event list). Cela peut être utile pour afficher un type de message par défaut comme “Je ne peux pas faire ça”. Les valeurs de QUOI et de TYPE vous renseignent sur ce que le joueur a fait.
Les valeurs possibles sont listées ici :
QUOI | TYPE | Description
1 | 1 | Regarder une zone interactive (hotspot)
1 | 2 | Interagir avec une zone interactive (hotspot)
1 | 3 | Utiliser un objet d'inventaire sur une zone interactive (hotspot)
1 | 4 | Parler à une zone interactive (hotspot)
1 | 7 | Ramasser une zone interactive (hotspot)
1 | 8 | Cursor Mode 8 sur une zone interactive (hotspot)
1 | 9 | Cursor Mode 9 sur une zone interactive (hotspot)
2 | 0 | Regarder un objet
2 | 1 | Interagir avec un objet
2 | 2 | Parler à un objet
2 | 3 | Utiliser un objet d'inventaire sur un objet
2 | 5 | Ramasser un objet
2 | 6 | Cursor Mode 8 sur un objet
2 | 7 | Cursor Mode 9 sur un objet
3 | 0 | Regarder un personnage
3 | 1 | Interagir avec un personnage
3 | 2 | Parler à un personnage
3 | 3 | Utiliser un objet d'inventaire sur un personnage
3 | 5 | Ramasser un personnage
3 | 6 | Cursor Mode 8 sur un personnage
3 | 7 | Cursor Mode 9 sur un personnage
4 | 1 | Regarder rien (c-à-d aucune zone interactive)
4 | 2 | Interagir avec rien
4 | 3 | Utiliser un objet d'inventaire sur rien
4 | 4 | Parler à rien
5 | 0 | Regarder un objet d'inventaire
5 | 1 | Interagir avec un objet d'inventaire (actuellement impossible)
5 | 2 | Parler à un objet d'inventaire
5 | 3 | Utiliser un objet d'inventaire sur un autre
5 | 4 | Autre clic sur un objet d'inventaire

Notez que l'événement “Character stands on hotspot” (”Le personnage est sur une zone interactive”) n'est pas concerné par cette fonction, et qu'elle ne sera pas déclenchée si un événement “Any click” (”N'importe quel clic”) est défini.
Cette fonction n'est pas déclenchée si le joueur ne clique sur rien (hotspot 0).

,


repexec

repeatedly_execute (_always)

Une des choses que vous aurez le plus souvent à faire dans vos scripts consiste à vérifier si quelque chose s'est passé dans le jeu – et si c'est le cas, alors provoquer une réaction en conséquence.

Par exemple, supposons que vous vouliez qu'un oiseau vole de part et d'autre de l'écran en arrière-plan. Vous aurez besoin de dire à l'oiseau de se déplacer dans une direction, de détecter lorsqu'il est arrivé, et de lui dire de faire le chemin inverse.

C'est là qu'interviennent les fonctions repeatedly_execute et repeatedly_execute_always.

Quelle différence y'a-t-il entre ces événements ?

L'événement repeatedly_execute est déclenché à chaque cycle de jeu (par défaut donc, 40 fois par seconde), mais seulement lorsque le jeu n'est pas bloqué. Cela signifie que l'événement sera déclenché tant qu'il n'y a pas d'animation ou de déplacement bloquants en cours (c'est-à-dire une commande Walk ou Animate passée avec le paramètre eBlock).

D'un autre côté, repeatedly_execute_always est inconditionnellement déclenché à chaque cycle, que le jeu soit bloqué ou non. Cette constance a un coût : vous ne pourrez y mettre aucun code qui bloquerait le jeu. Ainsi, si vous essayez d'y placer la commande player.Walk() avec le paramètre eBlock – ou plus simplement la commande Wait(1);, alors ces commandes échoueront car elles seront dans repeatedly_execute_always.

Quand est-ce que j'utilise l'un plutôt que l'autre ?

Vous utiliserez généralement repeatedly_execute pour faire des choses qui affectent le joueur et repeatedly_execute_always pour gérer des tâches d'arrière-plan qui n'affectent pas directement le joueur.

Par exemple, si votre jeu possède un système de gestion de la faim, vous pourrez vérifier dans repeatedly_execute depuis combien de temps le joueur n'a pas mangé – et si cela fait plus de 20 minutes, alors le personnage joueur devra s'arrêter et frotter son ventre. Puisque, pour cela, vous utiliserez une animation bloquante, et que vous ne voulez pas interrompre toute éventuelle scène en cours, repeatedly_execute sera l'endroit idéal pour gérer ça.

D'un autre côté, dans le cas de notre oiseau qui parcourt l'écran, vu que nous ne voulons pas bloquer le jeu lorsque l'oiseau vole et que cela se passe simplement en arrière-plan, repeatedly_execute_always sera l'endroit idéal pour gérer ça.

Comment je crée ces événements ?

Dans les scripts principaux, vous créez votre fonction repeatedly_execute en collant simplement ce qui suit dans le script. Dans GlobalScript.asc, ceci est déjà créé pour vous :

function repeatedly_execute()
{
  // Placez votre code ici
}

Dans les pièces, cela est un peu différent. Si vous voulez déclencher un script spécifique à une certaine pièce, ouvrez le tableau des événements (Events Pane) de la pièce et vous verrez l'événement “Repeatedly execute”. Cliquez sur le bouton ”…” et une fonction appelée Room_RepExec devrait être créée pour vous.

Rappelez-vous bien ceci – dans les scripts des pièces, vous ne pouvez pas simplement coller une fonction repeatedly_execute ; à la place vous devez utiliser le tableau des événements pour la créer.

Pour créer repeatedly_execute_always, vous pouvez simplement coller le script qui suit dans le script – ceci incluant les scripts de pièce. Le code suivant marchera dans n'importe quel script, que ce soit un script global ou un script de pièce :

function repeatedly_execute_always()
{
  // Placez votre code ici
}

Rappelez-vous, évidemment, que les fonctions RepExe et repeatedly_execute_always placées dans le script d'une pièce se déclencheront uniquement lorsque le joueur se trouve dans cette pièce !

Je peux avoir un exemple ?

Implémentons les deux choses que nous avons évoquées. Voici notre code pour la gestion de la faim :

function repeatedly_execute()
{
  // incrémentons notre variable timer (que nous avons auparavant
  // créée dans l'éditeur des variables globales)
  timerFaim++;

  if (timerFaim == 800)
  {
    Display("Vous avez très faim.");
    player.LockView(FROTTEVENTRE);
    player.Animate(0, 5, eOnce, eBlock, eForwards);
    player.UnlockView();
  }
}

et plaçons le code de l'oiseau volant dans le script de la pièce, parce que cela ne se passe que dans cette pièce :

function repeatedly_execute_always()
{
  if (!cOiseau.Moving)
  {
    if (cOiseau.x < 100)
    {
      // si l'oiseau est à gauche de l'écran,
      // déplaçons-le vers la droite
      cOiseau.Walk(400, cOiseau.y, eNoBlock, eAnywhere);
    }
    else
    {
      // sinon, déplaçons-le vers la gauche
      cOiseau.Walk(0, cOiseau.y, eNoBlock, eAnywhere);
    }
  }
}


personnalisation_de_l_affichage_des_options_des_dialogues

Affichage personnalisé des options de dialogue

Par défaut, AGS propose deux types d'options de dialogue – les afficher en utilisant les dimensions et la positions d'un GUI existant, ou crée une fenêtre de texte pour y afficher les options.

Avec AGS 3.1, si aucune de ces méthodes ne vous convient (par exemple, parce que vous voulez utiliser des options de dialogue basées sur des images, ou si vous voulez ajouter des flèches pour parcourir la liste), vous pouvez désormais implémenter vous-même l'affichage des options de dialogue dans le script.

NOTE : Ce sujet concerne du code complexe. Si vous débutez tout juste avec AGS, vous devriez pour le moment vous contenter des styles d'options de dialogue déjà implémentés, puis revenir à cela plus tard, lorsque vous serez plus à l'aide avec le code.

Pour écrire votre code d'options de dialogue personnalisées, vous devrez faire les choses suivantes :

  • Ajouter une fonction dialog_options_get_dimensions à votre script (voir l'exemple plus bas). Cette fonction est appelée par AGS pour déterminer sur quelle partie de l'écran vous dessinerez. En définissant des valeurs de largeur et de hauteur supérieures à 0, le système de dialogue personnalisé s'active.
  • Ajouter une fonction dialog_options_render, qui est appelée par AGS lorsqu'il faut dessiner les options du dialogue. Elle fournit une DrawingSurface standard, que vous pouvez utiliser pour dessiner.
  • Ajouter une fonction dialog_options_get_active, qui est appelée par AGS lorsque le joueur déplace la souris à l'écran. Elle permet de savoir l'option que la souris survole, afin qu'AGS sache quelle option traiter lorsque le joueur clic sur le bouton de la souris.
  • De façon optionnelle, ajouter une fonction dialog_options_mouse_click. Elle est appelée par AGS si le joueur clique alors qu'il ne survole aucune option. Vous pourriez l'utiliser pour gérer des flèches de défilement personnalisées, par exemple.

Il n'est pas obligatoire de placer ces fonctions dans la script global ; vous pouvez les placer dans le script que vous préférez. Toutefois, gardez-vous des éventuelles interférences et problèmes si vous placez ces fonctions dans plus d'un script à la fois.

IMPORTANT : Lorsque vous ajoutez ces fonctions au script, elles prennent toutes un paramètre de type Fonctions et propriétés d'affichage des options de dialogue (DialogOptionsRenderingInfo) et la fonction dialog_options_mouse_click demande un paramètre supplémentaire pour le bouton de souris. Voyez l'exemple ci-dessous.

IMPORTANT : Les quatre fonctions de dialogue personnalisées sont toutes exécutées sur le fil non-bloquant. Cela signifie que vous ne devriez pas appeler de fonction bloquante, telles que Character.Say, Wait ou Display, à l'intérieur car elles pourraient ne pas se comporter correctement.

Exemple

Voici une implémentation très simple d'un écran d'options de dialogue.

function dialog_options_get_dimensions(DialogOptionsRenderingInfo *info)
{
  // Crée une zone de dimensions 200x200 à la position (50,100) pour les options
  info.X = 50;
  info.Y = 100;
  info.Width = 200;
  info.Height = 200;
  // Place l'analyseur de texte (parser) tout en bas (s'il est activé)
  info.ParserTextBoxX = 10;
  info.ParserTextBoxY = 160;
  info.ParserTextBoxWidth = 180;
}

function dialog_options_render(DialogOptionsRenderingInfo *info)
{
  // Remplit la zone en jaune
  info.Surface.Clear(14);
  int i = 1,  ypos = 0;
  // Affiche toutes les options disponibles
  while (i <= info.DialogToRender.OptionCount)
  {
    if (info.DialogToRender.GetOptionState(i) == eOptionOn)
    {
      if (info.ActiveOptionID == i) info.Surface.DrawingColor = 13;
      else info.Surface.DrawingColor = 4;
      info.Surface.DrawStringWrapped(5, ypos, info.Width - 10,
                         eFontFont0, eAlignLeft, info.DialogToRender.GetOptionText(i));
      ypos += GetTextHeight(info.DialogToRender.GetOptionText(i), eFontFont0, info.Width - 10);
    }
    i++;
  }
}

function dialog_options_get_active(DialogOptionsRenderingInfo *info)
{
  int i = 1,  ypos = 0;
  // Trouve l'option située où le joueur a cliqué
  while (i <= info.DialogToRender.OptionCount)
  {
    if (info.DialogToRender.GetOptionState(i) == eOptionOn)
    {
      ypos += GetTextHeight(info.DialogToRender.GetOptionText(i), eFontFont0, info.Width - 10);
      if ((mouse.y - info.Y) < ypos)
      {
        info.ActiveOptionID = i;
        return;
      }
    }
    i++;
  }
}

function dialog_options_mouse_click(DialogOptionsRenderingInfo *info, MouseButton button)
{
  // faites quelque chose ici si vous le voulez !
}

L'exemple ci-dessus est un peu simpliste ; en réalité vous voudrez probablement mémoriser la position Y de chaque option dans une variable pour ne pas avoir à réexaminer continuellement toutes les options.

Pour plus de détails sur les commandes utilisées ici, consultez la page des fonctions des options de dialogues personnalisées.

Compatibilité : Supporté par AGS 3.1.0 et les versions plus récentes.


types_predefinis

Liste des types prédéfinis

AGS propose plusieurs types prédéfinis. Ils sont utilisés par plusieurs commandes, et s'afficheront généralement automatiquement par auto-complétion. Toutefois, lorsque l'auto-complétion ne marche pas, le manuel de référence s'avère très précieux :

enum BlockingStyle {
  eBlock,
  eNoBlock
};

Correspond généralement à la suspension temporaire de l'exécution du script.

Utilisé par : Character.Animate, Character.FaceCharacter, Character.FaceLocation, Character.FaceObject, Character.Move, Character.Walk, Character.WalkStraight, Object.Animate, Object.Move

enum Direction {
  eForwards,
  eBackwards
};

Correspond généralement au sens dans lequel une animation est jouée.

Utilisé par : Character.Animate, Object.Animate

enum WalkWhere {
  eAnywhere,
  eWalkableAreas
};

Correspond généralement à la possibilité pour un personnage de marcher hors des zones de déplacements (Walkable Areas).

Utilisé par : Character.Move, Character.Walk, Object.Move

enum RepeatStyle {
  eOnce,
  eRepeat
};

Correspond généralement à l'animation en boucle (Repeat) ou non (Once).

Utilisé par : Button.Animate, Character.Animate, Object.Animate

enum Alignment {
  eAlignLeft,
  eAlignCentre,
  eAlignRight
};

Correspond généralement à l'alignement des images d'une animation.

Utilisé par : Character.LockViewAligned

enum eFlipDirection {
  eFlipLeftToRight,
  eFlipUpsideDown,
  eFlipBoth
};

Correspond généralement au retournement des images d'animation.

Utilisé par : DynamicSprite.Flip

enum TransitionStyle {
  eTransitionFade,
  eTransitionInstant,
  eTransitionDissolve,
  eTransitionBoxout,
  eTransitionCrossfade
};

Correspond généralement au style de transition d'écran entre les pièces.

Utilisé par : SetScreenTransition, SetNextScreenTransition

enum MouseButton {
  eMouseLeft,
  eMouseRight,
  eMouseMiddle,
  eMouseLeftInv,
  eMouseMiddleInv,
  eMouseRightInv,
  eMouseWheelNorth,
  eMouseWheelSouth
};

Correspond généralement au bouton qui a servi pour cliquer à la souris.

Utilisé par : Mouse.IsButtonDown Passed into: on_mouse_click

enum EventType {
  eEventLeaveRoom,
  eEventEnterRoom,
  eEventGotScore,
  eEventGUIMouseDown,
  eEventGUIMouseUp,
  eEventAddInventory,
  eEventLoseInventory,
  eEventRestoreGame
};

Correspond généralement à l'occurrence d'un événement.

Passed into: on_event

enum RoundDirection {
  eRoundDown,
  eRoundNearest,
  eRoundUp
};

Correspond généralement à la façon d'arrondir un nombre.

Utilisé par : FloatToInt

enum eSpeechStyle {
  eSpeechLucasarts,
  eSpeechSierra,
  eSpeechSierraWithBackground,
  eSpeechFullScreen
};

Correspond généralement au style de discours utilisé.

Utilisé par : SetSpeechStyle

enum eVoiceMode {
  eSpeechTextOnly,
  eSpeechVoiceAndText,
  eSpeechVoiceOnly
};

Correspond généralement à la présence simultanée ou l'absence des voix et des textes.

Utilisé par : SetVoiceMode

enum DialogOptionState {
  eOptionOff,
  eOptionOn,
  eOptionOffForever
};

Utilisé par : Dialog.GetOptionState, Dialog.SetOptionState

enum CutsceneSkipType {
  eSkipESCOnly,
  eSkipAnyKey,
  eSkipMouseClick,
  eSkipAnyKeyOrMouseClick,
  eSkipESCOrRightButton
};

Correspond généralement à la possibilité et à la manière de passer une scène cinématique.

Utilisé par : StartCutscene

enum eOperatingSystem {
  eOSDOS,
  eOSWindows,
  eOSLinux,
  eOSMacOS
};

Correspond généralement au système d'opération.

Utilisé par : System.OperatingSystem

enum eCDAudioFunction {
  eCDIsDriverPresent,
  eCDGetPlayingStatus,
  eCDPlayTrack,
  eCDPausePlayback,
  eCDResumePlayback,
  eCDGetNumTracks,
  eCDEject,
  eCDCloseTray,
  eCDGetCDDriveCount,
  eCDSelectActiveCDDrive
};

Concerne les options multimédias.

Utilisé par : CDAudio

enum CursorMode {
  eModeXXXX,
  eModeXXXX,
  ...
};

Les types CursorMode sont automatiquement générés selon les modes de curseurs que vous avez définis. Le nom du mode de curseur est récupéré, les espaces éventuels sont supprimés, et eMode est placé devant.

Utilisé par : IsInteractionAvailable, ProcessClick, Mouse.ChangeModeGraphic, Mouse.ChangeModeHotspot, Mouse.DisableMode, Mouse.EnableMode, Mouse.UseModeGraphic, Mouse.Mode, InventoryItem.IsInteractionAvailable, InventoryItem.RunInteraction, Hotspot.RunInteraction, Object.RunInteraction, Character.RunInteraction

enum FontType {
  eFontXXXX,
  eFontXXXX,
  ...
};

Les types FontType sont automatiquement générés selon les polices que vous utilisez. Le nom de la police est récupéré, les espaces éventuels sont supprimés, et eFont est placé devant.

Utilisé par : Button.Font, DrawingSurface.DrawMessageWrapped, DrawingSurface.DrawString, DrawingSurface.DrawStringWrapped, Game.NormalFont, Game.SpeechFont, GetTextHeight, GetTextWidth, Label.Font, ListBox.Font, TextBox.Font, Overlay.CreateTextual, Overlay.SetText

enum LocationType {
  eLocationNothing,
  eLocationHotspot,
  eLocationCharacter,
  eLocationObject
};

Correspond généralement au type d'élément à l'écran.

Retourné par : GetLocationType

enum FileMode {
  eFileRead,
  eFileWrite,
  eFileAppend
};

Correspond généralement au mode d'accès à un fichier.

Utilisé par : File.Open

enum DialogOptionSayStyle {
  eSayUseOptionSetting,
  eSayAlways,
  eSayNever
};

Utilisé par : Dialog.DisplayOptions

enum VideoSkipStyle {
  eVideoSkipNotAllowed,
  eVideoSkipEscKey,
  eVideoSkipAnyKey,
  eVideoSkipAnyKeyOrMouse
};

Utilisé par : PlayVideo

enum AudioFileType {
  eAudioFileOGG,
  eAudioFileMP3,
  eAudioFileWAV,
  eAudioFileVOC,
  eAudioFileMIDI,
  eAudioFileMOD
};

Utilisé par : AudioClip.FileType

enum AudioPriority {
  eAudioPriorityVeryLow = 1,
  eAudioPriorityLow = 25,
  eAudioPriorityNormal = 50,
  eAudioPriorityHigh = 75,
  eAudioPriorityVeryHigh = 100
};

Utilisé par : AudioClip.Play, AudioClip.PlayFrom, AudioClip.PlayQueued


mots-cles

Table des matières
    • Les Mots-clés du Script
      • Tableaux
      • Types de données
      • Opérateurs
      • Constantes
      • Vérification de la Version
      • Comparaisons if, else
      • while
      • function
      • struct
      • enum
      • this
      • import
      • export
      • noloopcheck

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 nombres 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 &gt; 5.99) && (resultat &lt; 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.");
}

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.

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.


audiochannel

Table des matières
    • AudioChannel (fonctions et propriétés)
      • Seek
      • SetRoomLocation
      • Stop
      • ID
      • IsPlaying
      • LengthMs
      • Panning
      • PlayingClip
      • Position
      • PositionMs
      • Volume

AudioChannel (fonctions et propriétés)

Les éléments AudioChannel (canaux audio) représentent des fichiers audio en cours de lecture. Utilisez-les pour vérifier le statut des sons actuellement joués et les ajuster.

Seek

(Anciennement SeekMIDIPosition, désormais obsolète) (Anciennement SeekMODPattern, désormais obsolète) (Anciennement SeekMP3PosMillis, désormais obsolète)

AudioChannel.Seek(int position)

Se positionne à POSITION dans la séquence actuellement jouée sur ce canal. Ce que représente POSITION dépend du FileType (type de fichier) de la séquence :

  • MIDI - le temps/la pulsation (beat number)
  • MOD/XM/S3M - le numéro du patron (pattern number)
  • WAV/VOC - le numéro d'échantillon (par ex. dans un son échantillonné à 22050 Hz, 22050 = 1 seconde)
  • OGG/MP3 - la position en millisecondes

Exemple :

AudioChannel *canal = aExplosion.Play();
Wait(40);
canal.Seek(0);

commencera à jouer la séquence aExplosion, attendra une seconde, puis retournera au début.

Compatibilité : Supporté par AGS 3.2.0 et versions plus récentes.

Voir aussi : AudioChannel.Position

SetRoomLocation

(Formerly part of PlayAmbientSound, désormais obsolète)

AudioChannel.SetRoomLocation(int x, int y)

Définit la séquence en cours de lecture comme un son directionnel, provenant de (x,y).

Le volume du canal sera dynamiquement ajusté selon la proximité du personnage joueur aux coordonnées. Ainsi plus le joueur s'en rapproche, plus le volume augmente, et plus il s'éloigne, plus le volume diminue.

Le réglage Volume du canal définit le volume maximum possible lorsque le joueur se trouve aux coordonnées spécifiées.

Passez les coordonnées (0,0) pour supprimer l'effet directionnel et refaire jouer ce canal à son volume normal.

Exemple :

AudioChannel *canal = aMachine.Play();
canal.SetRoomLocation(oMachine.X, oMachine.Y);

jouera la séquence audio aMachine et la situera à l'endroit où se trouve l'objet oMachine.

Compatibilité : Supporté par AGS 3.2.0 et versions plus récentes.

Voir aussi : AudioChannel.Volume

Stop

(Anciennement StopAmbientSound, désormais obsolète) (Anciennement StopChannel, désormais obsolète)

AudioChannel.Stop()

Stoppe le son en cours de lecture sur le canal audio.

Exemple :

AudioChannel *canal = aExplosion.Play();
Wait(40);
canal.Stop();

jouera la séquence audio aExplosion durant une seconde puis l'arrêtera.

Compatibilité : Supporté par AGS 3.2.0 et versions plus récentes.

Voir aussi : Game.StopAudio

ID

readonly int AudioChannel.ID

Retourne le numéro ID de ce canal audio. Vous ne devriez normalement pas en avoir besoin, mais cela peut être utile pour gérer d'anciennes commandes comme StopChannel.

Exemple :

AudioChannel *canal = aExplosion.Play();
Display("Explosion en lecture sur le canal numéro %d", canal.ID);

jouera la séquence audio aExplosion et affichera sur quel canal celle-ci est jouée.

Compatibilité : Supporté par AGS 3.2.0 et versions plus récentes.

IsPlaying

(Anciennement IsChannelPlaying, désormais obsolète)

readonly bool AudioChannel.IsPlaying

Retourne si le canal audio joue actuellement un son ou non. Retourne true si c'est le cas, false sinon.

Exemple :

AudioChannel *canal = aExplosion.Play();
while (canal.IsPlaying) Wait(1);
Display("Explosion finie.");

lancera la séquence audio aExplosion et n'affichera le message qu'une fois la lecture achevée.

Compatibilité : Supporté par AGS 3.2.0 et versions plus récentes.

Voir aussi : AudioClip.Play

LengthMs

readonly int AudioChannel.LengthMs

Retourne la durée en millisecondes de la séquence jouée sur le canal.

Cette propriété fonctionne pour tous les types de fichier, mais n'est précise qu'à la seconde près concernant les MIDI.

Si ce canal ne joue aucune séquence, cette propriété vaudra 0.

Exemple :

AudioChannel *canal = aExplosion.Play();
Display("Le son Explosion dure %d ms.", canal.LengthMs);

lancera la séquence audio aExplosion et affichera sa durée.

Compatibilité : Supporté par AGS 3.2.0 et versions plus récentes.

Voir aussi : AudioChannel.PositionMs

Panning

int AudioChannel.Panning

Retourne/définit l'équilibrage du canal.

L'équilibrage vous permet d'ajuster la balance stéréo. La valeur par défaut est 0, ce qui signifie que la balance est centrée et que les sons seront émis au même volume par chaque enceinte audio. Vous pouvez l'ajuster entre -100 (son maximum sur l'enceinte gauche, absence de son sur la droite) et 100 (son maximum sur l'enceinte droite, absence de son sur la gauche).

NOTE : cette propriété n'affecte pas la lecture des fichiers MIDI.

Exemple :

AudioChannel *canal = aExplosion.Play();
canal.Panning = -100;

jouera la séquence aExplosion sur l'enceinte gauche uniquement (si la séquence n'est pas un MIDI).

Compatibilité : Supporté par AGS 3.2.0 et versions plus récentes.

Voir aussi : AudioClip.Play

PlayingClip

(Anciennement GetCurrentMusic, désormais obsolète)0

readonly AudioClip* AudioChannel.PlayingClip

Retourne la séquence audio jouée sur le canal. Cela vous permet de récupérer ensuite le type de la séquence et d'autres informations.

Retourne null si aucun son n'est jouée sur le canal.

Exemple :

AudioChannel *canal = System.AudioChannels[2];
if (canal.PlayingClip == null)
{
  Display("Le canal 2 est libre");
}
else
{
  Display("Le canal 2 joue une séquence de type numéro %d", canal.PlayingClip.Type);
}

affichera si le canal 2 est libre ou le type de ce qu'il joue.

Compatibilité : Supporté par AGS 3.2.0 et versions plus récentes.

Voir aussi : AudioClip.Play, System.AudioChannels

Position

(Anciennement GetMIDIPosition, désormais obsolète) (Anciennement GetMODPattern, désormais obsolète) (Anciennement GetMP3PosMillis, désormais obsolète)

readonly int AudioChannel.Position

Retourne la position actuelle de la séquence jouée sur le canal.

Ce que signifie la position dépend du type de fichier (FileType) de la séquence :

  • MIDI - le temps/la pulsation (beat number)
  • MOD/XM/S3M - le numéro du patron (pattern number)
  • WAV/VOC - le numéro d'échantillon (par ex. dans un son échantillonné à 22050 Hz, 22050 = 1 seconde)
  • OGG/MP3 - la position en millisecondes

Cette propriété est en lecture seule (readonly). Si vous voulez déplacer la position de lecture, utilisez la fonction AudioChannel.Seek.

Exemple :

AudioChannel *canal = aExplosion.Play();
Wait(40);
channel.Seek(canal.Position + 1000);

lancera la séquence aExplosion, attendra une seconde, puis déplacera la lecture à une seconde plus tard (si c'est un OGG/MP3/WAV) — la deuxième seconde de la séquence ne sera ainsi pas jouée.

Compatibilité : Supporté par AGS 3.2.0 et versions plus récentes.

Voir aussi : AudioChannel.PositionMs, AudioChannel.Seek

PositionMs

readonly int AudioChannel.PositionMs

Retourne la position actuelle de la séquence jouée sur le canal, en millisecondes.

Cette propriété fonctionne pour tous les types de fichier exceptés les MIDI, et retourne la position dans la séquence en millisecondes. Cette propriété vaudra toujours 0 pour les fichiers MIDI.

Cette propriété est en lecture seule (readonly). Si vous voulez vous déplacer dans la séquence, utilisez la fonction AudioChannel.Seek.

Exemple :

AudioChannel *canal = aExplosion.Play();
Wait(40);
Display("Après une seconde, la lecture est rendue à %dms.", channel.PositionMs);

lancera la séquence audio aExplosion, attendra une seconde et affichera la position de lecture.

Compatibilité : Supporté par AGS 3.2.0 et versions plus récentes.

Voir aussi : AudioChannel.LengthMs, AudioChannel.Position

Volume

(Anciennement SetChannelVolume, désormais obsolète) (Anciennement SetMusicVolume, désormais obsolète)

int AudioChannel.Volume

Retourne/définit le volume du canal audio, de 0 à 100. Ceci vous permet d'ajuster dynamiquement le volume d'un son en cours de lecture.

Cette commande ajuste le volume du canal relativement aux autres canaux. Cela signifie que le volume est toujours contraint par le volume général défini par la propriété System.Volume.

NOTE : Cette commande n'affecte que le son en cours de lecture sur le canal. Lorsqu'une nouvelle séquence est lancée sur ce canal, elle sera jouée à son volume par défaut (DefaultVolume).

NOTE : Le volume retourne par cette propriété est le volume de base du canal, c'est-à-dire qu'il ne prend pas en compte les effets directionnels définis par SetRoomLocation, ou toute baisse temporaire de volume lorsqu'un doublage est en cours.

Exemple :

AudioChannel *canal = aExplosion.Play();
Wait(40);
canal.Volume = 20;

lancera la séquence audio aExplosion, attendra une seconde puis réduira son volume.

Compatibilité : Supporté par AGS 3.2.0 et versions plus récentes.

//Voir aussi :// AudioChannel.SetRoomLocation, Game.SetAudioTypeVolume, System.Volume


audioclip

Table des matières
    • AudioClip (fonctions et propriétés)
      • Play
      • PlayFrom
      • PlayQueued
      • Stop
      • FileType
      • IsAvailable
      • Type

AudioClip (fonctions et propriétés)

Les AudioClips sont créés lorsque vous importez des fichiers dans l’Éditeur d'AGS. Les commandes dans cette section vous permettent de les jouer.

Play

(Anciennement PlayAmbientSound, désormais obsolète)
(Anciennement PlayMP3File, désormais obsolète)
(Anciennement PlayMusic, désormais obsolète)
(Anciennement PlaySound, désormais obsolète)
(Anciennement PlaySoundEx, désormais obsolète)
(Anciennement SetMusicRepeat, désormais obsolète)

AudioChannel* AudioClip.Play(optional AudioPriority, optional RepeatStyle)

Joue la séquence audio.

Facultativement, vous pouvez passer un paramètre de priorité et de répétition ; si vous n'en passez pas, les paramètres définis par défauts dans l'éditeur pour la séquence audio seront utilisés.

Cette commande scrute tous les canaux audio libres afin d'en trouver un disponible pour ce type d'audio. Si aucun canal n'est libre, elle en cherchera un qui joue une séquence de priorité inférieure ou égale et l’interrompra pour la remplacer par la nouvelle.

Si tous les canaux jouent des séquences d'une priorité supérieure, alors votre séquence ne sera pas jouée.

Cette commande retourne l'objet AudioChannel sur lequel est joué le son, ou null s'il n'a pas été joué pour une quelconque raison.

NOTE : AGS ne peut jouer qu'un seul fichier MIDI à la fois.

Exemple :

aExplosion.Play();

joue la séquence audio aExplosion. plays the aExplosion audio clip.

Compatibilité : Supporté par AGS 3.2.0 et versions plus récentes.

Voir aussi : AudioClip.PlayFrom, AudioClip.PlayQueued, AudioClip.Stop

PlayFrom

AudioChannel* AudioClip.PlayFrom(int position, optional AudioPriority,
                                 optional RepeatStyle)

Joue la séquence audio en démarrant depuis la position spécifiée. Consultez l'aide de AudioChannel.Seek pour le fonctionnement de la position.

À part cela, cette commande fonctionne de la même façon que AudioClip.Play. Consultez l'aide de cette commande pour plus d'informations.

Exemple :

aExplosion.PlayFrom(1000);

joue la séquence audio aExplosion en commençant avec un décalage de 1 seconde (pour un format OGG/MP3).

Compatibilité : Supporté par AGS 3.2.0 et versions plus récentes.

Voir aussi : AudioClip.Play

PlayQueued

(Anciennement PlayMusicQueued, désormais obsolète)

AudioChannel* AudioClip.PlayQueued(optional AudioPriority, optional RepeatStyle)

Joue la séquence audio, ou la met à la file afin qu'elle soit jouée plus tard si ce n'est pas possible actuellement.

Cette commande se comporte comme AudioClip.Play, à part que s'il n'y a pas de canal audio de libre, la séquence est mise en attente pour être jouée lorsqu'un canal se libère.

De plus, contrairement à la commande Play, utiliser PlayQueued n'interrompra aucune séquence audio en cours d'un niveau de priorité égal ; elle n'imterrompra que des séquences de priorité inférieure.

Vous pouvez mettre jusqu'à 10 morceaux à la file. Notez que si vous placez des séquences dans la file après une séquence qui boucle, elles ne seront jamais jouées.

Exemple :

aExplosion.Play();
aAftermath.PlayQueued();

joue la séquence audio aExplosion et place le son aAftermath dans la file pour qu'il soit joué juste après.

Compatibilité : Supporté par AGS 3.2.0 et versions plus récentes.

Voir aussi : AudioClip.Play

Stop

AudioClip.Stop()

Coupe toutes les diffusions en cours de cette séquence audio.

Exemple :

aExplosion.Play();
Wait(40);
aExplosion.Stop();

joue la séquence aExplosion, attend 1 seconde puis la stoppe.

Compatibilité : Supporté par AGS 3.2.0 et versions plus récentes.

Voir aussi : AudioClip.Play

FileType

readonly AudioFileType AudioClip.FileType;

Retourne le type de fichier de la séquence audio. Utilisez cette fonction avec PlayFrom et Seek pour déterminer ce que représente la position.

Exemple :

if (aExplosion.FileType == eAudioFileMIDI)
{
  Display("Explosion est un fichier MIDI !");
}

affiche un message si aExplosion est un fichier MIDI.

Compatibilité : Supporté par AGS 3.2.0 et versions plus récentes.

Voir aussi : AudioChannel.Seek, AudioChannel.Position, AudioClip.PlayFrom

IsAvailable

(Anciennement IsMusicVoxAvailable, désormais obsolète)

readonly bool AudioClip.IsAvailable;

Retourne si la séquence audio est disponible sur l'ordinateur du joueur.

En général, cela retournera true, à moins que la séquence ne soit contenue dans un fichier AUDIO.VOX externe et que le joueur ne l'ait pas sur son ordinateur.

Vous n'aurez normalement pas besoin d'utiliser cette propriété, puisque la commande Play échouera silencieusement si elle ne trouve pas la séquence.

Exemple :

if (aExplosion.IsAvailable)
{
  aExplosion.Play();
}

vérifie si la séquence audio aExplosion est disponible, et la joue le cas échéant.

Compatibilité : Supporté par AGS 3.2.0 et versions plus récentes.

Voir aussi : AudioClip.Play

Type

readonly AudioType AudioClip.Type;

Retourne le type de la séquence audio, telle que définie dans l'éditeur.

Les types AudioType vous permettent de trier les séquences en Sons et Musiques par exemple.

Exemple :

if (aExplosion.Type == eAudioTypeMusic)
{
  Display("La séquence Explosion est une musique !");
}

affiche un message si aExplosion est une musique.

Compatibilité : Supporté par AGS 3.2.0 et versions plus récentes.

//Voir aussi :// AudioClip.Play, Game.IsAudioPlaying


character

Table des matières
    • Fonctions et propriétés des personnages (Character)
      • AddInventory
      • AddWaypoint
      • Animate
      • ChangeRoom
      • ChangeRoomAutoPosition
      • ChangeView
      • FaceCharacter
      • FaceLocation
      • FaceObject
      • FollowCharacter
      • GetAtScreenXY
      • GetProperty
      • GetTextProperty
      • HasInventory
      • IsCollidingWithChar
      • IsCollidingWithObject
      • LockView
      • LockViewAligned
      • LockViewFrame
      • LockViewOffset
      • LoseInventory
      • Move
      • PlaceOnWalkableArea
      • RemoveTint
      • RunInteraction
      • Say
      • SayAt
      • SayBackground
      • SetAsPlayer
      • SetIdleView
      • SetWalkSpeed
      • StopMoving
      • Think
      • Tint
      • UnlockView
      • Walk
      • WalkStraight
      • ActiveInventory
      • Animating
      • AnimationSpeed
      • Baseline
      • BlinkInterval
      • BlinkView
      • BlinkWhileThinking
      • BlockingHeight
      • BlockingWidth
      • Clickable
      • DiagonalLoops
      • Frame
      • HasExplicitTint
      • ID
      • IdleView
      • IgnoreLighting
      • IgnoreWalkbehinds
      • InventoryQuantity
      • Loop
      • ManualScaling
      • MovementLinkedToAnimation
      • Moving
      • Name
      • NormalView
      • PreviousRoom
      • Room
      • ScaleMoveSpeed
      • ScaleVolume
      • Scaling
      • Solid
      • Speaking
      • SpeakingFrame
      • SpeechAnimationDelay
      • SpeechColor
      • SpeechView
      • ThinkView
      • Transparency
      • TurnBeforeWalking
      • View
      • WalkSpeedX
      • WalkSpeedY
      • x
      • y
      • z
      • SetCharacter

Fonctions et propriétés des personnages (Character)

AddInventory

(Anciennement “AddInventory”, désormais obsolète)
(Anciennement “AddInventoryToCharacter”, désormais obsolète).

Character.AddInventory(InventoryItem *item, optional int addAtIndex)

Cela ajoute un objet dans l'inventaire du personnage spécifié. L'objet est bien sûr ajouté à l'inventaire du personnage, et ce sur n'importe quel affichage d'inventaire s'il est mis à jour.

Le premier argument de la fonction est le Script O-Name de l'objet (par exemple, iPoster ).

Par défaut, le nouvel objet est ajouté à la fin de l'inventaire. Cependant, vous pouvez l'insérer dans toute autre position en complétant le second paramètre. L'objet est alors inséré avant celui défini dans “addAtIndex”. Les indexes sont numérotés à partir de 0, donc pour ajouter l'objet au début de la liste d'objet, mettez 0 au second paramètre.

Exemple :

cEgo.AddInventory(iKey);

Ceci donnera à EGO l'objet nommé iKey (clef).
Puisqu'il n'y a pas de second paramètre, la clef se trouvera à la fin de l'inventaire.

Voir aussi : Character.HasInventory, Character.LoseInventory, UpdateInventory

AddWaypoint

(Anciennement MoveCharacterPath, mais qui devient obsolète)

Character.AddWaypoint(int x, int y)

Indique les coordonnées (X, Y) où le personnage se déplacera directement après qu'il ait fini son déplacement initial. Cette fonction vous permet d'assigner une série de déplacements que votre personnage devra effectuer, si vous voulez qu'il prenne un itinéraire autour de l'écran. Notez que n'importe quel déplacement via cette commande ignore les walkable areas.

C'est utile si vous désirez qu'un villageois rentre par un côté de l'écran, fasse un itinéraire et quitte l'écran de nouveau.

Exemple:

cSomeguy.Walk(160, 100);
cSomeguy.AddWaypoint(50, 150);
cSomeguy.AddWaypoint(50, 50);

Indique au personnage SOMEGUY de marcher en premier lieu jusqu'au milieu de l'écran (walkable areas respectées), puis d'aller vers le coin inférieur gauche de l'écran et ensuite le coin supérieur.

Voir aussi : Character.Move Character.Walk

Animate

(Anciennement AnimateCharacter, désormais obsolète)
(Anciennement AnimateCharacterEx, désormais obsolète)

Character.Animate(int loop, int delay, optional RepeatStyle,
                  optional BlockingStyle, optional Direction)

Démarre l'animation d'un personnage, assignant le numéro de la loop de la view actuelle. La vitesse de l'animation est définit par l'argument DELAY, où 0 est le plus rapide ; les nombres supérieurs rendront la vitesse lente. Le temps entre chaque frames est délimité par DELAY + VITESSE DE FRAME, donc les vitesses des frames sont compensées par rapport à la vitesse initiale.

Mais avant d'utiliser cette commande, vous devriez utiliser celle-ci en premier : LockView dans le but de sélectionner la view que vous voulez animer et empêcher toutes animations automatiques (ex. animation de marche ou celle quand le personnage est immobile)du jeu.

Le paramètre RepeatStyle permet à l'animation d'être répétée jusqu'à ce qu'elle soit stoppée ou de l'animer une fois la dernière frame affichée. Il peut valoir eOnce (ou zéro), auquel cas l'animation sera jouée par la première loop, et passera par chaque image jusqu'à la dernière, puis elle s'arrêtera. Si RepeatStyle vaut eRepeat (ou 1), alors lorsque la dernière image sera atteinte, l'animation retournera à la première image et recommencera alors depuis le début.

direction spécifie dans quelle sens l'animation est jouée. Vous pouvez passer soit eForwards (par défaut) soit eBackwards (auquel cas l'animation sera jouée à l'envers).

En ce qui concerne blocking vous pouvez passer soit eBlock (auquel cas la fonction attendra que l'animation soit terminée pour libérer le script), ou eNoBlock (auquel cas l'animation commencera à jouer, mais votre script continuera de s'exécuter en parallèle). Par défaut, le paramètre vaut eBlock par défaut.

Si le personnage était en train de se déplacer, il sera arrêté.

Exemple :

cEgo.LockView(5);
cEgo.Animate(3, 1, 0, eBlock, eBackwards);
cEgo.UnlockView();

animera le personnage une seule fois, en utilisant la séquence numéro 3 de la vue 5, à l'envers ; et exécutera la suite du script une fois l'animation terminée.

Voir aussi : Object.Animate

ChangeRoom

(Anciennement NewRoom, désormais obsolète)
(Anciennement NewRoomEx, désormais obsolète)
(Anciennement NewRoomNPC, désormais obsolète)

Character.ChangeRoom(int room_number, optional int x, optional int y)

Change la pièce dans laquelle le personnage se trouve.

Si vous utilisez cette fonction sur le personnage joueur, alors le jeu suivra le personnage dans la nouvelle pièce.

IMPORTANT : Cette commande ne change pas la pièce immédiatement ; le changement de pièce n'a en fait lieu que lorsque le script a fini de s'exécuter (ceci afin d'éviter les problèmes causés par le déchargement du script alors qu'il est toujours en exécution). Cela signifie que vous ne devriez utiliser aucune commande qui concerne la nouvelle pièce (position d'objets, etc.) après cette commande dans le même code.

Si vous utilisez cette commande sur un personnage non-joueur, alors celui-ci est instantanément transporté vers la nouvelle pièce.

Facultativement, vous pouvez spécifier des coordonnées X et Y (vous ne pouvez pas n'en spécifier qu'une seule). Si vous le faites, alors le personnage sera en plus placé aux coordonnées spécifiées dans la nouvelle pièce.

Exemple :

player.ChangeRoom(4, 100, 50);

placera le personnage joueur dans la pièce 4 et le positionnera également aux coordonnées 100,50. Cela signifie aussi que le jeu se déroule désormais dans la pièce 4.

Voir aussi : Character.ChangeRoomAutoPosition

ChangeRoomAutoPosition

Character.ChangeRoomAutoPosition(int room_number, optional int newPosition)
Change la pièce dans laquelle le personnage se trouve, et le positionne le long d'un des bords de la pièce.

Cette commande simule le comportement de la vieille commande d'interaction “Go to room” présente dans AGS 2.72 et dans les versions précédentes. Si newPosition n'est pas fournie ou si elle vaut 0, alors le personnage sera placé au bord opposé de la nouvelle pièce, s'il se trouvait à moins de 10 pixels (inclus) d'un bord de l'ancienne pièce.

De façon alternative, vous pouvez spécifier la position où il sera placé dans la nouvelle pièce. newPosition peut valoir 1000 pour le bord gauche, 2000 pour le bord droit, 3000 pour le bord du bas et 400 pour le bord du haut. Ajoutez ensuite la valeur du nombre de pixels où vous voulez placer le personnage sur cet axe. IMPORTANT : Cette commande ne change pas la pièce immédiatement ; le changement de pièce n'a en fait lieu que lorsque le script a fini de s'exécuter (ceci afin d'éviter les problèmes causés par le déchargement du script alors qu'il est toujours en exécution). Cela signifie que vous ne devriez utiliser aucune commande qui concerne la nouvelle pièce (position d'objets, etc.) après cette commande dans le même code.

NOTE : Cette commande peut seulement s'utiliser sur le personnage joueur .

Exemple :
player.ChangeRoomAutoPosition(4, 2100);

déplacera le personnage joueur vers la pièce 4 et le placera à mi-hauteur (100 pixels) sur le côté droit de l'écran. Cela a aussi pour effet que le jeu se passera désormais dans la pièce 4.

Voir aussi : Character.ChangeRoom

ChangeView

(Anciennement ChangeCharacterView, désormais obsolète)

Character.ChangeView(int vue)

Change le numéro de la vue normal du personnage pour vue . Ceci est pratique si, par exemple, vous voulez que le personnage change de vêtements, et qu'il doit donc avoir en permanence un numéro de vue différent.

NOTE: Cette commande n'est pas faite pour changer temporairement la vue dans l'intention de faire une animation. Si vous voulez faire ceci, utilisez plutôt la commande LockView. Cete commande ChangeView change définitivement la vue normal de marche du personnage.

Exemple :

cEgo.ChangeView(5);

fera que le personnage EGO utilisera la vue numéro 5 en tant que vue normale de marche.

Voir aussi : Character.LockView, Character.NormalView

FaceCharacter

(Anciennement global function FaceCharacter, désormais obsolète)

Character.FaceCharacter(Character* autre, optional BlockingStyle)

Change la direction dans laquelle le personnage regarde pour qu'il soit en train de regarder le personnage AUTRE. Cela consiste à changer la séquence actuelle en celle appropriée, et à initialiser le numéro d'image de la séquence à 0 (attente).

Si le personnage est autorisé à se retourner (c'est-à-dire si l'option de jeu “Les personnages se retournent pour faire face” est active, et si le personnage n'a pas l'option “Ne pas se retourner avant de marcher” d'activée), alors le personnage se tournera dans la nouvelle direction. Dans ce cas, le paramètre Blocking détermine si le script attend ou non que le personnage ait fini de se retourner (eBlock, par défaut) ou s'il continue immédiatement son exécution tandis que le personnage finit de se retourner plus tard (eNoBlock).

Si le personnage n'est pas autorisé à se retourner, il regardera immédiatement dans la nouvelle direction et le paramètre Blocking n'a aucun effet. Dans ce cas, l'écran ne sera pas rafraichi directement – si vous voulez voir immédiatement le personnage regarder dans la nouvelle direction, utilisez Wait(1).

Exemple :

cEgo.FaceCharacter(cMan);

tournera le personnage EGO pour qu'il fasse face au personnage MAN

Voir aussi : Character.FaceLocation, Character.FaceObject, Character.Walk

FaceLocation

(Anciennement fonction gloable FaceLocation, désormais obsolète)

Character.FaceLocation(int x, int y, optional BlockingStyle)

Semblable à la fonction FaceCharacter, mais cette fois le personnage se tournera en direction des coordonnées (X,Y). Ceci lui permet de ne pas faire face uniquement à d'autres personnages, mais aussi à des hotspots ou tout aussi bien autre chose (vous pouvez récupérer les coordonnées en regardant les coordonnées affichées dans les réglages de la pièce lorsque vous déplacez la souris sur l'arrière-plan).

Si le personnage est autorisé à se retourner (c'est-à-dire si l'option de jeu “Les personnages se retournent pour faire face” est active, et si le personnage n'a pas l'option “Ne pas se retourner avant de marcher” d'activée), alors le personnage se tournera dans la nouvelle direction. Dans ce cas, le paramètre Blocking détermine si le script attend ou non que le personnage ait fini de se retourner (eBlock, par défaut) ou s'il continue immédiatement son exécution tandis que le personnage finit de se retourner plus tard (eNoBlock).

Si le personnage n'est pas autorisé à se retourner, il regardera immédiatement dans la nouvelle direction et le paramètre Blocking n'a aucun effet. Dans ce cas, l'écran ne sera pas rafraichi directement – si vous voulez voir immédiatement le personnage regarder dans la nouvelle direction, utilisez Wait(1).

Exemple :

cEgo.FaceLocation(cEgo.x + 50, cEgo.y);

tournera le personnage vers l'est (la droite).

Voir aussi : Character.FaceCharacter

FaceObject

Character.FaceObject(Object* objet, optional BlockingStyle)
Semblable à la fonction FaceCharacter, mais cette fois le personnage se tournera en direction de l'objet OBJET dans la pièce courante.

If the character has Turning enabled (ie. the “Characters turn to face direction” game option is turned on, and the character does not have the “Do not turn before walking” option checked), then the character will turn on the spot in order to face the new direction. Si le personnage est autorisé à se retourner (c'est-à-dire si l'option de jeu “Les personnages se retournent pour faire face” est active, et si le personnage n'a pas l'option “Ne pas se retourner avant de marcher” d'activée), alors le personnage se tournera dans la nouvelle direction. Dans ce cas, le paramètre Blocking détermine si le script attend ou non que le personnage ait fini de se retourner (eBlock, par défaut) ou s'il continue immédiatement son exécution tandis que le personnage finit de se retourner plus tard (eNoBlock).

Si le personnage n'est pas autorisé à se retourner, il regardera immédiatement dans la nouvelle direction et le paramètre Blocking n'a aucun effet. Dans ce cas, l'écran ne sera pas rafraichi directement – si vous voulez voir immédiatement le personnage regarder dans la nouvelle direction, utilisez Wait(1).

Exemple :
player.FaceObject(oPorte);

fera que le personnage joueur se tournera en direction de l'objet oPorte.

Voir aussi : Character.FaceCharacter

FollowCharacter

(Anciennement FollowCharacter, désormais obsolète)
(Anciennement FollowCharacterEx, désormais obsolète)

Character.FollowCharacter(Character* presoasuivre, optional int dist,
                          optional int delai)

Dit au personnage de suivre PERSOASUIVRE, où qu'il aille. Vous pourriez utiliser cette commande pour créer un groupe de personnages principaux qui se déplacent ensemble, ou par exemple lorsque le héros a sauvé quelqu'un d'une mauvaise situation, cette personne peut décider d'accompagner le héros jusqu'à chez lui.

Donnez la valeur null au paramètre PERSOASUIVRE pour faire cesser l'effet.

Il y a deux paramètres optionnels :

DIST définit à quelle distance de PERSOASUIVRE le personnage devra se tenir. Si DIST vaut 1, ils seront très proches ; si DIST vaut par exemple 20, il y aura une vingtaine de pixels entre eux.

DELAI définit combien de temps le personnage attend avant de vérifier s'il doit se déplacer ou non. Si vous donnez la valeur 0 à ce paramètre, le personnage se déplacera constamment jusqu'à ateindre PERSOASUIVRE ; si vous passez la valeur 99, il fera une petite pause avant de reprendre la route. Vous pouvez faire varier cette valeur pour faire varier le temps d'attente.

Par défaut les paramètres valent DIST=10 et DELAI=97.

En particulier, si vous mettez DIST=0 et DELAI=0, le personnage agira comme s'il s'accrochait à PERSOASUIVRE - il essaiera de s'en approcher le plus possible et le plus vite possible. Donner la valeur 0 à DELAI a aussi pour effet que le personnage se déplacera même lorsqu'il aura atteint PERSOASUIVRE, en lui tournant autour - utile si le personnage est un chien très énergique ou autre.

Il existe une autre utilisation particulière de cette commande. Vous pouvez donner la valeur FOLLOW_EXACTLY au paramètre DIST plutôt qu'un nombre. Si vous le faîtes, le personnage se placera toujours rigoureusement aux même coordonnées X et Y que PERSOASUIVRE. Cela peut être utile pour des effets de halo temporaire sur le personnage ou autre.

Si vous utilisez FOLLOW_EXACTLY, alors DELAI a un autre sens. Si vous le définissez à 0, le personnage sera dessiné devant PERSOASUIVRE ; si vous le définissez à 1, il sera dessiné derrière lui.

Exemple :

cHomme.FollowCharacter(cEgo, 5, 80);

fera que le personnage HOMME suivra le personnage EGO en laissant une distance d'environ 5 pixels entre eux et en attendant deux secondes entre chaque déplacement.

GetAtScreenXY

(Anciennement GetCharacterAt, désormais obsolète)

static Character* Character.GetAtScreenXY(int x, int y)

Vérifie s'il y a un personnage aux coordonnées (X,Y) de l'ÉCRAN. Retourne le personnage s'il y en a un, ou la valeur null s'il n'y en a pas. Allez voir la description de GetLocationName pour plus de détails sur les coordonnées à l'écran.

NOTE : Les personnage portant le flag “No interaction” ne seront pas détectés par cette fonction.

Exemple :

if (Character.GetAtScreenXY(mouse.x, mouse.y) == cEgo) {
  Display("The mouse is over the main character");
}

affichera le message si le curseur de la souris se situe sur le personnage EGO.

Voir aussi : Hotspot.GetAtScreenXY, Object.GetAtScreenXY, Game.GetLocationName

GetProperty

(Anciennement GetCharacterProperty, désormais obsolète)

Character.GetProperty(string propriete)

Retourne la valeur définie pour la PROPRIETE du personnage spécifié.

Cette commande fonctionne uniquement pour les propriétés numériques (retourne un nombre) et pour les propriétés booléennes (retourne 1 si vraie, 0 si fausse).

Utilisez la fonction équivalente GetTextProperty pour avoir une propriété textuelle.

Exemple :

if (cEgo.GetProperty("Value") &gt; 200)
  Display("EGO's value is over 200!");

affichera le message si la propriété “Valeur” d'EGO est supérieure à 200.

Voir aussi : Character.GetTextProperty

GetTextProperty

(Anciennement GetCharacterPropertyText, désormais obsolète)
(Anciennement Character.GetPropertyText, désormais obsolète)

String Character.GetTextProperty(string propriete)

Retourne la valeur définie pour la PROPRIETE du personnage spécifié.

Cette commande fonctionne uniquement pour les propriétés textuelles. Le texte de la propriété sera retournée par cette fonction.

Utilisez la fonction équivalente GetProperty pour obtenir une propriété non textuelle.

Exemple :

String description = cEgo.GetTextProperty("Description");
Display("EGO's description: %s", description);

récupérera la valeur (textuelle) de la propriété “description” d'EGO et l'affichera.

Voir aussi : Character.GetProperty

HasInventory

bool Character.HasInventory(InventoryItem *objet)
Vérifie si le personnage possède actuellement l'objet d'inventaire spécifié. Retourne true si c'est le cas, false si ça ne l'est pas.

Le paramètre correspond au nom de Script de l'objet d'inventaire, tel qu'il apparaît dans l'éditeur (par exemple, iPoster ).

Exemple :
if (player.HasInventory(iClef))
{
  Display("Le joueur a la clef !!");
}

affichera un message si le joueur possède la clef.

Compatibilité : Supporté par AGS 3.1.0 et les versions plus récentes.

Voir aussi : Character.AddInventory, Character.InventoryQuantity, Character.LoseInventory

IsCollidingWithChar

(Anciennement AreCharactersColliding, désormais obsolète)

Character.IsCollidingWithChar(Character* autrePerso)

Vérifie si le personnage touche AUTREPERSO. Cette fonction vérifie simplement la baseline de chaque personnage, donc si l'un des personnage se trouve à une certaine distance de l'autre, ils ne seront pas considérés comme se touchant.

Retourne 1 si les pieds des personnages se touchent, sinon 0.

Exemple :

if (cEgo.IsCollidingWithChar(cHomme) == 1) {
  // code déclenché par la collision ici
}

exécutera le code de collision uniquement si les personnages EGO et HOMME se touchent.

Voir aussi : Character.IsCollidingWithObject, Object.IsCollidingWithObject, AreThingsOverlapping

IsCollidingWithObject

(Anciennement AreCharObjColliding, désormais obsolète)

Character.IsCollidingWithObject(Object* obj)

Vérifie si les pieds d'un personnage (c'est-à-dire le tiers inférieur du personnage) touchent OBJ. Ceci peut être utilisé pour déterminé si un personnage se trouve près d'un objet.

Retourne 1 si c'est le cas, sinon 0.

Exemple :

if (cEgo.IsCollidingWithObject(object[3]) == 1) {
  // colliding code here
}

exécutera le code de collision uniquement si le personnage EGO et l'objet numéro 3 se touchent.

Voir aussi : Character.IsCollidingWithChar, Object.IsCollidingWithObject, AreThingsOverlapping

LockView

(Anciennement SetCharacterView, désormais obsolète)

Character.LockView(int vue)

Définit la vue du personnage à VUE. Cela peut être utilisé pour créer des animations avec les personnages, par exemple lorsqu'ils se baissent pour ramasser quelque chose, ce qui n'utilise pas la vue par défaut.

NOTE : Cette fonction fige la vue du personnage à la vue spécifiée, donc cela ne peut être changé que par une autre commande du script (c'est-à-dire que ça ne sera pas automatiquement changé par AGS sur les zones de déplacement libre, lors des changements à l'écran, etc.). Lorsque l'animation est terminée, utilisez UnlockView pour permettre à AGS de reprendre le contrôle.

Exemple :

cEgo.LockView(12);
cEgo.Animate(0, 0, eOnce, eBlock, eForwards);
cEgo.UnlockView();

définira la vue de EGO à la vue 12, lancera l'animation en utilisant la séquence 0, attendra que l'animation soit finie puis redonnera sa vue normale au personnage.

Voir aussi : Character.Animate, Character.ChangeView, Character.SpeechView, Character.LockViewAligned, Character.LockViewOffset Character.UnlockView,

LockViewAligned

(Anciennement SetCharacterViewEx, désormais obsolète)

Character.LockViewAligned(int vue, int sequence, Alignment)

Définit la vue du personnage à VUE, et définit l'image actuel du personnage à la première image dans la SEQUENCE de la VUE.

The main purpose of this command is that it can align the new frame to the previous one. L'intérêt principal de cette commande est de pouvoir aligner la nouvelle image sur la précédente. Ceci est particulièrement pratique si vous désirez passer de la vue normale de marche du personnage à une animation spécifique - puisque les personnage ont leur point central en leur 'axe', si vous avez une animation plus large alors il peut être difficile d'empêcher un certain effet de saut lorsque l'animation se lance.

Alignement peut prendre les valeurs suivantes :

align | Description
eAlignLeft | Déplace la nouvelle image de façon à ce que son côté gauche soit exactement à la même coordonnée X que l'ancienne.
eAlignCentre | Centre les images en leur milieu. Ceci est la valeur par défaut et la spécifier revient à un simple appel de LockView.
eAlignRight | Déplace la nouvelle image de façon à ce que son côté droit soit exactement à la même coordonnée X que l'ancienne.

Notez que cette commande aligne en fonction de la première image de l'animation, donc pour tirer un véritable profit de cette option, toutes les images de votre séquence d'animation devraient être de la même taille. Toutes les images suivantes seront alignées de la même façon, jusqu'à ce que UnlockView soit appelée.

NOTE : Cette fonction bloque la vue du personnage à la vue spécifiée, de façon à ce qu'elle ne puisse être changée que par d'autres commandes de script (c'est-à-dire qu'elle ne sera pas automatiquement changée par AGS en fonction des zones de déplacement libre, des changements à l'écran, etc.). Lorsque l'animation est terminée, utilisez UnlockView pour permettre à AGS de reprendre le contrôle.

Exemple :

cEgo.LockViewAligned(12, 1, eAlignLeft);
cEgo.Animate(1, 5, eOnce, eBlock, eForwards);
cEgo.UnlockView();

changera la vue du personnage EGO à la vue 12, lancera l'animation de la séquence 1 et en attendra la fin pour rendre sa vue normale au personnage.

Voir aussi : Character.LockView, Character.LockViewOffset, Character.UnlockView

LockViewFrame

(Anciennement SetCharacterFrame, désormais obsolète)

Character.LockViewFrame(int vue, int sequence, int image)

Change le graphisme du personnage pour l'image IMAGE de la séquence SEQUENCE de la vue numéro VUE. Ceci est utile si vous ne voulez pas lancer d'animation, mais simplement changer l'image du personnage.

L'image sera bloquée sur celle que vous avez spécifiée jusqu'à ce que vous appeliez UnlockView.

Exemple :

cEgo.LockViewFrame(SIDERE, 2, 4);
Wait(40);
cEgo.UnlockView();

changera l'image de EGO pour l'image 4 de la séquence 2 dans la vue SIDERE, attendra une seconde, et lui redonnera son apparence normale.

Voir aussi : Character.Animate, Character.LockView, Character.UnlockView

LockViewOffset

(Anciennement SetCharacterViewOffset, désormais obsolète)

Character.LockViewOffset(int vue, int xDecalage, int yDecalage)

Définit la vue du personnage à VUE, comme le fait LockView. Cependant, vous devez aussi spécifier un décalage pour toutes les images du personnage jusqu'à ce que UnlockView soit appelée.

Les paramètres XDECALAGE et YDECALAGE définissent selon l'unité de résolution du jeu de combien devrait être déplacée l'image du personnage. Des valeurs positives pour X décalent sur la droite, pour Y vers le bas ; et des négatives décalent à l'opposé.

Cette commande est conçue pour vous permettre de résoudre ces situations où l'animation se trouve décalée par rapport à l'image standard, en admettant que toutes les images de l'animation soient de la même taille. Notez que LockViewAligned est plus simple à utiliser si vos images s'aligneront sur la gauche ou sur la droite.

NOTE : Vous ne devriez utiliser cette commande que pour de petits ajustement, puisque le décalage n'affecte pas la zone cliquable du personnage, ni la zone de déplacement où il se trouve, ou quoique ce soit de tel. Vous devriez limiter votre usage de cette commande à des scènes “cinématiques” où le joueur n'a pas le contrôle.

NOTE : Ceci est la seule commande dans AGS qui utilise les coordonnées selon la résolution du jeu. Ainsi, spécifier une décalage de 1 pixel pour x décalera effectivement d'1 pixel dans un jeu de résolution 640×400, et ne le multipliera pas par deux (mais ce sera automatiquement ajusté si le joueur a décidé de jouer dans une résolution différente).

NOTE : Cette fonction bloque la vue du personnage à celle spécifiée, de façon à ce qu'elle ne puisse être changée que par d'autres commandes de script (c'est-à-dire qu'AGS ne la changera pas automatiquement pour les zones de déplacement libre, changements d'écrans, etc.). Lorsque l'animation est terminée, utilisez UnlockView pour permettre à AGS de reprendre le contrôle.

Exemple :

cEgo.LockViewOffset(12, 1, -1);
cEgo.Animate(1, 5, eOnce, eBlock, eForwards);
cEgo.UnlockView();

définira la vue de EGO à la vue 12 et l'animera en utilisant la séquence 1, de manière à ce que toutes les images soient décalées d'1 pixel sur la droite et d'1 pixel vers le haut.

Voir aussi : Character.LockView, Character.LockViewAligned, Character.UnlockView

LoseInventory

(Anciennement la fonction LoseInventory, désormais obsolète)
(Anciennement LoseInventoryFromCharacter, désormais obsolète)

Character.LoseInventory(InventoryItem *item)

Supprime l'objet d'inventaire spécifié de l'inventaire du personnage. S'il n'a pas l'objet, alors rien ne se passe.

Le seul paramètre est le Script O-Name de l'objet d'inventaire.

Exemple :

cEgo.LoseInventory(iClef);

fera que le personnage EGO perdra l'objet d'inventaire iClef de son inventaire.

Voir aussi : Character.AddInventory

Move

Character.Move(int x, int y, optional BlockingStyle,
                             optional WalkWhere);
Déplace le personnage depuis sa position actuelle vers (X,Y) sans jouer l'animation de déplacement du personnage.

Les paramètres pour cette commandes sont identiques à ceux de la commande [Character#Character.Walk|Character.Walk]]. La seule différence est que Walk joue l'animation de déplacement alors que Move ne le fait pas.

Dans la plupart des cas, vous préférerez utiliser Character.Walk .

Exemple :
cEgo.Move(155, 122, eBlock);

déplacera le personnage vers 155,122 sans jouer son animation de déplacement. Le script ne reprendra son exécution que lorsque le personnage aura atteint sa destination.

Compatibilité : Supporté par AGS 3.1.0 et les versions plus récentes.

Voir aussi : Character.AddWaypoint, Character.FaceCharacter, Character.Walk, MoveCharacterToObject, Object.Move, Character.StopMoving

PlaceOnWalkableArea

(Anciennement MoveToWalkableArea, désormais obsolète)

Character.PlaceOnWalkableArea()

Place le personnage sur la zone de déplacement libre la plus proche de sa position actuelle. Si le personnage est déjà sur une telle zone, rien ne se passe.

Ceci est utile par exemple dans l'événement de pièce Player Enters Room, pour s'assurer que le personnage puisse bouger si la commande ChangeRoom spécifiant des coordonnées a été utilisée pour l'amener dans la pièce. Vous pouvez aussi utiliser cette commande dans on_event avec eEventEnterRoomBeforeFadein pour chaque entrée du joueur dans une piècre.

Exemple :

cEgo.x = Random(320);
cEgo.y = Random(200);
cEgo.PlaceOnWalkableArea();

placera le personnage EGO à une position aléatoire mais s'assurera qu'il se trouve sur une zone de déplacement.

RemoveTint

Character.RemoveTint()
Annule les effets de la commande Tint, et utilise de nouveau la teinte ambiante de la pièce pour le personnage.

Exemple :
player.Tint(0, 250, 0, 30, 100);
Wait(40);
player.RemoveTint();

teintera le personnage joueur en vers pendant une seconde, puis le rendra à la normale.

Voir aussi : Character.HasExplicitTint, Character.Tint

RunInteraction

(Anciennement RunCharacterInteraction, désormais obsolète)

Character.RunInteraction(CursorMode)

Déclenche le script associé à l'événement comme si le joueur avait cliqué sur le personnage avec le mode de curseur spécifié parmi ceux de la fenêtre Curseurs de l'éditeur.

Exemple :

cHomme.RunInteraction(eModeTalk);

exécutera le code placé dans l'événement “TALK TO CHARACTER” de HOMME.

Voir aussi : ProcessClick, Hotspot.RunInteraction, InventoryItem.RunInteraction

Say

(Anciennement DisplaySpeech, désormais obsolète)

Character.Say(string message)

Affiche le texte MESSAGE en tant que discours au-dessus de la tête du personnage. Le texte restera à l'écran durant un temps limité, et l'utilisateur pourra ou non cliquer pour passer le message selon le réglage de l'option “Player can't skip speech text” (“le joueur ne peut pas passer les dialogues”). Le texte affiché par cette fonction a la même apparence que celle utilisée par le système de dialogues.

Vous pouvez insérer des valeurs de variables dans le message. Pour plus d'informations, voyez la section sur la syntaxe des chaînes de caractères.

Exemple :

cEgo.Say("My name is ego");

affichera le message au-dessus de la tête du personnage EGO comme dans les jeux Lucas, tout en jouant l'animation de dialogue du personage.

Voir aussi : Display, Character.SayAt, Character.SayBackground, Character.Think

SayAt

(Anciennement DisplaySpeechAt, désormais obsolète)

SayAt(int x, int y, int largeur, string message)

Semblable à Say, excepté que le texte s'affiche à (X,Y) (coin haut-gauche), dans un cadre de largeur LARGEUR.

Vous pouvez utiliser cette fonction pour écrire les paroles d'un personnage où vous le désirez, et AGS fera jouer l'animation de dialogue au personnage de manière appropriée.

NOTE : Cette fonction ne supporte pas le style de dialogue plein écran.

Exemple :

cEgo.SayAt(220, 20, 100, "My name is ego");

affichera le message en haut à droite de l'écran, tout en jouant l'animation de dialogue du personnage.

Voir aussi : Character.Say, Character.SayBackground

SayBackground

(Anciennement DisplaySpeechBackground, désormais obsolète)

Overlay* Character.SayBackground(string message)

Semblable à Say, excepté que cette fonction passe immédiatement à la suite, tandis que le personnage continue de parler. Cela vous permet de laisser les personnage parler en arrière-plan tandis que le joueur fait autre chose. Notez que l'animation de dialogue du personnage n'est pas jouée suite à l'utilisation de cette fonction.

Cette commande fonctionne en créant un calque textuel à l'écran qui se retire automatiquement après un certain temps. Le calque est retourné par cette commande, de façon à ce que vous puissiez le réutiliser plus tard avec les commandes Overlay.Valid et Overlay.Remove, si vous voulez supprimer le calque prématurément.

Si un discours d'arrière-plan est déjà affiché à l'écran pour le personage, il sera supprimé et remplacé par le nouveau MESSAGE.

Tout discours d'arrière-plan est automatiquement supprimé lorsqu'une commande normale Say est utilisée (à moins que vous définissiez la variable globalegame.bgspeech_stay_on_display à 1).

Exemple :

cHomme.SayBackground("Hé, pourquoi tu viens pas me parler ?");

affichera le message au-dessus de la tête de HOMME sans pour autant mettre le jeu en pause.

Voir aussi : Character.Say

SetAsPlayer

(Anciennement SetPlayerCharacter, désormais obsolète)

Character.SetAsPlayer()

Change le personnage que contrôle le joueur pour lui donner le personnage spécifié. Cette fonction aura aussi pour effet de changer la pièce pour celle où le personnage choisi se trouve actuellement (tout comme pour ChangeRoom, le changement n'opérera pas avant la fin du script.).

De plus, utiliser cette commande changera la valeur de la variable “player” pour la remplir avec le nouveau personnage.

Exemple :

cHomme.SetAsPlayer();

changera le personnage contrôlé par le joueur pour le personnage HOMME et changera également la pièce pour celle où se trouve HOMME, s'il n'est pas déjà dans la pièce actuelle.

Voir aussi : Character.ID, Character.ChangeRoom

SetIdleView

(Anciennement SetCharacterIdle, désormais obsolète)

Character.SetIdleView(int vueattente, int delai)

Change la vue d'attente d'un personnage pour VUEATTENTE, avec un temps de DELAI secondes d'inactivité avant qu'elle survienne. L'inactivité est définie par les moments où le personnage ne bouge pas et n'est pas animé.

Définir DELAI à 0 a pour effet de donner la vue d'attente au personnage dès qu'il ne bouge pas - ce qui est pratique lorsque par exemple le personnage est en train de nager et qu'il doit déplacer l'eau lorsqu'il patiente.

Si vous mettez -1 comme valeur pour VUEATTENTE, la vue d'attente est totalement désactivée.

NOTE : Le DELAI est relatif à la vitesse du jeu. Le définir à 1 signifie qu'il devrait être d'une seconde à un fps de 40, mais si vous avez ajusté la vitesse du jeu alors le délai sera ajusté en conséquences.

NOTE : A cause d'une propriété d'AGS, vous ne pouvez pas définir la Vue d'Attente à 1. Si vous aviez malencontreusement créé votre vue d'attente dans la Vue 1, vous devrez la déplacer à un autre numéro de vue.

Exemple :

cEgo.SetIdleView(12, 30);

définira la vue d'attente du personnage EGO à la vue 12. La vue d'attente se lancera dès que le personnage patientera 30 secondes.

SetWalkSpeed

(Anciennement SetCharacterSpeed, désormais obsolète)
(Anciennement SetCharacterSpeedEx, désormais obsolète)

Character.SetWalkSpeed(int x_vitesse, int y_vitesse)

Donne au personnage une vitesse de déplacement de X_VITESSE à l'horizontale et de Y_VITESSE à la verticale. Les valeurs utilisées pour X_VITESSE et Y_VITESSE sont identiques à celles entrées dans l'Editeur AGS pour la vitesse de marche.

X_VITESSE et Y_VITESSE peuvent avoir la même valeur, auquel cas le personnage se déplacera à la même vitesse dans les deux directions. (l'éditeur nomme ce cas “Vitesse de déplacement uniforme”)

NOTE : Cette fonction NE PEUT PAS être appelée lorsqu'un personnage se déplace, vous devez donc l'arrêter au préalable.

Exemple :

cEgo.SetWalkSpeed(10, 10);

donnera une vitesse de 10 au personnage après l'avoir arrêté.

Voir aussi : Character.AnimationSpeed, Character.StopMoving, Character.Walk, Character.WalkSpeedX, Character.WalkSpeedY

StopMoving

(Formerly known as global function StopMoving, désormais obsolète)

Character.StopMoving()

Arrête les déplacement du personnage et lui donne l'apparence de l'image standard de la séquence actuelle.

Exemple :

if (cEgo.x &gt; 299)
{
  cEgo.StopMoving();
}

arrêtera les déplacements du personnage EGO lorsqu'il atteindra la coordonnée x=300.

Voir aussi : Character.Walk, Object.StopMoving

Think

(Anciennement DisplayThought, désormais obsolète)

Character.Think(string message, ...)

Affiche le texte MESSAGE comme une pensée au-dessus de la tête du personnage spécifié. Le texte restera à l'écran pour un temps limité, et l'utilisera pourra ou non cliquer pour passer le message selon le réglage de l'option “Player can't skip speech text” (“Le joueur peut passer les dialogues”).

La manière d'afficher le texte dépend de quelques petites choses : les réglages du Style de Dialogues (Speech Style), les réglages de l'option “Thought uses bubble GUI” (“Penser utilise une bulle GUI”), et si le personnage a une animation ou non.

Si l'option “Thought uses bubble GUI” est désactivée, alors la pensée sera affichée comme du discours normal - la différence se situant dans l'animation du personnage pensant (ou l'absence d'animation s'il n'en a pas).

Si vous utilisez un style de dialogue à la Sierra et que le personnage n'a pas d'animation prévue pour la pensée, la bulle de pensées s'affichera dans le style lucasart.

Si l'option “Thought uses bubble GUI” est activée, alors la pensée s'affichera comme du discours normal, excepté que la bulle GUI sera utilisée en tant que fenêtre d'arrière-plan. Dans les dialogues de style lucasart, cela signifie au-dessus de la tête du personnage, dans le style Sierra, cela signifie en haut de l'écran.

Si le personnage a une animation de prévue, elle sera jouée une seule fois (et non répétée).

Vous pouvez insérer des valeurs variables dans le message. Pour plus d'informations, voyez la section sur la syntaxe dans les chaînes de caractères.

Exemple :

cEgo.Think("Je me demande ce qu'il y a à dîner.");

affichera le message au dessus de la tête de EGO et jouera l'animation du personnage qui pense.

Voir aussi : Character.BlinkWhileThinking, Character.Say, Character.ThinkView, game.speech_bubble_width

Tint

Character.Tint(int rouge, int vert, int bleu,
               int saturation, int luminosite)
Teinte le personnage à l'écran aux valeurs (ROUGE, VERT, BLEU) avec un saturation de SATURATION pour-cent.

Cette fonction applique la teinte sur le personnage spécifié. Pour connaître le sens de chacun des paramètres, voyez SetAmbientTint.

La teinte appliquée par cette fonction prend le dessus sur la teinte ambiente de la pièce. Pour cette raison, passer la SATURATION à 0 ne l'annule pas complètement - ça assure plutôt qu'aucune teinte ne sera appliquée sur le personnage (même si une teinte ambiente est définie).

Pour annuler la teinte appliquée par cette fonction et réutiliser la teinte ambiente sur le personnage, utilisez RemoveTint.

NOTE : Cette fonction fonctionne uniquement dans les jeux de résolution hautes-couleurs (hi-colour) avec des sprites en hautes-couleurs.

Exemple :
cEgo.Tint(0, 250, 0, 30, 100);

teintera le personnage EGO en vert.

Voir aussi : Character.HasExplicitTint, Character.RemoveTint, SetAmbientTint

UnlockView

(Anciennement ReleaseCharacterView, désormais obsolète)

Character.UnlockView()

Permet à la machine de contrôler les vues du personnage de manière normale. Utilisez cette commande lorsque vous avez fini de jouer une animation que vous aviez lancée suite à la commande LockView.

Exemple :

cEgo.LockView(12);
cEgo.Animate(0, 0, eOnce, eBlock, eForwards);
cEgo.UnlockView();

jouera l'animation utilisant la séquence 0 de la vue 12, puis redonnera au personnage sa vue normale.

Voir aussi : Character.LockView

Walk

(Anciennement MoveCharacter, désormais obsolète)
(Anciennement MoveCharacterBlocking, désormais obsolète)
(Anciennement MoveCharacterDirect, désormais obsolète)

Character.Walk(int x, int y, optional BlockingStyle,
                             optional marcheOu);

Déplace le personnage depuis sa position actuelle jusqu'aux coordonnées (X,Y) tout en utilisant son animation de déplacement.

Si Blocking vaut eNoBlock (par défaut) alors le script reprend immédiatement son exécution, et le personnage se déplacera en arrière-plan.

Si Blocking vaut eBlock alors cette le script attendra que le personnage ait terminé son mouvement pour reprendre son exécution.

Si marcheOu vaut eWalkableAreas (par défaut), alors le personnage tentera de s'approcher le plus possible de (X,Y) tout en restant dans les zones de déplacement libre.

Si marcheOu vaut eAnywhere, alors le personnage se déplacera directement de sa position actuelle à l'endroit (X,Y), en ignorant les zones de déplacement libre.

If you don't want the character's walking animation to play, you can use the Move command instead.

NOTE : cette fonction fonctionne uniquement avec les personnages actuellement à l'écran.

NOTE: si vous avez besoin de détecter quand le personnage a atteint sa destination, utilisez la propriété Moving. Voyez la section des propriétés pour plus d'information.

Exemple :

cEgo.Walk(155, 122, eBlock);

fera marcher le personnage EGO jusqu'aux coordonnées (155,122). Le script patientera jusqu'à ce que le personnage ait fini de se déplacer.

Voir aussi : Character.AddWaypoint, Character.FaceCharacter, Character.Move, MoveCharacterToObject, Object.Move, Character.StopMoving

WalkStraight

(Anciennement MoveCharacterStraight, désormais obsolète)

Character.WalkStraight(int x, int y, optional BlockingStyle);

Tentera de déplacer le personnage depuis sa position actuelle jusqu'aux coordonnées (X,Y) en ligne droite aussi longtemps que possible, jusqu'à ce qu'il rencontre une zone de non-déplacement (tout obstacle). Vous trouverez cette commande pratique si vous gérez le déplacement du personnage à l'aide des croix directionnelles, puisqu'elle garantit que le personnage se déplacera en ligne droite dans la direction spécifiée.

BlockingStyle détermine si la fonction attendra la fin du déplacement ou non pour que le script reprenne. eNoBlock est la valeur par défaut (ce qui signifie que le script reprend directement et que le personnage se déplace en fond). Vous pouvez également passer eBlock, auquel cas votre script attendra la fin du déplacement pour reprendre.

Exemple :

cEgo.WalkStraight(166, 78);

déplacement le personnage EGO en ligne droite jusqu'aux coordonnées (166,78) jusqu'à ce qu'il rencontre une zone où il ne peut pas marcher.

Voir aussi : Character.Walk

ActiveInventory

(Anciennement SetActiveInventory, désormais obsolète)
(Anciennement character[].activeinv, désormais obsolète)

InventoryItem* Character.ActiveInventory

Retourne/Définit l'objet d'inventaire actif actuel du personnage. Le définir mettra le curseur de la souris à jour de façon appropriée.

Cette propriété est utile dans les événements “Use inventory on hostpot/character/etc” (“Utiliser un objet d'inventaire sur une zone interactive/un personnage/etc”), pour déterminer quel est l'objet d'inventaire que le joueur tente d'utiliser sur la cible.

Pour déselectionner tout objet d'inventaire actif, définissez la valeur à null .

Exemple :

cEgo.ActiveInventory = iClef;

rendra l'objet d'inventaire iClef actif (avant d'utiliser cela assurez vous que le joueur dispose de l'objet d'inventaire).

Animating

(Anciennement character[].animating, désormais obsolète)

readonly bool Character.Animating

Retourne 1 si le personnage est actuellement en animation.

Retourne 0 si le personnage a fini son animation.

Cette propriété est en lecture seule. Pour changer l'animation du personnage, utilisez la commande Animate.

Exemple :

cEgo.Animate(5, 0);
while (cEgo.Animating) Wait(1);

animera le personnage EGO et attendra jusqu'à ce que l'animation soit achevée.

En réalité, en utilisant le paramètre Blocking des commandes d'animation vous n'auriez pas besoin de coder cela.

Voir aussi : Character.Animate, Character.Moving, Character.Speaking

AnimationSpeed

(Anciennement character[].animspeed, désormais obsolète)

int Character.AnimationSpeed;

Retourne/Définit le délai d'animation du personnage, comme on peut le faire dans l'éditeur.

Exemple :

player.AnimationSpeed = 4;

changera la vitesse d'animation du personnage à 4.

Voir aussi : Character.SetWalkSpeed

Baseline

(Anciennement SetCharacterBaseline, désormais obsolète)

int Character.Baseline

Retourne/Définit la baseline du personnage. Ceci vous permet de définir une baseline spécifique pour le personnage, qui fonctionne de la même façon que les zones “par-dessus” et les baselines des objets.

La baseline peut aller de 1 à la hauteur de la pièce (normalement 200), ou si vous lui donnez la valeur 0, la baseline se redéfinit sur les pieds du personnage.

Exemple :

cEgo.Baseline = 120;

déplacera la baseline du personnage (ce qui peut être utilisé pour tester les collisions, ou pour les zones qui s'affichent par-dessus le personnage) à une ligne positionnée à la coordonnée y = 120.

Voir aussi : Object.Baseline, SetWalkBehindBase

BlinkInterval

(Connu de SetCharacterBlinkView, désormais obsolète)

int Character.BlinkInterval

Retourne/Définit l'intervalle de clignement du personnage, ce qui détermine combien de temps le jeu attend entre chaque animation de clignement. L'unité est une séquence du jeu - un intervalle de 80 jouera l'animation de clignement à peu près toutes les 2 secondes, suivant le fps du jeu.

Cette propriété n'a pas d'effet si aucune BlinkView n'a été définie.

Exemple :

cEgo.BlinkView = 10;
cEgo.BlinkInterval = 160;

changera la vue de clignement du personange EGO à la vue 10, et jouera l'animation toutes les 4 secondes.

Voir aussi : Character.BlinkView, Character.SpeechView

BlinkView

(Connu de SetCharacterBlinkView, désormais obsolète)

int Character.BlinkView

Retourne/Définit la vue de clignement du personnage. Pour faire cesser le personnage de cligner des yeux, définissez cette propriété à -1.

La propriété BlinkInterval définit la fréquence de l'animation de clignement.

Exemple :

cEgo.BlinkView = 10;
cEgo.BlinkInterval = 160;

changera la vue de clignement du personnage EGO à la vue 10, et jouera l'animation toutes les 4 secondes.

Voir aussi : Character.BlinkInterval, Character.SpeechView

BlinkWhileThinking

bool Character.BlinkWhileThinking
Retourne/Définit si le personnage peut ou non cligner des yeux lorsqu'il pense. Par défaut cette valeur vaut true, mais si votre animation de clignement ne convient pas avec l'animation du personnage lorsqu'il pense, vous pouvez empêcher le personnage de cligner des yeux lorsqu'il pense en définissant cette propriété à la valeur false.

Exemple :

cEgo.BlinkWhileThinking = false;

empêchera le personnage EGO de cligner des yeux lorsqu'il pense.

Voir aussi : Character.BlinkView, Character.Think

BlockingHeight

int Character.BlockingHeight
Retourne/Définit la hauteur de blocage du personnage.

La hauteur de blocage définit le cadre entourant le personnage à travers lequel les autres personnage ne peuvent passer. Si vous définissez la valeur à 0 (par défaut), alors le cadre de blocage est automatiquement calculé pour avoir la largeur du personnage et une hauteur de 5 pixels.

Vous pouvez changer cette valeur en entrant une hauteur de blocage en pixels, ce qui changera la dimension de zone de déplacement libre que le personnage occupera en se trouvant dessus.

NOTE : Cette propriété n'a d'effet que si la propriété Solid vaut true .

Exemple :
cEgo.BlockingHeight = 20;

fera que le personnage bloquera 20 pixels de hauteur (10 au-dessus et 10 sous la baseline).

Voir aussi : Character.BlockingWidth, Character.Solid

BlockingWidth

int Character.BlockingWidth
Retourne/Définit la largeur de blocage du personnage.

La largeur de blocage définit le cadre entourant le personnage à travers lequel les autres personnages ne peuvent passer. Si vous définissez la valeur à 0 (par défaut), alors le cadre de blocage est automatiquement calculé pour avoir la largeur du personange et une hauteur de 5 pixels.

Vous pouvez changer cette valeur en entrant une largeur de blocage en pixels, ce qui changera la dimension de zone de déplacement libre que le personnage occupera en se trouvant dessus.

NOTE : Cette propriété n'a d'effet que si la propriété Solid vaut true .

Exemple :
cEgo.BlockingWidth = 50;

fera que le personnage EGO occupera 50 pixels de largeur (25 sur sa gauche, 25 sur sa droite, depuis sa coordonnée X).

Voir aussi : Character.BlockingHeight, Character.Solid

Clickable

(Anciennement SetCharacterClickable, désormais obsolète)

bool Character.Clickable

Retourne/Définit si le personnage est considéré comme un élément avec lequel le joueur peut interagir. Cela revient à modifier la propriété “Clickable” définie dans l'éditeur.

Si vous donnez la valeur true, alors le joueur peut regarder, parler, et interagir d'autres manières avec le personnage (comme dans les vieux jeux Sierra). Si vous donnez la valeur false, alors si le joueur clique sur le personnage, cela déclenchera les interactions prévues pour les éléments qui se trouvent derrière le héros (comme dans les vieux jeux Lucasarts).

Exemple :

cHomme.Clickable = 0;

fera que le jeu ignorera les clics sur le personnage HOMME.

Voir aussi : Object.Clickable

DiagonalLoops

(Connu de SetCharacterProperty, désormais obsolète)

bool Character.DiagonalLoops

Retourne/Définit si les séquences de marche en diagonale sont utilisées pour ce personnage. Si la valeur est true , alors les séquences 4 à 7 seront utilisées comme des séquence de déplacement en diagonale. Si la valeur est false , alors le personnage ne se tournera que dans 4 directions et vous pourrez utilisez les séquences 4 à 7 pour d'autres utilisations.

Exemple :

cEgo.DiagonalLoops = true;

activera les séquences de déplacement en diagonale pour le personnage EGO.

Frame

(Anciennement character[].frame, désormais obsolète)

int Character.Frame

Retourne/Définit le numéro de l'image (frame) actuelle du personnage. En général vous ne changerez pas directement ce paramètre mais utiliserez plutôt les commandes Animate pour jouer une animation.

Exemple :

Display("EGO currently using frame %d.", cEgo.Frame);

affiche le numéro de l'image qu'utilise actuellement EGO dans sa vue.

Voir aussi: Character.Animate, Character.Loop, Character.View

HasExplicitTint

readonly bool Character.HasExplicitTint
Retourne true si le personnage a une teinte explicitement définie par la commande Character.Tint.

Retourne false si le personnage n'a pas de teinte explicite, bien qu'il puisse malgré tout être teinté par SetAmbientTint ou par la teinte propre à une région.

Exemple :
if (player.HasExplicitTint)
{
  player.RemoveTint();
}

supprime la teinte propre au personnage s'il en a une.

Compatibilité : Supporté par AGS 3.1.0 et les versions plus récentes.

Voir aussi: Character.Tint, Character.RemoveTint

ID

readonly int Character.ID
Retourne l'ID du personnage. C'est le numéro du personnage dans l'éditeur, et il est utile si vous devez manipuler du code qui utilise le numéro des personnages plutôt que leurs noms.

Exemple :
MoveCharacter(cEgo.ID, 100, 50);

utilise la fonction obsolète MoveCharacter pour déplacer EGO aux coordonnées (100, 50).

IdleView

readonly int Character.IdleView
Retourne la vue d'attente actuelle du personnage. Si le personnage n'en a pas, retourne -1.

Cette propriété est en lecture seule, pour changer la vue, utilisez la fonction SetIdleView.

Exemple :
Display("La vue d'attente de EGO est actuellement la vue numéro %d.", cEgo.IdleView);

affichera le numéro de la vue d'attente actuelle de EGO.

Voir aussi : SetIdleView

IgnoreLighting

(Anciennement SetCharacterIgnoreLight, désormais obsolète)

bool Character.IgnoreLighting

Vous permet de modifier dynamiquement l'option “ignore lighting” pour le personnage. Si la valeur est de 0, le personnage sera touché par les effets de luminosité et les teintes de la région où il se trouve ; si la valeur est de 1, alors le personnage ignorera tous les effets de luminosité de la région.

Exemple :

cEgo.IgnoreLighting = 1;

fera que le personnage aura la même apparence, quel que soit le niveau de luminosité de la région où il se trouve.

IgnoreWalkbehinds

(Anciennement SetCharacterIgnoreWalkbehinds, désormais obsolète)

bool Character.IgnoreWalkbehinds

Retourne/Définit si le personnage passe derrière les zones “par-dessus”. Si la valeur est de 0 (par défaut), le personnage devra passer derrière les zones “par-dessus” en respectant les baselines.

Si la valeur est true, le personnage ne passera derrière aucune de ces zones. Ceci est utile lorsque vous voulez par exemple utiliser un personnage comme un calque pour afficher de la pluie ou de la neige dans la scène.

NOTE: activer cette propriété pose actuellement quelques soucis avec le pilote Direct3D. Exemple :

cEgo.IgnoreWalkbehinds = true;

fera que le personnage EGO ignorera les zones de surface (Walkbehind areas).

Voir aussi : Object.IgnoreWalkbehinds

InventoryQuantity

(Anciennement character[].inv, désormais obsolète)

int Character.InventoryQuantity[]

Retourne/Définit la quantitié de l'objet d'inventaire spécifié que le personnage transporte. L'index du tableau est le numéro de l'objet d'inventaire dans le panneau Inventaire de l'éditeur.

En général, vous utiliserez plutôt AddInventory et LoseInventory pour modifier l'inventaire des personnages ; cependant, si vous devez ajouter ou supprimer un grand nombre d'objet d'un seul coup, utiliser ce tableau peut rendre la chose plus facile.

Si vous utilisez directement ce tableau, l'inventaire à l'écran ne sera pas mis à jour. Dans ce cas, vous devrez appeler UpdateInventory pour voir les objets ajoutés ou supprimés.

Si vous voulez juste vérifier rapidement si un personnage possède un objet particulier ou non, utilisez plutôt la fonction HasInventory.

Exemple :

Display("Le joueur possède $%d€.", player.InventoryQuantity[iEuro.ID]);

affichera le nombre d'objets d'inventaire de type iEuro dont le joueur dispose.

Voir aussi : UpdateInventory, Character.AddInventory, Character.HasInventory, Character.LoseInventory

Loop

(Anciennement character[].loop, désormais obsolète)

int Character.Loop

Retourne/Définit le numéro de séquence actuelle du personnage. En général, vous ne changerez pas directement ce paramètre, mais utiliserez plutôt les commande Animate pour jouer une animation.

Exemple :

Display("EGO utilise actuellement la séquence numéro %d.", cEgo.Loop);

affiche de numéro de la séquence actuelle dans la vue de EGO.

Voir aussi : Character.Animate, Character.Frame, Character.View

ManualScaling

(Anciennement Character.IgnoreScaling, désormais obsolète)
(Connu de SetCharacterProperty, désormais obsolète)

bool Character.ManualScaling

Retourne/Définit si le niveau de zoom du personnage est déterminé par la zone de déplacement (walkable area) où se trouve le personnage, ou s'il est manuellement défini par le script. Ceci est équivalent à l'option “Ignore room area scaling” (“ignore les taux de zoom propres aux zones de la pièce”) dans l'éditeur.

Si la valeur est true , alors le niveau de zoom du personnage est manuellement défini par la propriété Scaling (qui vaut par défaut 100%). Si la valeur est false , alors les dimensions du personnage seront ajusté automatiquement suivant le réglage de zoom de la zone de déplacement (walkable area).

Exemple :

cEgo.ManualScaling = true;
cEgo.Scaling = 50;

fixera le niveau de zoom de EGO à 50% et lui fera ignorer les réglages de la zone de déplacement.

Voir aussi : Character.Scaling

MovementLinkedToAnimation

bool Character.MovementLinkedToAnimation

Retourne/définit si le déplacement du personnage est lié à son animation. Vaut true par défaut, ce qui signifie que quand le personnage se déplace son mouvement à l'écran est synchronisé avec son animation. Sans cela, le personnage peut sembler “glisser” sur l'écran.

Dans certains cas particulier vous pourriez vouloir désactiver cette option, donnez alors simplement la valeur false.

Dans les précédentes versions d'AGS, le nom de cette option était “Anti-glide mode” et était un réglage général.

Exemple :

player.MovementLinkedToAnimation = false;
player.Walk(50, 100, eBlock);
player.MovementLinkedToAnimation = true;

désactivera l'animation liée au mouvement pour le personnage joueur, le fera se déplacer aux coordonnées (50,100) puis réactivera cette option.

Compatibilité : Supporté par AGS 3.1.1 et les versions plus récentes.

Voir aussi : Character.Move, Character.Moving, Character.Walk

Moving

(Anciennement character[].walking, désormais obsolète)

readonly bool Character.Moving

Retourne true si le personnage est actuellement en train de se déplacer, false sinon.

Cette propiété est en lecture seule ; pour déplacer le personnage, utiliez les commadnes Walk, Move et StopMoving.

Exemple :

cEgo.Walk(125, 40);
while (cEgo.Moving) Wait(1);

déplacera le personnage jusqu'aux coordonnées (125,40) et rendra le contrôle au joueur lorsqu'il y sera arrivé (a le même effet que passer simplement eBlock à la commande Walk).

Voir aussi : Character.Animating, Character.Move Character.Speaking, Character.StopMoving, Character.Walk

Name

(Anciennement character[].name, désormais obsolète)

String Character.Name

Retourne/Définit le nom du personnage, de la même façon qu'on le définit dans l'éditeur AGS. Ceci est le nom complet du personnage, pas son nom de script.

Sachez que les noms de personnage sont limités à 40 caractères, donc les noms que vous entrerez seront coupés au-delà de cette limite.

Exemple :

Display("Vous contrôlez %s.", player.Name);

affichera le nom du personnage que contrôle le joueur.

NormalView

(Anciennement character[].defview, désormais obsolète)

readonly int Character.NormalView

Retourne la vue normale du personnage. Ceci est la vue de marche standard du personnage, qui est utilisée lorsque sa vue n'est pas bloquée sur une autre.

Cette propriété est en lecture seule, pour changer la vue, utilisez la commande ChangeView.

Exemple :

if (cEgo.View == cEgo.NormalView) {
  Display("EGO n'est pas actuellement animé, ne parle pas et ne patiente pas.");
}

affichera le message si EGO est actuellement affiché avec sa vue normale.

Voir aussi : Character.ChangeView, Character.View

PreviousRoom

(Anciennement character[].prevroom, désormais obsolète)

readonly int Character.PreviousRoom

Retourne le numéro de la pièce dans laquelle le personnage se trouvait auparavant. Si le personnage se trouve encore dans sa pièce de départ, retournera -1. Sinon, retournera le numéro de la dernière pièce dans laquelle le personnage s'est trouvé avant celle-ci.

C'est une propriété en lecture seule. Elle est automatiquement redéfinie par ChangeRoom.

Exemple :

Display("Avant, EGO se trouvait dans la pièce numéro %d.", cEgo.PreviousRoom);

affichera la pièce précédente de EGO.

Room

(Anciennement character[].room, désormais obsolète)

readonly int Character.Room

Retourne le numéro de la pièce dans laquelle se trouve actuellement le personnage.

C'est une propriété en lecture seule. Elle est définie par ChangeRoom.

Exemple :

Display("EGO se trouve dans la pièce numéro %d.", cEgo.Room);

affichera la pièce dans laquelle se trouve actuellement le personnage EGO.

ScaleMoveSpeed

(Connu de SetCharacterProperty, désormais obsolète)

bool Character.ScaleMoveSpeed

Retourne/Définit si la vitesse de déplacement du personnage est ajustée en fonction du niveau de zoom courant. Ceci vous permet de modifier l'option “Adjust speed with scaling” (“Ajuster la vitesse selon le zoom”) de l'éditeur.

Si vous donnez la valeur true , les mouvements du personnage seront ajustés de façon à ce qu'il se déplace à une vitesse proportionnelle à son niveau de zoom courant. Si vous donnez la valeur false , le personnage se déplacera tout le temps à sa vitesse normal.

Exemple :

cEgo.ScaleMoveSpeed = true;

signifie que la vitesse de EGO sera ajustée selon son zoom.

Voir aussi : Character.ScaleVolume

ScaleVolume

bool Character.ScaleVolume
Retourne/Définit si le volume propre au personnage est ajusté sur le niveau de zoom courant du personnage. Ceci vous permet de modifier l'option “Adjust volume with scaling” (“Ajuster le volume en fonction du zoom”) de l'éditeur.

Par défaut, cette propriété vaut false . Si vous passez la valeur true , alors tout son lié à une image du personnage (comme des sons de pas) verra son volume automatiquement ajusté sur le niveau de zoom du personnage. Au niveau de zoom normal de 100%, les sons seront joué à un volume normal, mais seront de plus en plus faibles selon les déplacements en profondeur du personnage (donc de son niveau de zoom).

Exemple :
cEgo.ScaleVolume = true;

signifie que les sons des pas de EGO seront ajustés selon son zoom.

Voir aussi : Character.ScaleMoveSpeed

Scaling

int Character.Scaling
Retourne/Définit le niveau de zoom actuel du personnage.

Cette propriété peut toujours être lue, et retourne le niveau de zoom courant du personnage, qui peut aller de 5 à 200 (100 par défaut, ce qui signifie que le personnage ne subit aucun effet de zoom).

Vous pouvez définir la valeur de cette propriété uniquement si ManualScaling est activée pour ce personnage ; sinon, le niveau de zoom est automatiquement défini par rapport à la zone de déplacement libre sur laquelle se situe le personnage.

Exemple :
cEgo.ManualScaling = true;
cEgo.Scaling = 50;

dira à EGO d'ignorer le zoom des zones de déplacement et fixera son niveau de zoom à 50%.

Voir aussi : Character.ManualScaling

Solid

(Connu de SetCharacterProperty, désormais obsolète)

bool Character.Solid

Retourne/Définit si les autres personnages peuvent passer à travers celui-ci.

Si la valeur est true , alors le personnage est solide et bloquera le chemin des autres personnages. Si la valeur est false , alors le personnage agira comme un hologramme, et les autres personnages pourront marcher sans se cogner à lui.

Exemple :

cEgo.Solid = true;

signifie que EGO bloquera le passage des autres personnages.

Voir aussi : Character.BlockingHeight, Character.BlockingWidth

Speaking

readonly bool Character.Speaking
Retourne true si le personnage est en train de parler, sinon false.

Cette propriété est en lecture seule. Elle retournera true uniquement si le personnage parle de façon active ; c'est-à-dire qu'elle retournera false si le personnage parle à l'aide de la commande SayBackground.

Puisque cette propriété ne sera vraie que lorsque le personnage parle, et que cela utilise une commande qui bloque l'exécution du script, cette propriété ne sera probablement manipulable que dans repeatedly_execute_always.

Exemple :
if ((cEgo.Speaking) && (!cEgo.Animating)) {
  cEgo.Animate(3, 5, eRepeat, eNoBlock);
}

will animate the character using loop 3 while they are talking (only useful with Sierra-style speech).

Voir aussi : Character.Animating, Character.Moving, Character.Say, Character.SpeakingFrame

SpeakingFrame

readonly int Character.SpeakingFrame
Retounre le numéro de l'image (frame) d'animation de dialogue du personnage actuelle. Ceci est utile lorsque vous utilisez le style de dialogue Sierra, si vous voulez synchroniser les événements avec l'avancée de l'apparence du visage du personnage.

Cette propriété est en lecture seule. Elle n'est accessible que lorsque le personnage est en train de parler ; si vous essayer d'y accéder lorsque Character.Speaking vaut false alors il se produira une erreur.

Puisque le discours correspond à une commande qui bloque l'exécution du script, vous n'aurez certainement recours à cette propriété que dans la fonction repeatedly_execute_always.

Exemple :
if (cEgo.Speaking) {
  if (cEgo.SpeakingFrame == 0) {
    cHomme.Move(cMan.x + 10, cMan.y, eNoBlock, eAnywhere);
  }
}

déplacera cHomme vers la droite chaque fois que l'animation de dialogue passe sur l'image (frame) 0.

Voir aussi : Character.Say, Character.Speaking

SpeechAnimationDelay

int Character.SpeechAnimationDelay;

Retourne/définit le délai d'animation de parole du personnage, tel que défini dans l'éditeur. Cela spécifie durant combien de cycles de jeu chaque image de l'animation de parole (speech animation) reste à l'écran.

NOTE : Cette propriété est ignorée si l'option lip sync (synchronisation des lèvres) est activée.

NOTE : Cette propriété ne peu tpas être utilisée si l'option de rétro-compatibilité “Old-style game-wide speech animation speed” (”Vitesse d'animation de parole globale”) est activée dans les Réglages Généraux (General Settings). Dans ce cas, c'est l'ancienne variable game.talkanim_speed qui est considérée.

Exemple :

player.SpeechAnimationDelay = 4;

mettra le délai d'animation de parole du personnage à 4.

Compatibilité : Supporté par AGS 3.1.2 et les versions plus récentes.

Voir aussi : Character.AnimationSpeed, Character.SpeechView, Game.TextReadingSpeed

SpeechColor

(Anciennement SetTalkingColor, désormais obsolète)

int Character.SpeechColor

Retourne/Définit la couleur du discours du personnage. La valeur par défaut se définit dans l'éditeur.

La valeur est l'index de la case couleur de la Palette de l'éditeur. Elle peut aller de 0 à 255 pour un jeu en 256 couleurs, ou l'un des index hautes-couleurs disponibles depuis la Palette de l'éditeur.

Exemple :

cEgo.SpeechColor = 14;

changera la couleur du texte du personnage EGO en jaune.

Voir aussi : Character.SpeechView

SpeechView

(Anciennement SetCharacterSpeechView, désormais obsolète)
(Anciennement character[].talkview, désormais obsolète)

int Character.SpeechView

Retourne/Définit la vue du personnage lorsqu'il parle. Si vous changez cela, le nouveau numéro de vue sera utilisé comme la vue de dialogue du personnage dans toutes les conversations qui suivront.

Vous pouvez donner la valeur -1 pour désactiver la vue de dialogue du personnage.

Exemple :

cEgo.SpeechView = 10;

utilisera la vue numéro 10 pour animer le personnage EGO lorsqu'il parlera.

Voir aussi : Character.ChangeView, Character.BlinkView, Character.SpeechColor

ThinkView

(Anciennement character[].thinkview, désormais obsolète)

int Character.ThinkView

Retourne/Définit la vue du personnage lorsqu'il pense. Ceci est utilisé pour animer le personnage lorsque sa pensée est affichée.

Exemple :

cEgo.ThinkView = 14;

utilisera la vue numéro 14 pour animer le personnage EGO lorsqu'il pensera.

Voir aussi : Character.Think

Transparency

(Anciennement SetCharacterTransparency, désormais obsolète)

int Character.Transparency

Retourne/Définit la transparence du personnage. La valeur passée est en pourcentage, de 0 à 100. 100 signifie totalement transparent (c'est-à-dire invisible), et 0 totalement opaque (totalement visible). Les nombres intermédiaires font varier le niveau de transparence.

NOTE : La transparence ne fonctionne qu'avec les jeux de couleurs 16 et 32 bits.

NOTE : Avec le pilote DirectX 5, un gros personnage transparent peut significativement ralentir AGS.

Un arrondissement est effectuée de façon interne lors du stockage de la transparence – ainsi, si vous la récupérer juste après l'avoir définie, la valeur peut être supérieure à la réelle. Dès lors, si vous bouclez sur cEgo.Transparency++;, vous risquez d'atteindre la limite trop vite. Si vous voulez faire un fondu sur un personnage, la meilleure solution serait de faire comme dans l'exemple qui suit :

Exemple :

int trans = cEgo.Transparency;
while (trans &lt; 100) {
  trans++;
  cEgo.Transparency = trans;
  Wait(1);
}

fondra graduellement le personnage depuis sa transparence actuelle pour le rendre totalement invisible.

Voir aussi : Object.Transparency

TurnBeforeWalking

(Connu de SetCharacterProperty, désormais obsolète)

bool Character.TurnBeforeWalking

Retourne/Définit si le personnage se tourne dans la nouvelle direction avant de marcher. Ceci est équivalent (mais avec des valeurs opposées) à l'option “Do not turn before walking” (“Ne pas tourner avant de marcher”) de l'éditeur.

Si vous passez la valeur 1, le personnage se retournera pour être dans la nouvelle direction avant de commencer à marcher. Si vous passez la valeur 0, le personnage commencera à marcher directement dans la nouvelle direction, sans se retourner au préalable.

Exemple :

cEgo.TurnBeforeWalking = 1;

dira à EGO de se retourner avant de marcher.

View

readonly int Character.View
Retourne la vue que le personnage utilise actuellement à l'écran.

Cette propriété est en lecture seule, pour changer la vue, utiliser les fonctions ChangeView et LockView.

Exemple :
Display("La vue de EGO est actuellement la vue numéro %d.", cEgo.View);

affichera le numéro de la vue dans laquelle EGO est actuellement affiché.

Voir aussi : Character.ChangeView, Character.Frame, Character.LockView, Character.Loop, Character.NormalView

WalkSpeedX

readonly int Character.WalkSpeedX;
Retourne la vitesse de déplacement horizontal (X) du personnage. S'il utilise des mouvements uniformes, cette vitesse sera la même que celle de déplacement vertical (Y).

Cette propriété est en lecture seule. Pour changer la vitesse de déplacement, utilisez la fonction SetWalkSpeed.

Exemple :
Display("vitesse x du joueur : %d", player.WalkSpeedX);

affichera la vitesse de déplacement sur l'axe X du joueur.

Voir aussi : Character.SetWalkSpeed, Character.WalkSpeedY

WalkSpeedY

readonly int Character.WalkSpeedY;
Retourne la vitesse de déplacement vertical (Y) du personnage. S'il utilise des mouvements uniformes, cette vitesse sera la même que celle de déplacement horizontal (X).

Cette propriété est en lecture seule. Pour changer la vitesse de déplacement, utilisez la fonction SetWalkSpeed.

Exemple :
Display("vitesse y du joueur : %d", player.WalkSpeedY);

affichera la vitesse de déplacement sur l'axe Y du joueur.

Voir aussi : Character.SetWalkSpeed, Character.WalkSpeedX

x

int Character.x;
Retourne/Définit la coordonnée X actuelle du personnage. La valeur est retournée selon les coordonnées normales de la pièce, depuis le centre de la sprite du personnage.

NOTE: NE changez PAS cette propriété lorsque le personnage se déplace. Assurez-vous que le personnage est à l'arrêt avant de changer ses coordonnées.

Exemple :
Display("le joueur se trouve aux coordonnées %d,%d.", player.x, player.y);

affichera les coordonnées actuelles du joueur.

Voir aussi : Character.y, Character.z

y

int Character.y;
Retourne/Définit la coordonnée Y actuelle du personnage. La valeur est retournée selon les coordonnées normales de la pièce, depuis le centre de la sprite du personnage.

NOTE: NE changez PAS cette propriété lorsque le personnage se déplace. Assurez-vous que le personnage est à l'arrêt avant de changer ses coordonnées.

Exemple :
Display("Le joueur se trouve aux coordonnées %d,%d.", player.x, player.y);

affichera les coordonnées actuelles du joueur.

Voir aussi : Character.x, Character.z

z

int Character.z;
Retourne/Définit la position actuelle Z du personnage. Ceci vous permet de faire décoller le personnage du sol, tout en respectant sa coordonnée Y normale pour les calculs de baseline et de régions.

Normalement, cette valeur vaut 0 (niveau du sol), mais vous pouvez l'augmenter pour faire flotter le personnage.

Exemple :
while (player.z &lt; 20) {
  player.z++;
  Wait(1);
}

fera graduellement léviter le personnage à 20 pixels de haut.

Voir aussi : Character.x, Character.y

SetCharacter

SetCharacterProperty (CHARID, PROPERTY, int nouvelle_valeur)
Cette commande est désormais obsolète. Elle a été remplacée par les propriétés suivantes :

Clickable

DiagonalLoops

IgnoreLighting

ManualScaling

ScaleMoveSpeed

Solid

TurnBeforeWalking


datetime

Table des matières
    • Fonctions et propriétés de dates et heures (DateTime)
      • Now
      • DayOfMonth
      • Hour
      • Minute
      • Month
      • RawTime
      • Second
      • Year

Fonctions et propriétés de dates et heures (DateTime)

Now

(Anciennement GetTime, désormais obsolète)

readonly static DateTime* DateTime.Now;

Retourne l'heure et la date actuelles du système. Vous pourriez vous en servir pour effectuer une boucle sur le temps (chronomètre), ou pour une gestion du cycle du sommeil (le personnage du joueur va se coucher), ou d'autres choses du genre.

Un objet DateTime est retourné, qui contient plusieurs propriétés utilisables.

Notez que l'objet DateTime que vous obtenez ne sera pas automatiquement mis à jour ; sa valeur restera celle retournée lorsque vous avez appelé DateTime.Now.

Exemple :

DateTime *dt = DateTime.Now;
Display("La date est : %02d/%02d/%04d", dt.DayOfMonth, dt.Month, dt.Year);
Display("L'heure est : %02d:%02d:%02d", dt.Hour, dt.Minute, dt.Second);

affichera la date actuelle et l'heure actuelle dans un format de 24 heures (à l'opposé de 2×12 heures).

Voir Aussi : DateTime.DayOfMonth, DateTime.Hour, DateTime.Minute, DateTime.Month, DateTime.RawTime, DateTime.Second, DateTime.Year

DayOfMonth

readonly int DateTime.DayOfMonth;
Retourne le jour du mois représenté dans l'objet DateTime. La valeur ira de 1 à 31, représentant le jour du mois.

Exemple : Pour un exemple, voyez DateTime.Now.

Voir Aussi : DateTime.Now

Hour

readonly int DateTime.Hour;
Retourne l'heure représentée dans l'objet DateTime. La valeur ira de 0 à 23, représentée dans le format 24 heures.

Exemple : Pour un exemple, voyez DateTime.Now.

Voir Aussi : DateTime.Now

Minute

readonly int DateTime.Minute;
Retourne les minutes représentées dans l'objet DateTime. La valeur ira de 0 à 59, représentant la partie minutes du format 24 heures.

Exemple : Pour un exemple, voyez DateTime.Now.

Voir Aussi : DateTime.Now

Month

readonly int DateTime.Month;
Retourne le mois représenté par l'objet DateTime. La valeur ira de 1 à 12, représentant le mois de l'année.

Exemple : Pour un exemple, voyez DateTime.Now.

Voir Aussi : DateTime.Now

RawTime

(Anciennement GetRawTime, désormais obsolète)

readonly int DateTime.RawTime;

Cette fonction retourne le temps écoulé depuis le 1er janvier 1970 (temps système). Cette propriété peut notamment servir à calculer la différence entre sa valeur actuelle et celle en début de partie, pour obtenir le temps écoulé depuis le commencement de la partie.

NOTE : Puisque cette fonction accède à l'horloge système de l'utilisateur, ce n'est pas une bonne idée de l'utiliser pour des tâches à longs termes, puisque la valeur retournée tiendra évidemment compte du temps écoulé lorsque l'utilisateur n'est pas sur le jeu.

Exemple :

DateTime *dt = DateTime.Now;
int temps_depart = dt.RawTime;
Wait(120);
dt = DateTime.Now;
Display("L'attente a été de %d secondes.", dt.RawTime - temps_depart);

devrait afficher que 3 secondes se sont écoulées. Voir Aussi : DateTime.Now, SetTimer

Second

readonly int DateTime.Second;
Retourne les secondes représentées dans l'objet DateTime. La valeur ira de 0 à 59, représentant la partie secondes du format 24 heures.

Exemple : Pour un exemple, voyez DateTime.Now.

Voir Aussi : DateTime.Now

Year

readonly int DateTime.Year;
Retourne l'année représentée dans l'objet DateTime. Ceci est l'année complète, par exemple 2005.

Exemple : Pour un exemple, voyez DateTime.Now.

Voir Aussi : DateTime.Now

,


dialog

Table des matières
    • Fonctions et propriétés des dialogues (Dialog)
      • DisplayOptions
      • GetOptionState
      • HasOptionBeenChosen
      • GetOptionText
      • ID
      • OptionCount
      • SetOptionState
      • ShowTextParser
      • Start
      • StopDialog

Fonctions et propriétés des dialogues (Dialog)

DisplayOptions

int Dialog.DisplayOptions(optional DialogOptionSayStyle)
Présente les options de ce dialogue à l'utilisateur et attend qu'il en sélectionne une. Le numéro de l'option sélectionné est retourné.

NOTE : Cette commande ne lance aucun script de dialogue, elle affiche simplement les options et attend que le joueur en choisisse une. Pour exécuter le dialogue normalement, utilisez plutôt la commande Dialog.Start.

Cette commande est utile si vous voulez implémenter votre propre système de dialogues, mais désirez tout de même utiliser les écrans standard de sélection d'options.

Le paramètre optionnel DialogOptionSayStyle détermine si l'option choisie est automatiquement prononcée par le personnage joueur. Vaut eSayUseOptionSetting par défaut, ce qui correpond aux réglages de l'option “Say” de l'éditeur de dialogues. D'autre part, vous pouvez utiliser eSayAlways , ce qui fera prononcer l'option indépendamment des réglages de l'éditeur ; ou eSayNever , ce qui ne prononcera pas l'option.

Si l'analyseur de texte est activé pour ce dialogue et que le joueur entre quelque chose plutôt que de sélectionner une option, la valeur spéciale DIALOG_PARSER_SELECTED sera retournée et AGS appellera automatiquement Parser.ParseText avec le texte entré par le joueur. Ainsi, vous pouvez appeler Parser.Said pour traiter le texte.

Exemple :
int resultat = dVieilHomme.DisplayOptions();
if (resultat == DIALOG_PARSER_SELECTED)
{
  Display("Quelque chose a été entré dans l'analyseur de texte !");
}
else
{
  Display("C'est l'option numéro %d qui a été choisie.", resultat);
}

affichera les options du dialogue dOldMan et affichera un message selon ce que le joueur a sélectionné.

Compatibilité : Supporté par AGS 3.0.2 et les versions plus récentes.

Voir aussi : Dialog.Start, Parser.ParseText

GetOptionState

(Anciennement global function GetDialogOption, désormais obsolète)

Dialog.GetOptionState(int option)

Retourne si une option d'une conversation est disponible pour le joueur ou non.

OPTION correspond au numéro de l'option dans le dialogue, de 1 à la plus haut valeur de l'option pour ce sujet.

La valeur retournée peut avoir les valeurs suivantes :

eOptionOff
  L'option est désactivée - le joueur ne la verra pas
eOptionOn
  L'option est activée - le joueur peut la voir et l'utiliser
eOptionOffForever
  L'option est désactivée en permanence - aucune commande ne peut la
  réactiver.

Ce sont les mêmes valeurs que celles passées à Dialog.SetOptionState.

Exemple :

if (dJoeEnerve.GetOptionState(2) != eOptionOn)
  Display("C'est désactivé !");

affichera un message si l'option 2 du dialogue dJoeEnerve n'est pas actuellement accessible.

Voir aussi : Dialog.HasOptionBeenChosen, Dialog.SetOptionState

HasOptionBeenChosen

bool Dialog.HasOptionBeenChosen(int option)

Informe s i le joueur a déjà choisi l'option spécifiée dans ce dialogue. C'est particulièrement utile lorsque vous dessinez vos propres options de dialogue personnalisées, puisque cela vous permet d'afficher différemment les options déjà explorées.

OPTION correspond au numéro d'option dans le dialogue, de 1 jusqu'à la plus haute valeur d'option pour ce sujet.

Exemple :

if (dJoeExcited.HasOptionBeenChosen(2))
  Display("The player has chosen option 2 in dialog dJoeExcited!");

affichera un message si le joueur a déjà utilisé l'option 2 du dialogue précédemment.

Compatibility: Supporté par AGS 3.1.1 et les versions plus récentes.

Voir aussi : Dialog.GetOptionState

GetOptionText

String Dialog.GetOptionText(int option)
Retourne le texte de l'option de dialogue spécifiée.

OPTION est le numéro de l'option dans le dialogue, de 1 à la plus haute valeur sur ce sujet.

Exemple :
String texteOption = dJoeDupont.GetOptionText(3);
Display("L'option 3 du dialogue dJoeDupont est %s!", texteOption);

affichera le texte de la troisième option du dialogue dJoeDupont.

Compatibilité : Supporté par AGS 3.0.2 et les versions plus récentes.

Voir aussi : Dialog.OptionCount, Dialog.GetOptionState

ID

readonly int Dialog.ID;
Retourne le numéro ID du dialogue tel qu'affiché dans l'éditeur.

Cela peut être utile si vous utilisez des anciens scripts qui utilisent les numéro ID des dialogues.

Exemple :
Display("dPecheur est le dialogue numéro %d !", dPecheur.ID);

affichera le numéro ID du dialogue dFisherman.

Compatibilité : Supporté par AGS 3.1.0 et les versions plus récentes.

OptionCount

readonly int Dialog.OptionCount;
Retourne le nombre d'option que contient ce dialogue.

Ceci peut être utile dans un module de script si vous devez itérer sur l'ensemble des choix possibles dans le dialogue.

Exemple :
Display("dPecheur a %d options !", dPecheur.OptionCount);

affichera le nombre d'options dans le dialogue dFisherman.

Compatibilité : Supporté par AGS 3.0.2 et les versions plus récentes.

Voir aussi : Dialog.GetOptionText, Dialog.GetOptionState

SetOptionState

(Anciennement fonction globale SetDialogOption, désormais obsolète)

Dialog.SetOptionState(int option, DialogOptionState)

Active/Désactive une option dans une conversation. Ceci vous permet d'ajouter des options supplémentaires à une conversation une fois que le joueur a accompli certaines choses.

OPTION est le numéro de l'option dans le sujet, de 1 à la plus haute valeur d'option pour ce sujet.

DialogOptionState indique ce qui doit arriver à cette option. Elle peut prendre les valeurs suivantes :

eOptionOff
  L'option est désactivée - le joueur ne la verra pas
eOptionOn
  L'option est activée - le joueur peut la voir et l'utiliser
eOptionOffForever
  L'option est désactivée en permanence - aucune commande ne peut la
  réactiver.

Elles sont équivalentes aux commandes de dialogue option-off, option-on et option-off-forever.

Exemple :

if (GetGlobalInt(10)==1)
    dialog[4].SetOptionState(2, eOptionOn);

activera l'option 2 du sujet numéro 4 si la variable entière globale 10 vaut 1.

Voir aussi : Dialog.GetOptionState, Dialog.Start, StopDialog

ShowTextParser

readonly bool Dialog.ShowTextParser;

Retourne si le dialogue propose une zone de saisie permettant au joueur d'entrer du texte.

Cette propriété est définie dans l'éditeur de dialogues (Dialog Editor).

Exemple:

if (dFisherman.ShowTextParser)
{
  Display("dFisherman possède une zone de saisie !");
}

affichera un message si dFisherman propose cette option.

Compatibilité : Supporté par AGS 3.2.1 et les versions plus récentes.

Start

(Anciennement global function RunDialog, désormais obsolète)

Dialog.Start()

Lance une conversation à partir du sujet spécifié.

NOTE : La conversation ne démarrera pas immédiatement ; plutôt, elle sera exécutée lorsque la fonction de script courante sera achevée.

Si vous utilisez cette commande depuis une fonction dialog_request, elle aura pour effet de lancer ce nouveau sujet une fois que le script sera terminé.

Exemple :

dMarchand.Start();

lancera le sujet de conversation nommé dMarchand.

Voir aussi : Dialog.DisplayOptions, Dialog.SetOptionState

StopDialog

StopDialog ()
Cette commande ne peut être utilisée que depuis une fonction dialog_request. Elle dit à AGS que lorsque dialog_request est terminée, l'intégralité de la conversation devrait s'arrêter plutôt que continuer à exécuter le script du dialogue.

Vous pouvez utiliser cette fonction à la fin d'une conversation selon que le joueur a accompli ou possède ou non certaines choses.

Exemple :
 function dialog_request (int dr) {
 if (dr==1) {
   cEgo.AddInventory(iAffiche);
   StopDialog();
 }

donnera l'objet d'inventaire iAffiche au joueur puis terminera la conversation.

Voir aussi : Dialog.SetOptionState


dialogoptionsrenderinginfo

Table des matières
    • Fonctions et propriétés d'affichage des options de dialogue (DialogOptionsRenderingInfo)
      • ActiveOptionID
      • DialogToRender
      • Height
      • ParserTextBoxWidth
      • ParserTextBoxX
      • ParserTextBoxY
      • Surface
      • Width
      • X
      • Y

Fonctions et propriétés d'affichage des options de dialogue (DialogOptionsRenderingInfo)

Les variables DialogOptionsRenderingInfo sont utilisez par le système d'options personnalisées de dialogue. Vous ne pouvez pas en créer vous-même, elles seront passées aux fonctions d'option de dialogue de la façon décrite dans la page précitée.

ActiveOptionID

int DialogOptionsRenderingInfo.ActiveOptionID;
Retourne/Définit l'option active courante de l'écran d'options du dialogue. Vous l'utilisez dans la fonction dialog_options_get_active pour déclarer à AGS quelle option survole la souris. Cela vous assure d'activer l'option correcte lorsque le joueur clique avec le bouton de la souris.

Vous pouvez lire cette propriété dans la fonction dialog_options_render pour illuminer l'option sélectionnée d'une manière différente des autres.

Cette propriété peut être définie à 0, ce qui signifie qu'aucune option n'est sélectionnée ; sinon, elle vaudra de l'option numéro 1 au nombre total d'options dans le dialogue.

Exemple :
function dialog_options_get_active(DialogOptionsRenderingInfo *info)
{
  info.ActiveOptionID = 1;
}

sélectionne toujours la première option.

Compatibilité : Supporté par AGS 3.1.0 et les versions plus récentes.

Voir aussi : Dialog.GetOptionState

DialogToRender

Dialog* DialogOptionsRenderingInfo.DialogToRender;
Retourne le dialogue qui doit être affiché. Vous pouvez parcourir toutes les options du dialogue pour décider quoi afficher à l'écran.

Exemple : Pour un exemple, veuillez consulter la page des options de dialogue personnalisées.

Compatibilité : Supporté par AGS 3.1.0 et les versions plus récentes.

Voir aussi : Dialog.GetOptionState, DialogOptionsRenderingInfo.Surface

Height

int DialogOptionsRenderingInfo.Height;
Retourne/Définit la hauteur de la zone nécessaire pour afficher les options de dialogue.

Cela peut seulement être défini dans la fonction dialog_options_get_dimensions, mais peut être lu dans toutes les autres fonctions afin d'afficher les options.

Exemple :
function dialog_options_get_dimensions(DialogOptionsRenderingInfo *info)
{
  info.Width = 300;
  info.Height = 150;
}

crée une zone de 300×150 pour y afficher les options du dialogue.

Compatibilité : Supporté par AGS 3.1.0 et les versions plus récentes.

Voir aussi : DialogOptionsRenderingInfo.Width

ParserTextBoxWidth

int DialogOptionsRenderingInfo.ParserTextBoxWidth;
Retourne/Définit la largeur de la zone de saisie (textbox) de l'analyseur de texte (parser) pour les options du dialogue. Si l'analyseur de texte n'est pas activé pour ce dialogue, ce réglage sera ignoré.

Cette propriété ne peut être définie que dans la fonction dialog_options_get_dimensions.

Exemple :
function dialog_options_get_dimensions(DialogOptionsRenderingInfo *info)
{
  info.Width = 300;
  info.Height = 150;
  // Place l'analyseur de texte en bas (s'il est activé)
  info.ParserTextBoxX = 10;
  info.ParserTextBoxY = 130;
  info.ParserTextBoxWidth = 180;
}

positionne l'analyseur de texte à (10,130) dans la zone des options du dialogue de dimensions 300×150.

Compatibilité : Supporté par AGS 3.1.0 et les versions plus récentes.

Voir aussi : DialogOptionsRenderingInfo.Width, DialogOptionsRenderingInfo.ParserTextBoxX, DialogOptionsRenderingInfo.ParserTextBoxY

ParserTextBoxX

int DialogOptionsRenderingInfo.ParserTextBoxX;
Retourne/Définit la position X de la zone de saisie (textbox) de l'analyseur de texte (parser) des options du dialogue. Si l'analyseur de texte n'est pas activé pour ce dialogue, ce réglage sera ignoré.

La position X est relative à la surface des options du dialogue. Ce la signifie qu'un X de 10 le positionnera à 10 pixels du bord gauche du cadre des options du dialogue, et non à 10 pixels du bord gauche de l'écran.

Cette propriété ne peut être définie que dans la fonction dialog_options_get_dimensions.

Exemple :
function dialog_options_get_dimensions(DialogOptionsRenderingInfo *info)
{
  info.Width = 300;
  info.Height = 150;
  // Place l'analyseur de texte en bas (s'il est activé)
  info.ParserTextBoxX = 10;
  info.ParserTextBoxY = 130;
  info.ParserTextBoxWidth = 180;
}

positionne l'analyseur de texte à (10,130) dans la zone des options du dialogue de dimensions 300×150.

Compatibilité : Supporté par AGS 3.1.0 et les versions plus récentes.

Voir aussi : DialogOptionsRenderingInfo.ParserTextBoxWidth, DialogOptionsRenderingInfo.ParserTextBoxY

ParserTextBoxY

int DialogOptionsRenderingInfo.ParserTextBoxY;
Retourne/Définit la position Y de la zone de saisie (textbox) de l'analyseur de texte (parser) des options du dialogue. Si l'analyseur de texte n'est pas activé pour ce dialogue, ce réglage sera ignoré.

La position Y est relative à la surface des options du dialogue. Ce la signifie qu'un Y de 10 le positionnera à 10 pixels du bord supérieur du cadre des options du dialogue, et non à 10 pixels du bord supérieur de l'écran.

Cette propriété ne peut être définie que dans la fonction dialog_options_get_dimensions.

Exemple :
function dialog_options_get_dimensions(DialogOptionsRenderingInfo *info)
{
  info.Width = 300;
  info.Height = 150;
  // Place l'analyseur de texte en bas (s'il est activé)
  info.ParserTextBoxX = 10;
  info.ParserTextBoxY = 130;
  info.ParserTextBoxWidth = 180;
}

positionne l'analyseur de texte à (10,130) dans la zone des options du dialogue de dimensions 300×150.

Compatibilité : Supporté par AGS 3.1.0 et les versions plus récentes.

Voir aussi : DialogOptionsRenderingInfo.ParserTextBoxX

Surface

DrawingSurface* DialogOptionsRenderingInfo.Surface;
Retourne la surface de dessin (drawing surface) qui peut être utilisée pour dessiner les options du dialogue.

Cela ne peut être utilisé que dans la fonction dialog_options_render ; retournera null dans toutes les autres fonctions.

Contrairement à la plupart des utilisations des DrawingSurface, vous ne devez PAS rafraîchir (Release) celle-ci. AGS le fera automatiquement pour vous une fois que la fonction dialog_options_render aura fini d'être exécutée.

La taille de la surface devrait correspondre aux paramètres Largeur (Width) et Hauteur (Height) requis dans la fonction dialog_options_get_dimensions.

Exemple :
function dialog_options_render(DialogOptionsRenderingInfo *info)
{
  info.Surface.Clear(14);
}

rend la zone d'options du dialogue entièrement jaune.

Compatibilité : Supporté par AGS 3.1.0 et les versions plus récentes.

Voir aussi : DrawingSurfaces (surfaces de dessin) : fonctions et propriétés

Width

int DialogOptionsRenderingInfo.Width;
Retourne/Définit la largeur de la surface nécessaire pour dessiner les options du dialogue.

Cette propriété ne peut être définie que dans la fonction dialog_options_get_dimensions, mais peut être consultée dans toutes les autres fonctions afin d'afficher les options.

Exemple :
function dialog_options_get_dimensions(DialogOptionsRenderingInfo *info)
{
  info.Width = 300;
  info.Height = 150;
}

crée une zone de 300×150 pour y afficher les options de dialogue.

Compatibilité : Supporté par AGS 3.1.0 et les versions plus récentes.

Voir aussi : DialogOptionsRenderingInfo.Height

X

int DialogOptionsRenderingInfo.X;
Retourne/Définit la coordonnée horizontale du coin supérieur gauche de la zone d'options du dialogue.

Cette propriété ne peut être définie que dans la fonction dialog_options_get_dimensions, mais peut être consultée dans toutes les autres fonctions afin d'afficher les options.

Exemple :
function dialog_options_get_dimensions(DialogOptionsRenderingInfo *info)
{
  info.X = 50;
  info.Y = 20;
  info.Width = 200;
  info.Height = 150;
}

crée une surface de dimensions 200×150 à (50,20) pour y afficher les options du dialogue.

Compatibilité : Supporté par AGS 3.1.0 et les versions plus récentes.

Voir aussi : DialogOptionsRenderingInfo.Y

Y

int DialogOptionsRenderingInfo.Y;
Retourne/Définit la coordonnée verticale du coin supérieur gauche de la zone d'options du dialogue.

Cette propriété ne peut être définie que dans la fonction dialog_options_get_dimensions, mais peut être consultée dans toutes les autres fonctions afin d'afficher les options.

Exemple :
function dialog_options_get_dimensions(DialogOptionsRenderingInfo *info)
{
  info.X = 50;
  info.Y = 20;
  info.Width = 200;
  info.Height = 150;
}

crée une surface de dimensions 200×150 à (50,20) pour y afficher les options du dialogue.

Compatibilité : Supporté par AGS 3.1.0 et les versions plus récentes.

Voir aussi : DialogOptionsRenderingInfo.X


drawingsurface

Table des matières
    • DrawingSurfaces (surfaces de dessin) : fonctions et propriétés
      • Clear
      • CreateCopy
      • DrawCircle
      • DrawImage
      • DrawLine
      • DrawMessageWrapped
      • DrawPixel
      • DrawRectangle
      • DrawString
      • DrawStringWrapped
      • DrawSurface
      • DrawTriangle
      • Release
      • DrawingColor
      • GetPixel
      • Height
      • UseHighResCoordinates
      • Width

DrawingSurfaces (surfaces de dessin) : fonctions et propriétés

La famille de fonctions DrawingSurface vous permet de dessiner directement sur les dynamic sprites et les arrière-plans du jeu. Vous obtenez une surface de dessin en appelant DynamicSprite.GetDrawingSurface ou Room.GetDrawingSurfaceForBackground, et vous pouvez ensuite utiliser les méthodes suivantes pour dessiner sur ces surfaces.

IMPORTANT : Vous DEVEZ appeler la méthode Release lorsque vous avez fini de dessiner sur une surface. Ceci permet à AGS de mettre à jour les copies en cache de l'image et de les charger en mémoire vidéo si nécessaire.

Clear

(Anciennement RawClearScreen, désormais obsolète)

DrawingSurface.Clear(optional int couleur)

Remplit la surface avec la COULEUR spécifiée (correspond aux numéros dans l'onglet Colours de l'éditeur). Le contenu en cours de la surface sera effacé.

Si vous n'entrez pas de paramètre COULEUR, ou utilisez COLOR_TRANSPARENT, la surface deviendra entièrement transparente.

Exemple :

DrawingSurface *surface = Room.GetDrawingSurfaceForBackground();
surface.Clear(14);
surface.DrawingColor = 13;
surface.DrawCircle(160,100,50);
surface.Release();

rend l'arrière-plan de la pièce entièrement jaune, puis dessine un cercle rose en son milieu.

Voir aussi : DrawingSurface.DrawingColor

CreateCopy

(Anciennement RawSaveScreen, désormais obsolète)

DrawingSurface* DrawingSurface.CreateCopy()

Crée une copie de la surface actuelle, de façon à pouvoir la récupérer plus tard pour la restaurer. Ceci peut être utile si vous voulez faire une copie de sauvegarde de l'arrière-plan avant de dessiner dessus, ou pour sauvegarder une étape de votre dessin et la restaurer plus tard.

Contrairement à la commande obsolète RawSaveScreen des versions précédentes d'AGS, les surfaces créées par cette commande ne sont pas perdues lorsque le joueur change de pièce ou restaure une partie. Toutefois, les surfaces qui contiennent des copies d'arrière-plans peuvent être très lourdes , occupant une grande place dans la mémoire et peuvent significativement alourdir le jeu. Ainsi, il est fortement recommandé d'utiliser Release sur la surface copiée dès que vous en avez fini avec elle.

Exemple :

DrawingSurface *surface = Room.GetDrawingSurfaceForBackground();
DrawingSurface *backup = surface.CreateCopy();
surface.DrawTriangle(0,0,160,100,0,200);
Wait(80);
surface.DrawSurface(backup);
backup.Release();
surface.Release();

fera une copie de sauvegarde de l'arrière-plan de la pièce, dessinera un triangle dessus, attendra un moment puis restaurera l'arrière-plan original.

Voir aussi : DrawingSurface.DrawSurface

DrawCircle

(Anciennement RawDrawCircle, désormais obsolète)

DrawingSurface.DrawCircle(int x, int y, int rayon)

Dessine un cercle plein de rayon RAYON centré à (X,Y) de la couleur de dessin courante.

Exemple :

DrawingSurface *surface = Room.GetDrawingSurfaceForBackground();
surface.DrawingColor = 14;
surface.DrawCircle(160,100,50);
surface.Release();

dessinera un cercle jaune au centre de l'écran, d'un rayon de 50 pixels.

Voir aussi : DrawingSurface.DrawLine, DrawingSurface.DrawingColor

DrawImage

(Anciennement RawDrawImage, désormais obsolète) (Anciennement RawDrawImageResized, désormais obsolète) (Anciennement RawDrawImageTransparent, désormais obsolète)

DrawingSurface.DrawImage(int x, int y, int bloc, optional int transparence,
                         optional int largeur, optional int hauteur)

Dessine l'image BLOC du gestionnaire de sprite sur la surface aux coordonnées (X,Y).

Facultativement, vous pouvez aussi spécifier la transparence de l'image. Cela correspond à un nombre de 0 à 100 ; passer une valeur de 50 pour transparence dessinera l'image à moitié transparente ; passer 0 signifiera que l'image n'est pas transparente du tout.

Vous pouvez aussi redimensionner l'image que vous dessinez. Pour cela, spécifiez simplement les largeur et hauteur auxquelles vous voulez redimensionner l'image sur le dessin.

NOTE : Cette commande ne fonctionne que si l'image à dessiner est de la même profondeur de couleur que la surface sur laquelle vous dessinez.

NOTE : La transparence ne marche pas dans les jeux 256 couleurs, ou avec des sprites 256 couleurs.

NOTE : Les coordonnées X et Y correspondent à celles de la PIECE, et non à celles de l'ECRAN. Cela signifie que dans une pièce à défilement, vous pouvez dessiner hors de la zone actuellement visible.

Exemple :

DrawingSurface *surface = Room.GetDrawingSurfaceForBackground();
surface.DrawImage(100, 100, oPorte.Graphic, 40);
surface.Release();

dessinera l'image de l'objet oPorte sur l'arrière-plan à (100,100), à 40% de transparence.

Voir aussi : DrawingSurface.DrawLine, DrawingSurface.DrawString, DrawingSurface.DrawSurface, Room.ColorDepth

DrawLine

(Anciennement RawDrawLine, désormais obsolète)

DrawingSurface.DrawLine(int depuis_x, int depuis_y, int a_x, int a_y,
                        optional int epaisseur)

Dessine une ligne depuis (depuis_x, depuis_y) jusqu'à (a_x, a_y) de la couleur en cours pour la surface.

Le paramètre epaisseur vous permet de spécifier l'épaisseur de la ligne, de 1 pixel par défaut.

NOTE : Les coordonnées X et Y sont les coordonnées de la PIECE, pas de l'ECRAN. Cela signifie que dans une pièce à défilement, vous pouvez dessiner hors de la zone actuellement visible.

Exemple :

DrawingSurface *surface = Room.GetDrawingSurfaceForBackground();
surface.DrawingColor = 14;
surface.DrawLine(0, 0, 160, 100);
surface.Release();

dessinera une ligne qui part du coin supérieur gauche de l'écran (0,0) jusqu'au milieu (160, 100).

Voir aussi : DrawingSurface.DrawCircle, DrawingSurface.DrawRectangle, DrawingSurface.DrawTriangle, DrawingSurface.DrawingColor

DrawMessageWrapped

(Anciennement RawPrintMessageWrapped, désormais obsolète)

DrawingSurface.DrawMessageWrapped(int x, int y, int largeur,
                                  FontType police, int numero_message)

Dessine le message NUMERO_MESSAGE sur la surface à (X,Y), en utilisant la POLICE spécifiée.

LARGEUR correspond à la largeur du cadre virtuelle entourant le texte, et après laquelle le texte sera retourné à la ligne. Cette commande est conçue pour écrire un long message à l'écran tout en le formattant normalement comme le ferait une étiquette (label) classique.

Le texte sera dessiné dans la couleur de dessin courante.

Exemple :

DrawingSurface *surface = Room.GetDrawingSurfaceForBackground();
surface.DrawingColor = 14;
surface.DrawMessageWrapped(80, 40, 160, Game.NormalFont, 10);
surface.Release();

affichera le message 10 au centre de l'écran, en commençant à Y = 40.

Voir aussi : DrawingSurface.DrawString, DrawingSurface.DrawingColor, DrawingSurface.DrawStringWrapped

DrawPixel

DrawingSurface.DrawPixel(int x, int y)
Dessine un simple pixel sur la surface à (X,Y) dans la couleur courante. L'épaisseur du pixel est définie par la propriété UseHighResCoordinates.

NOTE : Cette commande n'est pas suffisamment rapide pour l'utiliser en répétition afin de créer une image complète. Ne l'utilisez que pour de simples ajustements de pixels.

Exemple :
DrawingSurface *surface = Room.GetDrawingSurfaceForBackground();
surface.DrawingColor = 14;
surface.DrawPixel(50, 50);
surface.Release();

dessine un pixel jaune au coin supérieur gauche de l'arrière-plan.

Voir aussi : DrawingSurface.DrawingColor, DrawingSurface.DrawLine, DrawingSurface.GetPixel, DrawingSurface.UseHighResCoordinates

DrawRectangle

(Anciennement RawDrawRectangle, désormais obsolète)

DrawingSurface.DrawRectangle(int x1, int y1, int x2, int y2)

Dessine un rectangle plein dans la couleur courante avec son coin supérieur gauche à (X1,Y1) et son coin inférieur droit à (X2,Y2).

NOTE : Les coordonnées X et Y sont celles de la PIECE, pas celles de l'ECRAN. Cela signifie que dans une pièce à défilement vous pouvez dessiner hors de la zone actuellement visible.

Exemple :

DrawingSurface *surface = Room.GetDrawingSurfaceForBackground();
surface.DrawingColor = 14;
surface.DrawRectangle(0, 0, 160, 100);
surface.Release();

dessinera un rectangle sur le quart haut gauche de l'écran.

Voir aussi : DrawingSurface.DrawImage, DrawingSurface.DrawLine

DrawString

(Anciennement RawPrint, désormais obsolète)

DrawingSurface.DrawString(int x, int y, FontType police, string texte, ...)

Dessine le texte sur la surface à (X, Y), en utilisant le numéro de police spécifié. Le texte sera dessiné dans la couleur de dessin courante.

Vous pouvez insérer des valeurs de variables dans le message. Pour plus d'information, voyez la section formatage des chaînes de caractères.

Exemple :

DrawingSurface *surface = Room.GetDrawingSurfaceForBackground();
surface.DrawingColor = 14;
surface.DrawString(0, 100, Game.NormalFont, "Text written into the background!");
surface.Release();

dessinera du texte sur le milieu gauche de l'arrière-plan.

Voir aussi : GetTextWidth, DrawingSurface.DrawStringWrapped, DrawingSurface.DrawingColor

DrawStringWrapped

DrawingSurface.DrawStringWrapped(int x, int y, int largeur,
                                 FontType police, Alignment,
                                 const string texte)
Dessine le texte sur la surface à (X,Y), en utilisant la POLICE spécifiée.

largeur correspond à la largeur du cadre virtuel entourant le texte, et correspond au point où le texte sera retourné à la ligne. Vous pouvez utiliser le paramètre alignment pour déterminer comment le texte sera horizontalement aligné.

Le texte sera dessiné en utilisant la couleur de dessin en cours.

Exemple :
DrawingSurface *surface = Room.GetDrawingSurfaceForBackground();
surface.DrawingColor = 14;
surface.DrawStringWrapped(80, 40, 160, Game.NormalFont, eAlignCentre, "Hello, my name is Bob.");
surface.Release();

affichera le texte au centre de l'écran, en commençant à Y = 50.

Compatibilité : Supporté par AGS 3.0.1 et les versions plus récentes.

Voir aussi : DrawingSurface.DrawString, DrawingSurface.DrawingColor, DrawingSurface.DrawMessageWrapped

DrawSurface

(Anciennement RawDrawFrameTransparent, désormais obsolète) (Anciennement RawRestoreScreen, désormais obsolète)

DrawingSurface.DrawSurface(DrawingSurface *source, optional int transparence)

Dessine la surface spécifiée sur cette surface, en utilisant optionnellement une transparence de transparence pour-cent.

Ceci vous permet d'effectuer des fondus de tombée de nuit ou d'autres effets spéciaux.

NOTE : Vous ne pouvez pas utiliser le paramètre transparence sur les surfaces 256 couleurs.

NOTE : Cette commande peut être assez lente, ne l'appelez donc pas dans repeatedly_execute.

ASTUCE : Si vous voulez fondre graduellement vers un second arrière-plan, créez une copie de la surface originale puis restaurez-la à chaque itération, sinon l'arrière-plan changera trop rapidement.

Exemple :

DrawingSurface *mainBackground = Room.GetDrawingSurfaceForBackground(0);
DrawingSurface *nightBackground = Room.GetDrawingSurfaceForBackground(1);
mainBackground.DrawSurface(nightBackground, 50);
mainBackground.Release();
nightBackground.Release();

ceci dessinera l'image d'arrière-plan 1 sur l'image 0 à 50% d'opacité.

Voir aussi : DrawingSurface.DrawImage, SetAmbientTint

DrawTriangle

(Anciennement RawDrawTriangle, désormais obsolète)

DrawingSurface.DrawTriangle(int x1, int y1, int x2, int y2, int x3, int y3)

Dessine un triangle plein dans la couleur en cours avec ses coins aux points (X1,Y1), (X2,Y2) et (X3,Y3).

Oui, bon, me regardez pas comme ça, vous pourriez trouver ça utile pour quelque chose :-)

Exemple :

DrawingSurface *surface = Room.GetDrawingSurfaceForBackground();
surface.DrawingColor = 14;
surface.DrawTriangle(0,0,160,100,0,200);
surface.Release();

dessinera un triangle avec les coins aux points (0,0),(160,100),(0,200).

Voir aussi : DrawingSurface.DrawImage, DrawingSurface.DrawLine, DrawingSurface.DrawRectangle

Release

DrawingSurface.Release()
Informe AGS que vous avez fini de dessiner sur la surface, et lui permet de charger l'image modifiée dans la mémoire vidéo.

Après avoir appelé cette méthode, vous ne pouvez plus utiliser la variable DrawingSurface. Pour tout changement, vous devrez récupérer la surface à nouveau.

Exemple :
DrawingSurface *surface = Room.GetDrawingSurfaceForBackground();
surface.DrawingColor = 14;
surface.DrawLine(0, 0, 50, 50);
surface.Release();

dessine une ligne diagonale jaune à travers le coin supérieur gauche de l'arrière-plan en cours, puis affiche l'image.

Voir aussi : DynamicSprite.GetDrawingSurface, Room.GetDrawingSurfaceForBackground

DrawingColor

(Anciennement RawSetColor, désormais obsolète)

int DrawingSurface.DrawingColor

Retourne/Définit la couleur de dessin courante sur la surface. Définissez-la avant d'utiliser des commandes comme DrawLine, qui utilisent cette couleur pour dessiner.

Vous pouvez soit donner un Numéro de Couleur AGS (AGS Colour Number) (comme affichée dans l'onglet Colour de l'éditeur) ou la constante spéciale COLOR_TRANSPARENT, ce qui vous permet de dessiner des zones transparentes sur la surface.

Exemple :

DrawingSurface *surface = Room.GetDrawingSurfaceForBackground();
surface.DrawingColor = 14;
surface.DrawLine(0, 0, 160, 100);
surface.DrawingColor = Game.GetColorFromRGB(255, 255, 255);
surface.DrawLine(0, 199, 160, 100);
surface.Release();

affichera une ligne gauche depuis le coin supérieur gauche de l'écran (0,0) jusqu'au milieu (160,100), puis une ligne blanche depuis le coin inférieur gauche jusqu'au le milieu.

Voir aussi : DrawingSurface.DrawCircle, DrawingSurface.DrawLine, DrawingSurface.DrawRectangle, Game.GetColorFromRGB

GetPixel

int DrawingSurface.GetPixel(int x, int y)
Retourne le Numéro de Couleur AGS (AGS Colour Number) du pixel au point (X,Y) de la surface.

NOTE : Dans un jeu hautes-couleurs, les 32 premiers numéros de couleur ont un sens spécial, car AGS les utilise pour maintenir la compatibilité avec les jeux 8-bits. Ainsi, si vous dessinez sur la surface en utilisant une couleur bleu de numéro 0 à 31, vous obtiendrez un numéro différent lorsque vous appellerez GetPixel – et en fait la couleur dessinée pourrait ne pas correspondre à ce que vous attendez. Pour vous en sortir, ajoutez simplement une valeur de 1 de Rouge et de Vert pour ajuster le numéro de la couleur hors de cet intervalle.

NOTE : Cette commande est relativement lente. Ne l'utilisez pas pour tenter de traiter l'image entière.

Exemple :
DrawingSurface *surface = Room.GetDrawingSurfaceForBackground();
Display("The colour of the middle pixel is %d.", surface.GetPixel(160, 100));
surface.Release();

affiche la couleur du pixel du centre de l'écran.

Compatibilité : Supporté par AGS 3.0.1 et les versions plus récentes.

Voir aussi : DrawingSurface.DrawingColor, DrawingSurface.DrawPixel, DrawingSurface.UseHighResCoordinates

Height

readonly int DrawingSurface.Height
Retourne la hauteur de la surface.

Exemple :
DrawingSurface *surface = Room.GetDrawingSurfaceForBackground();
Display("L'arrière-plan est de dimension %d x %d !", surface.Width, surface.Height);
surface.Release();

affiche la dimension de la surface au joueur.

Voir aussi : DrawingSurface.UseHighResCoordinates, DrawingSurface.Width

UseHighResCoordinates

bool DrawingSurface.UseHighResCoordinates
Retourne/Définit si vous voulez utiliser les coordonnées haute-résolution sur cette surface.

Par défaut, cette propriété sera définie de façon à ce que les coordonnées de la surface de dessin utilisent les coordonnées du système comme le reste de l'écran, comme pour le réglage de jeu “Use low-res co-ordinates in script” (”Utiliser les coordonnées basse-résolution dans le script”) Toutefois, si votre jeu est en 640×400 ou supérieur, vous pouvez choisir si la surface utilisé les coordonnées natives ou les coordonnées de basse-résolution 320×200 en changeant cette propriété.

En définissant cette propriété vous affectez TOUTES les autres commandes effectuées sur cette surface de dessin, incluant les propriétés Width et Height.

Exemple :
DrawingSurface *surface = Room.GetDrawingSurfaceForBackground();
surface.UseHighResCoordinates = true;
surface.DrawingColor = 14;
surface.DrawLine(0, 0, 320, 200);
surface.Release();

dessine une ligne jaue depuis le coin gauche supérieur de l'écran jusqu'au milieu. Si UseHighResCoordinates ne valait pas true, cela dessinera la ligne depuis le coin gauche supérieur jusqu'au coin inférieur bas de l'écran.

Voir aussi : DrawingSurface.DrawCircle, DrawingSurface.DrawLine, DrawingSurface.DrawRectangle, DrawingSurface.DrawTriangle

Width

readonly int DrawingSurface.Width
Retourne la largeur de la surface.

Exemple :
DrawingSurface *surface = Room.GetDrawingSurfaceForBackground();
Display("L'arrière-plan est de dimension %d x %d !", surface.Width, surface.Height);
surface.Release();

affiche la taille de la surface au joueur.

Voir aussi : DrawingSurface.Height, DrawingSurface.UseHighResCoordinates


dynamicsprite

Table des matières
    • DynamicSprite (Images Dynamiques) : fonctions et propriétés
      • Create
      • CreateFromBackground
      • CreateFromDrawingSurface
      • CreateFromExistingSprite
      • CreateFromFile
      • CreateFromSaveGame
      • CreateFromScreenShot
      • ChangeCanvasSize
      • CopyTransparencyMask
      • Crop
      • Delete
      • Flip
      • GetDrawingSurface
      • Resize
      • Rotate
      • SaveToFile
      • Tint
      • ColorDepth
      • Graphic
      • Height
      • Width

DynamicSprite (Images Dynamiques) : fonctions et propriétés

Create

static DynamicSprite* DynamicSprite.Create(int largeur, int hauteur, optional bool possedeCanalAlpha)
Crée une nouvelle sprite dynamique vierge de la taille spécifiée. Sera totalement transparent au départ, et peut posséder un canal alpha. Cette commande est utile si vous voulez juste créer une nouvelle sprite puis utiliser les commandes DrawingSurface pour dessiner dessus.

Si la profondeur des couleurs du jeu est inférieure à 32-bit, alors le paramètres possedeCanalAlpha sera ignoré.

Utilisez la propriété Graphic de DynamicSprite avec les autres commandes et pour utiliser la nouvelle sprite dans le jeu.

IMPORTANT : Cette commande charge une sprite supplémentaire dans la mémoire, qui n'est pas contrôlée par le cache AGS normale, et qui ne sera pas automatiquement libérée. Ainsi, lorsque vous avez fini d'utiliser l'image, vous DEVEZ appeler Delete pour libérer la mémoire.

IMPORTANT : Si la variable DynamicSprite est libéré de la mémoire (c-à-di s'il n'y a plus de variable DynamicSprite* qui pointe dessus), alors la sprite elle-même sera aussi supprimée de la mémoire. Assurez-vous de garder une variable globale pointant sur la sprite jusqu'à ce que vous en ayez fini avec, puis appelez alors Delete.

Exemple :
DynamicSprite* sprite = DynamicSprite.Create(50, 30);
DrawingSurface *surface = sprite.GetDrawingSurface();
surface.DrawingColor = 14;
surface.DrawPixel(25, 15);
surface.Release();
sprite.Delete();

crée une sprite de taille 50×30, dessine un point blanc au milieu, puis supprime la sprite.

Voir aussi : DynamicSprite.Delete, DynamicSprite.Graphic, DynamicSprite.GetDrawingSurface

CreateFromBackground

static DynamicSprite* DynamicSprite.CreateFromBackground(optional int frame, optional int x, optional int y,
                                                         optional int largeur, optional int hauteur)
Crée une nouvelle sprite dynamique, contenant une copie de l'image d'arrière-plan de la pièce.

L'utilisation la plus basique de cette fonction consiste à ne passer aucun paramètre, auquel cas la sprite contiendra une copie exacte de l'arrière-plan de la pièce actuelle.

Si vous voulez, vous pouvez entrer seulement frame, auquel cas vous obtiendrez une copie complète de l'image d'arrière-plan correspondant à ce numéro, dans la pièce actuelle.

Facultativement, vous pouvez spécifier une portion de l'arrière-plan à capturer. Vous devrez alors entrer les paramètres X, Y, LARGEUR et HAUTEUR (et aucun de ceux-là si vous voulez l'image entière) ; si vous les entrez, cela vous permet d'obtenir juste une petite portion de l'arrière-plan dans la nouvelle sprite. Toutes les coordonnées sont données en résolution 320×200, et sont les coordonnées de la pièce.

Utilisez la propriété DynamicSprite.Graphic pour utiliser l'image de la sprite dans les autres commandes et pouvoir la manipuler dans le jeu.

IMPORTANT : Cette commande charge une sprite supplémentaire en mémoire qui n'est pas contrôlée par le cache classique d'AGS et qui ne sera pas automatiquement supprimée. C'est pourquoi, lorsque vous avez fini d'utiliser l'image, vous DEVEZ appeler Delete dessus pour libérer la mémoire.

IMPORTANT : Si l'objet DynamicSprite est supprimé de la mémoire (c'est-à-dire s'il n'y a plus de variable DynamicSprite* pointant vers l'image), alors la sprite sera aussi supprimée de la mémoire. Assurez vous que vous gardez une variable pointant vers la sprite jusqu'à ce que vous ayez fini de l'utiliser (vous appellerez alors Delete).

Exemple :
DynamicSprite* sprite = DynamicSprite.CreateFromBackground(GetBackgroundFrame(), 130, 70, 60, 60);
DrawingSurface *surface = Room.GetDrawingSurfaceForBackground();
surface.DrawImage(0, 0, sprite.Graphic);
surface.Release();
sprite.Delete();

copie dans la sprite une zone de 60×60 pixels du centre de l'arrière-plan, et dessine l'image au coin haut gauche de l'image d'arrière-plan.

Voir Aussi : DynamicSprite.Delete

CreateFromDrawingSurface

static DynamicSprite* DynamicSprite.CreateFromDrawingSurface(DrawingSurface* surface, int x, int y,
                                                             int largeur, int hauteur)
Crée une sprite dynamique contenant une copie de la portion spécifiée de la surface de dessin (drawing surface). Cela vous permet de créer facilement de nouvelle sprite à partir de portions d'autres sprites.

NOTE : Les paramètres x , y , largeur et hauteur respectent les réglages UseHighResCoordinates des Drawing Surface, donc assurez-vous que le type de coordonnées que vous utilisez correspond à ce que les surfaces de dessin requièrent.

Utilisez la propriété Graphic des DynamicSprite avec les autres commandes et pour utiliser la nouvelle sprite dans le jeu.

IMPORTANT : Cette commande charge une sprite supplémentaire dans la mémoire, qui n'est pas contrôlée par le cache AGS normale, et qui ne sera pas automatiquement libérée. Ainsi, lorsque vous avez fini d'utiliser l'image, vous DEVEZ appeler Delete pour libérer la mémoire.

IMPORTANT : Si la variable DynamicSprite est libéré de la mémoire (c-à-di s'il n'y a plus de variable DynamicSprite* qui pointe dessus), alors la sprite elle-même sera aussi supprimée de la mémoire. Assurez-vous de garder une variable globale pointant sur la sprite jusqu'à ce que vous en ayez fini avec, puis appelez alors Delete.

Exemple :
DynamicSprite* sprite = DynamicSprite.CreateFromExistingSprite(object[0].Graphic);
DrawingSurface *surface = sprite.GetDrawingSurface();
DynamicSprite *nouvelleSprite = DynamicSprite.CreateFromDrawingSurface(surface, 0, 0, 10, 10);
surface.Release();
sprite.Delete();
object[0].Graphic = nouvelleSprite.Graphic;

change l'image de l'objet 0 pour le simple coin haut-gauche (10×10) de l'ancienne image.

Compatibilité : Supporté par AGS 3.0.2 et les versions plus récentes.

Voir aussi : DynamicSprite.Delete

CreateFromExistingSprite

static DynamicSprite* DynamicSprite.CreateFromExistingSprite(int slot, optional bool preserverCanalAlpha)
Crée une nouvelle sprite dynamique contenant une copie de la sprite numéro slot spécifiée.

Retourne l'objet DynamicSprite représentant la nouvelle sprite. Cette fonction est utile puisqu'elle vous permet d'effectuer des modifications comme des redimensionnements sur toute sprite dans le jeu.

preserverCanalAlpha détermine si le canal Alpha de la sprite sera aussi copié. Vaut false par défaut, pour des raisons de rétro-compatibilité. Cette option est pratique puisqu'elle vous permet de gérer le canal alpha afin de rendre compte de toute la transparence de l'image. Ce paramètre n'a aucun effet si la sprite n'a pas de canal alpha.

Utilisez la propriété Graphic de la DynamicSprite pour utiliser l'image contenue dans les autres commandes et les manipuler dans le jeu.

IMPORTANT : Cette commande charge une sprite supplémentaire en mémoire qui n'est pas contrôlée par le cache classique d'AGS et qui ne sera pas automatiquement supprimée. C'est pourquoi, lorsque vous avez fini d'utiliser l'image, vous DEVEZ appeler Delete dessus pour libérer la mémoire.

IMPORTANT : Si l'objet DynamicSprite est supprimé de la mémoire (c'est-à-dire s'il n'y a plus de variable DynamicSprite* pointant vers l'image), alors la sprite sera aussi supprimée de la mémoire. Assurez vous que vous gardez une variable pointant vers la sprite jusqu'à ce que vous ayez fini de l'utiliser (vous appellerez alors Delete).

Exemple :
DynamicSprite* sprite = DynamicSprite.CreateFromExistingSprite(object[0].Graphic);
sprite.Resize(20, 20);
DrawingSurface *surface = Room.GetDrawingSurfaceForBackground();
surface.DrawImage(100, 80, sprite.Graphic);
surface.Release();
sprite.Delete();

crée une copie de la sprite actuelle de l'objet 0, la redimensionne à 20×20, puis dessine l'image obtenue sur l'arrière-plan.

Voir Aussi : DynamicSprite.Delete, DynamicSprite.Resize

CreateFromFile

(Anciennement LoadImageFile, désormais obsolète)

static DynamicSprite* DynamicSprite.CreateFromFile(string nomfichier)

Charge une image NOMFICHIER externe dans la mémoire en tant que sprite.

Retourne l'objet DynamicSprite représentant la sprite, ou null si l'image n'a pas pu être chargée (fichier non trouvé ou format non supporté).

Seuls les fichiers BMP et PCX peuvent être chargés avec cette commande.

Utilisez la propriété Graphic de la DynamicSprite pour utiliser l'image contenue dans les autres commandes et les manipuler dans le jeu.

IMPORTANT : Cette commande charge une sprite supplémentaire en mémoire qui n'est pas contrôlée par le cache classique d'AGS et qui ne sera pas automatiquement supprimée. C'est pourquoi, lorsque vous avez fini d'utiliser l'image, vous DEVEZ appeler Delete dessus pour libérer la mémoire.

IMPORTANT : Si l'objet DynamicSprite est supprimé de la mémoire (c'est-à-dire s'il n'y a plus de variable DynamicSprite* pointant vers l'image), alors la sprite sera aussi supprimée de la mémoire. Assurez vous que vous gardez une variable pointant vers la sprite jusqu'à ce que vous ayez fini de l'utiliser (vous appellerez alors Delete).

Exemple :

DynamicSprite* sprite = DynamicSprite.CreateFromFile("AvatarPerso.bmp");
if (sprite != null) {
DrawingSurface *surface = Room.GetDrawingSurfaceForBackground();
surface.DrawImage(100, 80, sprite.Graphic);
surface.Release();
sprite.Delete();
}

chargera le fichier “AvatarPerso.bmp” et si tout s'est bien passé, desinera l'image vers le milieu de l'écran.

Une fois qu'on a fini d'utiliser l'image, Delete est utilisée sur la sprite.

Voir Aussi : DynamicSprite.Delete, DynamicSprite.CreateFromSaveGame

CreateFromSaveGame

(Anciennement LoadSaveSlotScreenshot, désormais obsolète)

static DynamicSprite* DynamicSprite.CreateFromSaveGame(int slotSauvegarde, int largeur, int hauteur)

Charge la capture d'écran de la partie sauvée à l'emplacement SLOTSAUVEGARDE en mémoire, en la redimensionnant à LARGEUR x HAUTEUR.

Retourne l'objet DynamicSprite correspondant à l'image si tout s'est bien passé, ou retourne null si la capture d'écran n'a pas pu être chargée (si la partie sauvée n'en contenait pas par exemple).

Pour que cela fonctionne, l'option “Sauver les captures d'écran dans les sauvegardes des parties” (“Save screenshots in save games”) doit être cochée dans le panneau principal Game Settings.

IMPORTANT : Cette commande charge une sprite supplémentaire en mémoire qui n'est pas contrôlée par le cache classique d'AGS et qui ne sera pas automatiquement supprimée. C'est pourquoi, lorsque vous avez fini d'utiliser l'image, vous DEVEZ appeler Delete dessus pour libérer la mémoire.

IMPORTANT : Si l'objet DynamicSprite est supprimé de la mémoire (c'est-à-dire s'il n'y a plus de variable DynamicSprite* pointant vers l'image), alors la sprite sera aussi supprimée de la mémoire. Assurez vous que vous gardez une variable pointant vers la sprite jusqu'à ce que vous ayez fini de l'utiliser (vous appellerez alors Delete).

Exemple :

// tout en haut du script, hors des events
DynamicSprite *boutonSprite;

// dans une event
boutonSprite = DynamicSprite.CreateFromSaveGame(1, 50, 50);
if (boutonSprite != null) {
btnScrnshot.NormalGraphic = boutonSprite.Graphic;
}

chargera la capture d'écran de la première partie sauvegardée et la redimensionnera à 50×50. L'utilisera ensuite comme image pour le bouton de GUI btnScrnshot.

Ceci fait, Delete est appelée sur la sprite pour libérer la mémoire.

Voir Aussi : DynamicSprite.Delete, Game.GetSaveSlotDescription, DynamicSprite.CreateFromFile, DynamicSprite.CreateFromScreenShot

CreateFromScreenShot

static DynamicSprite* DynamicSprite.CreateFromScreenShot(optional int largeur, optional int hauteur)
Crée un nouvel objet DynamicSprite contenant une copie de la capture d'écran actuelle, en la redimensionnant à LARGEUR x HAUTEUR. Si vous n'entrez pas la largeur et la hauteur, alors une sprite de plein écran sera créée.

Cette commande peut être utilie si vous créez un GUI affichant des captures d'écran de parties sauvées, dans l'intention d'afficher la position dans la partie corresondant aux emplacements de sauvegarde.

IMPORTANT : Cette commande charge une sprite supplémentaire en mémoire qui n'est pas contrôlée par le cache classique d'AGS et qui ne sera pas automatiquement supprimée. C'est pourquoi, lorsque vous avez fini d'utiliser l'image, vous DEVEZ appeler Delete dessus pour libérer la mémoire.

NOTE : Cette commande peut être lente si vous utilisez le pilote graphique Direct3D.

IMPORTANT : Si l'objet DynamicSprite est supprimé de la mémoire (c'est-à-dire s'il n'y a plus de variable DynamicSprite* pointant vers l'image), alors la sprite sera aussi supprimée de la mémoire. Assurez vous que vous gardez une variable pointant vers la sprite jusqu'à ce que vous ayez fini de l'utiliser (vous appellerez alors Delete).

Exemple :
// tout en haut du script, hors des events
DynamicSprite *boutonSprite;

// dans une event
boutonSprite = DynamicSprite.CreateFromScreenShot(80, 50);
if (boutonSprite != null) {
btnScrnshot.NormalGraphic = boutonSprite.Graphic;
}

utilise la capture d'écran de la partie actuelle comme image du bouton btnScrnshot.

Ceci fait, Delete est appelée sur la sprite pour libérer la mémoire.

Voir Aussi : DynamicSprite.Delete, Game.GetSaveSlotDescription, DynamicSprite.CreateFromFile, DynamicSprite.CreateFromSaveGame

ChangeCanvasSize

DynamicSprite.ChangeCanvasSize(int largeur, int hauteur, int x, int y);
Change la taille de la sprite pour largeur x hauteur , et décale l'image actuelle vers (x, y) dans le nouveau cadre. Contrairement à la commande Resize, l'image obtenue par cette commande garde sa taille originale.

Cette fonction vous permet d'élargir l'arrière-plan de la sprite pour avoir plus de surface sur laquelle dessiner par rapport à son ancien cadre. C'est en fait l'opposé de la commande Crop. La surface additionnelle sera transparente.

La largeur et la hauteur sont spécifiées en résolution 320×200.

Exemple :
DynamicSprite* sprite = DynamicSprite.CreateFromExistingSprite(10);
sprite.ChangeCanvasSize(sprite.Width + 10, sprite.Height, 5, 0);
DrawingSurface *surface = sprite.GetDrawingSurface();
surface.DrawingColor = 14;
surface.DrawLine(0, 0, 5, surface.Height);
surface.Release();
sprite.Delete();

crée une sprite dynamique qui est une copie de la sprite 10, l'élargie de 5 pixels à gauche et à droite, puis dessine une ligne dans la nouvelle zone sur la gauche.

Voir aussi : DynamicSprite.Crop, DynamicSprite.Resize, DynamicSprite.Height, DynamicSprite.Width

CopyTransparencyMask

DynamicSprite.CopyTransparencyMask(int depuisSprite)
Copie le masque de transparence depuis le numéro de sprite spécifié vers la sprite dynamique. La transparence de la sprite dynamique et/ou son canal alpha seront remplacés par celle de l'autre sprite.

Cette commande est conçue pour les effets spéciaux. C'est assez lent puisqu'elle implique de scruter chaque pixel de l'image, il n'est donc pas recommander de l'utiliser souvent.

La sprite source doit être de la même dimension et de la même profondeur de couleur que la sprite dynamique.

NOTE : Cette commande rend tous les pixels qui sont transparents dans la sprite source également transparents dans la sprite dynamique. Elle ne rend pas opaques les pixels de la sprite dynamique qui sont opaques dans la sprite source (il n'y aurait pas moyen de savoir quelle couleur leur donner).

Si l'image source a un canal alpha, alors la sprite dynamique se verra créer un canal alpha qui sera un copie de la sprite source.

Exemple :
DynamicSprite* sprite = DynamicSprite.CreateFromExistingSprite(10);
sprite.CopyTransparencyMask(11);
object[0].Graphic = sprite.Graphic;
Wait(80);
sprite.Delete();

crée une sprite dynamique qui sera une copie de la sprite 10, change son masque de transparence pour utiliser celle de la sprite 11, et l'affiche sur l'objet 0.

Voir aussi : DynamicSprite.CreateFromExistingSprite

Crop

DynamicSprite.Crop(int x, int y, int largeur, int hauteur);
Rogne l'image à largeur x hauteur, en commençant aux coordonnées (X,Y) de l'image. La largeur et la hauteur sont spécifiées dans la résolution 320×200, comme d'habitude.

Ceci vous permet d'équilibrer les bords de la sprite, et d'effectuer des tâches correspondantes. Seule la zone allant de (X,Y) (coin haut gauche) et d'une largeur de LARGEUR ainsi que d'une hauteur de HAUTEUR sera conservée.

Exemple :
DynamicSprite* sprite = DynamicSprite.CreateFromFile("AvatarPerso.bmp");
sprite.Crop(10, 10, sprite.Width - 10, sprite.Height - 10);
DrawingSurface *surface = Room.GetDrawingSurfaceForBackground();
surface.DrawImage(100, 100, sprite.Graphic);
surface.Release();
sprite.Delete();

chargera l'image AvatarPerso.bmp, en coupera les 10 premiers pixels des bords haut et gauche, puis dessinera l'image résultant aux coordonnées (100,100) de l'arrière-plan.

Voir Aussi : DynamicSprite.Flip, DynamicSprite.Height, DynamicSprite.Width

Delete

(Anciennement DeleteSprite, désormais obsolète)

DynamicSprite.Delete();

Supprime la sprite dynamique spécifiée de la mémoire. Utilisez ceci lorsque vous n'affichez plus la sprite et qu'elle peut être supprimée en toute sûreté.

En temps normal, vous ne devriez pas avoir à supprimer les sprites, puisque le Cache de Sprite d'AGS se charge lui-même de charger et de supprimer automatiquement les sprites.

Cependant, lorsque d'une sprite externe a été chargée dans le jeu (par exemple, avec les commandes CreateFromFile ou CreateFromScreenShot), AGS ne la supprimera pas automatiquement, et vous devrez alors appeler cette commande.

Exemple :

DynamicSprite* sprite = DynamicSprite.CreateFromFile("AvatarPerso.bmp");
object[1].Graphic = sprite.Graphic;
Wait(200);
object[1].Graphic = 22;
sprite.Delete();

chargera le fichier “AvatarPerso.bmp”, utilisera cette image pour l'objet 1, attendra 5 secondes, puis réutilisera l'ancienne sprite 22 pour l'objet 1 et libérera la sprite.

Voir Aussi : DynamicSprite.CreateFromScreenShot, DynamicSprite.Graphic

Flip

DynamicSprite.Flip(eFlipDirection);
Retourne la sprite dynamique selon les paramètres :

eFlipLeftToRight pivote l'image de gauche à droite

eFlipUpsideDown pivote l'image de haut en bas

eFlipBoth pivote l'image de haut en bas et de gauche à droite

Exemple :

DynamicSprite* sprite = DynamicSprite.CreateFromFile("AvatarPerso.bmp");
sprite.Flip(eFlipUpsideDown);
DrawingSurface *surface = Room.GetDrawingSurfaceForBackground();
surface.DrawImage(100, 100, sprite.Graphic);
surface.Release();
sprite.Delete();

chargera l'image AvatarPerso.bmp, la retournera de haut en bas, puis la dessinera aux coordonnées (100,100) de l'arrière-plan.

Voir Aussi : DynamicSprite.Crop, DynamicSprite.Resize, DynamicSprite.Rotate

GetDrawingSurface

DrawingSurface* DynamicSprite.GetDrawingSurface();
Retourne la surface de dessin de la sprite dynamique, ce qui vous permet de modifier la sprite en dessinant dessus de diverses façons.

Après avoir appelé cette méthoe, utilisez les différentes fonctions DrawingSurface pour modifier la sprite, puis appelez Release sur la surface lorsque vous en avez terminé.

Exemple :
DynamicSprite *sprite = DynamicSprite.CreateFromExistingSprite(object[0].Graphic);
DrawingSurface *surface = sprite.GetDrawingSurface();
surface.DrawingColor = 13;
surface.DrawLine(0, 0, 20, 20);
surface.Release();
object[0].Graphic = sprite.Graphic;
Wait(40);
sprite.Delete();

ceci crée une sprite dynamique qui sera une copie de la sprite de l'objet 0, dessine une ligne diagonale rose dessus, place cette nouvelle sprite sur l'objet pour une seconde puis la supprime.

Voir aussi : DynamicSprite.CreateFromExistingSprite, DrawingSurface.DrawLine, DrawingSurface.Release

Resize

DynamicSprite.Resize(int largeur, int hauteur);
Redimensionne une sprite dynamique existante à LARGEUR x HAUTEUR pixels.

La largeur et la hauteur sont spécifiées selon la résolution 320×200, comme d'habitude.

NOTE : Le redimensionnement est une opération relativement lente, donc n'essayer pas de redimensionner des sprites à chaque cycle de jeu, mais seulement lorsque c'est nécessaire.

Exemple :
DynamicSprite* sprite = DynamicSprite.CreateFromFile("AvatarPerso.bmp");
sprite.Resize(sprite.Width * 2, sprite.Height * 2);
DrawingSurface *surface = Room.GetDrawingSurfaceForBackground();
surface.DrawImage(100, 100, sprite.Graphic);
surface.Release();
sprite.Delete();

chargera l'image AvatarPerso.bmp, doublera sa taille, puis la dessinera sur l'arrière-plan aux coordonnées (100,100) de la pièce.

Voir Aussi : DynamicSprite.Crop, DynamicSprite.Flip, DynamicSprite.Rotate, DynamicSprite.Height, DynamicSprite.Width

Rotate

DynamicSprite.Rotate(int angle, optional int largeur, optional int hauteur)
Effectue une rotation sur l'image de la sprite avec l'angle spécifié. L'angle est en degrés, et doit être entre 1 et 359. La rotation se fera dans le sens horaire avec l'angle spécifié.

Facultativement, vous pouvez spécifier la largeur et la hauteur pour l'image résultat. Par défaut, AGS caclulera automatiquement la nouvelle taille nécessaire pour contenir l'image, mais vous pouvez le faire vous-même en entrant ces paramètres.

Notez que spécifier largeur et hauteur ne redimensionne pas l'image, cela permet juste de définir la zone qu'utilisera l'image une fois la rotation effectuée.

NOTE : La rotation est une opération relativement lente, essayez donc de ne pas l'appeler à chaque cycle de jeu ; mais seulement lorsque c'est nécessaire.

Exemple :
DynamicSprite* sprite = DynamicSprite.CreateFromFile("AvatarPerso.bmp");
sprite.Rotate(90);
DrawingSurface *surface = Room.GetDrawingSurfaceForBackground();
surface.DrawImage(100, 100, sprite.Graphic);
surface.Release();
sprite.Delete();

chargera l'image AvatarPerso.bmp, effectuera une rotation de 90 degrés dans le sens horaire dessus, dessinera le résultat à l'écran, puis supprimera la sprite.

Voir Aussi : DynamicSprite.Flip, DynamicSprite.Resize, DynamicSprite.Height, DynamicSprite.Width

SaveToFile

DynamicSprite.SaveToFile(string nomfichier)
Sauvegardera la sprite dynamique dans le fichier spécifié.

L'extension du nom de fichier que vous spécifiez doit être .PCX ou .BMP ; ce sont les deux seuls types de fichier que la machine supporte.

Retourne 1 si la sprite a bien été sauvegardée, ou 0 si l'opération a été un échec.

Exemple :
DynamicSprite* sprite = DynamicSprite.CreateFromFile("AvatarPerso.bmp");
sprite.Rotate(90);
sprite.SaveToFile("AvatarPivote.bmp");
sprite.Delete();

chargera l'image AvatarPerso.bmp, effectuera une rotation de 90 degrés dans le sens des aiguilles d'une montre, puis sauvera le résultat en créant le fichier AvatarPivote.bmp sur le disque.

Voir Aussi : DynamicSprite.CreateFromFile, SaveScreenShot

Tint

DynamicSprite.Tint(int rouge, int vert, int bleu, int saturation, int luminosite)
Teinte la sprite dynamique pour (ROUGE, VERT, BLEU) avec une saturation de SATURATION pour-cents. Pour la signification des paramètres, voir SetAmbientTint.

La teinte définie par cette fonction est permanente pour les sprite dynamique – une fois que la teinte a été définie, il n'est pas possible de l'annuler. Si vous appelez à nouveau Tint avec des paramètres différents, la nouvelle teinte sera appliquée sur la sprite déjà teinte par le premier appel.

NOTE : Cette fonction ne fonctionne que sur les sprites en hautes couleurs.

Exemple :
DynamicSprite* sprite = DynamicSprite.CreateFromExistingSprite(object[0].Graphic);
sprite.Tint(255, 0, 0, 100, 100);
DrawingSurface *surface = Room.GetDrawingSurfaceForBackground();
surface.DrawImage(100, 80, sprite.Graphic);
surface.Release();
sprite.Delete();

crée une copie de la sprite de l'objet 0, la teint en rouge puis la dessine sur l'arrière-plan de la pièce.

Voir aussi : DynamicSprite.Flip, DynamicSprite.Height, DynamicSprite.Width, SetAmbientTint

ColorDepth

readonly int DynamicSprite.ColorDepth;
Retourne la profondeur des couleurs de la sprite dynamique. Elle peut valoir 8, 16 ou 32 et n'est pas nécessairement la même que celle du jeu (bien que ce soit usuellement le cas).

Exemple :
DynamicSprite* sprite = DynamicSprite.CreateFromFile("AvatarPerso.bmp");
if (sprite != null) {
Display("L'image est d'une taille de %d x %d pixels et d'une profondeur de %d-bit.", sprite.Width, sprite.Height, sprite.ColorDepth);
sprite.Delete();
}

affiche la profondeur des couleurs de l'image AvatarPerso.bmp ainsi que sa taille.

Voir Aussi : DynamicSprite.Height, DynamicSprite.Width

Graphic

readonly int DynamicSprite.Graphic;
Retourne le numéro de l'emplacement de sprite dans lequel la sprite dynamique est contenue. Cette valeur peut être passée aux autres fonctions et propriétés, comme par exemple Button.NormalGraphic.

Exemple :
DynamicSprite* ds = DynamicSprite.CreateFromScreenShot(50, 50);
DrawingSurface *surface = Room.GetDrawingSurfaceForBackground();
surface.DrawImage(100, 100, sprite.Graphic);
surface.Release();
ds.Delete();

charge la capture d'écran, puis la dessine aux coordonnées (100,100) de la pièce, sur l'arrière-plan.

Voir Aussi : DynamicSprite.CreateFromScreenShot, DynamicSprite.Delete

Height

readonly int DynamicSprite.Height;
Retourne la hauteur de la sprite dynamique. La hauteur est toujours retournée en résolution 320×200.

Exemple :
DynamicSprite* sprite = DynamicSprite.CreateFromFile("AvatarPerso.bmp");
if (sprite != null) {
Display("L'image est d'une taille de %d x %d pixels.", sprite.Width, sprite.Height);
sprite.Delete();
}

affiche la taille de l'image AvatarPerso.bmp.

Voir Aussi : DynamicSprite.Resize, DynamicSprite.Width

Width

readonly int DynamicSprite.Width;
Retourne la largeur de la sprite dynamique. La largeur est toujours retournée en résolution 320×200.

Exemple :
DynamicSprite* sprite = DynamicSprite.CreateFromFile("AvatarPerso.bmp");
if (sprite != null) {
Display("L'image est d'une taille de %d x %d pixels.", sprite.Width, sprite.Height);
sprite.Delete();
}

affiche la taille de l'image AvatarPerso.bmp.

Voir Aussi : DynamicSprite.Height, DynamicSprite.Resize


file

Table des matières
    • Fonctions et propriétés des fichiers (File)
      • Open
      • Close
      • Delete
      • Exists
      • ReadInt
      • ReadRawChar
      • ReadRawInt
      • ReadRawLineBack
      • ReadStringBack
      • WriteInt
      • WriteRawChar
      • WriteRawLine
      • WriteString
      • EOF
      • Error

Fonctions et propriétés des fichiers (File)

Open

(Formerly known as FileOpen, which is now obsolete)

static File* File.Open(string nomfichier, Mode)

Ouvre un fichier sur le disque dur pour lecture ou écriture. Ces fonctions d'accès au disque sont prévues pour des usages simples, comme la façon dont la série des QFG exporte un personnage lorsque vous en avez fini avec lui.

Le MODE peut être eFileRead, eFileWrite ou eFileAppend, selon que vous vouliez écrire dans ou lire le fichier. Si vous passez la valeur eFileWrite et qu'un fichier nommé NOMFICHIER existe déjà, il sera remplacé par vos opérations.

eFileAppend ouvre un fichier existant pour écrire des informations à la fin du fichier (c'est-à-dire que le contenu précédent n'est pas effacé).

Cette fonction retourne un objet File, que vous manipulerez pour effectuer des opérations sur le fichier. La valeur null est retournée s'il y a un problème (comme par exemple si le fichier n'existe pas alors que le MODE est eFileRead).

NOTE : Vous DEVEZ fermer le fichier avec la fonction Close lorsque vous avez fini de l'utiliser. Il y a un nombre limité de fichiers manipulés, et oublier de les fermer peut amener des problèmes à l'avenir.

IMPORTANT : Si vous ouvrez le fichier pour écrire dedans, alors vous pouvez UNIQUEMENT travailler sur des fichiers contenus dans le dossier du jeu. Vous NE POUVEZ PAS utiliser un chemin, donc tout nom de fichier contenant “\” ou ”/” sera invalide, pour des raisons de sécurité.

Les seules exceptions à cette règle sont les formules spéciales :

$SAVEGAMEDIR$ qui vous permet d'accéder aux fichiers du répertoire de sauvagargde.

$APPDATADIR$ qui vous permet d'écrire/lire des fichiers sur/depuis un dossier du système qui est accessible et partagé par tous les utilisateurs.

IMPORTANT : Sous Windows Vista, si votre jeu est installé dans Program Files alors il est possible que vous ne puissiez pas écrire de fichier dans le répertoire d'installation du jeu. Pour vous assurer que votre jeu n'aura pas de problèmes, écrivez toujours vos fichiers dans le dossier de sauvegarde du jeu ou dans le dossier App Data en utilisant les formules spéciales. Voyez l'exemple ci-dessous.

NOTE : Les pointeurs sur les fichiers ouverts ne sont pas conservés dans les sauvegardes de parties. C'est-à-dire que si vous ouvrez un fichier, sauvez la partie ; puis que vous restaurez la partie, le Fichier ne sera plus directement utilisable et vous devrez le réouvrir pour opérer dessus. Le plus pratique serait de ne pas déclarer de variable File globale.

Exemple :

File *output = File.Open("$SAVEGAMEDIR$/temp.tmp", eFileWrite);
if (output == null)
  Display("Erreur en ouvrant le fichier.");
else {
  output.WriteString("texte de test");
  output.Close();
}

ouvrira le fichier temp.tmp dans le dossier de sauvegarde du jeu en vue d'écrire dedans. Un message d'erreur sera affiché si le fichier ne peut pas être créé. Sinon, la ligne “texte de test” sera écrite à la fin du fichier puis il sera fermé.

Voir aussi : File.Close, File.Exists, File.ReadStringBack, File.WriteString

Close

(Formerly known as FileClose, which is now obsolete)

File.Close()

Ferme le fichier, et sauve les changements sur le disque. Vous devez appeler cette fonction lorsque vous avez fini d'écrire/lire un fichier.

Exemple :

File *output = File.Open("test.dat", eFileWrite);
output.WriteString("test string");
output.Close();

ouvrira le fichier test.dat, écrira la chaîne “texte de test”, et fermera le fichier.

Voir aussi : File.Open

Delete

static File.Delete(string filename)
Supprime le fichier spécifié du disque.

Cette commande ne fonctionne qu'avec les fichiers présents dans le répertoire du jeu. Vous NE pouvez PAS utiliser un chemin, ainsi tout nom de fichier contenant “\” ou ”/” sera automatiquement rejeté, pour des raisons de sécurité.

La seule exception à cette règle est la formule spéciale $SAVEGAMEDIR$, qui vous permet d'accéder aux fichiers du répertoire de sauvagargde. Ceci est particulièrement important depuis le passage à Windows Vista, qui fait que vous n'avez probablement plus accès au dossier principal du jeu. Vous pouvez utiliser la formule SAVEGAMEDIR pour écrire et lire des fichiers dans le répertoire de sauvegarde actuel, où vous pourrez toujours écrire.

NOTE : Ceci est une fonction statique, vous n'avez donc pas besoin d'un pointeur File pour l'utiliser. Voir l'exemple plus bas.

Exemple :
File.Delete("temp.tmp");

supprimera le fichier “temp.tmp” du répertoire du jeu, s'il existait.

Compatibility: Supported by AGS 3.0.1 and later versions.

Voir aussi : File.Exists, File.Open

Exists

static bool File.Exists(string filename)
Vérifie que le fichier spécifié existe sur l'ordinateur.

Cette commande supporte la formule spéciale $SAVEGAMEDIR$, qui vous permet d'accéder aux fichiers du répertoire de sauvagargde. Ceci est particulièrement important depuis le passage à Windows Vista, qui fait que vous n'avez probablement plus accès au dossier principal du jeu.

NOTE: Ceci est une fonction statique, vous n'avez donc pas besoin d'un pointeur File pour l'utiliser. Voir l'exemple plus bas.

Exemple :
if (!File.Exists("temp.tmp"))
{
  File *output = File.Open("temp.tmp", eFileWrite);
  output.WriteString("some text");
  output.Close();
}

créera le fichier “temp.tmp” s'il n'existait pas déjà.

Compatibility: Supported by AGS 3.0.1 and later versions.

Voir aussi : File.Delete, File.Open

ReadInt

(Formerly known as FileReadInt, which is now obsolete)

File.ReadInt()

Lit un entier depuis le fichier, et le retourne au script. Seuls les entiers écrits avec File.WriteInt peuvent être lus par cette fonction.

Exemple :

int nombre;
File *input = File.Open("stats.dat", eFileRead);
nombre = input.ReadInt();
input.Close();

ouvrira le fichier stats.dat, lira un entier dans nombre et fermera le fichier.

Voir aussi : File.ReadStringBack, File.WriteInt

ReadRawChar

(Formerly known as FileReadRawChar, which is now obsolete)

File.ReadRawChar()

Lit un caractère brut depuis le fichier et le retourne. Cette fonction vous permet de lire depuis des fichiers qui n'ont pas été créés par votre jeu, cependant ceci devrait être réservé aux utilisateurs experts.

Exemple :

File *input = File.Open("stats.txt", eFileRead);
String buffer = String.Format("%c", input.ReadRawChar());
input.Close();

lira un caractère brut depuis le fichier stats.txt et l'écrira dans la string 'buffer'.

Voir aussi : File.ReadStringBack, File.ReadRawInt, File.WriteRawChar

ReadRawInt

(Formerly known as FileReadRawInt, which is now obsolete)

File.ReadRawInt()

Lit un entier 32-bit depuis le fichier et le retourne au script. Ceci vous permet de lire depuis des fichiers créés par d'autres programmes, cependant ceci devrait être réservé aux utilisateurs experts.

Exemple :

int number;
File *input = File.Open("stats.txt", eFileRead);
number = input.ReadRawInt();
input.Close();

lira un entier depuis le fichier stats.txt et le mettra dans la variable nombre.

Voir aussi : File.ReadStringBack, File.ReadRawChar

ReadRawLineBack

(Formerly known as File.ReadRawLine, which is now obsolete)

String File.ReadRawLineBack()

Lit une ligne de texte brut depuis le fichier et la retourne. Ceci vous permet de lire les lignes d'un fichier et de les utiliser dans votre jeu.

NOTE : cette commande vous permet seulement de lire des lignes de texte brut depuis des fichiers texte. Si vous essayez de l'utiliser avec des fichiers binaires ou des fichiers écrits avec des commandes comme WriteString, WriteInt, etc. alors les résultats sont imprévisibles.

Exemple :

File *input = File.Open("error.log", eFileRead);
if (input != null) {
  while (!input.EOF) {
    String line = input.ReadRawLineBack();
    Display("%s", line);
  }
  input.Close();
}

affichera le contenu du fichier 'erreur.log', s'il existe.

Voir aussi : File.WriteRawLine

ReadStringBack

(Formerly known as FileRead, which is now obsolete) (Formerly known as File.ReadString, which is now obsolete)

String File.ReadStringBack()

Lit une chaîne de caractères depuis un fichier précédemment ouvert avec File.Open, et la retourne. Vous ne devriez utiliser cette commande qu'avec les fichiers écrits avec File.WriteString. N'utilisez PAS cette fonction avec d'autres fichiers, même des fichiers texte.

Exemple :

File *input = File.Open("test.dat", eFileRead);
String buffer = input.ReadStringBack();
input.Close();

ouvrira le fichier test.dat (dans lequel vous aviez précédemment écrit avec File.WriteString) et lira une chaîne pour la stocker dans buffer. Puis fermera le fichier.

Voir aussi : File.Open, File.WriteString

WriteInt

(Formerly known as FileWriteInt, which is now obsolete)

File.WriteInt(int value)

Ecrit VALEUR dans le fichier. Ceci vous permet de sauver le contenu d'une variable sur le disque. Le fichier doit au préalable avoir été ouvert avec File.Open, et vous pourrez retrouver la valeur avec File.ReadInt.

Exemple :

int number = 6;
File *output = File.Open("stats.dat", eFileWrite);
output.WriteInt(number);
output.Close();

ouvrira le fichier stats.dat et y écrira l'entier nombre.

Voir aussi : File.ReadInt, File.WriteString

WriteRawChar

(Formerly known as FileWriteRawChar, which is now obsolete)

File.WriteRawChar(int value)

Ecrit un simple caractère dans le fichier spécifié, en mode brut de façon à ce que les autres applications puissent aussi le lire. Si vous créez un fichier dans l'intention de le réutiliser uniquement dans votre jeu, préférez plutôt File.WriteInt, puisque cette commande est plus stable. N'utilisez cette fonction que si vous devez partager le fichier avec d'autres applications.

Cette commande écrit un simple octet dans le fichier de sortie, ainsi, VALEUR doit contenir une valeur allant de 0 à 255.

Exemple :

File *output = File.Open("output.txt", eFileWrite);
output.WriteRawChar('A');
output.WriteRawChar('B');
output.WriteRawChar(13);
output.Close();

écrira le texte “AB”, suivi d'un retour charriot (saut de ligne), dans le fichier.

Voir aussi : File.ReadRawChar, File.WriteInt

WriteRawLine

(Formerly known as FileWriteRawLine, which is now obsolete)

File.WriteRawLine(string texte)

Ecrit du texte dans le fichier en format texte brut. Ceci vous permet de le lire avec Notepad ou un autre éditeur de texte. Cette commande est utile pour générer des logs ou autres fichiers du genre.

Le TEXTE sera écrit dans le fichier, suivi des caractères standard annonçant une nouvelle ligne.

Exemple :

File *output = File.Open("error.log", eFileAppend);
output.WriteRawLine("There was an error playing sound1.wav");
output.Close();

écrira une ligne d'erreur dans le fichier erreur.log.

Voir aussi : File.ReadRawLineBack, File.WriteString

WriteString

(Formerly known as FileWrite, which is now obsolete)

File.WriteString(string text)

Ecrit TEXTE dans le fichier, qui doit avoir été au préalable ouvert avec File.Open. La chaîne de texte est écrite dans un format particulier, qui ne peut être lu en retour qu'en utilisant File.ReadStringBack.

Exemple :

File *output = File.Open("temp.tmp", eFileWrite);
if (output == null) Display("Error opening file.");
else {
  output.WriteString("test string");
  output.Close();
}

ouvrira le fichier temp.tmp pour écriture. Si le fichier ne peut être créé, affichera un message d'erreur. Sinon, la chaîne “chaîne de test” sera écrite puis le fichier fermé.

Voir aussi : File.ReadStringBack, File.Open, File.WriteRawLine

EOF

(Formerly known as FileIsEOF, which is now obsolete)

readonly bool File.EOF

Vérifie si le fichier spécifié a été entièrement lu. Ceci est utile uniquement avec les fichiers ouverts pour lecture. Retourne 1 lorsque tout le contenu du fichier a été lu, sinon 0.

Exemple :

File *output = File.Open("test.dat", eFileRead);
while (!output.EOF) {
  int temp = output.ReadRawChar();
  Display("%c", temp);
}
output.Close();

affichera chaque caractère du fichier test.dat, un par un, à l'écran.

Voir aussi : File.Error, File.Open, File.ReadStringBack

Error

(Formerly known as FileIsError, which is now obsolete)

readonly bool File.Error

Vérifie si une erreur est survenue en lisant depuis le fichier spécifié ou en écrivant dedans.

Une erreur peut survenir si, par exemple, vous dépssez l'espace disque disponible ou si l'utilisateur retire le disque depuis lequel le fichier est utilisé.

Cette fonction vérifie uniquement les erreurs survenue en lisant/écrivant des données. La fonction File.Open retournera null si une erreur est survenue en ouvrant ou en créant le fichier.

Pour savoir si toutes les données ont été lues depuis un fichier, utilisez plutôt EOF.

Exemple :

File *output = File.Open("test.dat", eFileWrite);
output.WriteInt(51);
if (output.Error) {
  Display("Error writing the data!");
}
output.Close();

écrira un nombre dans le fichier 'test.dat', et affichera un message s'il y a un problème.

Voir aussi : File.EOF, File.ReadStringBack


game

Table des matières
    • Fonctions de jeu globales (Game / Global functions)
      • AbortGame
      • CallRoomScript
      • ChangeTranslation
      • ClaimEvent
      • Debug
      • DeleteSaveSlot
      • DisableInterface
      • DoOnceOnly
      • EnableInterface
      • EndCutscene
      • GetColorFromRGB
      • GetFrameCountForLoop
      • GetGameOption
      • GetGameParameter
      • GetGameSpeed
      • GetGlobalInt
      • GetGraphicalVariable
      • GetLocationName
      • GetLocationType
      • GetLoopCountForView
      • GetRunNextSettingForLoop
      • GetSaveSlotDescription
      • GetTextHeight
      • GetTextWidth
      • GetTranslation
      • GetViewFrame
      • GiveScore
      • InputBox
      • InventoryScreen
      • IsGamePaused
      • IsInterfaceEnabled
      • IsInteractionAvailable
      • IsKeyPressed
      • IsTimerExpired
      • IsTranslationAvailable
      • MoveCharacterToHotspot
      • MoveCharacterToObject
      • PauseGame
      • ProcessClick
      • QuitGame
      • Random
      • RestartGame
      • RestoreGameDialog
      • RestoreGameSlot
      • RunAGSGame
      • SaveGameDialog
      • SaveGameSlot
      • SaveScreenShot
      • SetAmbientTint
      • SetGameOption
      • SetGameSpeed
      • SetGlobalInt
      • SetGraphicalVariable
      • SetMultitaskingMode
      • SetRestartPoint
      • SetSaveGameDirectory
      • SetTextWindowGUI
      • SetTimer
      • SkipUntilCharacterStops
      • StartCutscene
      • UpdateInventory
      • UnPauseGame
      • Wait
      • WaitKey
      • WaitMouseKey
      • CharacterCount
      • DialogCount
      • FileName
      • FontCount
      • GlobalMessages
      • GlobalStrings
      • GUICount
      • InSkippableCutscene
      • InventoryItemCount
      • MouseCursorCount
      • Name
      • NormalFont
      • SkippingCutscene
      • SpeechFont
      • SpriteHeight
      • SpriteWidth
      • TranslationFilename
      • UseNativeCoordinates
      • ViewCount

Fonctions de jeu globales (Game / Global functions)

AbortGame

AbortGame(string message, ...)
Arrête le jeu et retourne au système d'exploitation (OS).

La fenêtre standard d'erreur d'AGS est affichée, contenant les numéros de ligne du script et le code d'appel, ainsi que le message (dans lequel vous pouvez utiliser les codes variables %d et %s).

Vous pouvez utiliser cette fonction plutôt que QuitGame lorsque vous vérifiez que votre script est appelé correctement, de façon à vous assurer que l'utilisateur utilise vos fonctions comme il faut.

Dans l'idéal, cette fonction ne devrait jamais être appelée dans la version finale du jeu.

Exemple :
function Elargir(int nouvelleLargeur) {
  if (nouvelleLargeur < 10)
    AbortGame("nouvelleLargeur doit être au moins de 10 !");
}

arrêtera le jeu si Elargir est appelée avec un paramètre inférieur à 10.

Voir Aussi : QuitGame

CallRoomScript

CallRoomScript (int valeur)
Appelle la fonction on_call de la pièce actuelle. Ceci est utile par exemple pour le parser de texte, lorsque vous voulez vérifier les phrases générales du jeu, et voir si la phrase est significative pour la pièce actuelle.

La fonction on_call sera appelée dans le script de la pièce actuelle, avec le paramètre valant valeur, que vous aurez passée. Ceci vous permet de différencier les différents appels, et vous permettre de ne pas utiliser de GlobalInt pour dire ce qu'il faut faire.

Si la pièce actuelle n'a pas de fonction on_call, il ne se passera rien. Aucun message d'erreur de n'affichera.

Vous devez placer la fonction on_call dans le script de la pièce (bouton “Edit Script” dans le paneau de réglages de la pièce), de la même façon que vous le faîtes pour dialog_request dans le script global :
function on_call (int valeur) {
  if (valeur == 1) {
    // Vérification texte entré
    if (Parser.Said("prendre Pomme"))
      Display("Non, ne touchons pas à l'arbre.");
  }
}

La fonction on_call n'est pas appelée immédiatement, la machine suit plutôt son cours, et exécutera probablement le code à la prochaine séquence d'exécution, donc vous ne pouvez pas vous servir de cette fonction pour définir immédiatement des valeurs.

Une fois que la fonction on_call a été exécutée (ou non s'il n'en existe pas), la variable game.roomscript_finished vaudra 1, vous pourrez donc la tester dans votre script repeatedly_execute si vous devez faire autre chose à la suite.

Voir Aussi : L'analyseur de texte

ChangeTranslation

static bool Game.ChangeTranslation(string nomNouvelleTraduction)
Change la traduction en cours pour nomNouvelleTraduction . Cela doit représenter le nom du fichier sans l'extension, par exemple “Francais” ou “Espanol”. Ce peut aussi être une chaîne vide, auquel cas la traduction en cours sera annulée, et le jeu retournera dans sa langue par défaut.

Retourne true si la traduction a été correctement modifiée, ou false s'il y a eu un problème (par exemple, vous avez spécifié une traduction inexistante).

NOTE : Ceci est une fonction statique, vous devez donc taper Game. devant elle. Voyez l'exemple suivant.

Exemple :
if (Game.ChangeTranslation("Espanol") == true)
{
  Display("La traduction est maintenant espagnole !");
}
else
{
  Display("Impossible de changer la traduction");
}

tentera de permutter la traduction vers l'espagnol.

Compatibilité : Supporté par AGS 3.1.0 et les versions plus récentes.

Voir aussi : Game.TranslationFilename, IsTranslationAvailable

ClaimEvent

ClaimEvent()
Cette commande s'utilise dans les fonctions on_key_press et on_mouse_click des scripts de pièce ou de module , et empêche AGS de les appeler ensuite depuis le script global.

Par exemple, si le script de votre pièce réagit lorsque le joueur appuie sur la barre espace, et que vous ne voulez pas que le on_key_press du script global réagisse, alors utilisez cette commande.

Ceci est utile si vous faire par exemple un mini-jeu dans la pièce, et que vous voulez utiliser des touches qui ont ordinairement une autre fonction.

L'ordre normal dans lequel les scripts sont appelés pour on_key_press et on_mouse_click est le suivant :
Script de la pièce
Script des modules (dans l'ordre des modules)
Script global

Si l'un de ces scripts appelle ClaimEvent, alors la chaîne rompra à ce point.

Exemple :

if (keycode == ' ') {
  Display("Vous avez appuyé sur la barre espace dans cette pièce !");
  ClaimEvent();
}

empêche les on_key_press du script global et des éventuels modules d'être exécutés si le joueur appuie sur la barre espace.

Voir Aussi : Fonctions prédéfinies du script global

Debug

Debug (int command, int data)
Cette fonction gère tous les services de debug du moteur. Exécute différentes tâches, selon la valeur du paramètre COMMAND. Si le debug mode est désactivé, alors cette fonction n'a pas d'effet. Cet aspect vous permet de distribuer votre jeu sans toucher à votre script, il vous suffit juste de désactiver le debug mod dans l'Editeur AGS.

Le paramètre DATA dépend de command - passez 0 s'il n'est pas utile. Toutes les valeurs possibles pour le paramètre COMMAND sont listées ici, avec leur description :
0   Tout l'inventaire - Donne au personnage joueur un élément de chaque
objet de l'inventaire. Ceci est pratique pour tester, lorsque vous
avez besoin de ramasser un objet chaque fois que vous testez une partie
du jeu où celui-ci est nécessaire.
1   Affiche la version de l'interpréteur - la machine affichera son numéro
de version et sa date de création.
2   Zones de déplacement - colore les parties de l'écran où le joueur peut
se rendre depuis sa position actuelle. Ceci est utile si vous pensez que
le path-finder ne fonctionne pas correctement. Toutes les zones de déplacement
(//Walkable Areas//) sont peintes dans leurs couleurs respectives, sauf la partie
correspondant à la surface occupée par le personnage (sous ses pieds).
3   Téléportation - affiche une boîte de dialogue vous demandant dans quelle
pièce vous voulez vous rendre, et appelle ensuite ChangeRoom pour vous y
emmener. Utile pour passer des parties du jeu ou aller à un point spécifique
pour tester quelque chose.
4   Afficher FPS - active/désactive l'affichage du nombre d' images par seconde
à l'écran. Donnez la valeur 1 à DATA pour l'afficher, 0 pour l'effacer.

Voir Aussi : Options de débogage

DeleteSaveSlot

DeleteSaveSlot (int slot)
Supprime la sauvegarde contenue dans l'emplacement numéro SLOT.

NOTE : Si vous spécifiez un des emplacements standards (1 à 20), alors AGS réarrangera les autres sauvegardes de façon à former une suite d'emplacements complète. Vous devrez rafraîchir toute liste de sauvegardes après avoir appelé cette fonction.

Exemple :
DeleteSaveSlot (130);

supprime l'emplacement de sauvegarde 130 (qui aura été sauvé au préalable).

Voir Aussi : RestoreGameSlot, SaveGameSlot

DisableInterface

DisableInterface ()
Désactive l'interface du joueur. Ceci fonctionne de la même façon que lorsqu'une animation la désactive : le mode du curseur est celui d'attente, et les clics de la souris ne seront pas envoyés à la fonction “on_mouse_click”. Les boutons de GUI seront également désactivés.

NOTE : AGS retient le nombre de fois que DisableInterface est appelée. Chaque appel de DisableInterface doit être suivi d'un EnableInterface plus loin dans le jeu, sinon le joueur ne pourra plus accéder à l'interface.

Exemple :
DisableInterface();

désactivera l'interface du joueur.

Voir Aussi : EnableInterface, IsInterfaceEnabled

DoOnceOnly

static bool Game.DoOnceOnly(const string token)
Cette fonction vous fournit un moyen facile de n'exécuter du code que la première fois que le joueur le déclenche. C'est fréquemment utilisé pour gérer l'obtention de points.

Le paramètre token est une chaîne arbitraire. Vous pouvez passer ce que vous voulez, mais ELLE DOIT ETRE UNIQUE . Cela représente la chaîne qui permet à AGS de déterminer si la section de code a déjà été exécutée ou non, ainsi vous devriez vous assuer de ne pas utiliser la même chaîne token à deux endroits différentes dans votre jeu .

Retourne true la première fois qu'elle est appelée avec ce token, et false ensuite.

NOTE : Ceci est une fonction statique, et doit donc être précédée de Game. , voir l'exemple suivant.

Exemple :
if (Game.DoOnceOnly("ouvrir armoire")) {
  GiveScore(5);
}

donnera 5 points au joueur la première fois que ce code est exécuté.

Voir aussi : GiveScore

EnableInterface

EnableInterface ()
Réactive l'interface du joueur, qui avait été au préalable désactivée par la fonction DisableInterface. Chaque élément désactivé par cette fonction retourne à la normale.

Exemple :
EnableInterface();

réactivera l'interface du joueur.

Voir Aussi : DisableInterface, IsInterfaceEnabled

EndCutscene

EndCutscene()
Marque la fin d'une cutscene (cinématique). Si le joueur passe la cutscene, le jeu reprendra à partir de ce point. Cette fonction retourne 0 si le joueur a regardé la cutscene et 1 s'il l'a passée.

Voir Aussi : StartCutscene

GetColorFromRGB

(Anciennement RawSetColorRGB, désormais obsolète)

static int Game.GetColorFromRGB(int rouge, int vert, int bleu)

Récupère le Nombre de Couleur AGS (AGS Colour Number) pour la couleur RVG spécifiée. Les composants rouge, vert et bleu sont des valeurs de 0 à 255. Cette fonction vous donne durant l'exécution un équivalent du Colour Finder (Chercheur de Couleur) de l'éditeur.

Cette commande est lente dan les jeux 256 couleurs, puisque la palette doit être scannée afin de trouver la couleur la plus proche.

NOTE : Ceci est une fonction statique et doit donc être précédée de Game., voir l'exemple suivant.

Exemple :

DrawingSurface *surface = Room.GetDrawingSurfaceForBackground();
surface.DrawingColor = Game.GetColorFromRGB(0, 255, 0);
surface.DrawLine(0, 0, 50, 50);
surface.Release();

dessinera une ligne vert brillante sur l'arrière-plan de la pièce.

Voir aussi : DrawingSurface.DrawingColor

GetFrameCountForLoop

(Anciennement compris dans GetGameParameter, désormais obsolète)

static int Game.GetFrameCountForLoop(int vue, int sequence)

Retourne le nombre d'images dans la séquence spécifiée de la vue spécifiée.

NOTE : Ceci est une fonction statique et doit donc être précédée de Game., voir l'exemple suivant.

Exemple :

int nombreImages = Game.GetFrameCountForLoop(NAGE, 2);
Display("La deuxième séquence dans la vue NAGE possède %d images.", nombreImages);

Voir aussi : Game.GetLoopCountForView, Game.GetRunNextSettingForLoop, Game.GetViewFrame

GetGameOption

GetGameOption (option)
Retourne le réglage actuel d'une option du jeu, initialement définie dans le paneau de régalages généraux (Game Settings) de l'éditeur AGS.

OPTION détermine quelle option doit être considérée, et sa valeur est retournée.

Les valeurs possibles pour OPTION sont listées à SetGameOption.

Exemple :
if (GetGameOption (OPT_ANTIGLIDE) == 1) {
Display("Le mode anti-glide est activé !");
}

vérifiera si l'option angi-glide est activée (retourne 1), auquel cas le message sera affiché, ou non (retourne 0). Voir Aussi : SetGameOption

GetGameParameter

La fonction GetGameParameter est désormais obsolète.

Elle a été remplacée par les fonctions et propriétés suivantes :

Game.SpriteWidth (anciennement GP_SPRITEWIDTH)

Game.SpriteHeight (anciennement GP_SPRITEHEIGHT)

Game.GetLoopCountForView (anciennement GP_NUMLOOPS)

Game.GetFrameCountForLoop (anciennement GP_NUMFRAMES)

Game.GetRunNextSettingForLoop (anciennement GP_ISRUNNEXTLOOP)

Game.GetViewFrame (anciennement GP_FRAMExxx, GP_ISFRAMEFLIPPED)

Game.GUICount (anciennement GP_NUMGUIS)

Room.ObjectCount (anciennement GP_NUMOBJECTS)

Game.CharacterCount (anciennement GP_NUMCHARACTERS)

Game.InventoryItemCount(anciennement GP_NUMINVITEMS)

GetGameSpeed

GetGameSpeed ()
Retourne la vitesse actuelle du jeu (nombre de cycles par seconde).

Exemple :
if (GetGameSpeed() &gt; 40) {
SetGameSpeed(40);
}

gardera toujours la vitesse du jeu à 40 cycles par seconde (au cas où l'utilisateur l'a augmentée).

Voir Aussi : SetGameSpeed

GetGlobalInt

GetGlobalInt (int index)
Retourne la valeur de la variable globale entière numéro INDEX.

NOTE : Les GlobalInts sont désormais considérées comme obsolètes. Utilisez plutôt les variables globales, qui vous permettent de nommer vos variables.

Exemple :
if (GetGlobalInt(20) == 1) {
  // le code ici
}

exécutera le code seulement si la variable globale entière 20 vaut 1.

Voir aussi : SetGlobalInt, Game.GlobalStrings

GetGraphicalVariable

GetGraphicalVariable (string nom_variable);
Retourne la valeur de la variable NOM_VARIABLE de l'éditeur d'interaction. Ceci vous permet d'accéder aux valeurs que vous avez données aux variables propres à l'éditeur d'interaction. (Games - Set variable value)

NOTE : Cette commande est désormais obsolète, et n'est proposée que par soucis de compatibilité avec AGS 2.x. Lorsque vous écrivez de nouveaux codes, utilisez plutôt les variables globales.

Exemple :
if (GetGraphicalVariable("rocher enlevé")==1)
{ code ici }

n'exécutera le code que si la variable d'interaction “rocher enlevé” vaut 1.

Voir Aussi : GetGlobalInt, SetGraphicalVariable

GetLocationName

(Anciennement fonction globale GetLocationName, désormais obsolète)

static String Game.GetLocationName(int x, int y)

Retourne le nom de ce qui se trouve à l'écran aux coordonnées (X,Y). Ceci vous permet de créer une ligne de statut “Regarder xxx” à la Lucasarts lorsque le joueur déplace le curseur sur un élément.

NOTE : Contrairement à ProcessClick, cette fonction considère ce que le joueur voit à l'écran - ainsi, si les cooronnées correspondent à un GUI, une ligne vide est retournée.

NOTE : Les coordonnées sont celles de l'ECRAN, et PAS de la PIECE. Cela signifie que dans une pièce plus large que l'écran, les coordonnées que vous passez sont relatives à la position actuelle de l'écran, et NON sur les coordonnées de la pièce. Cette fonction serait donc à utiliser avec les variables de la position du curseur de la souris.

Exemple :

String alecran = Game.GetLocationName(mouse.x, mouse.y);

retournera le nom de tout ce que la souris survole dans une variable string.

Voir Aussi : Hotspot.Name, InventoryItem.Name, GetLocationType, Object.Name

GetLocationType

GetLocationType(int x, int y)
Retourne le type de l'élément qui se trouve aux coordonnées (X,Y) ; si c'est un personnage, un objet, un hotspot ou rien de tout cela. Ceci peut être utile si vous voulez gérer différemment les clics en fonction de ce sur quoi le joueur clique.

NOTE : Les coordonnées sont celles de l'écran, PAS de la pièce. Voyez la description de GetLocationName pour plus d'informations.

La valeur retournée peut être :
eLocationNothing    rien, un GUI ou l'inventaire
eLocationHotspot    un hotspot
eLocationCharacter  un personnage
eLocationObject     un objet

Exemple :

if (GetLocationType(mouse.x,mouse.y) == eLocationCharacter)
mouse.Mode = eModeTalk;

utilisera le mode dialogue pour le curseur si celui-ci est sur un personnage.

Voir Aussi : Hotspot.GetAtScreenXY, Game.GetLocationName, Object.GetAtScreenXY

GetLoopCountForView

(Anciennement compris dans GetGameParameter, désormais obsolète)

static int Game.GetLoopCountForView(int vue)

Retourne le nombre de séquences dans la vue spécifiée.

NOTE: Ceci est une fonction statique et doit donc être précédée de Game., voir l'exemple suivant.

Exemple :

int sequences = Game.GetLoopCountForView(NAGE);
Display("La vue NAGE (vue %d) possède %d séquences.", NAGE, sequences);

Voir aussi : Game.GetRunNextSettingForLoop, Game.GetFrameCountForLoop, Game.GetViewFrame

GetRunNextSettingForLoop

(Anciennement compris dans GetGameParameter, désormais obsolète)

static bool Game.GetRunNextSettingForLoop(int view, int loop)

Retourne si la séquence spécifiée dans la vue spécifiée a l'option “Run the next loop after this one” (Lancer la prochaine séquence après celle-ci) de cochée.

NOTE : Ceci est une fonction statique et doit donc être précédée de Game., voir l'exemple suivant.

Exemple :

if (Game.GetRunNextSettingForLoop(NAGE, 5) == true) {
  Display("La séquence 5 de la vue NAGE lancera la prochaine séquence.");
}
else {
  Display("La séquence 5 de la vue NAGE ne lancera pas la prochaine séquence.");
}

Voir aussi : Game.GetLoopCountForView, Game.GetFrameCountForLoop, Game.GetViewFrame

GetSaveSlotDescription

(Anciennement fonction globale GetSaveSlotDescription, désormais obsolète)

static String Game.GetSaveSlotDescription(int slot)

Retourne le texte de description de l'emplacement de sauvegarde numéro SLOT.

Si l'emplacement correspondant à ce numéro n'existe pas, retourne null.

Exemple :

String description = Game.GetSaveSlotDescription(10);

stockera la description de l'emplacement de sauvegarde 10 dans la variable.

Voir Aussi : DynamicSprite.CreateFromSaveGame, RestoreGameSlot, SaveGameSlot

GetTextHeight

GetTextHeight(string texte, FontType font, int largeur)
Calcule la hauteur à l'écran que prendra l'affichage de TEXTE en utilisant la police FONT dans une largeur de LARGEUR pixels.

Ceci vous permet de savoir la taille qu'un message affiché avec une commande comme DrawMessageWrapped occupera. LARGEUR est la largeur de la zone dans laquelle le texte sera affiché.

La hauteur est retournée dans la résolution normale de 320 pixels, donc elle peut être utilisée avec des commandes d'affichage à l'écran.

Exemple :
int height = GetTextHeight("Le message sur le GUI !", Game.NormalFont, 100);
gLigneDuBas.SetPosition(0, 200 - height);

déplacera le GUI LIGNEDUBAS de façon à ce qu'il puisse afficher le texte à l'écran.

Voir Aussi : GetTextWidth, DrawingSurface.DrawString

GetTextWidth

GetTextWidth(string texte, FontType font)
Retourne la largeur qu'occupera l'affichage à l'écran de TEXTE dans la police FONT sur une seule ligne.

Ceci peut être utile si vous avez besoin de centrer ou d'aligner à droite du texte, par exemple lorsque vous utilisez des commandes DrawingSurface.

La largeur est retournée dans la résolution normale de 320 pixels, donc elle peut être utilisée avec des commandes d'affichage à l'écran.

Exemple :
DrawingSurface *surface = Room.GetDrawingSurfaceForBackground();
surface.DrawingColor = 14;
int width = GetTextWidth("Salut !", Game.NormalFont);
surface.DrawString(160 - (width / 2), 100, Game.NormalFont, "Salut !");
surface.Release();

affichera “Salut !” au milieu de l'arrière-plan de la scène.

Voir Aussi : GetTextHeight, DrawingSurface.DrawString

GetTranslation

GetTranslation (string original)
Retourne la traduction du texte contenu dans la string. Normalement, vous n'aurez pas besoin de cette fonction puisque le jeu traduit la plupart des choses pour vous. Cependant, si vous utilisez une InputBox ou une autre forme d'input, et que vous voulez comparer ce que l'utilisateur a entré à une string particulière, la traduction ne sera pas automatique. Donc, vous devriez procéder ainsi :

Exemple :
String buffer = Game.InputBox("Entrez le mot de passe :");
if (buffer.CompareTo(GetTranslation("secret")) == 0) {
// correspond à la traduction actuelle de "secret"
}

S'il n'y a pas de traduction pour la string spécifiée, elle se trouvera inchangée, cette fonction est donc sans danger.

Voir Aussi : IsTranslationAvailable

GetViewFrame

(Anciennement compris dans GetGameParameter, désormais obsolète)

static ViewFrame* Game.GetViewFrame(int vue, int sequence, int image)

Retourne une variable ViewFrame pour l'image spécifiée dans la séquence et la vue spécifiées.

Cette variable vous permettra d'obtenir des propriétés sur l'image elle-même, comme son numéro d'image, le son qui lui est associée ou autres.

NOTE: Ceci est une fonction statique et doit donc être précédée de Game., voir l'exemple suivant.

Exemple :

ViewFrame *image = Game.GetViewFrame(NAGE, 2, 3);
Display("L'image numéro 3 de la séquence 2 de la vue NAGE a pour numéro de sprite %d", image.Graphic);

Voir aussi : Game.GetLoopCountForView, Game.GetRunNextSettingForLoop, Game.GetFrameCountForLoop, ViewFrame.Graphic, ViewFrame.Speed

GiveScore

GiveScore (int score)
Définit le SCORE du joueur. Préférez cette méthode à une modification directe du paramètre, puisqu'elle jouera le son associé à un changement de score, mettra à jour toute ligne de statut l'affichant et appellera la fonction on_event en passant le paramètre GOT_SCORE.

SCORE peut être une valeur négative, auquel cas le son associé au changement de score N'est PAS joué.

Exemple :
GiveScore(5);

définira le score du joueur à 5 points.

Voir aussi : Game.DoOnceOnly

InputBox

(Anciennement fonction globale InputBox, désormais obsolète)

static String Game.InputBox(string prompt)

Affiche une fenêtre demandant à l'utilisateur de taper du texte, utilisant PROMPT comme texte pour la fenêtre. Tout ce que l'utilisateur entrera sera retourné par cette fonction.

Cette commande affiche une fenêtre input très basique, utile principalement pour débuguer. La fenêtre étant assez petite, seules de courts textes d'environ 20 caractères pourront être entrés.

La façon recommandée pour récupérer ce que l'utilisateur entre est de créer votre propre GUI avec une boîte de texte, ce qui vous permet de personnaliser entièrement l'aspet de la fenêtre.

TIP : Si vous ajoutez un caractère '!' au début de PROMPT, alors un bouton Annuler (Cancel) sera disponible dans la fenêtre d'input. Si le joueur appuie sur ce bouton Annuler (ou sur la touche Echap), une ligne vide sera retournée.

Exemple :

String nom = Game.InputBox("!Quel est votre nom ?");

demandera son nom à l'utilisateur et le stockera dans la string NOM. S'il appuie sur Annuler, la string NOM sera vide.

Voir Aussi : String.AsInt

InventoryScreen

InventoryScreen ()
Cette commande est obsolète.

Cette commande été utilisée pour afficher une fenêtre d'inventaire par défaut dans les précédentes versions d'AGS, mais n'est désormais plus supportée.

Plutôt qu'utiliser cette commande, vous devez créer votre propre Inventaire de GUI. Le modèle de jeu par défaut en offre un exemple.

IsGamePaused

IsGamePaused ()
Retourne 1 si le jeu est actuellement en pause, sinon 0. Le jeu est en pause lorsque la barre d'icônes est affiché, ou qu'une interface “script-only” a été affichée à l'aide de GUI.Visible=true. Lorsque le jeu est en pause, aucune animation ou autre changement ne peut intervenir.

Exemple :
if (IsGamePaused() == 1) UnPauseGame();

reprendra le jeu s'il était en pause.

Voir Aussi : GUI.Visible

IsInterfaceEnabled

IsInterfaceEnabled()
Retourne 1 si l'interface du joueur est actuellement disponible, sinon 0. L'interface de l'utilisateur est désactivée lorsque le curseur est en mode d'attente - c'est-à-dire lorsque le personnage est en déplacement bloquant, ou autre action bloquante. (Blocking)

Exemple :
if (IsInterfaceEnabled())
DisableInterface();

désactivera l'interface d'utilisateur si elle était activée.

Voir Aussi : DisableInterface, EnableInterface

IsInteractionAvailable

IsInteractionAvailable (int x, int y, int mode)
Vérifie si une interaction serait déclenchée lors d'un clic à l'écran aux coordonnées (X,Y) avec un mode de curseur MODE.

Cette fonction est très similaire à ProcessClick, excepté qu'au lieu de traiter des interactions elles-mêmes, elle retourne simplement 1 si quelque chose se produisait, ou 0 si unhandled_event était appelée.

Ceci est utile pour activer des options dans un GUI basé sur des verbes, par exemple.

Exemple :
if (IsInteractionAvailable(mouse.x,mouse.y, eModeLookat) == 0)
Display("Regarder ici n'aurait aucun effet.");

Voir Aussi : InventoryItem.IsInteractionAvailable, ProcessClick

IsKeyPressed

IsKeyPressed (int numerotouche)
Vérifie si la touche du clavier spécifiée est actuellement pressée ou non. Vous pouvez utiliser ceci pour déplacer un objet lorsque le joueur appuie sur la flèche de bas, par exemple.

NUMERCOTOUCHE est une des valeurs ASCII, respectant certaines limites : puisque la fonction vérifie la pression ou non de la touche, vous NE POUVEZ PAS passer des valeurs correspondant à Ctrl+(A-Z) ou Alt+(A-Z) (puisque ce sont des combinaisons de touches). Vous pouvez, cependant, utiliser des valeurs particulières listées au bas de la page dédiée.

Retourne 1 si la touche est actuellement pressée, sinon 0

NOTE : Le clavier numérique a des valeurs variables entre IsKeyPressed et on_key_press. Avec IsKeyPressed, le clavier numérique utilise toujours des valeurs entre 370 et 381. on_key_press, cependant, considère des valeurs différentes si Verr Num (Num Lock) est activé puisque les touches pressées sont interprétées comme les touches de chiffres plutôt que comme les touches de flèches.

Exemple :
if (IsKeyPressed(372) == 1)
cEgo.Walk(character[EGO].x, character[EGO].y+3);

déplacera le personnage EGO de 3 pixels vers le haut lorsque la touche haut sera pressée.

Voir Aussi : Mouse.IsButtonDown

IsTimerExpired

bool IsTimerExpired (int id_timer)
Vérifie si le timer ID_TIMER est dépassé. Si le délai défini par SetTimer est expiré, retourne true . Sinon, retourne false .

Notez que cette fonction ne retournera true qu'une seule fois - après cela, le statut du timer passe à OFF ce qui fait qu'il retournera toujours false jusqu'à ce qu'il soit redémarré.

Exemple : (dans repeatedly_execute)
if (IsTimerExpired(1)) {
  Display("Timer 1 expiré");
}

affichera un message lorsque le timer 1 aura expiré et seulement une fois.

Voir Aussi : SetTimer

IsTranslationAvailable

IsTranslationAvailable ()
Informe si le joueur utilise une traduction du jeu ou non.

Retourne 1 si une traduction est utilisée, sinon 0.

Voir Aussi : GetTranslation, Game.TranslationFilename

MoveCharacterToHotspot

Cette fonction est désormais obsolète. Utilisez Character.Walk à la place.

MoveCharacterToHotspot (CHARID, int hotspot)

Déplace le personnage CHARID depuis sa position actuelle jusqu'à l'endroit “walk-to” du hotspot spécifié. Si le hotspot n'a pas d'endroit “walk-to”, rien n'arrivera.

Ceci est un appel bloquant (blocking) - le contrôle n'est rendu au script qu'une fois que le personnage a atteint sa destination.

Exemple :

MoveCharacterToHotspot(EGO,6);

déplacera le personnage EGO jusqu'au point “walk-to” du hotspot numéro 6.

Voir Aussi : Hotspot.WalkToX, Hotspot.WalkToY, Character.Walk, MoveCharacterToObject

MoveCharacterToObject

Cette fonction est désormais obsolète. Utilisez Character.Walk à la place.

MoveCharacterToObject (CHARID, int objet)

Déplace le personnage CHARID depuis sa position actuelle jusqu'à l'objet OBJET. Ceci est utile si par exemple vous voulez que le personnage ramasse un objet. Ceci est un appel bloquant (blocking) - le contrôle n'est rendu au script qu'une fois que le personnage a atteint sa destination.

Exemple :

MoveCharacterToObject (EGO, 0);
object[0].Visible = false;

Déplacera le personnage EGO jusqu'à l'objet numéro 0, puis effacera l'objet 0.

Voir Aussi : Character.Walk, MoveCharacterToHotspot

PauseGame

PauseGame ()
Stoppe le processus de la machine, les animations et déplacements du personnage, et tout autre aspect. Ceci a le même effet sur le jeu que lorsqu'une interface script-only s'affiche. Le processus ne reprendra que lorsque la fonction UnPauseGame sera appelée.

NOTE : Lorsque le jeu est en pause, les cycles de jeu continuent à tourner mais aucune animation ni mouvement n'est effectuée. Ainsi, tous les timers ou toute commande Wait() que vous avez lancés continueront à s'exécuter normalement. Exemple :
if (IsKeyPressed(32)==1) PauseGame();

mettra le jeu en pause si le joueur appuie sur la barre d'espace.

Voir Aussi : UnPauseGame

ProcessClick

ProcessClick (int x, int y, CursorMode)
Simule un clic de la souris aux coordonnées (X,Y) de l'écran, dans le mode de curseur spécifié. Toute conséquence prévue sera exécutée. Par exemple,
ProcessClick (100, 50, eModeLook);

simulera un clic de la souris aux coordonnées (100,50) dans le mode Regarder.

NOTE : Cette fonction ignore les interfaces qui se trouvent au point spécifié. C'est-à-dire qu si aux coordonnées que vous avez passées se trouve un bouton d'interface, le jeu se comportera comme si on avait cliqué sous l'interace, à l'écran.

Les modes de curseur disponibles sont ceux définis dans la partie Curseurs de l'éditeur (précédés de eMode). En général, ce sont eModeWalkto, eModeLook, etc.

Exemple :

ProcessClick(mouse.x,mouse.y, eModeLookat);

simulera un clic dans mode de curseur “Regarder” à l'endroit où le curseur se trouve.

Voir Aussi : IsInteractionAvailable, Hotspot.RunInteraction

QuitGame

QuitGame(int prevenir)
Quitte le jeu et retourne au système d'exploitation (OS).

Si PREVENIR vaut 0, cela quittera immédiatement. Si PREVENIR ne vaut pas 0, cela affichera une fenêtre de message demandant à l'utilisateur s'il est sûr de vouloir quitter.

Exemple :
QuitGame(0);

quittera le jeu sans demander au joueur de confirmer.

Voir Aussi : AbortGame

Random

Random (int max)
Retourne un nombre aléatoire entre 0 et MAX. Ceci peut être utile pour divers effets dans votre jeu.

NOTE : L'intervalle de retour est inclusif - c'est-à-dire que si vous appelez Random(3); alors la valeur de retour peut être 0, 1, 2 ou 3.

Exemple :
int alea=Random(2);
if (alea==0) cEgo.ChangeRoom(1);
else if (alea==1) cEgo.ChangeRoom(2);
else cEgo.ChangeRoom(3);

Changera la pièce actuelle pour la pièce 1, 2 ou 3 selon le résultat aléatoire.

RestartGame

RestartGame ()
Redémarre le jeu depuis le début.

Exemple :
if (IsKeyPressed(365) == 1) RestartGame();

redémarrera le jeu si le joueur appuie sur la touche F7.

Voir aussi : SetRestartPoint

RestoreGameDialog

RestoreGameDialog ()
Affiche le dialogue de chargement de jeu, où le joueur peut sélectionner une partie précédemment sauvegardée pour la restaurer.

Le dialogue n'est pas affiché immédiatement, il s'affichera en fait une fois que le script a fini son exécution.

Exemple :

if (IsKeyPressed(363) == 1) RestoreGameDialog();

affichera le dialogue de chargement si le joueur appuie sur la touche F5.

Voir Aussi : RestoreGameSlot, SaveGameDialog

RestoreGameSlot

RestoreGameSlot (int slot)
Charge la position de la partie sauvegardée dans l'emplacement numéro SLOT. Vous voudrez utiliser ces fonctions si par exemple vous voulez que le joueur n'utilise qu'une seule partie sauvegardée plutôt que les 20 habituelles. Si l'emplacement correspondant au numéro est vide, un message d'erreur avertira le joueur mais le jeu continuera. Pour éviter toute erreur, utilisez la fonction GetSlaveSlotDescription pour voir si l'emplacement contient une partie avant de la charger.

NOTE : La partie ne sera pas chargée immédiatement mais seulement lorsque le script aura terminé exécution.

Exemple :
RestoreGameSlot(30);

chargera la partie de l'emplacement 30 si celui-ci n'est pas vide.

Voir Aussi : Game.GetSaveSlotDescription, RestoreGameDialog, SaveGameSlot

RunAGSGame

RunAGSGame (string nomfichier, int mode, int data)
Quitte la partie actuelle, et lance NOMFICHIER à la place. NOMFICHIER doit être un jeu AGS exécutable ou un fichier AC2GAME.AGS, et doit se trouver dans le répertoire courant.

MODE définit la façon dont vous voulez lancer le jeu. Pour le moment les valeurs peuvent être :
0   La partie actuelle est totalement quittée, et le nouveau jeu est exécuté comme s'il avait
été lancé séparemment.
1   Les valeurs GlobalInt sont conservées, ne sont pas remises à 0 pour le nouveau jeu.

DATA vous permet de passer un entier au nouveau jeu. La valeur que vous passez ici sera accessible par le jeu chargé à l'aide de la variable game.previous_game_data .

Les emplacements de sauvegarde seront partagés par les deux jeux, et si vous chargez une partie sauvegardée dans l'autre jeu, elle sera automatiquement chargée.

Gardez à l'esprit que puisque les jeux doivent être dans le même dossier, il partageront aussi les fichiers music.vox, speech.vox et autres. C'est une limite d'utilisation pour cette commande.

NOTE : Le jeu que vous exécutez sera lancé dans la même résolution et profondeur des couleurs que le jeu actuel ; si vous ne considérez pas la profondeur des couleurs, de mauvaises surprises pourraient se présenter.

NOTE: Assurez-vous que le jeu que vous voulez lancer a un nom de fichier de 8 caractères ou moins, ou cette commande échouera dans la machine DOS.

NOTE: Le jeu que vous voulez lancer doit avoir été créé avec la même version d'AGS que celui à partir duquel il est lancé. (version 2.xy - X doit être le même pour les deux jeux).

Exemple :

RunAGSGame ("MonJeu.exe", 0, 51);

lancera le jeu MonJeu, en lui passant la valeur 51.

SaveGameDialog

SaveGameDialog ()
Affiche le dialogue de sauvegarde, où le joueur peut sauvegarder sa progression dans la partie actuelle. S'il choisissent de sauvegarder, alors la position dans le jeu sera sauvée.

NOTE: Le dialogue ne s'affichera pas directement ; il ne sera montré que lorsque le script aura terminé son exécution.

Exemple :
if (keycode == 361) SaveGameDialog();

affichera le dialogue de sauvegarde si le joueur appuie sur la touche F3.

Voir Aussi : RestoreGameDialog, SaveGameSlot

SaveGameSlot

SaveGameSlot (int slot, string description)
Sauvegarde la progression de la partie actuelle dans l'emplacement spécifié par SLOT, en utilisant DESCRIPTION comme texte de description pour la sauvegarde. Soyez prudent en utilisant cette fonction, car vous pourriez écraser une des parties sauvées par le joueur par mégarde.

La fonction SaveGameDialog utilise les emplacements numérotés de 1 à 20, donc si vous ne voulez pas pas interférer avec les sauvegardes du joueur, vous devriez utiliser des emplacements supérieurs à 100.

NOTE : La partie ne sera pas sauvegardée immédiatement ; la fonction attendra que le script ait fini son exécution avant de sauvegarder.

Exemple :
SaveGameSlot(30, "Sauver partie");

sauvera la progression de la partie actuelle dans l'emplacement 30 avec la description “Sauver partie”.

Voir Aussi : DeleteSaveSlot, RestoreGameSlot, SaveGameDialog

SaveScreenShot

SaveScreenShot (string nomfichier)
Prend une capture d'écran et la sauve sur le disque. Le NOMFICHIER doit se terminer par ”.BMP” ou ”.PCX”, qui sont les types de fichiers qui peuvent être sauvés. Retourne 1 si la capture a été correctement sauvée, ou 0 si une extension de fichier invalide a été spécifiée.

NOTE : La capture d'écran sera sauvée dans le dossier de sauvegarde (Saved Game folder).

NOTE : Cette commande peut s'avérer lente si vous utilisez le pilote graphique Direct3D.

Exemple :
String input = Game.InputBox("Entrez le nom du fichier :");
input = input.Append(".pcx");
SaveScreenShot(input);

demandera au joueur un nom de fichier et sauvera la capture d'écran dans le fichier entré par le joueur.

Voir Aussi : DynamicSprite.SaveToFile

SetAmbientTint

SetAmbientTint(int rouge, int vert, int bleu, int saturation, int luminosite)
Teinte tous les objets et personnages à l'écran en (ROUGE, VERT, BLEU) à une saturation de SATURATION pour-cent.

Ceci vous permet d'appliquer une teinte globale à tous les éléments à l'écran. Les paramètres ROUGE, VERT et BLEU vont de 0 à 255, et définissent la couleur de teinte.

Le paramètre SATURATION définit le taux d'application de la teinte, et va de 0 à 100. Une saturation de 100 recolorisera entièrement les sprites dans la couleur spécifiée, et une saturation de 1 leur donnera une teinte très faible dans la couleur spécifiée.

Le paramètre LUMONISITE vous permet d'ajuster la brillante des sprites du même coup. Il va de 0 à 100. Passer 100 dessinera les sprites à une brillance normale. Des nombres inférieurs assombrira les images en conséquence, jusqu'à 0 qui les dessinera entièrement noires.

La teinte appliquée par cette fonction est globale. Pour l'annuler, appeler cette commande une nouvelle fois mais en spécifiant une saturation de 0.

NOTE : Cette fonction marche uniquement avec des jeux hautes-couleurs et des sprites hautes-couleurs.

NOTE : Cette fonction remplace tout niveau de luminosité ou de teinte propre à une région à l'écran.

Exemple :
SetAmbientTint(0, 0, 250, 30, 100);

teintera tout ce qui se trouve à l'écran dans une nuance de bleu.

Voir Aussi : DrawingSurface.DrawImage, Character.Tint, Object.Tint

SetGameOption

SetGameOption (option, int valeur)
Change une des options du jeu, initialement définie dans le paneau des Réglages du Jeu de l'éditeur AGS (Game Settings).

OPTION spécifie quelle option doit être changée, et VALEUR est sa nouvelle valeur. Les valeurs pour OPTIONS peuvent être :

Option Valeurs

OPT_WALKONLOOK Marcher jusqu'au hotspot en mode Regarder (0 ou 1)

OPT_DIALOGOPTIONSGUI Options de dialogue pour GUI (0 = aucune, sinon nom/numéro du GUI)

OPT_ANTIGLIDE Mode Anti-glide (0 ou 1)

OPT_DIALOGOPTIONSGAP Pixels entre les choix des dialogues (0 = aucun, sinon nombre de pixels)

OPT_WHENGUIDISABLED Lorsque le GUI est désactivé, 0 = grisé, 1 = noir, 2 = inchangé, 3 = non-affiché

OPT_ALWAYSSPEECH Toujours affiché le texte comme du discours (0 ou 1)

OPT_PIXELPERFECT Détection des clics au pixel près (0 ou 1)

OPT_NOWALKMODE Ne pas déplacer automatiquement le personnage en mode Marche (0 ou 1)

OPT_FIXEDINVCURSOR Ne pas utiliser les icônes d'inventaire comme curseurs (0 ou 1)

OPT_DONTLOSEINV Ne pas perdre automatiquement les objets de l'inventaire (0 ou 1)

OPT_TURNBEFOREWALK Les personnages tournent avant de commencer à marcher (0 ou 1)

OPT_HANDLEINVCLICKS Gérer les clics sur l'inventaire dans le script (0 ou 1)

OPT_MOUSEWHEEL Activer la gestion de la molette de la souris (0 ou 1)

OPT_DIALOGNUMBERED Numéroter les choix des dialogues (0 ou 1)

OPT_DIALOGUPWARDS Les choix des dialogues surlignent le GUI (0 ou 1)

OPT_CROSSFADEMUSIC Fondre les musiques (0 = non, 1 = lent, 2 = moins lent, 3 = moyen, 4 = rapide)

OPT_ANTIALIASFONTS Rendu anti-alias pour les polices TTF (0 ou 1)

OPT_THOUGHTGUI Penser utilise des bulles GUI (nom/numéro du GUI) Thought uses bubble GUI (GUI name/number)

OPT_TURNWHENFACING Les personnages se tournent en direction (0 ou 1)

OPT_LIPSYNCTEXT Synchronisation des lèvres activée ou non (1 ou 0)

OPT_RIGHTTOLEFT Ecriture du texte de droite à gauche (0 ou 1)

OPT_MULTIPLEINV Possibilité d'afficher plusieurs inventaires (0 ou 1)

OPT_SAVEGAMESCREENSHOTS Sauver les captures d'écran dans les parties sauvegardées (0 ou 1)

OPT_PORTRAITPOSITION Côté du portrait dans les dialogues (0 = gauche, 1 = droite, 2 = alterné, 3 = xpos)

Les réglages du jeu qui ne sont pas listés ici ont soit une commande séparée pour les changer (comme SetSpeechStyle), ou ne peuvent simplement pas être changés lorsque le jeu est lancé (comme Letterbox Mode).

Cette commande retourne l'ancienne valeur du réglage.

Exemple :

SetGameOption (OPT_PIXELPERFECT, 0);

désactivera la détection précise des clics.

Voir Aussi : GetGameOption, SetSpeechStyle, SetTextWindowGUI

SetGameSpeed

SetGameSpeed (int nouvelle_vitesse)
Définit la fréquence maximum d'images par seconde à NOUVELLE_VITESSE images par seconde, ou aussi près que possible de cette vitesse. La fréquence par défaut est de 40 fps, mais vous pouvez accélérer ou ralentir le jeu en utilisant cette fonction. Notez que cette vitesse est aussi la fréquence à laquelle les fonctions Repeatedly_Execute seront déclenchées.

La NOUVELLE_VITESSE doit valoir entre 10 et 1000. Si ce n'est pas le cas, la vitesse sera ajustée à 10 ou 1000. Notez que si vous définissez une vitesse que l'ordinateur de l'utilisateur ne supporte pas (par exemple, un 486 ne pourra pas supporter un fps de 80), alors le jeu ira aussi vite que possible.

NOTE : Puisque le curseur de la souris est rafraîchi à la fréquence du jeu, à de très basses vitesses, comme un fps de 10 à 20, la souris ne semblera pas répondre correctement.

NOTE : Si vous donnez la valeur true à la propriété System.VSync, la vitesse du jeu sera limitée selon le taux de rafraîchissement de l'écran, et vous ne pourrez alors pas la définir à plus de 60-85 (en fonction du taux de rafraîchissemment de l'écran du joueur).

Exemple :
SetGameSpeed(80);

définira la vitesse du jeu à 80.

Voir Aussi : GetGameSpeed

SetGlobalInt

SetGlobalInt (int index, int valeur)
Définit la variable globale INDEX à VALEUR. Vous pouvez récupérer cette valeur depuis d'autres scripts en utilisant GetGlobalInt.

Il y a 500 variables globales disponibles, indexées de 0 à 499.

NOTE : Les variables globales entières (GlobalInts) sont désormais obsolètes. Utilisez plutôt les variables globales à la place, qui vous permettent de nommer vos variables.

Exemple :
SetGlobalInt(10,1);

définira la valeur de la variable globale entière 10 à 1.

Voir Aussi : GetGlobalInt

SetGraphicalVariable

SetGraphicalVariable(string nom_variable, int valeur);
Donnera la valeur VALEUR à la variable d'interaction NOM_VARIABLE. Ceci vous permet de changer les valeurs des variables définies dans la fenêtre d'interaction de l'éditeur.

NOTE : Cette commande est désormais obsolète, et n'est fournie que par soucis de compatibilité avec AGS 2.x. Lorsque vous écrivez de nouveaux codes, utilisez plutôt les variables globales.

Exemple :
SetGraphicalVariable("rocher enlevé", 1);

donnera la valeur 1 à la variable de l'éditeur d'interaction “rocher enlevé”.

Voir Aussi : GetGraphicalVariable

SetMultitaskingMode

SetMultitaskingMode (int mode)
Vous permet de définir ce qui se passera quand l'utilisateur réduira votre jeu.

Si MODE vaut 0 (par défaut), alors si l'utilisateur utilise Alt+Tab sous votre jeu, ou clique sur une autre fenêtre, le jeu sera mis en pause et ne reprendra pas jusqu'à ce qu'il remette le jeu au premier plan.

Si MODE vaut 1, alors le jeu continuera de tourner en arrière-plan si l'utilisateur le réduit (utile si, par exemple, vous créez juste une sorte de lecteur de musiques avec AGS).

Notez que le mode 1 ne fonctionne pas avec certaines cartes graphiques en mode plein écran, vous ne devriez donc considérer que ceci ne fonctionne que lorsque votre jeu tourne en mode fenêtre.

Plateformes qui supportent le multitâche

Windows: Oui MS-DOS: Non Linux: Oui MacOS: Oui

Exemple :

SetMultitaskingMode (1);

signifiera que le jeu devra continuer à tourner en arrière-plan.

SetRestartPoint

SetRestartPoint ()
Change le point de départ du jeu pour la position actuelle. Cela signifie qu'à partir de ce moment-là, si le joueur choisit de redémarrer le jeu, il recommencera à partir d'ici.

Cette fonction est utile si le point de départ par défaut ne fonctionne pas correctement dans votre jeu - utilisez cette fonction seulement pour le déplacer.

NOTE : Le point de départ ne peut pas être redéfini lorsqu'un script est en exécution – ainsi, lorsque vous appelez cette fonction, le point ne sera véritablement redéfini que lors du prochain cycle qui ne présente pas de script bloquant en arrière-plan.

Voir aussi : RestartGame

SetSaveGameDirectory

static bool Game.SetSaveGameDirectory(string repertoire)
Change le répertoire où les fichiers de sauvegarde du jeu sont stockées pour repertoire . Si le dossier spécifié n'existe pas, AGS tentera de le créer.

Vous ne pouvez pas utiliser de chemins de dossier complets avec cette commande (par exemple C:\Jeux\Cool\Sauvegardes), parce que le joueur peut avoir installé votre jeu dans n'importe quel dossier, et qu'il peut ne pas être sous Windows.

Ainsi, seules deux types de chemins sont supportés : 1. Les chemins relatifs (par exemple “Sauvegardes”). Ceci créea un dossier “Sauvegardes” dans le dossier du jeu. 2. Le mot-clé spécial $MYDOCS$ qui vous permet de créer un dossier pour les sauvegardes du jeu dans le dossier principal des documents de l'utilisateur. Sur Vista, correspond au dossier “Saved Games” ; sur Windows XP et avant, correspond à “Mes Documents”. Sur Mac et Linux, pointe simplement le dossier du jeu pour le moment.

Retourne true si le répertoire de sauvegarde a correctement été modifié ; false sinon.

NOTE: Il est recommandé de ne pas utiliser cette fonction. A la place, modifiez la propriété “Save games folder name” (”Nom du dossier de sauvegarde”) dans l'onglet General Settings (Réglages généraux) de l'éditeur, qui vous permet à l'Explorateur de Jeu Vista (Vista's Game Explorer) de détecter les sauvegardes de jeu afin d'éviter des problèmes en tentant d'écrire dans le dossier Program Files.

Exemple :
Game.SetSaveGameDirectory("$MYDOCS$/Sauvegardes De Mon Super Jeu");

changera le répertoire de sauvegarde pour “Sauvegardes De Mon Super Jeu” dans Mes Documents, en créant le dossier s'il n'existe pas (peut être pratique dans game_start).

Voir aussi : ListBox.FillSaveGameList, RestoreGameDialog

SetTextWindowGUI

SetTextWindowGUI (int gui)
Change le GUI utilisé comme fenêtre de texte pour le GUI spécifié. Ceci change le réglage “Fenêtres de texte utilisent GUI” dans l'éditeur.

Vous pouvez passer -1 en numéro de GUI pour réutiliser la fenêtre par défaut.

Exemple :
SetTextWindowGUI (4);

utilisera le GUI 4 pour afficher les fenêtres de texte à l'avenir.

SetTimer

SetTimer (int id_timer, int delai)
Lance le timer ID_TIMER - sera décompté à chaque cycle du jeu (normalement 40 fois par seconde), jusqu'à la fin du DELAI (en nombre de cycles de jeu), après quoi il sera arrêté. Vous pouvez vérifier si le timer est expiré en appelant la fonction IsTimerExpired.

Donnez la valeur 0 à DELAI pour désactiver le timer qui tourne actuellement.

Il y a 20 timers disponibles, ID_TIMER allant de 1 à 20.

Exemple :
SetTimer(1,1000);

dira au timer 1 d'expirer après 1000 cycles de jeu.

Voir Aussi : IsTimerExpired

SkipUntilCharacterStops

SkipUntilCharacterStops(CHARID)
En jeu, saute la séquence de déplacement du personnage spécifié, et un script bloquant est alors exécuté, ou une boîte de message affichée.

Cette commande permet de reproduire la fonctionnalité dans les jeux comme The Longest Journey, où le joueur peut appuyer sur Echap pour que le personnage arrive directement à destination. Cela sert comme option manuelle, pour vous permettre de donner une vitesse de déplacement relativement lente au personnage principal, sans que le joueur s'impatiente pour autant en attendant que le personnage aille d'un point A à un point B.

Si le personnage spécifié n'est pas en déplacement lorsque cette fonction est appelée, rien ne se passe.

Exemple : (dans on_key_press)
if (keycode == 27) SkipUntilCharacterStops(EGO);

Ceci signifie que si le joueur appuie sur Echap, le jeu sautera le déplacement du personnage EGO pour reprendre ensuite, ou sera interrompu par une commande Display ou encore par une cutscene (cinématique) bloquante.

Voir Aussi : StartCutscene

StartCutscene

StartCutscene(CutsceneSkipType)
Marque le début d'une cutscene (cinématique). Une fois que le script a passé ce point, le joueur peut choisir de passer cette partie en appuyant sur une touche ou sur le bouton de la souris. Ceci est utile pour des choses comme des séquences d'introductions, que vous voulez que le joueur puisse passer puisqu'il les aura déjà vues.

CutsceneSkipType détermine comment la cutscene peut être passée :
eSkipESCOnly
seulement en appuyant sur Echap
eSkipAnyKey
en appuyant sur n'importe quelle touche
eSkipMouseClick
en cliquant sur le bouton de la souris
eSkipAnyKeyOrMouseClick
en appuyant soit sur une touche, soit sur le bouton de la souris
eSkipESCOrRightButton
en appuyant sur Echap ou en faisant un clic droit

Vous devez également marqué la fin de la cutscene avec la commande EndCutscene.

Faîtes très attention à l'endroit où vous placez la command EndCutscene correspondante. Le script doit arriver à EndCutscene dans son ordre d'exécution normal pour que le saut puisse fonctionner - sinon, lorsque le joueur appuyera sur Echap, le jeu pourra planter.

Voir Aussi : EndCutscene, SkipUntilCharacterStops, Game.InSkippableCutscene, Game.SkippingCutscene.

UpdateInventory

UpdateInventory ()
Met à jour l'affichage de l'inventaire à l'écran. Si vous ajoutez ou enlevez un objet d'inventaire manuellement (c'est-à-dire en utilisant le tableau InventoryQuantity plutôt que les fonction AddInventory/LoseInventory), l'affichage ne sera pas automatiquement mis à jour. Dans ce cas appelez cette fonction après avoir opéré vos changements, pour mettre à jour ce qui sera affiché au joueur.

Notez qu'utiliser cette fonction redéfinira l'odre dans lequel les objets sont affichés dans l'inventaire, en celui qui a été créé dans l'éditeur.

Voir Aussi : Character.AddInventory, Character.LoseInventory, Character.InventoryQuantity

UnPauseGame

UnPauseGame ()
Reprend le jeu.

Exemple :
if (IsGamePaused() == 1)
UnPauseGame();

reprendra le jeu s'il était en pause.

Voir Aussi : PauseGame

Wait

Wait (int temps)
Marque une pause dans l'exécution du script et laisse le jeu continuer durant TEMPS cycles de jeu. La norme est de 40 cycles/seconde (à moins que vous ne changiez ce paramètre avec SetGameSpeed), donc utiliser une valeur de 80 aura pour effet dattendre 2 secondes. Notez qu'aucun autre script ne peut être exécuté tant que la fonction Wait agit en fond.

Exemple :
cEgo.Walk(120, 140, eBlock, eWalkableAreas);
Wait(80);
cEgo.FaceLocation(1000,100);

déplacera le personnage EGO aux coordonnées (120,140), attendra qu'il y soit rendu puis attendra 2 secondes (80 cycles) pour enfin le tourner vers la droite.

Voir Aussi : WaitKey, WaitMouseKey

WaitKey

WaitKey (int temps)
Marque une pause dans l'exécution du script et laisse le jeu continuer jusqu'à ce que soit :

(a) TEMPS cycles de jeu se sont écoulés, soit

(b) le joueur appuie sur une touche

Retourne 0 si le temps s'est écoulé, ou 1 si le joueur a interrompu la pause.

Exemple :
WaitKey(200);

marquera une pause dans le script et attendra que 5 secondes soient passées ou bien que le joueur ait pressé une touche pour reprendre.

Voir Aussi : Wait, WaitMouseKey

WaitMouseKey

WaitMouseKey (int temps)
Marque une pause dans l'exécution du script et laisse le jeu continuer jusqu'à ce que soit :

(a) TEMPS cycles de jeu se sont écoulés, soit

(b) le joueur appuie sur une touche, soit

© le joueur clique avec la souris

Retourne 0 si le temps s'est écoulé, ou 1 si le joueur a interrompu la pause.

Exemple :
WaitMouseKey(200);

marquera une pause dans le script et attendra que 5 secondes soient passées ou bien que le joueur ait pressé une touche ou cliqué avec la souris pour reprendre.

Voir Aussi : Wait, WaitKey

CharacterCount

(Anciennement compris dans GetGameParameter, désormais obsolète)

readonly static int Game.CharacterCount

Retourne le nombre de personnages dans le jeu.

Ceci est utile pour les modules de script si vous devez itérer tous les personnages pour une raison quelconque.

Exemple :

Display("Le jeu a %d personnages", Game.CharacterCount);

DialogCount

readonly static int Game.DialogCount
Retourne le nombre de dialogues dans le jeu.

Ceci est utile pour les modules de script si vous devez itérer tous les dialogues pour une raison quelconque. Les dialogues sont numérotés de 0 à DialogCount - 1.

Exemple :
Display("Le jeu a %d dialogues.", Game.DialogCount);

Compatibilité : Supporté par AGS 3.0.2 et les versions plus récentes.

FileName

readonly static String Game.FileName
Retourne le nom de fichier qui a lancé le jeu. Cela correspondra généralement au fichier EXE, mais peut aussi correspondre à “ac2game.dat” si vous exécutez le jeu en utilisant ACWIN.EXE.

Exemple :
Display("Le fichier principal du jeu est : %s", Game.FileName);

affichera le fichier du jeu.

Voir aussi : Game.Name

FontCount

readonly static int Game.FontCount
Retourne le nombre de polices dans le jeu.

Ceci est utile pour les modules de script si vous avez besoin d'itérer toutes les polices pour certaines raisons.

Exemple :
Display("Le jeu a %d polices.", Game.FontCount);

GlobalMessages

(Anciennement fonction globale GetMessageText, désormais obsolète)

readonly static String Game.GlobalMessages[int message]

Retourne le texte du message global spécifié. Le numéro du message est un des numéros de message global, allant de 500 à 999.

Si un numéro de message invalide est entré, null sera retourné. Sinon, le contenu du message sera retourné.

Exemple :

String message = Game.GlobalMessages[997];
Display("Le message global 997 dit : %s", message);

affichera le message global 997.

GlobalStrings

(Anciennement GetGlobalString, désormais obsolète) (Anciennement SetGlobalString, désormais obsolète)

static String Game.GlobalStrings[index]

Retourne/Définit la string globale index. Les strings globales vous permettent de partager aisément des variables strings entre les scripts. Il y a 50 strings globales disponibles, les valeurs de index allant de 0 à 49.

Exemple :

Game.GlobalStrings[15] = "Joe";
Display("La string globale 15 vaut maintenant : %s", Game.GlobalStrings[15]);

donnera la valeur “Joe” à la string globale 15.

Voir Aussi : GetGlobalInt, SetGlobalInt

GUICount

(Anciennement compris dans GetGameParameter, désormais obsolète)

readonly static int Game.GUICount

Retourne le nombre de GUIs dans le jeu.

Ceci est utile pour les modules de script si vous devez itérer tous les GUIs pour certaines raisons. Les GUIs sont numérotés de 0 à GUICount - 1.

Exemple:

Display("Le jeu a %d GUIs.", Game.GUICount);

InSkippableCutscene

(Anciennement game.in_cutscene, désormais obsolète)

static bool Game.InSkippableCutscene

Retourne si le jeu est actuellement entre une StartCutscene et une EndCutscene, et ainsi si le joueur est est autorisé à passer ou non cette partie du jeu.

Lorsque le joueur choisit de passer une cutscene, tout le code de script est exécuté comme d'habitude, mais toute commande bloquante est exécutée sans les délais habituels des cycles du jeu. Ainsi vous ne devriez normalement jamais avoir à utiliser cette propriété puisque les cutscenes sont toutes censées êtres gérées automatiquement, mais cela peut s'avérer utile dans des modules de script.

NOTE : Ceci est une fonction statique et doit donc être précédée de Game., voir l'exemple suivant.

Exemple :

if (Game.InSkippableCutscene)
{
  Display("Le joueur ne verra peut-être jamais ce message !");
}

affichera un message si nous sommes dans une cutscene.

Compatibilité : Supportée par AGS 3.0.1 et les versions plus récentes.

Voir aussi : StartCutscene, EndCutscene, Game.SkippingCutscene

InventoryItemCount

(Anciennement compris dans GetGameParameter, désormais obsolète)

readonly static int Game.InventoryItemCount

Retourne le nombre d'objets d'inventaires dans le jeu. Ceci correspond au nombre total d'objets que vous avez créé dans l'onglet Inventory Items de l'éditeur, pas au nombre dont le joueur dispose actuellement.

Exemple :

Display("Le jeu a %d objets d'inventaire.", Game.InventoryItemCount);

MouseCursorCount

readonly static int Game.MouseCursorCount
Retourne le nombre de curseurs dans le jeu.

Ceci est utile dans les modules si vous avez besoin d'itérer tous les curseurs pour une raison quelconque.

Exemple:
Display("Le jeu a %d curseurs.", Game.MouseCursorCount);

Name

static String Game.Name
Retourne/définit le nom du jeu. Ceal est initiallement défini dans l'onglet General Settings de l'éditeur, mais vous pouvez le changer durant l'exécution pour changer le titre de la fenêtre de votre jeu.

Exemple :
Display("Le nom du jeu est : %s", Game.Name);

affichera le nom du jeu.

Voir aussi : Game.FileName

NormalFont

(Anciennement global function SetNormalFont, désormais obsolète)

static FontType Game.NormalFont

Retourne/Définit la police utilisée pour tout texte du jeu, sauf les discours. Le numéro de police doit être un numéro présent dans l'onglet Fonts de l'éditeur.

Plus spécifiquement, AGS utilise la police normale pour les choses suivantes :

  • Display (fonction)
  • DisplayTopBar (fonction)
  • le texte des options de dialogue
  • les dialogues par défaut de sauvegarde et de chargement

La police normale vaut 0 par défaut.

Exemple:

Game.NormalFont = eFontSpecial;

changera la police normal pour la police “Special”.

Voir aussi : Game.SpeechFont

SkippingCutscene

(Anciennement game.skipping_cutscene, désormais obsolète)

static bool Game.SkippingCutscene

Vous permet de savoir si le joueur a choisi de passer la cutscene en cours. Cette fonction retourne true si le jeu est entre une commande StartCutscene et une commande EndCutscene et si le joueur a choisi de passer.

Bien que le passage des cutscene soit géré automatiquement par AGS, vous pouvez utiliser cette propriété pour optimiser le processus en ignorant de longs blocs de code qui ne sera pas exécuté si une cutscene est passée.

NOTE : Ceci est une fonction statique, vous devez donc la faire précéder de Game., voir l'exemple suivant.

Exemple :

if (!Game.SkippingCutscene)
{
  aScaryMusic.Play();
  Wait(100);
  Game.StopAudio();
}

ne jouera la music que si le joueur ne passe pas la scène.

Compatibilité : Supporté par AGS 3.0.1 et les versions plus récentes.

Voir aussi : StartCutscene, EndCutscene, Game.InSkippableCutscene

SpeechFont

(Anciennement global function SetSpeechFont, désormais obsolète)

static FontType Game.SpeechFont;

Retourne/définit la police utiliser pour le discours des personnages. Le numéro de police que vous entrez doit correspondre à un nombre présent dans l'onglet Fonts de l'éditeur.

Par défaut la Police de Discours vaut 1.

Exemple :

Game.SpeechFont = eFontStandard;

changera la police de discours pour “Standard”.

Voir aussi : Game.NormalFont

SpriteHeight

(Anciennement compris dans GetGameParameter, désormais obsolète)

readonly static int Game.SpriteHeight[int slot]

Retourne la hauteur de la sprite spécifiée.

La taille sera retournée dans les coordonnées de résolution habituelle 320×200. Si un numéro de sprite invalide est entré, retournera 0.

Exemple :

Display("La sprite de l'objet 0 a une taille de %d x %d.", Game.SpriteWidth[object[0].Graphic],
                                               Game.SpriteHeight[object[0].Graphic]);

Voir aussi : Game.SpriteWidth

SpriteWidth

(Anciennement compris dans GetGameParameter, désormais obsolète)

readonly static int Game.SpriteWidth[int slot]

Retourne la largeur de la sprite spécifiée.

La taille sera retournée dans les coordonnées de résolution habituelle 320×200. Si un numéro de sprite invalide est entré, retournera 0.

Exemple :

Display("La sprite de l'objet 0 a une taille de %d x %d.", Game.SpriteWidth[object[0].Graphic],
                                               Game.SpriteHeight[object[0].Graphic]);

Voir aussi : Game.SpriteHeight

TranslationFilename

(Anciennement GetTranslationName, désormais obsolète)

readonly static String Game.TranslationFilename;

Retourne le nom du fichier de traduction actuel (sans l'extension ”.tra”). Ceci peut être utile si vous voulez utiliser un graphisme différent à un endroit selon la traduction qui a cours.

Si aucune traduction n'est utilisée, une ligne vide est retournée.

Exemple :

if (Game.TranslationFilename == "Allemand") {
Display("Vous utilisez une traduction allemande.");
}

Voir Aussi : IsTranslationAvailable

UseNativeCoordinates

readonly static bool Game.UseNativeCoordinates
Retourne si le jeu utilise les coordonnées natives ou non. S'il les utilise, alors toutes les variables X, Y, Top, Bottom, Width et Height dans le jeu auront des valeurs correspondant à la résolution du jeu.

Si cette propriété vaut false , alors le jeu s'exécute en mode rétro-comptabilité où toutes les coordonnées sont en basse résolution.

Si la résolution du jeu est de 320×200 ou 320×240, ce paramètre n'a pas d'effet.

Cette propriété est en lecture seule ; vous ne pouvez pas la changer en cours d'exécution.

Exemple :
if (Game.UseNativeCoordinates)
{
  Display("Le joueur se trouve à %d, %d -- VRAIMENT !", player.x, player.y);
}
else
{
  Display("Le joueur se trouve à %d, %d dans le système old-school", player.x, player.y);
}

Compatibilité : Supporté par AGS 3.1.0 et les versions plus récentes.

ViewCount

(Anciennement compris dans GetGameParameter, désormais obsolète)

readonly static int Game.ViewCount

Retourne le nombre de vues dans le jeu.

Ceci est pratique pour les modules de script si vous devez itérer sur toutes les vues pour une raison quelconque. Les vues sont numérotées de 1 à ViewCount.

Exemple:

Display("Il y a %d vues dans le jeu.", Game.ViewCount);


gui

Table des matières
    • GUI : propriétés et fonctions
      • Centre
      • GetAtScreenXY
      • SetPosition
      • SetSize
      • BackGroundGraphic
      • Clickable
      • ControlCount
      • Controls
      • Propriété
      • ID
      • Transparency
      • Visible
      • Width
      • X
      • Y
      • ZOrder

GUI : propriétés et fonctions

Centre

(Anciennement CentreGUI, désormais obsolète)

GUI.Centre()

Centre le GUI au milieu de l'écran. Utile si vous l'avez bougé avec la fonction SetPosition et que vous voulez qu'il se replace au centre.

Exemple :

gControlpanel.Centre();

Centrera le GUI CONTROLPANEL au milieu de l'écran.

Voir aussi : GUI.SetPosition

GetAtScreenXY

(Anciennement GetGUIAt, désormais obsolète)

static GUI* GUI.GetAtScreenXY(int x, int y)

Vérifie s'il y a un GUI affiché à l'écran aux coordonnées (X,Y). Si c'est le cas, ce GUI est retourné. Si deux GUIs se supperposent, c'est celui qui se trouve le plus au premier plan qui sera concerné – cet état peut être changé avec la propriété GUI.Zorder. S'il n'y a aucun GUI affiché et cliquable aux coordonnées énoncées, null est retourné. Si c'est le cas, n'essayez pas de tenter des méthodes ou d'utiliser des propriétés du GUI (puisque ce dernier n'existe pas).

NOTE : Cette commande ne trouvera pas les GUIs qui sont définis comme Non-Clickable (C'est à dire si la case “Cliquable” n'est pas cochée).

Exemple :

GUI *theGui = GUI.GetAtScreenXY(mouse.x, mouse.y);
if (theGui == gInventory) {
Display("GUI d'inventaire à l'endroit où se trouve le curseur.");
}
else if (theGui == null) {
Display("Aucun GUI à l'endroit où se trouve le curseur");
}
else {
Display("GUI numéro %d à l'endroit où se trouve le curseur.", theGui.ID);
}

Affichera le numéro du GUI survolé par le curseur de la souris.

Voir aussi : GUIControl.GetAtScreenXY, GUI.ID, GUI.ZOrder

SetPosition

(Anciennement SetGUIPosition, désormais obsolète)

GUI.SetPosition(int x, int y)

Place le coin supérieur gauche du GUI aux nouvelles coordonnées (X,Y) à l'écran. Cela vous permet de faire bouger dynamiquement les GUI à l'écran pendant que vous êtes en train de jouer. Les coordonnées sont celles de l'écran et non celles de la room, et utilisent la même échelle que dans l'éditeur.

Exemple :

gVerbcoin.SetPosition(mouse.x, mouse.y);

Fera bouger le GUI VERBCOIN vers la position du curseur.

Voir aussi : GUI.Centre, GUI.BackgroundGraphic, GUIControl.SetPosition, GUI.SetSize, GUI.X, GUI.Y

SetSize

(Anciennement SetGUISize, désormais obsolète)

GUI.SetSize(int largeur, int hauteur)

Change la taille du GUI spécifié aux mesures LARGEUR x HAUTEUR Cela peut être utile pour cacher au début du jeu une partie 'avancée' d'un écran d'option du GUI, par exemple. La taille définie est calculée selon la résolution normale du jeu de 320×200 pixels. Définir la taille du GUI à 320×200 obligera le GUI à occuper tout l'écran.

Exemple :

gIconbar.SetSize(160, 100);

Redimensionnera le GUI ICONBAR pour qu'il occupe la moitié de l'écran.

Voir Aussi : GUI.Centre, GUI.BackgroundGraphic, GUIControl.SetPosition, GUI.SetSize, GUI.X, GUI.Y

BackGroundGraphic

(Anciennement SetGUIBackgroundPic, désormais obsolète)

int GUI.BackgroundGraphic

Retourne/Définit l'image de fond du GUI.

Vous pouvez la définir à 0 pour enlever l'image de fond du GUI.

Voir Aussi : GUI.SetPosition, Button.NormalGraphic

Clickable

(Anciennement SetGUIClickable, désormais obsolète)

bool GUI.Clickable

Définit si le GUI est cliquable ou non. Cela vous a le même effet que modifier la case à cocher “Cliquable” dans l'éditeur de GUI.

S'il est définit à 1, le GUI répondra normalement aux clics de souris.

S'il est définit à 0, le GUI ne sera pas cliquable. Cela peut être utile pour un GUI transparent et superposé à d'autres éléments qui affiche des informations, tout en permettant au joueur de cliquer sur ce qui se trouve en dessous de ce GUI (un personnage par exemple).

Exemple :

gStatusline.Clickable = false;

rebndra le GUI STATUSLINE comme non cliquable.

Voir Aussi : GUI.GetAtScreenXY

ControlCount

readonly int GUI.ControlCount;
Retourne le nombre de contrôles que contient le GUI. Normalement, vous n'aurez pas besoin de cette propriété, mais dans certaines circonstances vous pourriez vouloir scruter tous les contrôles du GUI, et cela vous permet de déterminer où vous arrêter.

Exemple :
int i = 0;
while (i < gInventory.ControlCount) {
  gInventory.Controls[i].Enabled = false;
  i++;
}

Désactive tous les contrôles du GUI INVENTORY.

Voir Aussi : GUI.Controls

Controls

GUIControl* GUI.Controls[index]
Crée une liste à partir de laquelle vous pouvez accéder aux contrôles du GUI par leur numéro d'index. Normalement, vous n'aurez pas besoin faire cela, étant donné que chercher les contrôles par leur nom est beaucoup plus facile ; cependant, si vous avez besoin de le coupler avec du code ancien qui utilise encore les numéros de contrôle, cela peut être utile.

Retourne l'objet GUIControl correspondant à l'index spécifié, ou retourne null si vous avez entré un index de contrôle invalide.

Vous pouvez convertir l'objet retourné dans type spécifique du GUIControl (AsType) en utilisant les propriétés AsButton, AsListBox, etc…

Exemple :
GUIControl *control = gInventory.Controls[4];
if (control == null) {
  Display("Le GUI d'inventaire n'a pas d'élément numéro 4.");
}
else {
  control.Enabled = true;
  control.AsListBox.AddItem("Nouvel élément !!");
}

Renvoie l'élément liste dont l'index est 4 du GUI INVENTORY, et ajoute une ligne à celle-ci. Si le contrôle numéro 4 n'est pas une listbox, vous obtiendrez une erreur “Null Reference”.

Voir Aussi : GUIControl.As*, GUI.ControlCount

Propriété

int GUI.Height
Retourne/Définit la hauteur du GUI. Cela vous permet de changer la hauteur du GUI à l'écran pour donner un effet dynamique.

La hauteur est définie pour la résolution normale de 320 pixels.

Exemple :
Display("La barre d'icônes a une hauteur de %d pixels.", gIconbar.Height);

Indique la hauteur du GUI ICONBAR.

Voir Aussi : GUI.SetSize, GUI.Width

ID

readonly int GUI.ID
Retourne le numéro d'identification du GUI. Il s'agit du numéro défini dans l'éditeur, ce qui est utile si vous avez besoin de manipuler du code ancien qui utilise le numéro des GUI plutôt que leur nom.

Exemple :
SetGUIClickable(gIconbar.ID, 1);
gIconbar.Clickable = false;

Utilisera la fonction obsolète SetGUIClickable pour rendre le GUI ICONBAR cliquable, et ensuite utilise la nouvelle propriété équivalente pour l'empêcher d'être cliquable.

Voir Aussi : GUIControl.ID

Transparency

(Anciennement SetGUITransparency, désormais obsolète)

int GUI.Transparency

Retourne/Définit la transparence du GUI, en pourcentage.

Mettre la valeur à 100 signifie que le GUI est totalement invisible, et faire baisser cette valeur fera varier les différents niveaux de transparence. Mettez-là à 0 pour que le GUI cesse d'être transparent.

NOTE : La transparence ne marche que dans les jeux en haute définition.

NOTE : Utiliser un GUI très transparent peut entraîner un ralentissement de l'ordinateur du joueur.

Quelques arrondissements sont faits de manière interne quand la transparence est enregistrée – de plus, si vous essayez d'obtenir le niveau de transparence juste après l'avoir défini, la valeur que vous récupérerez pourrait ne pas être la même que celle que vous avez entrée au début. De plus, utiliser une boucle (while) avec gInventory.Transparency++; n'est pas recommandé car la boucle cesserai trop rapidement.

Pour faire un fondu entre un GUI activé et un GUI désactivé, l'approche optimale est présentée dans l'exemple suivant :

Exemple :
int trans = gInventory.Transparency;
while (trans < 100) {
  trans++;
  gInventory.Transparency = trans;
  Wait(1);
}

Fera un fondu du GUI INVENTORY jusqu'à ce qu'il devienne invisible.

Voir Aussi : Object.Transparency

Visible

(Anciennement GUIOff, désormais obsolète) (Anciennement GUIOn, désormais obsolète) (Anciennement InterfaceOff, désormais obsolète) (Anciennement InterfaceOn, désormais obsolète) (Anciennement IsGUIOn, désormais obsolète)

bool GUI.Visible

Retourne/Définit si le GUI est visible ou non. Cette propriété agit différemment selon le style d'affichage du GUI (popup par exemple).

Pour un GUI “Normal” ou “Persistent”, cette propriété alterne simplement l'état du GUI de visible à non visible, et n'a pas d'autres effets.

Pour un GUI “Popup modal”, définir la propriété Visible comme true met le le jeu en pause jusqu'à ce que le GUI soit à nouveau effacé en redéfinissant la propriété Visible comme false (par exemple quand le joueur presse un bouton OK, ou fait une action similaire).

Pour un GUI déroulant (”Mouse Ypos”), la propriété Visible ne détermine pas si le GUI peut être vu, mais il définit si le GUI est autorisé à apparaître. Si la propriété Visible est définie comme false, dans ce cas bouger la souris en haut de l'écran n'affichera pas le GUI. Si la propriété est définie comme true, le GUI pourra apparaître.

Exemple :

gSettings.Visible = true;

Activera le GUI SETTINGS.

Voir Aussi : IsGamePaused

Width

int GUI.Width
Retourne/Définit la largeur du GUI. Cela vous permet de changer la hauteur du GUI à l'écran pour donner un effet dynamique.

La largeur est définie pour la résolution normale de 320 pixels.

Exemple :
gInventory.Width += 5;

Augmentera la hauteur du GUI INVENTORY de 5 pixels.

Voir Aussi : GUI.Height, GUI.SetSize

X

int GUI.X
Retourne/Définit la position X du GUI. Cela vous permet de changer position du GUI à l'écran pour donner un effet dynamique.

La position X correspond au côté gauche du GUI, et est comprise entre 0 et 320. Les coordonnées utilisées sont celles de l'écran, pas celles de la pièce, et sont calculées selon la résolution de jeu de 320.

Exemple :
gVerbcoin.X += 5;

Fera bouger le GUI VERBCOIN de 5 pixels vers la droite.

Voir Aussi : GUI.SetPosition, GUI.Y

Y

int GUI.Y
Retourne/Définit la position Y du GUI. Cela vous permet de changer dynamiquement la position du GUI à l'écran.

La position Y correspond au haut du GUI, et est comprise entre 0 et 200 (ou 240, selon la hauteur de la pièce). Les coordonnées utilisées sont celles de l'écran, pas celles de la pièce, et sont calculées selon la résolution de jeu de 320×200.

Exemple :
gVerbcoin.Y += 5;

Fera bouger le GUI VERBCOIN de 5 pixels vers le bas.

Voir Aussi : GUI.SetPosition, GUI.X

ZOrder

(Anciennement SetGUIZOrder, désormais obsolète)

int GUI.ZOrder

Retourne/Définit le ZOrder du GUI. Cela vous permet de changer dynamiquement l'ordre d'affichage des GUIs à l'écran.

Le paramètre du ZOrder est un nombre arbitraire compris entre 0 et 1000. AGS affiche les GUIs dans l'ordre, du plus petit nombre (celui qui se trouvera tout en arrière-plan) au nombre le plus élevé (celui qui se trouvera au tout premier plan).

Exemple :

gStatusline.ZOrder = 0;

Placera le GUI STATUSLINE derrière tous les autres GUIs.

Voir Aussi : GUI.GetAtScreenXY


guicontrol

Table des matières
    • Fonctions et propriétés des contrôles de GUI (GUI control)
      • GetAtScreenXY
      • AsType
      • BringToFront
      • Clickable
      • Enabled
      • Height
      • ID
      • OwningGUI
      • SendToBack
      • SetPosition
      • SetSize
      • Visible
      • Width
      • X
      • Y

Fonctions et propriétés des contrôles de GUI (GUI control)

Cette section liste les fonctions et propriétés communes à tous les types de contrôles GUI. Chaque type de contrôle (Button, ListBox, etc.) possède également sa section spécifique.

GetAtScreenXY

(Anciennement GetGUIObjectAt, désormais obsolète)

static GUIControl* GUIControl.GetAtScreenXY(int x, int y)

Vérifie s'il y a un contrôle GUI aux coordonnées (X,Y) de l'écran. Retourne l'objet contrôle s'il y en a un, ou null sinon. Vous voudrez probablement utiliser cette fonction avec GetGUIAtLocation.

Exemple :

GUIControl *leControle = GUIControl.GetAtScreenXY(mouse.x, mouse.y);
if (leControle == lstPartiesSauvees) {
  Display("La souris survole la liste Parties Sauvées.");
}
else if (leControle == null) {
  Display("La souris ne survole pas de contrôle.");
}
else {
  GUI *surGui = leControle.OwningGUI;
  Display("La souris survole le contrôle numéro %d du GUI numéro %d.", theControl.ID, onGui.ID);
}

affichera le contrôle que survole la souris.

Voir aussi : GUI.GetAtScreenXY

AsType

Button*    GUIControl.AsButton;
InvWindow* GUIControl.AsInvWindow;
Label*     GUIControl.AsLabel;
ListBox*   GUIControl.AsListBox;
Slider*    GUIControl.AsSlider;
TextBox*   GUIControl.AsTextBox;
Convertie un pointeur GUIControl* générique en une variable du type correct, et la retourne. Si le contrôle n'est pas du type requis, retourne null.

Exemple :
Button *leBouton = gBarreIcones.Controls[2].AsButton;
if (leBouton == null) {
  Display("Le contrôle 2 n'est pas un bouton !!!!");
}
else {
  leButton.NormalGraphic = 44;
}

tentera d'attribuer la sprite 44 comme NormalGraphic au Bouton 2 du GUI BarreIcones, mais si ce n'est en fait pas un bouton, affichera une image.

Voir aussi : GUI.Controls

BringToFront

GUIControl.BringToFront()
Place le contrôle au-dessus de tous les autres. Ceci vous permet de réarranger l'ordre d'affichage des contrôle dans le GUI.

S'applique à

Hérité par Button, InvWindow, Label, ListBox, Slider and TextBox.

Exemple :
btnGrosBouton.BringToFront();

placera le bouton btnGrosBouton au-dessus de tous les autres contrôle du GUI.

Voir aussi : GUIControl.SendToBack

Clickable

bool GUIControl.Clickable
Retourne/Définit si l'on peut cliquer sur le contrôle du GUI.

Cette propriété détermine si le joueur peut cliquer avec la souris sur le contrôle. Si elle est définie à false, alors tout clic de souris traversera le contrôle pour trouver se qui se trouve derrière. Contrairement à la propriété Enabled (Activé), donner false à Clickable n'altère pas l'apparence du contrôle.

Notez que désactiver le contrôle en définissant Enabled à false remplace ce réglage – c'est-à-dire que si Enabled vaut false, alors le joueur ne pourra pas cliquer sur le contrôle, indépendamment du réglage de la propriété Clickable.

Gardez aussi à l'esprit que si vous donnez false à Clickable alors, s'il y a un contrôle derrière celui-ci, c'est lui qui sera activé par le clic. D'autre part, si Enabled vaut false alors le contrôle “absorbe” le clic de la souris et rien ne se passe.

S'applique à

Hérité par Button, InvWindow, Label, ListBox, Slider and TextBox.

Exemple :
btnSauverPartie.Clickable = false;

rendra le bouton btnSauverPartie non-cliquable.

Voir aussi : GUIControl.Enabled

Enabled

(Anciennement SetGUIObjectEnabled, désormais obsolète)

bool GUIControl.Enabled

Active ou désactive le contrôle de GUI.

Normalement, vous vos contrôles de GUI (boutons, ascenseurs, etc.) sont activés en permanence sauf lors d'une cutscene (cinématique), durant lesquelles ils sont désactivés. Cette commande vous permet de désactiver explicitement un contrôle par le script.

Si vous donnez true, le contrôle sera activé ; donnez false pour le désactiver.

Que vous l'activiez ou non, il sera toujours désactivé lors d'une cutscene bloquante, ainsi que tous les autres contrôles.

Lorsqu'un contrôle est désactivé, il ne répondra pas aux clics de souris. Si c'est un bouton, ses images de survol et de pression ne seront pas affichées. Le contrôle sera dessiné selon les réglages du jeu “When GUI Disabled” (”Lorsque GUI Désactivé”), comme d'habitude.

S'applique à

Hérité par Button, InvWindow, Label, ListBox, Slider and TextBox.

Exemple :

btnSauverPartie.Enabled = false;

désactivera le bouton btnSauverPartie.

Voir aussi : GUIControl.Clickable, GUIControl.Visible

Height

int GUIControl.Height;
Retourne/Définit la hauteur du contrôle de GUI. Ceci vous permet de redimensionner dynamiquement le contrôle du GUI lors de l'exécution du jeu.

S'applique à

Hérité par Button, InvWindow, Label, ListBox, Slider and TextBox.

Exemple :
btnConfirmer.Height = 20;

fera que le bouton btnConfirmer fera 20 pixels de haut.

Voir aussi : GUIControl.SetSize, GUIControl.Width

ID

readonly int GUIControl.ID
Retourne le numéro ID du contrôle de GUI. Ceci est le numéro de l'objet contrôle dans l'éditeur de GUI, et est pratique si vous devez gérer du code ancien qui utilise le numéro du contrôle plutôt que son nom d'objet.

S'applique à

Hérité par Button, InvWindow, Label, ListBox, Slider and TextBox.

Exemple :
SetGUIObjectEnabled(lstSauvegardes.OwningGUI.ID, lstSauvegardes.ID, 1);
lstSauvegardes.Enabled = false;

utilise la fonction obsolète SetGUIObjectEnabled pour activer la liste lstSauvegardes, puis utilise la propriété actuelle équivalente pour la désactiver.

Voir aussi : GUIControl.OwningGUI, GUI.ID

OwningGUI

readonly GUI* GUIControl.OwningGUI
Retourne le GUI qui contient le contrôle.

Retourne un GUI, ce qui vous permet d'utiliser toutes les fonctions et propriétés des Interfaces habituelles.

S'applique à

Hérité par Button, InvWindow, Label, ListBox, Slider and TextBox.

Exemple :
GUI *legui = lstSauvegardes.OwningGUI;
legui.Visible = false;

lstSauvegardes.OwningGUI.Visible = true;

efface le GUI qui contient la liste lstSauvegardes, puis l'affiche à nouveau en utilisant une approche sans pointeur intermédiaire.

Voir aussi : GUIControl.ID, GUI.ID

SendToBack

GUIControl.SendToBack()
Place ce contrôle à l'arrière-plan. Ceci vous permet de réarranger l'ordre d'affichage des contrôle dans le GUI.

S'applique à

Hérité par Button, InvWindow, Label, ListBox, Slider and TextBox.

Exemple :
btnGrosBouton.SendToBack();

placera le bouton btnGrosBouton derrière tous les autres contrôle du GUI.

Voir aussi : GUIControl.BringToFront

SetPosition

(Anciennement SetGUIObjectPosition, désormais obsolète)

GUIControl.SetPosition(int x, int y)

Déplace le coin supérieur gauche du contrôle de GUI à (X,Y). Ces coordonnées sont relatives au GUI qui contient le contrôle.

Ceci vous permet de déplacer dynamiquement les contrôles de GUI à l'écran durant l'exéuction du jeu, et pourrait être assez utile avec GUI.SetSize si vous voulez proposer un GUI redimensionnable dynamiquement.

S'applique à

Hérité par Button, InvWindow, Label, ListBox, Slider and TextBox.

Exemple :

btnConfirmer.SetPosition(40, 10);

déplacera le bouton btnConfirmer pour le positionner à (40,10) dans le GUI.

Voir aussi : GUIControl.Enabled, GUI.SetPosition, GUIControl.SetSize, GUIControl.X, GUIControl.Y

SetSize

(Anciennement SetGUIObjectSize, désormais obsolète)

GUIControl.SetSize(int largeur, int hauteur)

Redimensionne le contrôle de GUI spécifié à LARGEUR x HAUTEUR.

Ceci vous permet de redimensionner dynamiquement les contrôles de GUI à l'écran durant l'exécution du jeu et pourrait être assez utile avec GUI.SetSize et GUIControl.SetPosition si vous voulez créer un GUI dynamiquement redimensionnable.

S'applique à

Hérité par Button, InvWindow, Label, ListBox, Slider and TextBox.

Exemple :

invMain.SetSize(160, 100);

redimensionne le contrôle invMain à la taille 160 x 100.

Voir aussi : GUIControl.Height, GUIControl.SetPosition, GUI.SetSize, GUIControl.Width,

Visible

bool GUIControl.Visible
Retourne/Définit si le contrôle de GUI est visible. Vaut true par défaut, mais vous pouvez donner la valeur false afin d'enlever temporairement le contrôle du GUI.

Tant ce contrôle est invisible, il n'est pas affiché à l'écran, et ne répond plus aux clics ou autres actions de l'utilisateur.

S'applique à

Hérité par Button, InvWindow, Label, ListBox, Slider and TextBox.

Exemple :
btnPartiesSauvees.Visible = false;

rendra le bouton btnPartiesSauvees invisible.

Voir aussi : GUIControl.Enabled

Width

int GUIControl.Width;
Retourne/Définit la largeur du contrôle du GUI. Ceci vous permet de redimensionner dynamiquement vos contrôles de GUI durant l'exécution du jeu.

S'applique à

Hérité par Button, InvWindow, Label, ListBox, Slider and TextBox.

Exemple :
btnConfirmer.Width = 110;

donne une largeur de 110 pixels au bouton btnConfirm.

Voir aussi : GUIControl.Height, GUIControl.SetSize

X

int GUIControl.X;
Retourne/Définit la position X du contrôle de GUI. Ceci spécifie son bord droit, et est relatif au GUI qui contient le contrôle.

Ceci vous permet de déplacer dynamiquement les contrôles dans le GUI durant l'exécution du jeu.

S'applique à

Hérité par Button, InvWindow, Label, ListBox, Slider and TextBox.

Exemple :
btnConfirmer.X = 10;

déplacera le bouton btnConfirmer afin de le positionner à 10 pixels à partir de la gauche du GUI.

Voir aussi : GUIControl.SetPosition, GUIControl.Y

Y

int GUIControl.Y;
Retourne/Définit la position Y du contrôle de GUI. Ceci spécifie le bord du haut, et est relatif au GUI qui contient le contrôle.

Ceci vous permet de déplacer dynamiquement les contrôles dans le GUI durant l'exécution du jeu.

S'applique à

Hérité par Button, InvWindow, Label, ListBox, Slider and TextBox.

Exemple :
btnConfirmer.Y = 20;

déplacera le bouton btnConfirmer afin de le positionner à 20 pixels à partir du haut du GUI.

Voir aussi : GUIControl.SetPosition, GUIControl.X


button

Table des matières
    • Fonction et propriétés des boutons (GUI Button)
      • Animate
      • ClipImage
      • Font
      • Graphic
      • MouseOverGraphic
      • NormalGraphic
      • PushedGraphic
      • Text
      • TextColor

Fonction et propriétés des boutons (GUI Button)

Animate

(Anciennement AnimateButton, désormais obsolète)

Button.Animate(int vue, int sequence, int delai, RepeatStyle)

Anime un bouton GUI en jouant la séquence de la vue spécifiées. Ceci peut être utile pour des animations de mort dans le style Sierra ou pour d'autres effets.

La SEQUENCE de la VUE sera jouée sur le bouton. Le DELAI spécifie la vitesse de l'animation - plus le nombre est haut, plus l'animation est lente. Cette fonction prend les mêmes paramètres que les commandes Character.Animate et Object.Animate.

REPEAT détermine si l'animation sera jouée en boucle de façon répétée, ou ne sera jouée qu'une fois et s'arrêtera sur la dernière image (les valeurs possibles sont eReapeat ou eOnce).

Vous pouvez arrêter une animation à tout moment en redéfinissant la propriété NormalGraphic du bouton, ou en lançant une nouvelle animation sur ce même bouton.

NOTE : Cette commande détruit les images normale, pressée et survolée du bouton. Si vous voulez retrouver une utilisation normale du bouton après une animation, vous devrez redéfinir ses propriétés Graphic pour retrouver les images.

NOTE : Cette commande ne supporte pas les images d'animation retournées. Toute image marquée comme “Flipped” (”Inversée”) sera en fait dessinée normalement sur un bouton.

Exemple :

btnAnimMort.Animate(6, 2, 4, eRepeat);

animera le bouton 'btnAnimMort' en utilisant la séquence 2 de la vue 6, avec un délai de 4 cycles par image, puis répétera l'animation continuellement.

Voir aussi : Button.NormalGraphic

ClipImage

bool Button.ClipImage;
Retourne/Définit si le bouton rogne l'image à son cadre.

Par exemple, si le bouton a une taille de 30×30, mais que son graphique est une image de 50×50, alors cette propriété définit si l'image est autorisée à déborder ou non du cadre du bouton.

Vaut false par défaut, c'est-à-dire que l'image n'est pas rognée.

Définir cette valeur à true peut être utile pour vous assurer que l'image du bouton n'est pas plus large que la zone cliquable du bouton, ce qui pourrait entraîner des confusions.

Exemple :
btnOK.ClipImage = true;

restreindra la taille visible de l'image à la zone cliquable du bouton btnOK.

Voir aussi : Button.Graphic

Font

FontType Button.Font
Retourne/Définit la police utilisée par le bouton pour afficher du texte.

Le numéro de police doit correspondre à une des polices dans l'onglet Fonts (Polices) de l'éditeur AGS.

Exemple :
btnOK.Font = eFontPrincipale;

changer la police utilisée par le bouton btnOK pour la police “Principale”.

Voir aussi : Label.Font, TextBox.Font

Graphic

(Anciennement compris dans GetButtonPic, désormais obsolète)

readonly int Button.Graphic;

Retourne l'image actuelle du bouton. Si la valeur retournée est inférieure à 1, alors aucune image n'est actuellement affichée sur le bouton.

Cette propriété est en lecture seule ; pour définir l'image, vous devez utiliser une des propriétés NormalGraphic, MouseOverGraphic ou PushedGraphic.

Exemple :

Display("Le bouton utilise actuellement la sprite numéro %d.", btnJouer.Graphic);

affichera le numéro de sprite actuel de btnJouer.

Voir aussi : Button.ClipImage, Button.MouseOverGraphic, Button.NormalGraphic, Button.PushedGraphic

MouseOverGraphic

(Anciennement compris dans GetButtonPic, désormais obsolète) (Anciennement compris dans SetButtonPic, désormais obsolète)

int Button.MouseOverGraphic;

Retourne/Définit la sprite de survol du bouton. Ceci peut valoir -1, ce qui indique que le bouton n'a pas de graphique particulier lorsque la souris le survole.

Exemple :

Display("Le bouton utilise la sprite numéro %d lorsque la souris le survole.", btnJouer.MouseOverGraphic);

affichera le numéro de la sprite de survol de btnJouer.

Voir aussi : Button.Graphic, Button.NormalGraphic, Button.PushedGraphic

NormalGraphic

(Anciennement compris dans GetButtonPic, désormais obsolète) (Anciennement compris dans SetButtonPic, désormais obsolète)

int Button.NormalGraphic;

Retourne/Définit la sprite normale du bouton (c'est-à-dire l'image utilisée lorsque le bouton n'est ni pressée ni survolé par la souris).

Notez que changer cette propriété aura pour effet de redimensionner le bouton de façon à ce que sa taille corresponde à celle de la nouvelle sprite.

Exemple :

Display("L'image normale du bouton est la sprite numéro %d.", btnJouer.NormalGraphic);

afficher le numéro de sprite normale du bouton btnJouer.

Voir aussi : Button.ClipImage Button.Graphic, Button.MouseOverGraphic, Button.PushedGraphic, Button.TextColor

PushedGraphic

(Anciennement compris dans GetButtonPic, désormais obsolète) (Anciennement compris dans SetButtonPic, désormais obsolète)

int Button.PushedGraphic;

Retourne/Définit la sprite du bouton pressé (c'est-à-dire l'image utilisée lorsque l'utilisateur clique sur le bouton). Ceci peut valoir -1, auquel cas le bouton n'a pas d'image particulière lorsque l'utilisateur clique dessus.

Exemple :

Display("Le bouton utilise la sprite numéro %d lorsqu'on clique dessus.", btnJouer.PushedGraphic);

affichera le numéro de sprite de btnJouer lorsqu'on clique dessus.

Voir aussi : Button.Graphic, Button.MouseOverGraphic, Button.NormalGraphic

Text

(Anciennement SetButtonText, désormais obsolète) (Anciennement Button.GetText, désormais obsolète) (Anciennement Button.SetText, désormais obsolète)

String Button.Text;

Retourne/Définit le texte affiché sur le bouton.

Exemple :

Display("Le bouton affichait : %s", btnControleur.Text);
btnControleur.Text = "Activer truc";

affichera l'ancien texte affiché sur btnControleur avant de le changer en 'Activer truc'.

Voir aussi : Button.NormalGraphic, Label.Text

TextColor

int Button.TextColor;
Retourne/Définit la couleur utilisée pour afficher le texte du bouton.

Si le bouton affiche une image plutôt que du texte, alors cette propriété n'a pas d'effet.

Exemple :
btnRecommencer.TextColor = 15;

écrira le texte de 'btnRecommencer' en blanc.

Voir aussi : Button.NormalGraphic


invwindow

Table des matières
    • Fonctions et propriétés des inventaires (GUI InvWindow)
      • ScrollDown
      • ScrollUp
      • CharacterToUse
      • ItemAtIndex
      • ItemCount
      • ItemHeight
      • ItemWidth
      • ItemsPerRow
      • RowCount
      • TopItem

Fonctions et propriétés des inventaires (GUI InvWindow)

ScrollDown

InvWindow.ScrollDown()
Fait défiler la fenêtre d'inventaire d'une ligne vers le bas, s'il y a davantage d'objets à afficher. Si la fenêtre d'inventaire est déjà tout en bas, alors il ne se passe rien.

Vous ne l'utiliserez normalement que lorsque le joueur appuie sur un bouton GUI ou sur une flèche avec votre GUI.

Exemple :
invMain.ScrollDown();

fera défiler la fenêtre d'inventaire invMain d'une ligne vers le bas.

Voir aussi : InvWindow.ScrollUp, InvWindow.TopItem

ScrollUp

InvWindow.ScrollUp()
Fait défiler la fenêtre d'inventaire d'une ligne vers le haut, s'il y a davantage d'objets à afficher. Si la fenêtre d'inventaire est déjà tout en haut, alors il ne se passe rien.

Vous ne l'utiliserez normalement que lorsque le joueur appuie sur un bouton GUI ou sur une flèche avec votre GUI.

Exemple :
invMain.ScrollUp();

fera défiler la fenêtre d'inventaire invMain d'une ligne vers le haut.

Voir aussi : InvWindow.ScrollDown, InvWindow.TopItem

CharacterToUse

Character* InvWindow.CharacterToUse;
Retourne/Définit le personnage dont la fenêtre affiche actuellement l'inventaire. Peut être défini à un personnage spécifique, ou peut être défini à null, auquel cas la fenêtre d'inventaire concernera le personnage joueur en cours (c'est le cas par défaut).

Exemple :
invMain.CharacterToUse = cJack;

fera afficher l'inventaire du personnage JACK dans la fenêtre invMain.

ItemAtIndex

readonly InventoryItem* InvWindow.ItemAtIndex[];
Retourne l'objet d'inventaire qui est actuellement affiché à la position spécifiée dans la fenêtre d'inventaire. Le nombre d'objets dans la fenêtre peut être récupéré par la propriété ItemCount. Les valeurs vont de 0 à ItemCount - 1.

Si une valeur invalide est entrée, la valeur null sera retournée.

Exemple :
String premier = invMain.ItemAtIndex[0].Name;
Display("Le premier objet est %s.", premier);

affichera le nom du premier objet affiché dans la fenêtre d'inventaire invMain .

Voir aussi : InvWindow.ItemCount

ItemCount

(Anciennement game.num_inv_items, désormais obsolète)

readonly int InvWindow.ItemCount;

Retourne le nombre total d'objets contenus dans la fenêtre d'inventaire. Correspondra la plupart du temps au nombre d'objets que possède le personnage (bien que ce puisse ne pas être le cas si l'option “Display multiple items multiple times” – ”Afficher les objets multiples en plusieurs fois” – n'est pas cochée).

Exemple :

if (invMain.ItemCount < (invMain.ItemsPerRow * invMain.RowCount)) {
  btnInvHaut.Enabled = true;
  btnInvBas.Enabled = true;
}

activera les boutons btnInvHaut et btnInvBas s'il y a plus d'objets d'inventaire que la fenêtre ne peut en contenir à la fois.

Voir aussi : InvWindow.ItemAtIndex, InvWindow.ItemsPerRow, InvWindow.RowCount

ItemHeight

(Anciennement SetInvDimensions, désormais obsolète)

int InvWindow.ItemHeight;

Retourne/Définit la taille d'une ligne de la fenêtre d'inventaire. Vous devriez généralement définir ceci dans game_start pour la hauteur de votre plus gros objet d'inventaire. Vaut 22 par défaut.

Exemple :

invMain.ItemWidth = 50;
invMain.ItemHeight = 30;

fait que l'inventaire invMain utilise des cases de taille 50×30.

Voir aussi : InvWindow.ItemWidth, InvWindow.RowCount

ItemWidth

(Anciennement SetInvDimensions, désormais obsolète)

int InvWindow.ItemWidth;

Retourne/Définit la taille d'une ligne de la fenêtre d'inventaire. Vous devriez généralement définir ceci dans game_start pour la hauteur de votre plus gros objet d'inventaire. Vaut 22 par défaut.

Exemple :

invMain.ItemWidth = 50;
invMain.ItemHeight = 30;

fait que l'inventaire invMain utilise des cases de taille 50×30.

Voir aussi : InvWindow.ItemHeight, InvWindow.ItemsPerRow

ItemsPerRow

(Anciennement game.items_per_line, désormais obsolète)

readonly int InvWindow.ItemsPerRow;

Retourne le nombre d'objets qui peuvent être affichés dans chaque ligne de la fenêtre d'inventaire. Ceci est calculé comme la largeur de la fenêtre d'inventaire divisée par la largeur de case ItemWidht.

Exemple :

Display("La fenêtre d'inventaire peut afficher %d objets à la fois.", invMain.ItemsPerRow * invMain.RowCount);

affiche le nombre d'objets visibles à la fois dans la fenêtre invMain.

Voir aussi : InvWindow.ItemWidth, InvWindow.RowCount

RowCount

readonly int InvWindow.RowCount;
Retourne le nombre de lignes qui peuvent être affichées dans la fenêtre d'inventaire. Ceci est calculé en divisant la hauteur de la fenêtre par la hauteur des cases ItemHeight.

Exemple :
Display("La fenêtre d'inventaire peut afficher %d objets à la fois.", invMain.ItemsPerRow * invMain.RowCount);

affiche le nombre d'objets visibles à la fois dans la fenêtre invMain.

Voir aussi : InvWindow.ItemHeight, InvWindow.ItemsPerRow

TopItem

(Anciennement game.top_inv_item, désormais obsolète)

int InvWindow.TopItem;

Retourne/Définit l'indice du premier objet actuellement visible dans la fenêtre d'inventaire. La tout premier objet correspond à 0, et le dernier objet a un indice de ItemCount - 1.

Vous pouvez utiliser cette propriété pour déterminer s'il faut ou non afficher des flèches de défilement.

Exemple :

if (invMain.TopItem > 0) {
  btnHaut.Visible = true;
}
else {
  btnHaut.Visible = false;
}

rend le bouton btnHaut visible ou invisible selon que la liste d'inventaire peut être défilée ou non.

Voir aussi : InvWindow.ItemCount


label

Table des matières
    • Fonctions et propriétés des étiquettes de GUI (Label)
      • Font
      • Text
      • TextColor

Fonctions et propriétés des étiquettes de GUI (Label)

Font

(Anciennement SetLabelFont, désormais obsolète)

FontType Label.Font;

Retourne/Détermine la police utilisée pour afficher le texte de l'étiquette. Ceci est utile si vous avez une police SCI standard pour la version anglaise, mais que vous voulez changer pour une police TTF pour des versions dans d'autres langues.

Exemple :

if (IsTranslationAvailable()) {
  lblStatuts.Font = eFontEtrangere;
}

changera la police utilisée par l'étiquette 'lblStatuts' pour la police “Etrangere” si une traduction est en cours d'utilisation.

Voir aussi : IsTranslationAvailable, Label.Text, TextBox.Font

Text

(Anciennement SetLabelText, désormais obsolète) (Anciennement Label.GetText, désormais obsolète) (Anciennement Label.SetText, désormais obsolète)

String Label.Text;

Retourne/Définit le texte affiché dans l'étiquette spécifiée. Ceci vous permet de changer le texte pendant l'exécution du jeu, par exemple pour créer une ligne de statut à la Lucasarts.

Exemple :

lblStatuts.Text = Game.GetLocationName(mouse.x, mouse.y);

affichera le nom de ce que le curseur survole dans l'étiquette 'lblStatuts'.

Voir aussi : Button.NormalGraphic, Button.Text, Label.TextColor, Label.Font

TextColor

(Anciennement SetLabelColor, désormais obsolète)

int Label.TextColor;

Retourne/Définit la couleur du texte utilisée pour afficher le texte de l'étiquette.

Exemple :

lblStatuts.TextColor = 14;

rendra le texte de l'étiquette 'lblStatuts' jaune.

Voir aussi : Label.Font, Label.Text


listbox

Table des matières
    • Fonctions et propriétés des listes (GUI List Box)
      • AddItem
      • Clear
      • FillDirList
      • FillSaveGameList
      • GetItemAtLocation
      • InsertItemAt
      • RemoveItem
      • ScrollDown
      • ScrollUp
      • Font
      • HideBorder
      • HideScrollArrows
      • ItemCount
      • Items
      • RowCount
      • SaveGameSlots
      • SelectedIndex
      • TopItem

Fonctions et propriétés des listes (GUI List Box)

AddItem

(Anciennement ListBoxAdd, désormais obsolète)

ListBox.AddItem(string nouvelleLigne)

Ajoute NOUVELLELIGNE à la liste spécifiée. La ligne sera ajoutée à la fin de la liste.

NOTE: Les listes ont une limite de 200 lignes. Si vous essayez d'en ajouter plus que ça, cette fonction retournera false et la ligne ne sera pas ajoutée.

Exemple :

String entree = txtEntreeJoueur.Text;
lstChoix.AddItem(entree);

récupérera l'entrée de l'utilisateur et l'ajoutera à la liste.

Voir aussi : ListBox.Clear, ListBox.FillDirList, ListBox.InsertItemAt, ListBox.Items, ListBox.RemoveItem

Clear

(Anciennement ListBoxClear, désormais obsolète)

ListBox.Clear()

Supprime toutes les lignes de la liste spécifiée.

Exemple :

lstCarnet.Clear();

supprimera toutes les lignes de la liste lstCarnet .

Voir aussi : ListBox.AddItem

FillDirList

(Anciennement ListBoxDirList, désormais obsolète)

ListBox.FillDirList(string filemask)

Remplit la liste avec une série des noms de fichiers correspondant à FILEMASK dans le répertoire courant. Ceci peut être utile si vous avez plusieurs fichiers de donnée et que le joueur peut choisir lequel charger.

FILEMASK correspond à une expression de recherche DOS/Windows standard telle que “*.dat” ou “data*.*”.

Cette commande supporte le mot-clé $SAVEGAMEDIR$, qui vous permet d'accéder aux fichiers du répertoire de sauvegardes. Ceci est spécialement important depuis le passage à Windows Vista, où vous ne pouvez potentiellement pas accéder au dossier principal du jeu.

Exemple :

lstPartiesSauvees.FillDirList("agssave.*");

remplira la liste avec les parties sauvegardées. Notez que vous utiliseriez plutôt FillSaveGameList pour cette de tâche.

Voir aussi : ListBox.AddItem, ListBox.Clear, ListBox.FillSaveGameList

FillSaveGameList

(Anciennement ListBoxSaveGameList, désormais obsolète)

ListBox.FillSaveGameList()

Remplit la liste spécifiée avec les parties sauvegardées, triées correctement de la plus récente (en haut) à la moins récente (en bas).

La propriété SaveGameSlots est mise à jour pour contenir le numéro du bloc de sauvegarde de chaque index dans la liste, vous pouvez donc faire :

int index = lstPartiesSauvees.SelectedIndex;
RestoreGameSlot(lstPartiesSauvees.SaveGameSlots[index]);

NOTE : La liste de parties sauvegardées ne gère que 50 parties. Si ListBox.ItemCount retourne 50 et que vous avez un dialogue de sauvegarde, vous pourrez demander à l'utilisateur de choisir de remplacer un fichier existant plutôt que créer une nouvelle sauvegarde.

Exemple :

lstPartiesSauvees.FillSaveGameList();

will fill listbox lstPartiesSauvees with the list of the saved games.

Voir aussi : ListBox.FillDirList, ListBox.ItemCount, ListBox.SaveGameSlots, ListBox.SelectedIndex

GetItemAtLocation

ListBox.GetItemAtLocation(int x, int y)
Détermine quelle ligne dans la liste est aux coordonnées (X,Y). Ceci vous permet de trouver quelle ligne la souris survole, par exemple.

Retourne le numéro de la ligne (où la première vaut 0), ou -1 si les coordonnées spécifiées ne correspondent à aucune ligne ou son hors de la liste.

Exemple :
int index = lstOptions.GetItemAtLocation(mouse.x, mouse.y);
if (index < 0) {
  Display("La souris ne survole aucune ligne !");
}
else {
  String ligneSelectionnee = lstOptions.Items[index];
  Display("La souris survole la ligne '%s'.", selectedItem);
}

affichera le texte de la ligne que la souris survole actuellement.

Voir aussi : ListBox.SelectedIndex

InsertItemAt

ListBox.InsertItemAt(int index, string nouvelleLigne)
Intsère NOUVELLELIGNE dans la liste spécifiée. La ligne sera insérée avant celle dont l'index est spécifié.

Les indices des listes vont de 0 (première ligne) à ItemCount - 1 (dernière ligne). La nouvelle ligne sera insérée avant l'index que vous spécifiez.

NOTE : Les listes ont une limite de 200 lignes. Si vous essayez d'en ajouter davantage, cette fonction retournera false et la ligne ne sera pas ajoutée.

Exemple :
lstChoices.AddItem("Première ligne");
lstChoices.AddItem("Deuxième ligne");
lstChoices.InsertItemAt(1, "Troisième ligne");

insérera la Troisième Ligne entre la Première (index 0) et la Seconde (index 1).

Voir aussi : ListBox.AddItem, ListBox.RemoveItem

RemoveItem

(Anciennement ListBoxRemove, désormais obsolète)

ListBox.RemoveItem(int ligne)

Supprime la LIGNE de la liste spécifiée. LIGNE correspond à l'index de la ligne à supprimer dans la liste, en commençant à 0 pour la première.

Si vous voulez supprimer toutes les lignes de la liste, utilisez ListBox.Clear à la place.

NOTE : Appeler cette fonction fait que les autres lignes dans la liste sont renumérotés, assurez-vous donc de ne pas garder d'anciennes références par ListBox.SelectedIndex et les autres fonctions lorsque vous utilisez cette commandes.

Exemple :

lstTest.AddItem("Première ligne");
lstTest.AddItem("Deuxième ligne");
lstTest.RemoveItem(0);

la liste ne contiendra plus que “Deuxième ligne”.

Voir aussi : ListBox.Clear, ListBox.FillDirList

ScrollDown

ListBox.ScrollDown()
Fait défiler la liste d'un cran vers le bas. Si elle se trouve déjà tout en bas, rien ne se passe.

Exemple :
lstTest.ScrollDown();

fait défiler la liste lstTest d'un cran vers le bas.

Voir aussi : ListBox.ScrollUp

ScrollUp

ListBox.ScrollUp()
Fait défiler la liste d'un cran vers le haut. Si elle se trouve déjà tout en haut, rien ne se passe.

Exemple :
lstTest.ScrollUp();

fait défiler la liste lstTest d'un cran vers le haut.

Voir aussi : ListBox.ScrollDown

Font

FontType ListBox.Font
Retourne/Définit la police utilisée par la liste spécifiée.

Exemple :
lstPartiesSauvees.Font = eFontSpeech;

fera utiliser la police “Speech” à la liste lstPartiesSauvees .

Voir aussi : Label.Font, TextBox.Text

HideBorder

bool ListBox.HideBorder
Retourne/Définit si les bordures de la liste sont cachées.

Notez que cacher les bordures a pour effet implicite de cacher également les flèches de défilement de la liste.

Exemple :
lstPartiesSauvees.HideBorder = true;

cachera les bordures entourant la liste des Parties Sauvées.

Voir aussi : ListBox.HideScrollArrows

HideScrollArrows

bool ListBox.HideScrollArrows
Retourne/Définit si les flèches de défilement sont cachées ou non.

Vu que l'apparence des flèches de défilement n'est pas personnalisable, vous pourriez vouloir utiliser cette propriété pour les cacher afin de proposer vos propres flèches à l'aide de boutons de GUI.

NOTE : Si le réglage “Hide Border” (”Cacher Bordures”) de la liste est activé, alors les flèches seront assi cachées, puisque “Hide Border” contient “Hide Scroll Arrows” (”Cacher Flèches Défilement”). Vous n'avez besoin d'utiliser cette propriété que si vous voulez que les bordures soient visibles, mais pas les flèches.

Exemple :
lstPartiesSauvees.HideScrollArrows = true;

cachera les flèches de défilement pré-fournies de la liste.

Voir aussi : ListBox.HideBorder

ItemCount

(Anciennement ListBoxGetNumItems, désormais obsolète)

readonly int ListBox.ItemCount

Retourne le nombre de lignes dans la liste spécifiée. Les indices de ligne vont de 0 à (nombreLignes - 1).

Cette propriété est en lecture seule. Pour changer le nombre de ligne, utilisez les méthodes AddItem et RemoveItem.

Exemple :

int sauvegardes = lstPartiesSauvees.ItemCount;

donnera le nombre de parties sauvées comme valeur à la variable int SAUVEGARDES.

Voir aussi : ListBox.Items

Items

(Anciennement ListBoxGetItemText, désormais obsolète) (Anciennement ListBox.GetItemText, désormais obsolète) (Anciennement ListBox.SetItemText, désormais obsolète)

String ListBox.Items[index]

Retourne/Définit le texte de la ligne INDEX de la liste.

Les lignes des listes sont numérotées à partir de 0, la première ligne a donc l'indice 0, la seconde l'indice 1, etc. La plus haute valeur possible vaut ItemCount mois 1.

Si vous voulez ajouter une nouvelle ligne à la liste, utilisez la méthode ListBox.AddItem.

Exemple :

String texteLigneSelectionnee = lstOptions.Items[lstOptions.SelectedIndex];

récupérera le texte de la ligne sélectionnée dans la liste.

Voir aussi : ListBox.SelectedIndex, ListBox.ItemCount, ListBox.AddItem

RowCount

readonly int ListBox.RowCount
Retourne le nombre de lignes qui peuvent être affichées dans la liste. Cela dépend de la taille de la liste et ne dépend pas du nombre de lignes qui sont véritablement contenues dans la liste.

Cette propriété est en lecture seule. Pour changer le nombre de lignes affichées, ajustez la taille de la liste.

Exemple :
Display("Vous pouvez actuellement voir %d lignes dans la liste", lstPartiesSauvees.RowCount);

affichera le nombre de lignes que la liste Parties Sauvées peut afficher simultanément.

Voir aussi : ListBox.ItemCount, ListBox.ScrollDown, ListBox.ScrollUp

SaveGameSlots

(Anciennement global array savegameindex, désormais obsolète)

readonly int ListBox.SaveGameSlots[];

Contient le bloc de sauvegarde correspondant pour chaque ligne dans la liste.

Cela est nécessaire puisque la commande FillSaveGameList trie la liste des parties sauvées pour placer la plus récente en premier. Ainsi, vous pouvez utiliser le tableau pour faire correspondre chaque ligne à la sauvegarde correspondante.

NOTE : Vous devez utiliser la commande FillSaveGameList pour remplir ce tableau.

Exemple :

int index = lstPartiesSauvees.SelectedIndex;
RestoreGameSlot(lstPartiesSauvees.SaveGameSlots[index]);

chargera la sauvegarde actuellement sélectionnée dans la liste, en supposant que FillSaveGameList a été utilisé plus tôt.

Voir aussi : ListBox.FillSaveGameList, ListBox.SelectedIndex

SelectedIndex

(Anciennement ListBoxGetSelected, désormais obsolète) (Anciennement ListBoxSetSelected, désormais obsolète)

int ListBox.SelectedIndex

Retourne/Définit l'indice de la liste de la ligne actuellement sélectionnée. La première ligne est 0, la seconde 1, etc. Si aucune ligne n'est sélectionnée, cette propriété vaut -1.

Vous pouvez lui donner la valeur -1 pour dé-sélectionner les lignes.

Exemple :

String texteSelectionne = lstOptions.Items[lstOptions.SelectedIndex];

retournera le texte de la ligne sélectionnée dans la liste.

TopItem

(Anciennement ListBoxSetTopItem, désormais obsolète)

int ListBox.TopItem

Retourne/Définit la ligne du haut dans la liste. La ligne du haut est la première ligne visible dans la liste, qui varie donc lorsque vous la faîtes défiler vers le haut ou vers le bas.

Les valeurs pour TopItem commencent à 0 pour la première ligne de la liste.

Exemple :

lstPartiesSauvees.TopItem = 0;

fera automatiquement défiler la liste lstPartiesSauvees tout en haut.


slider

Table des matières
    • Propriétés des barres de défilement (GUI Slider)
      • BackgroundGraphic
      • HandleGraphic
      • HandleOffset
      • Max
      • Min
      • Value

Propriétés des barres de défilement (GUI Slider)

BackgroundGraphic

int Slider.BackgroundGraphic;
Retourne/Définit la sprite utilisée pour l'arrière-plan de la barre. Cette image est répétée tout le long de la barre.

Vous pouvez passer 0, ce qui dessinera l'arrière-plan gris par défaut pour les barres de défilement.

Exemple :
Display("L'arrière-plan de sldSante est la sprite numéro %d", sldSante.BackgroundGraphic);

affiche le numéro de l'image d'arrière-plan de la barre sldSante .

Compatibilité : Supporté par AGS 3.1.0 et les versions plus récentes.

Voir aussi : Slider.HandleGraphic

HandleGraphic

int Slider.HandleGraphic;
Retourne/Définit la sprite utilisée pour dessiner le curseur sur la barre. Le curseur correspond à la position actuelle de défilement, et peut être glissé par le joueur.

L'image du curseur peut valoir 0, auquel cas ce sera un curseur gris par défaut.

Exemple :
Display("Le curseur de sldSante est la sprite numéro %d", sldSante.HandleGraphic);

affiche le numéro de l'image du curseur de la barre de défilement sldSante .

Compatibilité : Supporté par AGS 3.1.0 et les versions plus récentes.

Voir aussi : Slider.BackgroundGraphic, Slider.HandleOffset

HandleOffset

int Slider.HandleOffset;
Retourne/Définit le décalage à utiliser pour l'image du curseur. Cette valeur est initialement définie dans l'éditeur.

Exemple :
sldSante.HandleOffset = 2;

dessinera le curseur de la barre sldSante après 2 pixels sur sa droite.

Compatibilité : Supporté par AGS 3.1.0 et les versions plus récentes.

Voir aussi : Slider.HandleGraphic

Max

int Slider.Max;
Retourne/Définit la valeur maximum de la barre de GUI spécifiée.

En changeant le maximum, la valeur de la barre de défilement sera ajustée si nécessaire de façon à rester dans l'intervalle Min - Max.

Une erreur survient si vous essayez de définir le maximum à une valeur inférieure au minimum.

Exemple :
sldSante.Max = 200;

donne la valeur maximum 200 à la barre de défilement sldSante .

Voir aussi : Slider.Min, Slider.Value

Min

int Slider.Min;
Retourne/Définit la valeur minimum de la barre de GUI spécifiée.

En changeant le minimum, la valeur de la barre de défilement sera ajustée si nécessaire de façon à rester dans l'intervalle Min - Max.

Une erreur survient si vous essayez de définir le minimum à une valeur supérieure au maximum.

Exemple :
sldSante.Min = 0;

donnera la valeur minimum 0 à la barre de défilement sldSante.

Voir aussi : Slider.Max, Slider.Value

Value

(Anciennement GetSliderValue, désormais obsolète) (Anciennement SetSliderValue, désormais obsolète)

int Slider.Value;

Retourne/Définit la valeur de la barre de défilement spécifiée. Vous utiliserez généralement ceci dans la fonction interface_click pour déterminer à quelle valeur le joueur a placé le curseur de la barre, afin d'exécuter la commande appropriée.

En définissant cette valeur, la nouvelle valeur doit être comprise entre les valeurs MIN et MAX de la barre, telles que définies dans l'éditeur de GUI.

Exemple :

SetMusicMasterVolume(sldVolume.Value);

réglera le volume générale de la musique à la valeur de la barre de défilement sldVolume .

Voir aussi : Label.Text


textbox

Table des matières
    • Fonctions et propriétés des zones de saisie de GUI (Text Box)
      • Font
      • Text
      • TextColor

Fonctions et propriétés des zones de saisie de GUI (Text Box)

Font

(Anciennement SetTextBoxFont, désormais obsolète)

FontType TextBox.Font

Retourne/Définit la police utilisée par la zone de saisie spécifiée. Ceci peut être utile si vous voulez que le texte entré par l'utilisateur utilise une police différente selon la langue du jeu, par exemple.

Exemple :

txtUtilisateur.Font = eFontNormal;

utilisera la police “Normal” pour la zone de saisie txtUtilisateur.

Voir aussi : Label.Font, TextBox.Text

Text

(Anciennement GetTextBoxText, désormais obsolète) (Anciennement SetTextBoxText, désormais obsolète) (Anciennement TextBox.GetText, désormais obsolète) (Anciennement TextBox.SetText, désormais obsolète)

String TextBox.Text;

Retourne/Définit le contenu de la zone de saisie. Ceci peut être utile pour vider la zone une fois que l'utilisateur a entré quelque chose, ou pour y mettre une valeur par défaut.

Exemple :

txtUtilisateur.Text = "";

videra la zone de saisie 'txtUtilisateur'.

Voir aussi : TextBox.Font, String.CompareTo, Label.Text

TextColor

int TextBox.TextColor;
Retourne/Définit la couleur utiliée pour dessiner la zone de saisie. Cela affecte aussi bien le texte à l'intérieur que les bordure du cadre.

Exemple :
txtUtilisateur.TextColor = 14;

rendra le texte et les bordures de 'txtUtilisateur' jaunes.

Compatibilité: Supporté par AGS 3.1.0 et les versions plus récentes.

Voir aussi : TextBox.Text


hotspot

Table des matières
    • Fonctions et propriétés des Hotspots
      • GetAtScreenXY
      • GetProperty
      • GetTextproperty
      • RunInteraction
      • Enabled
      • ID
      • Name
      • WalkToX
      • WalkToY

Fonctions et propriétés des Hotspots

GetAtScreenXY

(Anciennement fonction globale GetHotspotAt, désormais obsolète)

static Hotspot* Hotspot.GetAtScreenXY(int x, int y)

Retourne le hotspot se trouvant aux coordonnées (X,Y) à l'ECRAN. S'il n'y a aucun hotspot à cet endroit, ou si des coordonnées invalides ont été spécifiées, la variable Hotspot* représentant le hotspot 0 sera retourné.

NOTE : Les coordonnées sont celles de l'ECRAN, PAS celles de la PIECE. Cela signifie que dans une pièce plus grande que l'écran, les coordonnées que vous passerez seront relatives à la position actuelle de l'écran, et ne seront PAS les coordonnées absolues de la pièce. Ceci signifie qu'il convient d'utiliser cette fonction avec les coordonnées du curseur.

Exemple :

if (Hotspot.GetAtScreenXY(mouse.x, mouse.y) == hPorte)
Display("La souris survole la porte.");
else if (Hotspot.GetAtScreenXY(mouse.x, mouse.y) != hotspot[0])
Display("La souris survole quelque chose (mais pas la porte) !");
else
Display("La souris ne survole aucun hostpot.");

affichera un message selon ce que survole le curseur de la souris.

Voir Aussi : Game.GetLocationName, GetLocationType

GetProperty

(Anciennement GetHotspotProperty, désormais obsolète)

Hotspot.GetProperty(string propriété)

Retourne la valeur de la propriété personnelle PROPRIETE du hotspot.

Cette commande ne fonctionne qu'avec les propriétés numériques (retourne un nombre), et avec les booléennes (retourne 1 si la case est cochée, sinon 0).

Utilisez la fonction équivalente GetTextProperty pour obtenir une propriété textuelle.

Exemple :

if (hotspot[1].GetProperty("Valeur") &gt; 200)
Display("La valeur du Hotspot 1 est supérieure à 200 !");

afficher le message si la propriété “Valeur” du hotspot 1 est supérieure à 200.

Voir Aussi : Hotspot.GetTextpropriété

GetTextproperty

(Anciennement GetHotspotPropertyText, désormais obsolète) (Anciennement Hotspot.GetPropertyText, désormais obsolète)

String Hotspot.GetTextProperty(string propriété)

Retourne la valeur de la propriété personnelle PROPRIETE du hotspot.

Cette commande ne fonctionne qu'avec les propriétés textuelles. Le texte de la propriété sera retourné par cette fonction.

Utilisez la fonction équivalente GetProperty pour obtenir une propriété numérique.

Exemple :

String description = hotspot[2].GetTextProperty("Description");
Display("Description du Hotspot 2 : %s", description);

récupérera la “description” du hostpot 2 et l'affichera.

Voir Aussi : Hotspot.Getpropriété

RunInteraction

(Anciennement RunHotspotInteraction, désormais obsolète)

Hotspot.RunInteraction(CursorMode)

Lancera l'événement associé au mode du curseur passé dans la liste des interactions, comme si le joueur avait cliqué sur le hotspot avec le mode de curseur spécifié. Peut être utile avec le parseur de texte pour simuler un clic de souris si un texte spécifique est entré.

Exemple :

hPorte.RunInteraction(eModeLook);

lancera le code contenu dans l'interaction “Look At Hotspot” pour le hotspot hPorte.

Voir Aussi : ProcessClick, Character.RunInteraction, Object.RunInteraction

Enabled

(Anciennement DisableHotspot, désormais obsolète) (Anciennement EnableHotspot, désormais obsolète)

bool Hotspot.Enabled

Active/Désactive le hotspot spécifié. Si vous définissez cette propriété à false, toutes les zones de l'écran qui correspondaient auparavant au hotspot seront alors considérées comme de type 0 (aucun hotspot). Vous pouvez ensuite réactiver le hotspot en donnant la valeur true à la propriété.

Ce réglage persiste dans le jeu ; cela signifie que le hotspot ne sera pas réinitialisé lorsque le joueur entrera une nouvelle fois dans la pièce.

La valeur par défaut de cette propriété est toujours true.

Exemple :

hArbreBrun.Enabled = false;

désactivera le hotspot hArbreBrun.

Voir Aussi : Region.Enabled, RemoveWalkableArea, RestoreWalkableArea

ID

readonly int Hotspot.ID
Retourne le numéro d'identification de ce hotspot. Ceci vous permet d'utiliser de l'ancien code ayant recourt à des fonctions utilisant les numéros des hotspots.

Exemple :
Display("Le numéro du hotspot hPorte est le numéro %d.", hPorte.ID);
Display("Le hotspot 3 a pour numéro %d.", hotspot[3].ID);

affichera le numéro d'identification du hotspot hPorte, puis affichera le numéro d'identification du hotspot 3 (qui sera évidemment 3).

Voir Aussi : Hotspot.GetAtScreenXY

Name

(Anciennement GetHotspotName, désormais obsolète) (Anciennement Hotspot.GetName, désormais obsolète)

readonly String Hotspot.Name;

Retourne le nom du hotspot.

Cette propriété est en lecture seule ; il n'est pour le moment pas possible de changer le nom du hotspot en cours de jeu.

Exemple :

Display("Le nom du hotspot 3 est %s.", hotspot[3].Name);

récupérera puis affichera le nom du hotspot 3.

Voir Aussi : Game.GetLocationName

WalkToX

(Anciennement GetHotspotPointX, désormais obsolète)

readonly int Hotspot.WalkToX

Retourne la coordonnée de pièce X du point d'accès au hotspot (walk-to point). Si le hotspot n'en a pas, retourne -1.

Exemple :

player.Walk(hTable.WalkToX, hTable.WalkToY, eBlock, eWalkableAreas);

déplacera le personnag joueur au point d'accès (“walk-to point”) du hotspot hTable.

Voir Aussi : Hotspot.WalkToY, MoveCharacterToHotspot

WalkToY

(Anciennement GetHotspotPointY, désormais obsolète)

readonly int Hotspot.WalkToY

Retourne la coordonnée de pièce Y du point d'accès au hotspot (walk-to point). Si le hotspot n'en a pas, retourne -1.

Exemple :

player.Walk(hTable.WalkToX, hTable.WalkToY, eBlock, eWalkableAreas);

déplacera le personnag joueur au point d'accès (“walk-to point”) du hotspot hTable.

Voir Aussi : Hotspot.WalkToX, MoveCharacterToHotspot


inventoryitem

Table des matières
    • Fonctions et propriétés des Objets d'Inventaire
      • GetAtScreenXY
      • GetProperty
      • GetTextProperty
      • IsInteractionAvailable
      • RunInteraction
      • Graphic
      • ID
      • Name

Fonctions et propriétés des Objets d'Inventaire

GetAtScreenXY

(Anciennement fonction globale GetInvAt, désormais obsolète)

static InventoryItem* InventoryItem.GetAtScreenXY(int x, int y)

Retourne l'objet d'inventaire aux coordonnées d'ECRAN (X,Y). Notez que cette fonction ne détecte que les objets d'inventaire contenus dans les fenêtres Inventaire personnelles (qui s'affichent lorsque la fonction est appelée), et est prévue pour vous permettre de proposer un GUI basé sur des verbes (“Utiliser Objet”,…) et autres du genre.

S'il n'y a aucune objet d'inventaire à cet endroit, ou que des coordonnées invalides ont été spécifiées, retourne null .

NOTE : Les coordonnées sont celles de l'ECRAN, PAS celles de la PIECE. Cela signifie que dans une pièce plus large que l'écran, les coordonnées que vous passez sont relatives à la position actuelle de l'écran, et ne sont PAS les coordonnées absolues de la pièce. Ceci signifie qu'il convient d'utiliser cette fonction avec les coordonnées du curseur de la souris.

Exemple :

InventoryItem *item = InventoryItem.GetAtScreenXY(mouse.x, mouse.y);
if (item == null) {
Display("Aucun objet d'inventaire aux coordonnées de la souris.");
}
else {
Display("Objet d'inventaire numéro %d à la positions de la souris.", item.ID);
}

affichera le numéro de l'objet d'inventaire que la souris survole.

Voir Aussi : InventoryItem.Name, Game.GetLocationName

GetProperty

(Anciennement GetInvProperty, désormais obsolète)

InventoryItem.GetProperty(string propriété)

Retourne la valeur de la propriété personnelle PROPRIETE pour l'objet d'inventaire.

Cette commande fonctionne avec les propriétés numériques (retourne un nombre), et avec les propriétés booléennes (retourne 1 si la case est cochée, sinon 0).

Utilisez la fonction équivalente GetTextProperty pour récupérer une propriété textuelle.

Exemple :

if (inventory[1].GetProperty("Valeur") &gt; 200)
Display("La valeur de l'objet d'inventaire 1 est supérieure à 200 !");

affichera le message si la propriété “Valeur” de l'objet d'inventaire 1 est supérieure à 200.

Voir Aussi : InventoryItem.GetTextProperty

GetTextProperty

(Anciennement GetInvPropertyText, désormais obsolète) (Anciennement InventoryItem.GetPropertyText, désormais obsolète)

String InventoryItem.GetTextProperty(string propriété)

Retourne la valeur de la propriété personnelle PROPRIETE pour l'objet d'inventaire.

Cette commande ne fonctionne qu'avec les propriétés textuelles. Le texte sera retourné par cette fonction.

Utilisez la fonction équivalente GetProperty pour récupérer une propriété non textuelle.

Exemple :

String description = inventory[2].GetTextProperty("Description");
Display("Description de l'objet d'inventaire 2 : %s", description);

récupérera la “description” de l'objet d'inventaire 2 et l'affichera.

Voir Aussi : InventoryItem.GetProperty

IsInteractionAvailable

(Anciennement IsInventoryInteractionAvailable, désormais obsolète)

InventoryItem.IsInteractionAvailable(CursorMode)

Vérifie si une interaction est prévue pour un clic sur l'objet d'inventaire avec le mode de curseur MODE.

Cette fonction est très similaire à RunInteraction, mais au lieu de lancer les événements correspondants, celle-ci retourne simplement 1 lorsque quelque chose se passerait, ou 0 lorsque unhandled_event serait appelée.

Ceci est utile pour activer des choix dans un GUI basé sur les verbes, par exemple.

Exemple :

if (iPortecles.IsInteractionAvailable(eModeLook) == 0)
Display("Regarder cet objet n'aurait aucun effet.");

Voir Aussi : IsInteractionAvailable, InventoryItem.RunInteraction

RunInteraction

(Anciennement RunInventoryInteraction, désormais obsolète)

InventoryItem.RunInteraction(CursorMode)

Lance le code associé à l'évenement correspondant dans la liste des interactions comme si le joueur avait cliqué sur l'objet d'inventaire, en utilisant le mode de curseur MODE.

Exemple :

if (button == eMouseLeftInv)
inventory[game.inv_activated].RunInteraction(mouse.Mode);

lancera l'interaction d'inventaire correspondant au mode de curseur actuel lorsque le joueur cliquera sur l'objet (“Handle Inv Clicks” doit être activé pour que cela fonctionne).

Voir Aussi : InventoryItem.IsInteractionAvailable, ProcessClick, Character.RunInteraction

Graphic

(Anciennement GetInvGraphic, désormais obsolète) (Anciennement SetInvItemPic, désormais obsolète)

int InventoryItem.Graphic

Retourne/Définit le numéro d'emplacement de la sprite de l'objet d'inventaire. Vous pouvez utiliser cela avec la propriété Object.Graphic pour donner l'effet que le joueur 'fait tomber' l'objet d'inventaire ; ou encore cette propriété peut être utile une fenêtre d'inventaire dessinée avec les fonctions Raw*.

Exemple :

int slot = player.ActiveInventory.Graphic;

stockera le numéro de sprite de l'objet d'inventaire actuel du joueur dans la variable slot.

Voir Aussi : InventoryItem.GetAtScreenXY, InventoryItem.Name

ID

readonly int InventoryItem.ID
Retourne le numéro d'identification de l'objet d'inventaire spécifié. Cela correspond au numéro figurant dans l'éditeur, et est utile pour utiliser des commandes comme Character.AddInventory, auxquelles il faut passer le numéro de l'objet d'inventaire à ajouter.

Exemple :
AddInventory(EGO, iPelle.ID);

utilise la commande obsolète AddInventory pour ajouter la pelle à l'inventaire de EGO.

Voir Aussi : Character.AddInventory, Character.LoseInventory

Name

(Anciennement GetInvName, désormais obsolète) (Anciennement SetInvItemName, désormais obsolète) (Anciennement InventoryItem.GetName, désormais obsolète) (Anciennement InventoryItem.SetName, désormais obsolète)

String InventoryItem.Name;

Retourne/Définit le nom de l'objet d'inventaire. Ceci est le nom qui est initialement définit dans la fenêtre “Inventory items” de l'Editeur AGS.

Vous pouvez changer cette propriété si par exemple vous voulez remplacer un 'bol' par un 'bol rempli d'eau', sans pour autant utiliser un autre objet d'inventaire.

Notez que la longueur maximale du nom d'un objet d'inventaire est de 24 caractères - si vous donnez un nom plus long, alors le texte sera tronqué.

Exemple :

Display("Objet d'inventaire actif : %s", player.ActiveInventory.Name);

affichera le nom de l'objet d'inventaire que le joueur utilise actuellement.

Voir Aussi : InventoryItem.GetAtScreenXY, InventoryItem.Graphic, Game.GetLocationName


maths

Table des matières
    • Fonctions et propriétés mathématiques (Maths)
      • FloatToInt
      • IntToFloat
      • ArcCos
      • ArcSin
      • ArcTan
      • ArcTan2
      • Cos
      • DegreesToRadians
      • RadiansToDegrees
      • RaiseToPower
      • Sin
      • Sqrt
      • Tan
      • Pi

Fonctions et propriétés mathématiques (Maths)

FloatToInt

int FloatToInt(float valeur, optional RoundDirection)
Convertit la valeur décimale (à virgule) en valeur entière.

Cette fonction est nécessaire puisque les conversions implicites ne sont pas supportées par le script.

RoundDirection peut être eRoundDown (par défaut), qui retournera un nombre arrondi à l'entier inférieur ; eRoundUp qui retournera un nombre arrondi à l'entier supérieur ; ou eRoundNearest, qui retournera l'entier le plus proche du nombre à virgule (selon que la partie décimale est supérieure ou non à 0.4 - 0.5 arrondira à l'entier supérieur).

Exemple :
Display("Arrondi à l'inférieur : %d", FloatToInt(10.7));
Display("Arrondi au supérieur : %d", FloatToInt(10.7, eRoundUp));
Display("Arrondi au plus près : %d", FloatToInt(10.7, eRoundNearest));

affichera la valeur entière de 10.7, arrondie de trois façons différentes.

Voir Aussi : IntToFloat

IntToFloat

float IntToFloat(int valeur)
Convertit la valeur entière entrée en nombre à virgule.

Cette fonction est nécessaire puisque les conversions implicites ne sont pas supportées par le scipt.

Exemple :
float nombre = IntToFloat(10);

donnera la valeur 10.0 à la variable nombre.

Voir Aussi : FloatToInt

ArcCos

float Maths.ArcCos(float valeur)
Calcule l'ArcCosinus, en radians, de la valeur spécifiée.

Pour convertir un angle de radians à degrés, utilisez la fonction Maths.RadiansToDegrees.

Exemple :
float angle = Maths.ArcCos(1.0);

calcule l'ArcCosinus de 1.0 et stocke la valeur retournée dans la variable angle.

Voir Aussi : Maths.Cos, Maths.DegreesToRadians,

ArcSin

float Maths.ArcSin(float valeur)
Calcule l'ArcSinus, en radians, de la valeur spécifiée.

Pour convertir un angle de radians à degrés, utilisez la fonction Maths.RadiansToDegrees.

Exemple :
float angle = Maths.ArcSin(0.5);

calcule l'ArcSinus de 0.5 et stocke la valeur retournée dans la variable angle.

Voir Aussi : Maths.Sin, Maths.DegreesToRadians,

ArcTan

float Maths.ArcTan(float valeur)
Calcule l'ArcTangente, en radians, de la valeur spécifiée.

Pour convertir un angle de radians à degrés, utilisez la fonction Maths.RadiansToDegrees.

Exemple :
float angle = Maths.ArcTan(0.5);

calcule l'ArcTangente de 0.5 et stocke la valeur obtenue dans la variable angle.

Voir Aussi : Maths.ArcTan2, Maths.DegreesToRadians, Maths.Tan

ArcTan2

float Maths.ArcTan2(float y, float x)
Calcule l'ArcTangente de Y / X. Cette fonction fonctionne parfaitement pour tout point différent de l'origine du repère, tant que y ne vaut pas 0. Le résultat retourné est en radians.

Pour convertir un angle de radians à degrés, utilisez la fonction Maths.RadiansToDegrees.

Exemple :
float angle = Maths.ArcTan2(-862.42, 78.5149);

calculera l'ArcTangente de -862.42 / 78.5149 et placera la valeur obtenue dans la variable angle.

Voir Aussi : Maths.DegreesToRadians, Maths.ArcTan

Cos

float Maths.Cos(float radians)
Calcule le cosinus de l'angle spécifié (en radians).

Pour convertir un angle de radians à degrés, utilisez la fonction Maths.RadiansToDegrees.

Exemple :
float cosinus = Maths.Cos(Maths.DegreesToRadians(360.0));

calcule le cosinus de 360 degrés (qui vaut 1.0) et stocke la valeur obtenue dans la variable cosinus.

Voir Aussi : Maths.ArcCos, Maths.DegreesToRadians, Maths.Sin, Maths.Tan

DegreesToRadians

float Maths.DegreesToRadians(float degres)
Convertit l'angle entrée en degrés, en l'angle en radians équivalent.

Du fait que les fonctions trigonométriques comme Sin, Cos et Tan prennent des paramètres en radians, cette fonction est utile si vous voulez obtenir une valeur en radians à partir de degrés.

Exemple :
float cosinus = Maths.Cos(Maths.DegreesToRadians(360.0));

calcule le cosinus de 360 degrés (qui vaut 1.0) et stocke la valeur obtenue dans la variable cosinus.

Voir Aussi : Maths.Cos, Maths.RadiansToDegrees, Maths.Sin, Maths.Tan

RadiansToDegrees

float Maths.RadiansToDegrees(float radians)
Convertit l'angle entré en radians, en l'angle en degrés équivalent.

Du fait que les fonctions trigonométriques comme Sin, Cos et Tan prennent des paramètres en radians, cette fonction est utile si vous voulez obtenir une valeur en degrés à partir de radians.

Exemple :
float halfCircle = Maths.RadiansToDegrees(Maths.Pi);

convertit PI de sa valeurs en radians à sa valeur en degrés (qui est 180).

Voir Aussi : Maths.Cos, Maths.DegreesToRadians, Maths.Sin, Maths.Tan

RaiseToPower

float Maths.RaiseToPower(float base, float exposant)
Calcule la valeur de base élevée à la puissance exposant.

Cela signifie que base sera multipliée par soi-même exposant fois.

Exemple :
float valeur = Maths.RaiseToPower(4.0, 3.0);

calcule 4 à la puissance 3 (qui vaut 64).

Voir Aussi : Maths.Sqrt

Sin

float Maths.Sin(float radians)
Calcule le sinus de l'angle spécifié (en radians).

Pour convertir un angle de radians à degrés, utilisez la fonction Maths.RadiansToDegrees.

Exemple :
float sinus = Maths.Sin(Maths.DegreesToRadians(360.0));

calculera le sinus de 360 degrés (qui vaut 0) et placera la valeur retournée dans la variable sinus.

Voir Aussi : Maths.ArcSin, Maths.DegreesToRadians, Maths.Cos, Maths.Tan

Sqrt

float Maths.Sqrt(float value)
Calcule la racine carrée de la valeur entrée.

La racine carrée de valeur est le nombre qui, multiplié par lui-même, vaut valeur.

Exemple :
Display("La racine carrée de 4 est %d !", FloatToInt(Maths.Sqrt(4.0)));

affichera la racine carrée de 4 (arrondie à l'entier le plus proche).

Voir Aussi : Maths.Cos, Maths.RaiseToPower, Maths.Sin, Maths.Tan

Tan

float Maths.Tan(float radians)
Calcule la tangente de l'angle spécifié (en radians).

Pour convertir un angle de radians à degrés, utilisez la fonction Maths.RadiansToDegrees.

Exemple :
float tan = Maths.Tan(Maths.DegreesToRadians(45.0));

calcule la tangente de 45 degrés (qui vaut 1.0) et place le résultat obtenu dans la variable tan.

Voir Aussi : Maths.ArcTan, Maths.DegreesToRadians, Maths.Cos, Maths.Sin,

Pi

readonly float Maths.Pi
Retourne la valeur de Pi (qui vaut ici 3.14159265358979323846).

Exemple :
Display("Pi vaut %f !", Maths.Pi);

affiche la valeur de Pi.

Voir Aussi : Maths.Cos, Maths.Sin, Maths.Tan


mouse

Table des matières
    • Fonctions et propriétés de la Souris (Mouse)
      • ChangeModeGraphic
      • ChangeModeHotspot
      • ChangeModeView
      • DisableMode
      • EnableMode
      • GetModeGraphic
      • IsButtonDown
      • SaveCursorUntilItLeaves
      • SelectNextMode
      • SetBounds
      • SetPosition
      • Update
      • UseDefaultGraphic
      • UseModeGraphic
      • Mode
      • Visible

Fonctions et propriétés de la Souris (Mouse)

ChangeModeGraphic

(Anciennement ChangeCursorGraphic, désormais obsolète)

Mouse.ChangeModeGraphic(CursorMode, int slot)

Change le graphique du mode de curseur spécifié pour celui contenu à l'emplacement SLOT. Ceci change le graphique du mode de façon permanente. Cette fonction peut être utile si vous avez besoin de plus de modes de curseurs qu'il n'en est prévu.

Exemple :

mouse.ChangeModeGraphic(eModeLookAt, 120);

changera le graphique du curseur en mode “Regarder” pour lui attribuer l'image importée à l'emplacement 120 du Sprite Manager.

Voir Aussi : Mouse.ChangeModeHotspot, Mouse.ChangeModeView, Mouse.Mode, Mouse.GetModeGraphic

ChangeModeHotspot

(Anciennement ChangeCursorHotspot, désormais obsolète)

Mouse.ChangeModeHotspot(CursorMode, int x, int y)

Change de façon permanente le point de réaction du graphique du curseur pour le point aux coordonnées (X,Y) de l'image. Cela correspond au décalage sur le graphique à partir duquel le clic est considéré. (0,0) est le coin haut gauche du graphique du curseur.

Exemple :

mouse.ChangeModeHotspot(eModeWalkto, 10, 10);

placera le point de réaction du curseur pour le mode Marcher aux coordonnées (10,10) de l'image utilisée.

Voir Aussi : Mouse.ChangeModeGraphic, Mouse.ChangeModeView

ChangeModeView

Mouse.ChangeModeView(CursorMode, int vue)
Utilise la vue numéro VUE pour le mode de curseur spécifié.

Vous pouvez donner la valeur -1 à vue pour cesser l'animation du curseur.

Ceci vous permet de changer dynamiquement la vue utilisée pour l'animation du curseur lorsque le jeu est lancé.

Exemple :
mouse.ChangeModeView(eModeLookAt, YEUXROULANT);

changera la vue du curseur Regarder pour la vue numéro YEUXROULANT.

Voir Aussi : Mouse.ChangeModeGraphic, Mouse.ChangeModeHotspot

DisableMode

(Anciennement DisableCursorMode, désormais obsolète)

Mouse.DisableMode(int mode)

Désactive le mode de curseur MODE. Il ne sera plus possible d'attribuer ce mode à la souris tant qu'il sera désactivé (en utilisant UseModeGraphic par exemple). Cette fonction grise également et désactive tout bouton d'interface dont le clic gauche est associé à la commande “Définit mode à X”, où X est égal à MODE.

Si le mode actuel du curseur est MODE, alors la machine passera le curseur dans le prochain mode disponible.

Exemple :

mouse.DisableMode(eModeWalkto);

désactivera le mode Marcher jusqu'à ce qu'il soit réactivé.

Voir Aussi : Mouse.EnableMode

EnableMode

(Anciennement EnableCursorMode, désormais obsolète)

Mouse.EnableMode(int mode)

Réactive le mode de curseur MODE. Cette fonction active également tout bouton d'interface qui avait été désactivé par la commande DisableMode.

Exemple :

mouse.EnableMode(eModeWalkto);

activera le mode de curseur Marcher qui au préalable avait été désactivé.

Voir Aussi : Mouse.DisableMode

GetModeGraphic

static int Mouse.GetModeGraphic(CursorMode)
Retourne le numéro de l'image (sprite) utilisée pour le mode de curseur spécifié.

Cela peut être utile si vous voulez la changer manuellement avec ChangeModeGraphic tout en gardant en mémoire l'image précédente.

Exemple :
Display("L'image actuelle du curseur de la souris est la %d.", mouse.GetModeGraphic(mouse.Mode));

affichera le numéro de l'image du curseur en cours d'utilisation.

Voir aussi : Mouse.ChangeModeGraphic

IsButtonDown

(Anciennement fonction globale IsButtonDown, désormais obsolète)

Mouse.IsButtonDown(MouseButton)

Vérifie si l'utilisateur maintient actuellement enfoncé le bouton de sa souris. BUTTON sera soit eMouseLeft (bouton gauche), soit eMouseRight (bouton droit). Le bouton du milieu n'est pas supporté par cette fonction. Retourne 1 si le bouton est actuellement pressé, sinon 0. Ceci peut être utilisé pour calculer la longueur d'un clic ou des effets similaires.

Exemple :

int timer = 0;  // (en haut du fichier script)
if (mouse.IsButtonDown(eMouseRight)) {
if (timer == 40) {
Display("Vous avez appuyé sur le bouton droit durant une seconde");
timer = 0;
}
else {
timer++;
}
}

affichera le message si le joueur presse le bouton droit pendant 1 seconde.

Voir Aussi : IsKeyPressed

SaveCursorUntilItLeaves

(Anciennement SaveCursorForLocationChange, désormais obsolète)

Mouse.SaveCursorUntilItLeaves()

Garde en mémoire le curseur actuel de la souris, et le restaure lorsque la souris quitte le hotspot, l'objet ou le personnage actuel.

Ceci vous permet de changer temporairement le curseur de la souris lorsque celle-ci survole un hotspot, et de lui redonner son ancien curseur automatiquement lorsque le joueur l'éloigne du hotspot.

NOTE : Vous devez appeler cette fonction AVANT d'appliquer le nouveau curseur temporaire, sinon ce sera le nouveau curseur qui sera gardé en mémoire par cette commande.

Exemple :

mouse.SaveCursorUntilItLeaves();
mouse.Mode = eModeTalk;

utilisera le mode de curseur Parler tant que la souris survolera l'objet actuel.

Voir Aussi : Mouse.Mode

SelectNextMode

(Anciennement SetNextCursorMode, désormais obsolète)

Mouse.SelectNextMode()

Passe le curseur de la souris au prochain mode disponible. Ceci est utile pour gérer le clic droit à la façon des jeux Sierra, où celui-ci permet de changer de mode. Cette fonction choisira le prochain mode défini comme Standard Mode, et utilisera également le mode Utiliser Inventaire (Use Inventory) si le joueur a un objet d'inventaire d'activé.

Voir Aussi : Mouse.Mode

SetBounds

(Anciennement SetMouseBounds, désormais obsolète)

Mouse.SetBounds(int gauche, int haut, int droite, int bas)

Restreint la zone d'écran dans laquelle la souris peut se déplacer. Les quatre paramètres correspondent aux coordonnées définissant les bords du rectangle qui correspond à la zone de déplacement de la souris. Ils sont compris entre les valeurs habituelles : (0,0) - (320,200).

Vous pouvez passer (0,0,0,0) pour désactiver la restriction et permettre à la souris de se déplacer sur tout l'écran, de façon normale.

NOTE : L'effet de cette fonction dure jusqu'à ce que le joueur quitte la pièce, après quoi la restriction n'aura plus lieu.

Exemple :

mouse.SetBounds(160, 100, 320, 200);

limitera la zone de déplacement du curseur au quart bas droit de l'écran.

Voir Aussi : Mouse.SetPosition

SetPosition

(Anciennement SetMousePosition, désormais obsolète)

Mouse.SetPosition(int x, int y)

Place le pointeur de la souris aux coordonnées d'écran (X,Y). Celles-ci sont comprises dans l'ensemble habituel : 0,0 - (320,200/240). Les variables mouse.x et mouse.y seront mises à jour de façon à correspondre à la nouvelle position.

NOTE : N'utilisez cette commande que lorsque c'est absolument nécessaire. Déplacer le curseur de la souris à la place du joueur est la meilleure façon de l'énerver si vous le faîtes trop souvent durant le jeu.

Exemple :

mouse.SetPosition(160, 100);

placera le curseur de la souris au centre de l'écran.

Voir Aussi : Mouse.SetBounds

Update

(Anciennement RefreshMouse, désormais obsolète)

Mouse.Update();

Mettra à jour les variables globales “mouse.x” et “mouse.y” selon la position actuelle de la souris. Normalement, ces variables sont définies avant tout appel de fonction. Cependant, si vous avez écrit un très long script où la souris peut avoir bougé depuis le début de son exécution, et que vous devez récupérer la position exacte de la souris, alors cette commande mettra les variables à jour.

Exemple :

Display("La souris se trouvait aux coordonnées : %d, %d.", mouse.x, mouse.y);
mouse.Update();
Display("La souris se trouve maintenant aux coordonnées : %d, %d.", mouse.x, mouse.y);

affichera la position à laquelle se trouve la souris avant l'affichage de chaque message.

UseDefaultGraphic

(Anciennement SetDefaultCursor, désormais obsolète)

Mouse.UseDefaultGraphic()

Redonne son apparence normale au curseur de la souris, celle définie par défaut pour le mode de curseur actuel. Utilisez ceci pour restaurer l'image du curseur après l'avoir changée avec la fonction UseModeGraphic.

Voir Aussi : Mouse.UseModeGraphic

UseModeGraphic

(Anciennement SetMouseCursor, désormais obsolète)

Mouse.UseModeGraphic(CursorMode)

Change l'apparence du curseur de la souris dans le mode de curseur spécifié. Contrairement à la propriété Mouse.Mode, ceci ne change pas le mode considéré lors d'un clic sur un élément interactif (hotspot, personnage, objet). Ceci est utile pour afficher temporairement un curseur “Attente”.

Exemple :

mouse.UseModeGraphic(eModeWait);

utilisera le graphique du mode 'Wait' ('Attente') spécifié dans la fenêtre Cursors de l'Editeur.

Voir Aussi : Mouse.ChangeModeGraphic, Mouse.Mode, Mouse.UseDefaultGraphic

Mode

(Anciennement GetCursorMode, désormais obsolète) (Anciennement SetCursorMode, désormais obsolète)

int Mouse.Mode;

Retourne/Définit le mode actuel qu'utilise le curseur de la souris. La valeur est un des modes de curseur définis dans la fenêtre Curseurs de l'Editeur (mais précédé de “eMode”). Par exemple, un mode de curseur nommé “Walk to” dans la fenêtre Curseurs donnerait eModeWalkto .

Redéfinir cette propriété change et l'apparence du curseur, et le mode considéré lors d'un clic sur une zone interactive (hotspot, personnage, objet).

Exemple :

if (mouse.Mode == eModeWalkto)
{
// code ici
}

exécutera le code seulement si le mode de curseur actuel est le mode eModeWalkto (Marcher).

Voir Aussi : Mouse.SaveCursorUntilItLeaves, Mouse.UseModeGraphic, Mouse.SelectNextMode

Visible

(Anciennement HideMouseCursor, désormais obsolète) (Anciennement ShowMouseCursor, désormais obsolète)

bool Mouse.Visible;

Retourne/Définit si le curseur de la souris est visible. Cette propriété vaut initialement true par défaut, mais la redéfinir à false est utile pour cacher le curseur un certain moment dans des situations où vous ne voulez pas qu'il gêne.

Si vous désirez un style Lucasarts où le curseur de la souris n'est jamais visible durant les scène cinématiques (cutscenes), alors une solution plus facile serait d'importer simplement une image totalement transparente à utiliser comme graphique pour le curseur d'attente, de façon à ce que ce curseur soit totalement invisible.

Exemple :

mouse.Visible = false;
Wait(40);
mouse.Visible = true;

cache la souris, attend une seconde, puis la montre à nouveau.

Voir Aussi : Mouse.UseModeGraphic


multimedia

Table des matières
    • Fonctions Multimedia
      • CDAudio
      • IsAudioPlaying
      • IsSpeechVoxAvailable
      • PlayFlic
      • PlaySilentMIDI
      • PlayVideo
      • SetAudioTypeSpeechVolumeDrop
      • SetAudioTypeVolume
      • SetSpeechVolume
      • SetVoiceMode
      • StopAudio

Fonctions Multimedia

CDAudio

CDAudio (eCDAudioFunction, int param)
Cette fonction vous permet de jouer et de contrôle un CD audio dans votre jeu. Différentes tâches peuvent être accomplies, selon la valeur du paramètre AudioFunction. S'il n'y a pas de lecteur CD sur le système, cette fonction n'a aucun effet.

Le paramètre PARAM est utilisé par certaines fonctions pour certaines raisons ; s'il n'est pas requis par une fonction que vous appelez, passer plutôt zéro.

Les tâches possibles sont les suivantes et dépendent du paramètre eeCDAudioFunction :
eCDIsDriverPresent - vérifie s'il y a un lecteur CD-ROM disponible sur
   le système. Retourne 1 si c'est le cas, 0 sinon.
eCDGetPlayingStatus - vérifie si le lecteur CD est actuellement en train
   de jouer une piste audio. Retourne 1 si c'est le cas, 0 sinon.
eCDPlayTrack - commence à jouer la piste PARAM sur le CD. Si la piste
   n'existe pas, ou si c'est une piste de données, rien ne se passe.
eCDPausePlayback - met la lecture audio courante en pause.
eCDResumePlayback - continue à partir de l'endroit de la piste où la
   lecture était rendue lors de la pause.
eCDGetNumTracks - retourne le nombre de pistes sur le CD actuellement
   dans le lecteur. Si le lecteur est vide, retourne 0.
eCDEject - éjecte le lecteur si cette fonction est disponible. C'est
   une fonctionnalité avec laquelle vous vous amuserez au début parce
   que c'est marrant, puis vous réaliserez que ça n'a pas vraiment
   d'utilité dans votre jeu.
   Votre script se bloque jusqu'à ce que le lecteur soit tout à fait
   éjecté.
eCDCloseTray - l'inverse de Eject. Cela aura pour effet de ramener
   le lecteur.
   Votre script se bloque jusqu'à ce que le lecteur soit tout à fait
   refermé.
eCDGetCDDriveCount - retourne le nombre de lecteurs CD sur le système,
   normalement 1.
eCDSelectActiveCDDrive - change le lecteur CD actuel pour PARAM, où
   PARAM peut valoir de 1 à (nombre de lecteurs). Toutes les autres
   fonctions de CD Audio opèrent sur le lecteur CD en cours.

NOTE: Ces fonctions CD Audio sont lentes comparées aux autres fonctions de script. Vous ne le verrez pas particulièrement si vous les appelez depuis la plupart des scripts, mais si vous les utilisez dans un script repeatedly_execute, le jeu ralentira significativement.

Support selon les plateformes

Windows: Oui, mais ne supporte qu'un seul lecteur CD-ROM
MS-DOS: Oui, si le pilote du matériel CD-ROM est chargé
Linux: Oui, mais ne supporte qu'un seul lecteur CD-ROM
MacOS: Non supporté

Exemple :

CDAudio(eCDPlayTrack, 3);

jouera la piste 3 du CD qui se trouve dans le lecteur.

IsAudioPlaying

(Anciennement IsMusicPlaying, désormais obsolète)
(Anciennement IsSoundPlaying, désormais obsolète)

static bool Game.IsAudioPlaying(optional AudioType)

Retourne true s'il y a une séquence audio du type spécifié en cours de lecture. Si vous ne passez aucun type audio, alors true sera retourné si aucune quelconque séquence n'est en cours de lecture dans le jeu. Si aucune séquence du type spécifié n'est en cours de lecture, retournera false. Vous pouvez utiliser cette commande pour attendre qu'une musique ait finie de jouer, par exemple.

Exemple :

while (Game.IsAudioPlaying(eAudioTypeMusic))
{
  Wait(1);
}

attend que toute musique en cours ait fini de jouer.

Compatibilité : Supporté par AGS 3.2.0 et les versions plus récentes.

Voir aussi : Game.StopAudio

IsSpeechVoxAvailable

IsSpeechVoxAvailable()
Retourne si le fichier SPEECH.VOX est ou non utilisé par le jeu. Cela peut être utile si vous proposez un pack de voix optionnel en téléchargement, et que vous voulez savoir si le joueur le possède ou non.

Retourne 1 si les fichiers sont disponibles, 0 sinon.

Exemple :
if (IsSpeechVoxAvailable()==0)
    Display ("Vous n'avez pas le pack de voix.");

affichera un message si le pack de voix n'est pas disponible.

NOTE : Cette fonction s'appelait avant IsVoxAvailable, mais a été renommée pour éviter toute confusion.

Voir aussi : IsMusicVoxAvailable

PlayFlic

PlayFlic (int numero_flic, int options)
Joue une animation FLI ou FLC. Le jeu regarde s'il trouve un fichier FLICx.FLC ou FLICx.FLI (où X vaut numero_flic) et si c'est le cas, il le joue.

Selon sa valeur, OPTIONS signifie :
0  le joueur ne peut pas passer l'animation
1  le joueur peut presser ESC (//Echap//) pour passer l'animation
2  le joueur peut passer l'animation en cliquant ou en appuyant sur n'importe quelle touche
+10 (c-à-d 10,11,12) ne joue pas en plein écran, juste à la taille flc
+100 ne vide pas l'écran avant de lancer l'animation

Le jeu reste en pause durant l'animation.

Exemple :

PlayFlic(2, 1);

jouera le fichier flic2 et le joueur pourra passer l'animation en appuyant sur la touche ESC (Echap).

Voir aussi : PlayVideo

PlaySilentMIDI

PlaySilentMIDI (int numero_musique)
Cette commande est obsolète.

Utilisez la commande AudioClip.Play et définissez sa propriété Volume à 0 pour simuler l'effet.

Voir aussi : AudioClip.Play, AudioChannel.Volume

PlayVideo

PlayVideo (string nomfichier, int passer, int flags)
Joue un fichier AVI ou MPG, ou tout autre type de fichie supporté par le Lecteur Media.

PASSER définit comment le joueur peut passer la vidéo :
0   le joueur ne peut pas passer
1   le joueur peut appuyer sur ESC (Echap) pour passer la vidéo
2   le joueur peut passer la vidéo avec n'importe quelle touche
3   le joueur peut passer la vidéo avec un clic ou n'importe quelle touche

FLAGS peut avoir les valeurs suivantes :

0:   la vidéo sera jouée à sa taille originale, avec la bande-son
     de l'AVI
1:   la vdiéo sera étendue en plein écran, avec des bandes noires
     appropriées pour maintenir l'aspect d'origine, avec la bande-
     son de l'AVI
10:  taille originale, avec les sons du jeu (la bande-son de l'AVI
     est coupée)
11:  étendue en plein écran, avec les sons du jeu (la bande-son de
     l'AVI est coupée)

Le jeu se met en pause durant l'animation.

IMPORTANT : Les fichiers vidéo ne peuvent pas être compilés dans le fichier de données principal du jeu, vous devrez donc les placer séparément dans le dossier Compiled pour qu'ils soient lancés.

IMPORTANT: Le lecteur média devra posséder les codecs corrects d'installés pour que la vidéo soit jouée. Gardez à l'esprit que si vous encodez votre intro en DivX, par exemple, le lecteur nécessitera les codecs appropriés pour lire la vidéo.

NOTE : Puisque la vidéo est jouée selon la profondeur de couleurs de votre jeu, vous comprendrez qu'il est difficile d'avoir un bon rendu vidéo pour les jeux 256 couleurs, puisqu'il y a réduction simultanée de la profondeur de la vidéo. Le format FLIC peut s'avérer un choix plus judicieux pour les jeux 256 couleurs.

Support selon les plateformes

Windows: Oui MS-DOS: Non Linux: Non MacOS: Oui

Exemple :

PlayVideo ("intro.mpg", 1, 1);

jouera la vidéo Intro.mpg, et le joueur pourra passer avec ESC (Echap) s'il l'a déjà vue.

Voir aussi : PlayFlic

SetAudioTypeSpeechVolumeDrop

(Anciennement game.speech_music_drop, désormais obsolète)

static Game.SetAudioTypeSpeechVolumeDrop(AudioType, int volumeReduction)

Change la propriété VolumeReductionWhileSpeechPlaying du type audio (AudioType) spécifié. Cela modifie le réglage initialement défini dans la section Audio Types (Types Audio) de l'éditeur. Détermine à quel point le volume des séquences de ce type sera réduit lorsque des voix sont jouées.

Passez la valeur 0 pour annuler l'ajustement de volume, passez jusqu'à 100 pour rendre ces séquences totalement muettes lorsque du doublage est en cours.

Exemple :

Game.SetAudioTypeSpeechVolumeDrop(eAudioTypeMusic, 25);

réduira le volume des séquences audio de type Music (Musique) de 25% lorsqu'une voix est jouée.

Compatibilité : Supporté par AGS 3.2.0 et les versions plus récentes.

Voir aussi : Game.SetAudioTypeVolume

SetAudioTypeVolume

(Anciennement SetSoundVolume, désormais obsolète)

static Game.SetAudioTypeVolume(AudioType, int volume, ChangeVolumeType)

Change le volume par défaut du type audio (AudioType) spécifié. Ceci vous permet de changer le volume de toutes les séquences audio d'un type particulier, de façon à contrôler facilement le volume des sons et des musiques séparément, par exemple.

Les valeurs possibles pour ChangeVolumeType sont :

eVolChangeExisting      change le volume des séquences audio en cours de lecture
eVolSetFutureDefault    change le volume par défaut des séquences de ce type
eVolExistingAndFuture   change le volume aussi bien des séquences ultérieurement qu'actuellement jouées

Si vous utilisez eVolSetFutureDefault ou eVolExistingAndFuture, alors la propriété DefaultVolume de toutes les séquences audio de ce type sera remplacée. Cela signifie que tout réglage de DefaultVolume depuis l'éditeur sera perdu.

Exemple :

Game.SetAudioTypeVolume(eAudioTypeMusic, 20, eVolExistingAndFuture);

définira le volume de toutes les musiques actuellement jouées et qui seront jouées plus tard à 20%.

Compatibilité : Supporté par AGS 3.2.0 et les versions plus récentes.

Voir aussi : SetSpeechVolume, AudioClip.Play, System.Volume

SetSpeechVolume

SetSpeechVolume (int volume)
Définit le volume des paroles dans le jeu. VOLUME va de 0 à 255, où 255 est le plus fort. Le volume des paroles par défaut est 255, cette fonction est donc utile pour réduire le volume.

Exemple :
SetSpeechVolume(200);

définira le volume des paroles à 200.

Voir aussi : SetMusicVolume, SetSoundVolume

SetVoiceMode

SetVoiceMode (VoiceMode)
Détermine si les voix et/ou le texte des discours sont utilisés dans le jeu.

Les valeurs pour VoiceMods peuvent être :
eSpeechTextOnly      pas de voix, texte seul
eSpeechVoiceAndText  voix et texte
eSpeechVoiceOnly     voix seule, pas de texte

Vaut eSpeechVoiceAndText par défaut si les paroles sont activées, et eSpeechTextOnly si ce n'est pas le cas. Changer ce paramètre change le comportement de toutes les commandes Say et Display auxquelles est assigné un fichier de paroles.

ATTENTION : vous ne devriez utiliser eSpeechVoiceOnly que si le joueur le spécifie volontairement, puisque vous ne pouvez pas être sûr qu'il possède une carte sonore et alors il ne comprendrait pas ce qui se passe.

Exemple :

if (IsSpeechVoxAvailable()==1)
    SetVoiceMode(eSpeechVoiceAndText);

jouera les voix ainsi que les textes seulement si le pack de voix est disponible.

StopAudio

(Anciennement Game.StopSound, désormais oboslète)
(Anciennement StopMusic, désormais obsolète)

static Game.StopAudio(optional AudioType)

Stoppe toute séquence en cours de lecture. Si vous ne passez aucun paramètre, alors tout son cessera. Autrement, vous pouvez passer un type audio (AudioType) pour n'arrêter que les séquences de ce type.

S'il y a des séquences mises en attente de lecture par PlayQueued, elles seront annulées.

Exemple :

Game.StopAudio();

arrêtera toute séquence en cours de lecture.

Compatibilité : Supporté par AGS 3.2.0 et les versions plus récentes.

//Voir aussi :// Game.IsAudioPlaying, AudioClip.Play, AudioChannel.Stop


object

Table des matières
    • Fonctions et propriétés des Objets (Object)
      • Animate
      • GetAtScreenXY
      • GetProperty
      • GetTextProperty
      • IsCollidingWithObject
      • MergeIntoBackground
      • Move
      • RemoveTint
      • RunInteraction
      • SetPosition
      • SetView
      • StopAnimating
      • StopMoving
      • Tint
      • Animating
      • Baseline
      • BlockingHeight
      • BlockingWidth
      • Clickable
      • Frame
      • Graphic
      • ID
      • IgnoreScaling
      • IgnoreWalkbehinds
      • Loop
      • Moving
      • Name
      • Solid
      • Transparency
      • View
      • Visible
      • X
      • Y

Fonctions et propriétés des Objets (Object)

Animate

(Anciennement AnimateObject, désormais obsolète) (Anciennement AnimateObjectEx, désormais obsolète)

Object.Animate(int loop, int delai, optionnel RepeatStyle,
optionnel BlockingStyle, optionnel Direction)

Anime l'objet, en utilisant la séquence numéro LOOP de sa vue actuelle. La vitesse générale de l'animation est définie par DELAI, où 0 signifie rapide, les nombres supérieurs ralentissant l'animation. Le délai pour chaque image se calcule par DELAI + FRAME SPD (vitesse propre à l'image), donc la vitesse de chaque image influe sur la vitesse générale.

Le paramètre RepeatStyle définit si l'animation répétera le cycle des images continuellement ou non. Il peut valoir eOnce (ou zéro), auquel cas l'animation débutera à la première image de la séquence, et fera défiler jusqu'à atteindre la dernière avant d'arrêter l'animation. S'il vaut eRepeat (ou 1), alors lorsque la dernière image arrivera, l'animation reprendra à partir de la première image de la séquence et ainsi de suite. Si RepeatStyle vaut 2 alors l'animation sera jouée une fois, mais retournera ensuite à la première image de la séquence avant de s'arrêter (tandis que si le paramètre vaut 0, l'image de l'objet inanimé sera la dernière de la séquence).

Pour BlockingStyle vous pouvez passer eBlock (auquel cas la fonction attendra la fin de l'animation pour reprendre l'exécution), ou eNoBlock (auquel cas l'animation commencera à jouer, mais le script continuera de s'exécuter). La valeur par défaut est eBlock.

Direction spécifie la façon dont est jouée l'animation. Vous pouvez lui donner la valeur eForwards (par défaut), auquel cas l'animation est jouée dans l'ordre normal de la séquence, ou eBackwards, auquel cas la séquence est jouée à l'envers.

Vous devez utiliser SetView avant d'utiliser cette commande, pour pouvoir définir la vue actuelle de l'objet.

Exemple :

object[0].Animate(2, 5);
object[1].Animate(1, 3, eOnce, eBlock, eBackwards);

animera l'objet 0 en utilisant la séquence 2 de sa vue courante, à la vitesse 5, et ne jouera l'animation qu'une seule fois. Tout ceci exécuté en arrière-plan. Ensuite, l'objet 1 sera animé dans l'ordre inverse de la séquence 1 de sa vue actuelle, à la vitesse 3. La fonction ne permettra au script de poursuivre son exécution qu'une fois l'animation terminée.

Voir Aussi : Character.Animate, Object.Animating, Object.SetView, Object.StopAnimating

GetAtScreenXY

(Anciennement fonction globale GetObjectAt, désormais obsolète)

static GameObject* Object.GetAtScreenXY(int x, int y)

Vérifie s'il y a un objet dans la pièce aux coordonnées (X,Y) de l'ECRAN. Retourne l'objet s'il y en a un, ou null s'il n'y en a pas.

Voyez la description de GetLocationName pour plus de détails sur les coordonnées à l'écran.

Exemple :

if (Object.GetAtScreenXY(211,145) == oRocher) {
// code ici
}

n'exécutera le code que s'il y a l'objet oRocher aux coordonnées propre à l'écran (211,145).

Voir Aussi : Hotspot.GetAtScreenXY, Game.GetLocationName

GetProperty

(Anciennement GetObjectProperty, désormais obsolète)

Object.GetProperty(string propriete)

Retourne la valeur de la propriété personnalisée PROPRIETE pour l'objet spécifié.

Cette commande fonctionne avec les propriétés numériques (retourne le nombre), et avec les propriétés booléennes (retourne 1 si la case est cochée, sinon 0).

Utilisez la fonction équivalente GetTextProperty pour obtenir une propriété textuelle.

Exemple :

if (object[0].GetProperty("Valeur") &gt; 200)
Display("La valeur de l'objet 0 est supérieure à 200 !");

affichera le message si la propriété “Valeur” de l'objet 0 est supérieure à 200.

Voir Aussi : Object.GetTextProperty

GetTextProperty

(Anciennement GetObjectPropertyText, désormais obsolète) (Anciennement Object.GetPropertyText, désormais obsolète)

String Object.GetTextProperty(string propriete)

Retourne la valeur de la propriété personnalisée PROPRIETE pour l'objet spécifié.

Cette commande ne fonctionne qu'avec les propriétés textuelles. Elle retourne le texte de la propriété.

Utilisez la fonction équivalente GetProperty pour obtenir une propriété non-textuelle.

Exemple :

String description = object[0].GetTextProperty("Description");
Display("La description de l'objet 0 : %s", description);

récupérera la propriété “description” de l'objet 0 et l'affichera.

Voir Aussi : Object.GetProperty

IsCollidingWithObject

(Anciennement AreObjectsColliding, désormais obsolète)

bool Object.IsCollidingWithObject(Object* obj2)

Vérifie si l'objet spécifié et OBJ2 se touchent. Retourne true si c'est le cas, sinon false.

NOTE : Cette fonction effectue une vérification rectangulaire, même si la détection au pixel près est activée.

Exemple :

if (object[2].IsCollidingWithObject(object[3]))
{
Display("Les objets 2 et 3 se touchent !");
}

affichera le message si les objets 2 et 3 se touchent.

Voir Aussi : AreThingsOverlapping

MergeIntoBackground

(Anciennement MergeObject, désormais obsolète)

Object.MergeIntoBackground()

Passe l'objet en tant qu'élément d'arrière-plan pour la pièce. En faisant cela, l'objet devient une partie de l'arrière-plan et ainsi ne réduit pas la vitesse du jeu. C'est une opération à sens unique - une fois que l'objet a été incorporé, ça ne peut pas être annulé et l'état de la pièce est définitivement altéré. Ainsi, vous ne devriez utiliser cette fonction que si un événement du jeu signifiant que la pièce est définitivement changée est survenu.

NOTE : après avoir appelé cette fonction, vous ne pouvez plus utiliser l'objet et il est devient définitivement inaccessible dans le jeu.

NOTE : les objets ne peuvent être incorporés que si l'image qu'ils utilisent a été importée à la même profondeur des couleurs que l'image d'arrière-plan.

Exemple :

object[3].MergeIntoBackground();

incorporera l'image de l'objet à l'image d'arrière-plan de la pièce et rendra l'objet inutilisable.

Move

(Anciennement MoveObject, désormais obsolète) (Anciennement MoveObjectDirect, désormais obsolète)

Object.Move(int x, int y, int vitesse, optional BlockingStyle,
optional WalkWhere);

Commence à déplacer l'objet depuis sa position actuelle vers (X,Y). Il se déplacera à la vitesse VITESSE, qui utilise la même échelle que pour les valeur Walk Speed (Vitesse Déplacement) dans l'Editeur AGS.

Si BlockingStyle vaut eNoBlock (par défut), alors le script reprend immédiatement son exécution, et l'objet se déplacera en arrière-plan.

Si BlockingStyle vaut eBlock, alors cette commande attendra que l'objet ait fini son mouvement avant de rendre le contrôle au script.

Si WalkWhere vaut eWalkableAreas (par défaut), alors l'objet tentera de se rapprocher le plus possible de (X,Y) en respectant les zones de déplacement libre de la pièce.

Si WalkWhere vaut eAnywhere, alors l'objet se rendra directement de sa position actuelle à (X,Y), en ignorant toute zone de déplacement.

Exemple :

object[2].Move(125, 40, 4, eBlock);

déplacera l'objet 2 vers (125,40) et ne rendra le contrôle au joueur qu'une fois que l'objet y sera rendu.

Voir Aussi : Object.Moving, Character.Walk, Object.StopMoving

RemoveTint

(Anciennement RemoveObjectTint, désormais obsolète)

Object.RemoveTint()

Annule les effets de la commande Tint, et réutilise la teinte ambiante de la pièce sur l'objet.

Exemple :

object[1].Tint(0, 250, 0, 30, 100);
Wait(40);
object[1].RemoveTint();

teintera l'objet 1 en vert pendant une seconde, puis le rendra à la normale.

Voir Aussi : Object.Tint

RunInteraction

(Anciennement RunObjectInteraction, désormais obsolète)

Object.RunInteraction(CursorMode)

Lance la liste d'interactions propres à l'objet comme si le joueur avait cliqué dessus dans la pièce, en utilisant le mode spécifié de curseur.

Exemple :

object[3].RunInteraction(eModeInteract);

exécutera le code placé dans l'interaction “Interact with object” de l'objet 3.

Voir Aussi : ProcessClick, Character.RunInteraction, Hotspot.RunInteraction

SetPosition

(Anciennement SetObjectPosition, désormais obsolète)

Object.SetPosition(int x, int y)

Change la position de l'objet pour (X,Y). Ces coordonnées déterminent la position du coin bas-gauche de l'objet.

Cette commande est équivalente à définir object.X et object.Y séparemment, mais offre une façon plus pratique de le faire.

NOTE : Cette commande ne peut pas être utilisée lorsque l'objet est en déplacement.

Exemple :

object[2].SetPosition(50, 100);

changera la position de l'objet 2 pour (50,100).

Voir Aussi : Object.X, Object.Y

SetView

(Anciennement SetObjectFrame, désormais obsolète) (Anciennement SetObjectView, désormais obsolète)

Object.SetView(int vue, optionnel int loop, optional int frame)

Définit la vue de l'objet à VUE, et change l'image de l'objet pour l'image numéro FRAME de la séquence numéro LOOP de la VUE. Si vous n'entrez pas la séquence ou l'image, alors elles seront inchangées.

Vous devez utiliser cette commande avant d'appeler Animate, de façon à ce que AGS puisse savoir avec quelle vue animer l'objet.

Exemple :

object[3].SetView(14);
object[1].SetView(5, 2, 0);

changera la vue de l'objet 3 pour la vue numéro 14, et changera la vue de l'objet 5 pour la vue 1, en utilisant l'image 0 de la séquence 2.

Voir Aussi : Object.Animate

StopAnimating

Object.StopAnimating()
Stoppe l'animation de l'objet. Il utilisera alors l'image sur laquelle l'animation s'est arrêtée jusqu'à ce que vous la changier ou que vous lancier une nouvelle animation.

Exemple :
if (object[2].Animating) {
object[2].StopAnimating();
}

stoppera l'animation de l'objet 2 s'il était animé.

Voir Aussi : Object.Animate, Object.Animating

StopMoving

(Anciennement StopObjectMoving, désormais obsolète)

Object.StopMoving()

Stoppe le déplacement de l'objet. Il restera à la position où il était rendu jusqu'à ce qu'une commande la change plus loin.

Exemple :

if (object[2].Moving) {
object[2].StopMoving();
}

stoppera le déplacement de l'objet 2 s'il se déplaçait.

Voir Aussi : Object.Moving, Object.Move, Character.StopMoving

Tint

(Anciennement SetObjectTint, désormais obsolète)

Object.Tint(int rouge, int vert, int bleu,
int saturation, int luminosite)

Teinte l'objet à l'écran avec les couleurs (ROUGE, VERT, BLEU) avec une saturation de SATURATION pourcents.

Cette fonction applique une teinte à l'objet spécifié. Pour savoir le sens de tous les paramètres, voyez SetAmbientTint.

La teinte définie par cette fonction prend le dessus sur toute teinte ambiante définie pour la pièce. Pour cette raison, passer une SATURATION de 0 dans cette fonction n'annule pas toute saturation sur l'objet - cela assure plutôt qu'aucune teinte ne sera appliquée à l'objet (même si une teinte ambiante est définie).

Pour annuler la teinte définie par cette fonction et réutiliser la teinte ambiante sur l'objet, appelez RemoveTint.

NOTE : Cette fonction ne fonctionne qu'avec les jeux hautes-couleurs et avec les sprites hautes-couleurs.

Exemple :

object[1].Tint(0, 250, 0, 30, 100);

teintera l'objet 1 avec du vert.

Voir Aussi : Object.RemoveTint, SetAmbientTint

Animating

(Anciennement IsObjectAnimating, désormais obsolète)

readonly bool Object.Animating

Retourne 1 si l'objet spécifié est actuellement animé. Retourne 0 si l'objet a fini son animation.

Cette propriété est en lecture seule. Pour changer l'animation de l'objet, utilisez la commande Animate.

Exemple :

object[2].Animate(5, 0);
while (object[2].Animating) Wait(1);

animera l'objet 2 et attendra que l'animation soit finie.

En réalité, vous utiliseriez simplement le paramètre Blocking de Animate, vous n'avez donc pas besoin de faire ceci.

Voir Aussi : Object.Animate, Object.Moving, Object.StopAnimating, Object.X, Object.Y

Baseline

(Anciennement GetObjectBaseline, désormais obsolète) (Anciennement SetObjectBaseline, désormais obsolète)

int Object.Baseline

Retourne/Définit la baseline de l'objet. Ceci vous permet de modifier la ligne que vous manipulez dans l'éditeur. Vous pouvez désactiver la baseline (et ainsi réutiliser la base de l'image de l'objet à l'écran) en donnant la valeur 0 à cette propriété.

Sinon, donnez-lui la coordonnée d'écran Y que vous voulez utiliser, normalement de 1 à 200 à moins que vous soyez dans une pièce plus grande qu'habituellement.

Si vous voulez récupérer la baseline et que la valeur retournée est 0, alors la baseline est la coordonnée Y de l'objet.

Exemple :

object[4].Baseline = 100;

utilisera une ligne horizontale à la coordonnée Y = 100 comme baseline pour l'objet 4.

Voir Aussi : Character.Baseline, Object.Y, SetWalkBehindBase

BlockingHeight

int Object.BlockingHeight
Retourne/Définit la hauteur de blocage de l'objet.

La hauteur de blocage détermine la dimension du rectangle qu'occupera l'objet dans la pièce, auquel les personnages se percuteront. Si cette propriété vaut 0 (par défaut), alors le rectangle de blocage est automatiquement défini en fonction de la largeur de l'objet, avec une hauteur de 5 pixels.

Vous pouvez changer manuellement la valeur en entrant une hauteur de blocage en pixels, qui définira la dimension de la zone de déplacement qu'occupera l'objet.

NOTE : Cette propriété n'a d'effet que si la propriété Solid vaut true.

Exemple :
oRocher.BlockingHeight = 20;

fera que l'objet Rocher bloquera 20 pixels de hauteur (10 au-dessus et 10 sous sa basline).

Voir Aussi : Object.BlockingWidth, Object.Solid

BlockingWidth

int Object.BlockingWidth
Retourne/Définit la largeur de blocage de l'objet.

La largeur de blocage détermine la dimension du rectangle qu'occupera l'objet dans la pièce, auquel les personnages se percuteront. Si cette propriété vaut 0 (par défaut), alors le rectangle de blocage est automatiquement défini en fonction de la largeur de l'objet, avec une hauteur de 5 pixels.

Vous pouvez changer manuellement la valeur en entrant une largeur de blocage en pixels, qui définira la dimension de la zone de déplacement qu'occupera l'objet.

NOTE : Cette propriété n'a d'effet que si la propriété Solid vaut true.

Exemple :
oRocher.BlockingWidth = 50;

fera que l'objet Rocher bloquera 50 pixels de hauteur (25 pixels à sa gauche et 25 à sa droite, à partir du centre).

Voir Aussi : Object.BlockingHeight, Object.Solid

Clickable

(Anciennement SetObjectClickable, désormais obsolète)

bool Object.Clickable

Retourne/Définit si l'objet est considéré comme un élément avec lequel le joueur peut interagir.

Si cette propriété vaut 1, alors le joueur peut le regarder, lui parler, etc. Si elle vaut 0, alors l'objet ne réagira pas aux clics et la souris cliquera sur ce qui se trouve derrière l'objet. Ceci est utile si vous utilisez l'objet comme un effet visuel et que vous ne voulez pas que le joueur puisse cliquer dessus.

Exemple :

object[2].Clickable = 0;

fera que l'objet 2 ignorera les clics du joueur.

Voir Aussi : Character.Clickable, Object.IgnoreWalkbehinds

Frame

readonly int Object.Frame
Retourne le numéro d'image (Frame) qui correspond actuellement à l'objet. Si aucune vue ne lui est actuellement associée, vaudra 0 (auquel cas la propriété Graphic correspondra au numéro de sprite).

Cette propriété est en lecture seule. Pour changer l'image (Frame), utilisez les fonctions d'animation.

Exemple :
Display("L'image de l'objet est actuellement la frame numéro %d.", oPorte.Frame);

affichera le numéro d'image actuelle de l'objet oPorte.

Voir aussi : Object.Graphic, Object.Loop, Object.View

Graphic

(Anciennement GetObjectGraphic, désormais obsolète) (Anciennement SetObjectGraphic, désormais obsolète)

int Object.Graphic

Retourne/Définit le numéro de la sprite que l'objet utilise actuellement. Vous pouvez trouver le numéro de sprite dans le Sprite Manager. Si l'objet est actuellement animé (grâce à une commande Animate) et que vous changez son image, alors l'animation sera stoppée.

Exemple :

object[2].Graphic = 100;

changera l'image de l'objet 2 pour utiliser l'image contenue à l'emplacement 100 du sprite manager.

Voir Aussi : Object.SetView

ID

readonly int Object.ID
Retourne le numéro ID de l'objet. Ceci est le numéro de l'objet dans l'éditeur, ce qui est utile si vous devez gérer du code qui requiert l'utilisation du numéro de l'objet plutôt que son nom.

Exemple :
MoveObject(oRocher.ID, 100, 50, 5);

utilise la fonction obsolète MoveObject pour déplacer l'objet Rocher à (100, 50) à une vitesse de 5.

IgnoreScaling

bool Object.IgnoreScaling
Retourne/Définit si l'objet est concerné par le zoom des zones de déplacement. Ceci revient, bien que les valeurs soient inversées, à cocher ou non la case “Use walkable area scaling” dans la fenêtre Objets de l'éditeur.

Si la valeur est true, l'objet conservera toujours sa taille. Si elle vaut false, alors l'objet sera réduit ou agrandi selon sa position sur la zone de déplacement.

Exemple :
oPorte.IgnoreScaling = true;

empêchera l'objet Porte d'être redimensionné en fonction des zones de déplacement libre.

Voir Aussi : Object.IgnoreWalkbehinds

IgnoreWalkbehinds

(Anciennement SetObjectIgnoreWalkbehinds, désormais obsolète)

bool Object.IgnoreWalkbehinds

Définit si l'objet est affecté ou non par les zones “par-dessus”. Donner la valeur 0 à ce paramètre (par défaut) signifie que l'objet sera placer derrière toute zone “par-dessus” en fonction des baselines.

Si la valeur est de 1, alors l'objet ne sera jamais placé derrière une zone “par-dessus”. Ceci est utile si par exemple vous voulez qu'un objet représente une photo sur un mur, et que le mur correspond à une zone “par-dessus” - mais dans le même temps, vous voulez garder une concordance avec les personnage, et changer la baseline ne fonctionnerait alors pas.

Exemple :

object[1].IgnoreWalkbehinds = 1;

fera que l'objet 1 ignorera les zones “par-dessus”.

Voir Aussi : Character.IgnoreWalkbehinds, Object.Clickable, Object.IgnoreScaling

Loop

readonly int Object.Loop
Retourne la séquence correspondant actuellement à l'objet. Si aucune vue n'est actuellement assignée à l'objet, cela vaudra 0 (auquel cas la propriété Graphic correspondra à son numéro de sprite).

Cette propriété est en lecture seule. Pour changer de séquence, utiliser les fonctions d'animation.

Exemple :
Display("La séquence de l'objet oPorte est la séquence numéro %d.", oDoor.Loop);

affichera le numéro de séquence courante de l'objet oPorte.

Voir aussi : Object.Frame, Object.Graphic, Object.View

Moving

(Anciennement IsObjectMoving, désormais obsolète)

readonly bool Object.Moving

Retourne 1 si l'objet se déplace actuellement, sinon 0.

Cette propriété est en lecture seule ; pour modifier le déplacement de l'objet, utilisez les commandes Move et StopMoving.

Exemple :

object[2].Move(125,40,3);
while (object[2].Moving) Wait(1);

déplacera l'objet 2 aux coordonnées (125,40) et rendra le contrôle au joueur lorsque l'objet y sera rendu.

Voir Aussi : Object.Animating, Object.StopMoving

Name

(Anciennement GetObjectName, désormais obsolète) (Anciennement Object.GetName, désormais obsolète)

readonly String Object.Name;

Retourne le nom de l'objet.

NOTE : Cette propriété est en lecture seule. Il n'est pour le moment pas possible de changer le nom d'un objet lorsque le jeu est en exécution.

Exemple :

Display("Le nom de l'objet 0 est %s", object[0].Name);

récupérera puis affichera le nom de l'objet 0.

Voir Aussi : Game.GetLocationName

Solid

bool Object.Solid
Retourne/Définit si l'objet peut être traversé ou non par les personnages.

Si la valeur est true, alors l'objet est solide et bloquera le chemin des personnages solides. Si la propriété vaut false, alors l'objet peut être traversé par les personnages.

NOTE : les objets solides ne bloquent que les personnages, ils n'empêchent pas les autres objets de les traverser.

Exemple :
oPetitrocher.Solid = 1;

signifiera que l'objet Petitrocher bloquera le chemin des personnages.

Voir Aussi : Object.BlockingHeight, Object.BlockingWidth

Transparency

(Anciennement SetObjectTransparency, désormais obsolète)

int Object.Transparency

Retourne/Définit le niveau de transparence de l'objet.

Si la valeur est 100, cela signifie que l'objet est totalement invisible, et des valeurs inférieures font varier le niveau de transparence. Définissez la propriété à 0 pour rendre l'objet totalement opaque.

NOTE : La transparence ne fonctionne pour le moment qu'avec les jeux hautes-couleurs, et l'image de l'objet doit avoir été importée en hautes-couleurs pour que la transparence s'applique.

NOTE : Rendre un grand objet transparent peut ralentir sensiblement la machine.

Des arrondissements sont faits pour appliquer la transparence – c'est pourquoi, si vous récupérez la transparence après l'avoir définie, la valeur que vous obtiendrez peut être différente. Ainsi, utiliser une boucle avec object[0].Transparency++; n'est pas recommandé puisqu'elle s'achèvera probablement trop vite.

Pour afficher/faire disparaître un objet en fondu, la meilleure façon de faire est celle-ci :

Exemple :

int trans = object[0].Transparency;
while (trans < 100) {
trans++;
object[0].Transparency = trans;
Wait(1);
}

fera graduellement disparaître l'objet en fondu depuis son niveau de transparence actuelle, jusqu'à ce qu'il soit totalement invisible.

Voir Aussi : Character.Transparency, GUI.Transparency

View

readonly int Object.View
Retourne la vue actuellement définie pour l'objet. Ceci est soit le numéro de la vue, soit 0 si l'objet n'est pas actuellement assigné à une vue (auquel cas la propriété Graphic contiendra plutôt son numéro de sprite).

Cette propriété est en lecture seule. Pour changer la vue, utilisez la fonction SetView. Pour annuler la vue, définissez la propriété Graphic à un emplacement de sprite.

Exemple :
Display("La vue de l'objet Porte est actuellement la vue numéro %d.", oPorte.View);

affichera le numéro de vue actuelle de l'objet oPorte.

SeeAlso: Object.SetView, Object.Graphic

Visible

(Anciennement IsObjectOn, désormais obsolète) (Anciennement ObjectOff, désormais obsolète) (Anciennement ObjectOn, désormais obsolète)

bool Object.Visible

Retourne/Définit si l'objet est visible ou non. Si la valeur est 1 (true), l'objet est activé et visible dans la pièce. Si vous passez la valeur 0 (false), l'objet disparaît et n'apparaît plus dans la pièce.

Exemple :

object[5].Visible = false;

fera disparaître l'objet numéro 5 de la pièce actuelle.

X

(Anciennement GetObjectX, désormais obsolète)

int Object.X

Retourne/Définit la coordonnée X de l'objet.

NOTE : Cette propriété ne peut pas être modifiée tant que l'objet est en déplacement.

Exemple :

Display("La coordonnée X de l'objet 1 est %d", object[1].X);

affichera la coordonnée X de l'objet 1.

Voir Aussi : Object.Y, Object.Animating, Object.Visible, Object.SetPosition

Y

(Anciennement GetObjectY, désormais obsolète)

int Object.Y

Retourne/Définit la coordonnée Y de l'objet, qui correspond au bas de l'image de l'objet.

NOTE : Cette propriété ne peut pas être modifiée tant que l'objet est en déplacement.

NOTE : Si vous tentez d'utiliser cette coordonnée avec Objet.GetAtScreenXY, vous trouverez que l'objet n'est pas détecté. La sprite de l'objet est dessinée de la coordonnée Y (Objet.Y - Hauteur) à (Object.Y - 1).

Exemple :

Display("La coordonnée Y de l'objet 1 est %d", object[1].Y);

affichera la coordonnée Y de l'objet 1.

Voir Aussi : Object.Animating, Object.Baseline, Object.X, Object.SetPosition


overlay

Table des matières
    • Fonctions et propriétés des Calques (Overlay)
      • CreateGraphical
      • CreateTextual
      • Remove
      • SetText
      • Valid
      • X
      • Y

Fonctions et propriétés des Calques (Overlay)

CreateGraphical

(Anciennement CreateGraphicOverlay, désormais obsolète)

static Overlay* Overlay.CreateGraphical(int x, int y, int slot, bool transparent)

Crée un calque sur l'écran contenant une copie de l'image contenue à l'emplacement SLOT du Sprite Manager. L'image est placée aux coordonnées (X,Y) à l'écran (et non à celles de la pièce).

Si transparent vaut 'true', alors le calque sera dessiné de la même façon que les personnages/objets, et si la valeur est 'false' alors un rectangle noir sera peint comme fond de la sprite.

Voyez la description de Overlay.CreateTextual pour plus de précisions sur les calques.

Exemple :

Overlay* monCalque = Overlay.CreateGraphical(100, 100, 300, true);
Wait(40);
monCalque.Remove();

créera un calque de l'image contenue dans l'emplacement 300 du Sprite Manager, aux coordonnées (100,100). Cela l'affichera durant une seconde, puis l'effacera.

Voir Aussi : Overlay.CreateTextual, Overlay.Remove

CreateTextual

(Anciennement CreateTextOverlay, désormais obsolète)

static Overlay* Overlay.CreateTextual(int x, int y, int largeur, FontType font, int couleur, string texte)

Crée un calque à l'écran contenant le texte que vous passez à la position spécifiée. Un tel calque ressemble trait pour trait à du texte de discours affiché pour les conversations, cependant avec cette commande le texte reste affiché à l'écran jusqu'à ce que vous l'effacier avec la commande Remove, ou que le joueur change de pièce, auquel cas le calque est automatiquement effacé.

Les paramètres X et Y définissent la position où sera affiché le calque à l'écran, selon son coin haut-gauche. LARGEUR est la largeur, en pixels, de la zone de texte. FONT est le numéro de police utilisé par l'éditeur (0 est la police normale, 1 est la police de discours). COULEUR est la couleur du texte - utilisez une couleur allant de 1 à 15. Finalement, TEXTE est bien entendu le texte qui sera affiché.

La fonction retourne un objet Overlay, que vous utiliserez plus tard pour repositionner et effacer le calque.

Vous pouvez insérer des valeurs de variables dans le message. Pour plus d'information, voyez la section string formatting.

NOTE : des grands calques, tout comme de grands objets, peuvent ralentir la machine lorsqu'ils sont affichés.

NOTE : pour le moment il n'est possible d'afficher que 10 calques à la fois. D'autres commandes comme Say et SayBackground créent des calques de façon interne, donc n'espérez pas pouvoir en créer 10 avec CreateTextual.

NOTE : si la variable contenant l'objet Overlay est créée dans une fonction, le calque sera supprimé lorsque celle-ci aura terminé son exécution. Par conséquent, si vous vouez que le calque reste affiché à l'écran après l'exécution de la fonction où il a été créé, la déclaration Overlay* de la variable doit être placée en haut du script et hors de toute fonction.

Exemple :

Overlay* monCalque = Overlay.CreateTextual(50,80,120, Game.SpeechFont, 15,"Ceci est le texte du calque");
Wait(40);
monCalque.Remove();

affichera une zone de texte de 120 pixels, dont le coin haut gauche sera placé aux coordonnées (50,80), contenant la chaîne “Ceci est le texte du calque” qui utilisera la police de discours (SpeechFont) et la couleur blanche. Le calque restera affiché durant une seconde, puis sera effacé.

Voir Aussi : Overlay.CreateGraphical, Overlay.X, Overlay.Y, Overlay.Remove

Remove

(Anciennement RemoveOverlay, désormais obsolète)

Overlay.Remove()

Efface le calque spécifié de l'écran. Utilisez ceci lorsque vous avez fini d'utiliser le calque.

Exemple :

Overlay* monCalque = Overlay.CreateTextual(50,80,120,2,15,"Ceci est le texte du calque");
Wait(200);
monCalque.Remove();

créera un calque de texte, attendra 200 cycles de jeu (environ 5 secondes) puis effacera le calque de l'écran.

Voir Aussi : Overlay.CreateTextual

SetText

(Anciennement SetTextOverlay, désormais obsolète)

Overlay.SetText(int largeur, FontType font, int couleur, string texte, ...)

Remplace le calque spécifié par un nouveau, aux mêmes coordonnées mais spécifié avec un nouveau texte, une nouvelle largeur, une nouvelle police et une nouvelle couleur.

Vous pouvez insérer des valeurs de variables dans le message. Pour plus d'information, voyez la section string formatting.

Exemple :

Overlay* monCalque = Overlay.CreateTextual(50,80,120,Game.SpeechFont,15,"Ceci est le texte du calque");
Wait(200);
monCalque.SetText(120,2,15,"Ceci est le texte qui remplace l'ancien");

créera un calque de texte, attendra 200 cycles de jeu (environ 5 secondes), puis remplacera le calque par un nouveau.

Voir Aussi : Overlay.CreateTextual, Overlay.Remove

Valid

(Anciennement IsOverlayValid, désormais obsolète)

readonly bool Overlay.Valid;

Vérifie si le calque est actuellement affiché ou non. Retourne 1 si c'est le cas, sinon 0.

Exemple :

Overlay* monCalque = Overlay.CreateTextual(50,80,120,2,15,"Ceci est le texte du calque");
Display("Propriété valide du calque avant : %d", myOverlay.Valid);
monCalque.Remove();
Display("Propriété valide du calque après : %d", myOverlay.Valid);

créera un calque, et affichera la proriété Valid (qui vaudra 1). Puis, efface le calque et affiche une nouvelle fois sa propriété Valid (qui sera alors 0).

Voir Aussi : Overlay.CreateTextual, Overlay.Remove

X

(Anciennement MoveOverlay, désormais obsolète)

int Overlay.X;

Retourne/Définit la coordonnée X du calque (c'est-à-dire le côté gauche du calque).

Ceci vous permet de déplacer dynamiquement les calques à l'écran.

Exemple :

Overlay* calqueTest = Overlay.CreateTextual(50,80,120,2,15,"Ceci est le texte du calque");
while (calqueTest.X &lt; 100) {
calqueTest.X++;
Wait(1);
}
calqueTest.Remove();

crée un calque de texte, puis le déplace graduellement vers la droite pour enfin l'effacer.

Voir Aussi : Overlay.CreateTextual, Overlay.Y, Overlay.Remove

Y

(Anciennement MoveOverlay, désormais obsolète)

int Overlay.Y;

Retourne/Définit la coordonnée Y du calque (c'est-à-dire le haut du calque).

Ceci vous permet de déplacer dynamiquement les calques à l'écran.

Exemple :

Overlay* calqueTest = Overlay.CreateTextual(50,50,120,2,15,"Ceci est un calque textuel");
while (calqueTest.Y &lt; 100) {
calqueTest.Y++;
Wait(1);
}
calqueTest.Remove();

crée un calque textuel, puis le déplace graduellement vers le bas pour enfin l'effacer.

Voir Aussi : Overlay.CreateTextual, Overlay.X, Overlay.Remove


palette

Table des matières
    • Fonctions de Palette
      • CyclePalette
      • SetPalRGB
      • UpdatePalette

Fonctions de Palette

CyclePalette

CyclePalette (int debut, int fin)
Sert pour les effets spéciaux, comme les couleurs fluctuantes à l'écran titre de Space Quest 4, ou le logo Sierra des jeux Sierra les plus récents. Les indices de la palette de DEBUT à FIN sont décalés d'un bloc en cycle. Utiliser cette fonction dans repeatedly_execute donne l'effet d'une animation.

Par défaut, les couleurs sont décalées sur la gauche. Si vous passez les arguments dans l'autre sens (c-à-d si DEBUT est plus grand que FIN) alors les couleurs sont décalées dans la direction opposées.

NOTE : Cette commande ne fonctionne que pour les jeux en 256 couleurs.

Exemple :
CyclePalette(10,200);

décalera les indices 10 à 200 de la palette d'un bloc (où l'indice 10 prendra la couleur de l'indice 200) et provoquera un effet de couleur.

Voir aussi : FadeIn, FadeOut, SetPalRGB

SetPalRGB

SetPalRGB (int bloc, int rouge, int vert, int bleu)
Change les valeurs RVB d'un bloc de la palette. La palette est initialement définie dans l'éditeur de palette (Palette Editor), mais vous pouvez le modifier durant le jeu en utilisant cette fonction pour des effets spéciaux. Les paramètres ROUGE, VERT et BLEU vont chacun de 0 à 63 (comme dans l'éditeur de palette).

Si BLOC est un bloc d'arrière-plan, alors l'effet de cette fonction durera jusqu'à ce que le joueur change d'écran, moment où la palette est changée pour celle de la nouvelle pièce. Si BLOC n'est pas un bloc d'arrière-plan, l'effet de cette fonction est permanent.

NOTE : Cette fonction vous permettra de changer les couleurs qui sont “bloquées” dans l'éditeur d'AGS. Cependant, vous ne devriez normalement pas le faire car cela risquerait de provoquer des couleurs étranges dans le jeu.

Exemple :
SetPalRGB(10,63,63,21);

changera le bloc numéro 10 de la palette de vert clair à jaune.

Voir aussi : CyclePalette, FadeIn, FadeOut, UpdatePalette

UpdatePalette

UpdatePalette()
Applique les changements que vous avez effectués sur la palette du jeu. La variable globale de script palette[] stocke l'état de toutes les couleurs de la palette. Vous pouvez accéder aux composants rouge, vert et bleu respectivement avec les extensions .r, .g et .b. Les valeurs vont de 0 à 63.

Exemple :
palette[16].r = 60;
UpdatePalette();

transformera la couleur noire en rouge vif. Lorsque vous modifiez la variable, rien ne se passe. En appelant cette fonction, le changement devient effectif à l'écran.

Voir aussi : SetPalRGB


parser

Table des matières
    • Fonctions de l'Analyseur de texte
      • FindWordID
      • ParseText
      • Said
      • SaidUnknownWord

Fonctions de l'Analyseur de texte

FindWordID

static int Parser.FindWordID(string motATrouver)
Cherche motATrouver dans le dictionnaire du parser, et retourne son numéro ID.

Si le mot est introuvable, retourne -1. Sinon, le numéro du groupe de mots (Word Group) est retourné, tel qu'il apparaît dans l'onglet Text Parser de l'éditeur.

Vous pouvez vérifier si deux mots sont synonymes en comparant leur numéro ID grâce à cette fonction.

Les mots ignorés ont le numéro ID 0.

Cette fonction est pratique si vous voulez utiliser le dictionnaire AGS du Text Parser, mais que vous voulez ajouter des fonctionnalités personnelles sans pour autant utiliser directement la fonction ParseText.

Exemple :
 if (Parser.FindWordID("machine") > 0)
 {
   Display("machine se trouve dans le dictionnaire du jeu");
 }

affichera le message si le dictionnaire du jeu inclut le mot “machine”.

Compatibilité : Supporté par AGS 3.1.0 et les versions plus récentes.

Voir aussi : Parser.ParseText

ParseText

static Parser.ParseText(string texte)
Stocke le texte spécifié pour être utilisé plus tard par Said. Vous devez d'abord appeler cette commande avec l'entrée de l'utilisateur avant d'utiliser la commande Said. Vous l'utiliserez certainement à l'intérieur de la fonction interface_click lorsque votre TextBox est activée.

Exemple :
 String commande = txtParser.Text;
 Parser.ParseText(commande);

récupérera le texte saisi par le joueur et le stockera dans la chaîne “commande” pour une utilisation ultérieure avec la commande Said.

Voir aussi : Parser.FindWordID, Parser.Said

Said

static bool Parser.Said(string texte)
Vérifie si le joueur a entré TEXTE dans ce qui a été passé à ParseText. Retourne true s'il y a correspondance, false sinon.

Voyez la documentation du parser de texte pour une description plus détaillée.

Exemple :

String entree = txtParserInput.Text;
Parser.ParseText(entree);
if (Parser.Said("charger")) {
  txtParserInput.Text = "";
  RestoreGameDialog();
}

affichera le dialogue de chargement de partie si le joueur tape “charger” dans le parser de texte.

Voir aussi : Parser.ParseText, Parser.SaidUnknownWord

SaidUnknownWord

static String Parser.SaidUnknownWord()
Si un mot qui ne se trouve pas dans le dictionnaire du jeu a auparavant été passé à ParseText, alors le mot est retourné par cette commande. Cela vous permet d'afficher un message comme “Désolé, ce jeu ne reconnaît pas 'XXXX'.”

Si tous les mots ont été reconnus, cela retourne null .

Exemple :
String mauvaisMot = Parser.SaidUnknownWord();
if (mauvaisMot != null)
   Display("Vous ne pouvez pas utiliser '%s' dans ce jeu.", mauvaisMot);

affichera le message si le joueur entre un mot qui n'est pas dans le dictionnaire.

Voir aussi : Parser.ParseText, Parser.Said


region

Table des matières
    • Fonctions et propriétés des Régions (Region)
      • GetAtRoomXY
      • RunInteraction
      • Tint
      • Enabled
      • ID
      • LightLevel
      • TintEnabled
      • TintBlue
      • TintGreen
      • TintRed
      • TintSaturation

Fonctions et propriétés des Régions (Region)

GetAtRoomXY

(Anciennement fonction globale GetRegionAt, désormais obsolète)

static Region* Region.GetAtRoomXY(int x, int y)

Retourne la région se situant aux coordonnées (X,Y) de la PIECE. S'il n'y a pas de région à l'endroit spécifié, ou si des coordonnées invalides ont été passées, la variable Region* représentant la région 0 sera retournée.

NOTE : Contrairement à Hotspot.GetAtScreenXY, les coordonnées spécifiées sont ici celles de la PIECE. Cela signifie que si vous voulez utiliser la position du curseur de la souris, vous devez ajouter le décalage de la pièce à l'écran pour que les valeurs concordent, dans une pièce plus large que l'écran.

Exemple :

if (Region.GetAtRoomXY(player.x, player.y) == region[0])
Display("Le joueur ne se trouve actuellement sur aucune région.");

Voir Aussi : GetWalkableAreaAt

RunInteraction

(Anciennement RunRegionInteraction, désormais obsolète)

Region.RunInteraction(int evenement)

Lance l'EVENEMENT associé à la région dans sa liste d'interactions.

NOTE : Contrairement aux autres commandes RunInteraction, celle-ci n'utilise pas le mode du curseur. Il faut en fait utiliser un type d'événement parmi les suivants :

0 Tant que le joueur se trouve sur la région

1 Lorsque le joueur arrive sur la région

2 Lorsque le joueur quitte la région

Exemple :

region[4].RunInteraction(1);

lancera les actions entrées dans l'éditeur d'interactions pour l'événement “Player walks onto region” (“Le joueur arrive sur la région”) de la région 4.

Voir Aussi : Character.RunInteraction, Hotspot.RunInteraction

Tint

(Anciennement SetRegionTint, désormais obsolète)

Region.Tint(int rouge, int vert, int bleu, int taux)

Attribue la teinte RGB spécifiée à la région (ROUGE, VERT, BLEU).

Les valeurs rouge, vert et bleu vont de 0 à 255, vous entrez donc les mêmes valeurs que celles utilisées dans l'éditeur.

TAUX détermine le taux d'application de la teinte, et va de 1 à 100, représentant un pourcentage. 100% colorisera complètement les personnages sur la zone avec la couleur spécifiée.

NOTE : La teinte initiale sera restaurée lorsque le joueur quittera la pièce, vous devez donc utiliser l'événement Player Enters Room (“le joueur entre dan sla pièce”) si vous voulez changer la teinte propre à la région de façon permanente.

NOTE : Cette fonction ne marche que pour les jeux hautes-couleurs.

NOTE : Pour annuler la teinte d'une région, définissez la propriété LightLevel à 0.

Exemple :

region[2].Tint(180, 20, 20, 50);

définira la teinte de la région 2 avec les valeurs RGB (180, 20, 20), avec une opacité de 50%.

Voir Aussi : Region.LightLevel

Enabled

(Anciennement DisableRegion, désormais obsolète) (Anciennement EnableRegion, désormais obsolète)

bool Region.Enabled

Active/Désactive la région spécifiée. Si vous donnez la valeur false, toutes les zones de l'écran qui faisaient auparavant partie de la région seront alors considéré comme de type 0 (aucune région). Vous pouvez ensuite réactiver la région en définissant la propriété à true.

Tant qu'une région est désactivée, elle ne sera pas détectée par Region.GetAtRoomXY, et si le personnage marche dessus, alors les interactions correspondantes ne se lanceront pas.

Exemple :

region[3].Enabled = false;

désactivera la région numéro 3.

Voir Aussi : Hotspot.Enabled, RemoveWalkableArea, RestoreWalkableArea

ID

readonly int Region.ID
Retourne le numéro de cette région. Ceci vous permet d'utiliser de l'ancien code utilisant des fonctions demandant le numéro de région.

Exemple :
Display("La troisième région a pour numéro %d.", region[3].ID);

afficher le numéro de la troisième région (qui bien sûr sera 3).

Voir Aussi : Region.GetAtRoomXY

LightLevel

(Anciennement SetAreaLightLevel, désormais obsolète)

int Region.LightLevel

Retourne/Définit le niveau de luminosité de la région. Ceci correspondrait à modifier la valeur entrée dans la case de texte “Light Level” de l'éditeur, mais vous permet ici d'opérer des modifications lorsque le jeu est en exécution.

Le niveau de luminosité va de -100 à 100. Cette fonction diffère donc par rapport à l'éditeur, qui prend des valeurs allant de 0 à 200. Soustrayez 100 de la valeur que vous utiliseriez dans l'éditeur pour entrer une valeur correspondante dans cette fonction. La raison de cette anomalie provient d'un problème de compatibilité avec l'éditeur DOS de l'époque.

Pour annuler l'effet de luminosité de la région ainsi que ses effets de teinte, passer LightLevel à 0.

NOTE : Le niveau de luminosité sera réinitialisé selon la valeur de l'éditeur lorsque le joueur quittera la pièce, vous devrez donc la modifier dans l'événement “Player Enters Room” (“Le joueur entre dans la pièce”) si vous voulez que l'effet soit permanent.

NOTE : Définir un niveau de luminosité annule toute teinte RGB définie pour la région.

Exemple :

if (GetGlobalInt(10)==1)
region[2].LightLevel = 100;

appliquera un niveau de luminosité de 100 à la région 2 si la variable entière globale 10 vaut 1.

Voir Aussi : Region.Tint

TintEnabled

readonly bool Region.TintEnabled

Retourne si la région est actuellement affectée par une teinte RGB.

Retourne true si c'est le cas, false sinon. Si ce n'est pas le cas, alors la propriété LightLevel correspond à l'éclairage de la région.

Si cette propriété vaut false , alors les propriétés TintRed, TintGreen, TintBlue et TintSaturation sont invalides.

Exemple :

if (region[4].TintEnabled) {
  Display("La région 4 est teintée !!");
}

affichera un message si la région 4 est teintée.

Voir aussi : Region.Tint

TintBlue

readonly int Region.TintBlue
Retourne le taux de Bleu (Blue) de la teinte actuelle de la région.

Cette propriété est en lecture seule ; pour la changer, utilisez la commande Region.Tint.

NOTE : Si la propriété Region.TintEnabled vaut false , alors cette valeur n'est pas pertinente.

Exemple :
if (region[4].TintEnabled) {
  Display("La region 4 est teintée en RVB (%d,%d,%d), Saturation %d.",
          region[4].TintRed, region[4].TintGreen,
          region[4].TintBlue, region[4].TintSaturation);
}

affichera un message avec les teintes de la région.

Voir aussi : Region.Tint, Region.TintEnabled, Region.TintGreen, Region.TintRed

TintGreen

readonly int Region.TintGreen
Retourne le taux de Vert (Green) de la teinte actuelle de la région.

Cette propriété est en lecture seule ; pour la changer, utilisez la commande Region.Tint.

NOTE : Si la propriété Region.TintEnabled vaut false , alors cette valeur n'est pas pertinente.

Exemple :
if (region[4].TintEnabled) {
  Display("La region 4 est teintée en RVB (%d,%d,%d), Saturation %d.",
          region[4].TintRed, region[4].TintGreen,
          region[4].TintBlue, region[4].TintSaturation);
}

affichera un message avec les teintes de la région.

Voir aussi : Region.Tint, Region.TintEnabled, Region.TintBlue, Region.TintRed

TintRed

readonly int Region.TintRed
Retourne le taux de Rouge (Red) de la teinte actuelle de la région.

Cette propriété est en lecture seule ; pour la changer, utilisez la commande Region.Tint.

NOTE : Si la propriété Region.TintEnabled vaut false , alors cette valeur n'est pas pertinente.

Exemple :
if (region[4].TintEnabled) {
  Display("La region 4 est teintée en RVB (%d,%d,%d), Saturation %d.",
          region[4].TintRed, region[4].TintGreen,
          region[4].TintBlue, region[4].TintSaturation);
}

affichera un message avec les teintes de la région.

Voir aussi : Region.Tint, Region.TintEnabled, Region.TintBlue, Region.TintGreen

TintSaturation

readonly int Region.TintSaturation
Retourne la Saturation de la teinte actuelle de la région.

Cette propriété est en lecture seule ; pour la changer, utilisez la commande Region.Tint.

NOTE : Si la propriété Region.TintEnabled vaut false , alors cette valeur n'est pas pertinente.

Exemple :
if (region[4].TintEnabled) {
  Display("La region 4 est teintée en RVB (%d,%d,%d), Saturation %d.",
          region[4].TintRed, region[4].TintGreen,
          region[4].TintBlue, region[4].TintSaturation);
}

affichera un message avec les teintes de la région.

Voir aussi : Region.Tint, Region.TintEnabled, Region.TintBlue, Region.TintGreen , Region.TintRed


room

Table des matières
    • Fonctions des Pièces (Room)
      • AreThingsOverlapping
      • DisableGroundLevelAreas
      • EnableGroundLevelAreas
      • GetBackgroundFrame
      • GetDrawingSurfaceForBackground
      • GetPlayerCharacter
      • GetRoomProperty
      • GetTextProperty
      • GetScalingAt
      • GetViewportX
      • GetViewportY
      • GetWalkableAreaAt
      • HasPlayerBeenInRoom
      • ReleaseViewport
      • RemoveWalkableArea
      • ResetRoom
      • RestoreWalkableArea
      • SetAreaScaling
      • SetBackgroundFrame
      • SetViewport
      • SetWalkBehindBase
      • BottomEdge
      • ColorDepth
      • Height
      • LeftEdge
      • Messages
      • MusicOnLoad
      • ObjectCount
      • RightEdge
      • TopEdge
      • Width

Fonctions des Pièces (Room)

AreThingsOverlapping

AreThingsOverlapping(int chose1, int chose2)
Vérifie si deux personnage ou objets se superposent à l'écran. Ceci tient simplement compte du rectangle qu'occupe la sprite des personnages ou objets - donc si vous avez d'importantes zones transparentes autour du graphisme, la superposition semblera trop large.

CHOSE1 et CHOSE2 peuvent être l'ID d'un personnage (CHARID) ou le numéro d'un objet PLUS 1000. Donc par exemple, passer EGO en tant que CHOSE1, et 1004 en tant que CHOSE2, comparera le personnage EGO à l'objet 4 dans la salle actuelle.

Retourne 0 si les objets ne se touchent pas, ou le taux de superposition s'ils se touchent. Ce taux est à une échelle arbitraire, mais 1 signifie qu'ils se touchent à peine, et tous les nombres supérieurs signifient que la superposition est plus importante.

Appeler cette fonction en passant des objets pour les deux paramètres revient à appeler Object.IsCollidingWithObject.

Exemple :
if (AreThingsOverlapping(1002, EGO)) {
// code ici
}

exécutera le code si l'objet 2 touche EGO. Ceci peut être utile si l'objet 2 est une balle, par exemple.

Voir Aussi : Character.IsCollidingWithChar, Object.IsCollidingWithObject

DisableGroundLevelAreas

DisableGroundLevelAreas(int desactiverTeintes)
Désactive toutes les interactions au niveau du sol. Cela signifie que tous les événements de région, l'événement “Joueur Se Trouve Sur Hotspot”, et les côtés de la pièce seront désactivés.

Cette commande est utile si vous l'utilisez correctement avec la variable character[].z, si vous voulez que le joueur puisse voler ou léviter temporairement, par exemple. Ceci vous permet d'empêcher le personnage de déclencher les interactions “Joueur Se Trouve Sur…” tandis qu'il est dans les airs.

Cette commande est aussi utile durant certaines cinématiques (cutscenes), si vous ne voulez pas que le personnage joueur déclenche des événements alors qu'ils se déplace dans la pièce durant la scène.

Le paramètre DESACTIVERTEINTES spécifie si les effets visuels des régions (c'est-àdire la luminosité et la teinte) sont aussi désactivés ou non. Si vous passez 0, alors seules les interactions seront désactivées.

Exemple :
DisableGroundLevelAreas(0);

désactivera toutes les interactions en rapport au sol, mais laissera la luminosité s'appliquer.

Voir Aussi : Hotspot.Enabled, Region.Enabled, EnableGroundLevelAreas

EnableGroundLevelAreas

EnableGroundLevelAreas()
Réactive toutes les interactions au sol. Cette commande est utilisée pour inverser les effets de la commande DisableGroundLevelAreas, et fera revenir les choses à la normale.

Exemple :
EnableGroundLevelAreas();

Réactivera toutes les interactions au sol.

Voir Aussi : Hotspot.Enabled, Region.Enabled, DisableGroundLevelAreas

GetBackgroundFrame

GetBackgroundFrame()
Retourne le numéro de l'arrière-plan qui est actuellement affiché. Dans une pièce sans animation d'arrière-plan, ceci retourne toujours 0. Sinon, le numéro de l'image actuelle est retournée de 0 à 4.

Exemple :
if (GetBackgroundFrame()==4)
object[2].Visible = true;

affichera l'objet 2 si l'image d'arrière-plan de la pièce est l'image 4.

Voir Aussi : SetBackgroundFrame

GetDrawingSurfaceForBackground

static DrawingSurface* Room.GetDrawingSurfaceForBackground(optional int backgroundNumber)
Retourne une surface de dessin (drawing surface) contenant l'arrière-plan de la pièce, ce qui vous permet de dessiner sur son image. Vous pouvez spécifier un numéro d'image pour l'arrière-plan si vous le voulez ; si vous ne le faites pas, c'est l'image en cours qui sera retournée.

Après avoir appelé cette méthode, utilisez les fonctions DrawingSurface pour modifier l'arrière-plan, puis appelez Release sur la surface lorsque vous avez fini.

Les changements que vous appliquez seront annulés lorsque le joueur quittera la pièce, et ils seront alors perdus. Si vous devez faire des changements permanents, vous pouvez soit utiliser cette méthode dans l'événement Player Enters Room (Le Joueur Entre dans la Pièces), soit envisager d'utiliser une image supplémentaire comme arrière-plan.

NOTE : Dessiner sur l'arrière-plan de la pièce peut être lent, particulièrment si vous utilisez le pilote Direct3D. N'utilisez pas cette commande dans repeatedly_execute ; assurez-vous de n'utiliser cette commande qu'en cas d'absolue nécessité.

Exemple :
DrawingSurface *surface = Room.GetDrawingSurfaceForBackground();
surface.DrawingColor = 14;
surface.DrawLine(0, 0, 50, 50);
surface.Release();

dessine une ligne diagonale jaune depuis le bord gauche-haut de l'arrière-plan de la pièce en cours, puis met à jour l'image.

Voir aussi : DrawingSurface.DrawLine, DrawingSurface.Release

GetPlayerCharacter

GetPlayerCharacter ()
CETTE COMMANDE EST DESORMAIS OBSOLETE. La méthode de remplacement recommandée est d'utiliser la propriété ID du personnage joueur, comme suit :

Exemple :
Display("Le numéro du personnage est : %d", player.ID);

Voir Aussi : Character.ID

GetRoomProperty

GetRoomProperty (string propriete)
Retourne la valeur de la propriété personnelle PROPRIETE pour la pièce actuelle.

Cette commande fonctionne avec des propriétés numériques (retourne le nombre), et avec des propriété boléennes (retourne 1 si la case est cochée, sinon 0).

Utilisez la fonction équivalente Room.GetTextProperty pour obtenir une propriété textuelle.

Notez que vous ne pouvez pas récupérer les propriétés des autres pièces - seule la pièce actuelle peut être testée.

Exemple :
if (GetRoomProperty("PeutEtreAttaqueIci"))
Display("Un monstre diabolique vous attaque !");

affichera le message si la propriété “PeutEtreAttaqueIci” est activée pour la pièce actuelle.

Voir Aussi : Room.GetTextProperty

GetTextProperty

(Anciennement fonction globale GetRoomPropertyText, désormais obsolète)

static String Room.GetTextProperty(string propriete)

Retourne la valeur de la propriété personnelle PROPRIETE pour la pièce actuelle.

Cette commande fonctionne uniquement pour les propriétés textuelles. Le texte de la propriété sera retournée par cette fonction.

Utilisez la fonction équivalente GetRoomProperty pour obtenir une propriété non textuelle.

Notez que vous ne pouvez pas récupérer les propriétés des autres pièces - seule la pièce actuelle peut être testée.

Exemple :

String description = Room.GetTextProperty("Description");
Display("La description de la pièce : %s", description);

récupérera la propriété “description” de la pièce et l'affichera.

Voir Aussi : GetRoomProperty

GetScalingAt

GetScalingAt (int x, int y)
Retourne le zoom de la zone de la pièce aux coordonnées (X,Y).

La valeur retournée va de 1 à 200, 100 étant le réglage normal du zoom.

Exemple :
if (GetScalingAt(player.x, player.y) == 100)
Display ("Le joueur a actuellement sa taille normale.");

Voir Aussi : GetWalkableAreaAt, SetAreaScaling

GetViewportX

GetViewportX ()
Retourne le décalage X de la caméra par rapport à la pièce. Ceci vous permet de savoir quelle partie de la pièce le joueur est en train de regarder. La valeur retournée correspond au décalage par rapport au côté gauche de l'écran, et sa valeur peut donc aller de 0 à (LARGEUR DE LA PIECE - 320).

Si la pièce n'entraîne pas de scrolling, retourne 0.

Voyez la fonction SetViewport pour plus d'informations.

Exemple :
if (GetViewportX()&gt;100)
object[2].Visible = true;

affichera l'objet 2 si le joueur a déplacé la caméra de 100 pixels vers la droite.

Voir Aussi : GetViewportY, SetViewport

GetViewportY

GetViewportY ()
Retourne le décalage Y de la caméra par rapport à la pièce. Ceci vous permet de savoir quelle partie de la pièce le joueur est en train de regarder. La valeur retournée correspond au décalage par rapport au haut de l'écran, et sa valeur peut donc aller de 0 à (HAUTEUR DE LA PIECE - 200).

Si la pièce n'entraîne pas de scrolling, retourne 0.

Voyez la fonction SetViewport pour plus d'informations.

Exemple :
if (GetViewportY()&gt;20)
object[2].Visible = true;

affichera l'objet 2 si le joueur a déplacé la caméra de 20 pixels vers le bas.

Voir Aussi : GetViewportX, SetViewport

GetWalkableAreaAt

GetWalkableAreaAt (int x, int y)
Retourne le numéro de la zone de déplacement à l'ECRAN aux coordonnées (X,Y). S'il ne se trouve pas de zone de déplacement à cet endroit, ou si les coordonnées spécifiées sont invalides, retourne 0.

NOTE: Les coordonnées sont celles à l'ECRAN, PAS celles de la pièce. Cela signifie qu'avec une pièce plus grande que l'écran, les coordonnées que vous passez sont relatives à la position actuelle de la caméra, et ne sont PAS les coordonnées absolues de la pièce. Ceci signifie qu'il convient d'utiliser cette fonction avec les variables retournant la position du curseur de la souris.

Exemple :
if (GetWalkableAreaAt(mouse.x,mouse.y) == 0)
Display ("Vous ne pouvez pas marcher ici.");

Voir Aussi : Hotspot.GetAtScreenXY, Region.GetAtRoomXY, GetScalingAt

HasPlayerBeenInRoom

HasPlayerBeenInRoom(int numero_piece)
Vérifie si le joueur s'est déjà rendu dans la pièce NUMERO_PIECE (c'est-à-dire si l'événement 'First Time Player Enters Room' s'est déjà déclenché). Retourne 1 si c'est le cas, sinon 0.

Vous pouvez utiliser cette fonction pour déterminer si le joueur a déjà été à un endroit particulier au préalable. Si vous redémarrez la pièce avec ResetRoom, alors cette commande retournera 0 jusqu'à ce que le joueur y retourne.

Cette commande retournera 1 si vous l'utilisez avec la pièce actuelle, et 0 si vous l'utilisez avec une pièce sans sauvegarde de statut (c'est-à-dire les pièces numérotées à partir de 301).

Exemple :
if (HasPlayerBeenInRoom(14)) {
Display("Le joueur s'est déjà rendu dans la pièce 14.");
}

affichera un message si le joueur a déjà visité la pièce 14.

Voir Aussi : ResetRoom

ReleaseViewport

ReleaseViewport ()
Débloque la caméra, l'autorisant à se déplacer automatiquement pour suivre les déplacements du personnage joueur, de façon normale.

Exemple :
int x;
while (x&lt;100) {
SetViewport(x,0);
x++;
Wait(1);
}
ReleaseViewPort();

déplacera la caméra de 100 pixels vers la droite puis la remettra dans sa position originale et la débloquera.

Voir Aussi : SetViewport

RemoveWalkableArea

RemoveWalkableArea (int numzone)
Supprime les zones de déplacements de couleur NUMZONE dans la pièce actuelle. Vous pouvez réactiver ces zones avec RestoreWalkableArea.

NOTE : Lorsque le joueur quitte la pièce, toutes les zones de déplacement libre sont restaurées. Ainsi, si vous voulez qu'une zone reste désactivée après que le joueur a quitté l'écran, vous devrez utiliser un marqueur pour utiliser la commande RemoveWalkableArea dans l'événement “Player enters room” lorsque le joueur reviendra.

Exemple :
RemoveWalkableArea(5);

supprimera la zone de déplacement numéro 5.

Voir Aussi : RestoreWalkableArea

ResetRoom

ResetRoom (int numero_piece)
Libère toutes les données que le moteur a en mémoire à propos de la pièce depuis que le joueur y est entré, et les redéfinit comme s'il n'y était jamais entré. La prochaine fois que le joueur ira dans cette pièce, tous les objets et scripts seront dans leur état initial (comme défini dans l'éditeur), et pas comme ils étaient lorsque le joueur a quitté la pièce. L'événement “First time enters room” sera déclenché lorsque le joueur reviendra.

Cette fonction est utile si vous voulez mettre une option “Voir intro” pour permettre au joueur de regarder une intro une nouvelle fois - cette fonction permet de remettre tous les objets de la pièce dans leur position de départ.

NOTE : Vous ne pouvez pas remettre la pièce actuelle à zéro (c'est-à-dire la pièce dans laquelle le joueur se trouve).

Exemple :
ResetRoom(0);

remettra la pièce d'intro à zéro de façon à pouvoir la rejouter si le joueur le veut.

Voir Aussi : HasPlayerBeenInRoom

RestoreWalkableArea

RestoreWalkableArea (int numzone)
Réactive la zone de déplacement NUMZONE.

Exemple :
RestoreWalkableArea(4);

permettra au joueur de se déplacer à nouveau sur la zone de déplacement numéro 4.

Voir Aussi : RemoveWalkableArea

SetAreaScaling

SetAreaScaling(int zone, int min, int max)
Change l'échelle de zoom de la zone de déplacement numéro ZONE.

Il y a deux façons d'utiliser cette commande : 1. Passer la même valeur pour MIN et MAX. Ceci donnera un zoom fixe unique pour la zone de déplacement (comme si l'option “Use continuous scaling” de l'éditeur n'était pas cochée). 2. Passer des valeurs différentes pour MIN et MAX. Dans ce cas, le zoom continu est activé pour la zone de déplacement, et ira de MIN en haut de la zone à MAX en bas.

MIN et MAX ont des valeurs entre 5 et 200, comme dans l'éditeur. Passez 100 pour les deux valeurs afin de revenir à un niveau de zoom normal (100%) pour la zone.

Exemple :
SetAreaScaling(5, 120, 170);

fera utiliser un zoom continu allant de 120 à 170 pourcents pour la zone de déplacement numéro 5.

Voir Aussi : GetScalingAt, GetWalkableAreaAt

SetBackgroundFrame

SetBackgroundFrame (int image)
Fige l'arrière-plan sur l'image numéro IMAGE pour un écran d'arrière-plan animé. (Les valeurs de FRAME vont de 0 à 4). Ceci vous permet d'utiliser les arrière-plans animés pour d'autres buts - vous pouvez avoir deux images d'arrière-plan, où un vaisseau s'est écrasé sur la deuxième, par exemple. Une fois que le crash s'est produit, appelez SetBackgroundFrame dans l'événement “Player Enters Room” pour utiliser cette image comme arrière-plan.

Appelez SetBackgroundFrame(-1) pour utiliser l'image par défaut.

L'arrière-plan est débloqué lorsque le jeu change de pièce.

Exemple :
if (GetGlobalInt(20)==1)
SetBackgroundFrame(4);

changera l'image d'arrière-plan actuelle pour utiliser la numéro 4 si la variable entière globale 20 vaut 1.

Voir Aussi : GetBackgroundFrame

SetViewport

SetViewport (int x, int y)
Fige la caméra de façon à ce que le coin gauche de l'écran correspondent aux coordonnées (X,Y) de la pièce. Ceci vous permet de parcourir manuellement la pièce avec la caméra ou bien de suivre un personnage non-joueur.

La caméra est débloquée lorsque vous appelez ReleaseViewport ou lorsque le joueur change de pièce.

NOTE : Les coordonnées entrées respectent la résolution 320×200, et seront automatiquement adaptées par le moteur.

NOTE : Cette fonction n'a aucun effet si la pièce actuelle n'est pas plus grande que l'écran, si elle ne “déborde” pas.

Exemple :
int ypos = 0;
while (ypos < 60) {
SetViewport(0, ypos);
Wait(1);
ypos++;
}
ReleaseViewport();

déplacera la caméra de 60 pixels vers le bas depuis le haut, puis la recentrera sur le joueur.

Voir Aussi : GetViewportX, GetViewportY, ReleaseViewport

SetWalkBehindBase

SetWalkBehindBase (int zone, int baseline)
Donne à la zone couvrante (Walkbehind area) numéro ZONE une nouvelle BASELINE. Ceci vous permet aussi bien de désactiver les zones que de faire d'autres choses. BASELINE est compris entre 1 et la hauteur de la pièce (normalement 200) et déplace la ligne que vous aviez initialement placée à l'aide de l'éditeur.

Passer 0 pour BASELINE désactive la zone couvrante, de façon à ce que le joueur ne sera jamais recouvert par elle.

A la base, si les pieds du personnage se trouvent sous la BASELINE, il sera dessiné par-dessus, sinon il sera dessiné derrière.

Exemple :
SetWalkBehindBase (3,0);

désactivera la zone couvrante numéro 3.

Voir Aussi : Object.Baseline

BottomEdge

readonly static int Room.BottomEdge
Retourne la coordonnée Y du bord bas du cadre de la pièce, tel que défini dans l'onglet Room Settings (Réglages de la Pièces) dans l'éditeur.

Exemple :
Display("Le bord bas de la pièce actuelle se trouve à %d.", Room.BottomEdge);

Voir aussi : Room.LeftEdge, Room.RightEdge, Room.TopEdge

ColorDepth

readonly static int Room.ColorDepth
Retourne la profondeur de couleurs de l'arrière-plan de la pièce. Ceci est important si vous voulez utiliser DrawImage, puisque toute sprite que vous dessinez doit être de la même profondeur de couleurs que la pièce elle-même.

Exemple :
Display("L'arrière-plan actuel est en couleurs %d-bit.", Room.ColorDepth);

Voir aussi : DrawingSurface.DrawImage

Height

(Anciennement game.room_height, désormais obsolète)

readonly static int Room.Height

Retourne la hauteur de la pièce, en coordonnées 320×200. Correspond à la taille affichée comme “Relative size” (”Taille relative”) dans l'éditeur.

Exemple :

Display("La pièce est de dimension %d x %d.", Room.Width, Room.Height);

Voir aussi : Room.Width

LeftEdge

readonly static int Room.LeftEdge
Retourne la coordonnée X du bord gauche du cadre de la pièce, tel que défini dans l'onglet Room Settings (Réglages de la pièce) dans l'éditeur.

Exemple :
Display("Le bord gauche de la pièce est à %d.", Room.LeftEdge);

Voir aussi : Room.BottomEdge, Room.RightEdge, Room.TopEdge

Messages

(Anciennement fonction globale GetMessageText, désormais obsolète)

readonly static String Room.Messages[int message]

Retourne le texte du message de pièce spécifié. Ceci est utile si vous voulez stocker, par exemple, une description de la pièce dans le Message 1 pour chaque pièce – cette propriété vous permet de récupérer le texte pour le message de la pièce courante.

Si un numéro de message invalide est entré, null sera retournée. Sinon, le contenu du message sera retourné.

Exemple :

String message1 = Room.Messages[1];
Display("Le message 1 dit : %s", message1);

affichera le contenu du message de pièce numéro 1.

MusicOnLoad

readonly static int Room.MusicOnLoad
Retourne le numéro de la musique qui est jouée lorsque le joueur entre dans cette pièce, tel que défini dans l'onglet “Room Settings” (”Réglages de la pièce”) dans l'éditeur. Si aucune musique n'est définie pour cette pièce, retourne 0.

Exemple :
Display("La pièce actuelle joue la musique %d lorsque le joueur entre.", Room.MusicOnLoad);

ObjectCount

(Formerly part of GetGameParameter, désormais obsolète)

readonly static int Room.ObjectCount

Retourne le nombre d'objets dans la pièce.

Exemple :

Display("La pièce actuelle contient %d objets.", Room.ObjectCount);

RightEdge

readonly static int Room.RightEdge
Retourne la coordonnée X du bord droit du cadre de la pièce, tel que défini dans l'onglet Room Settings (Réglages de la Pièce) de l'éditeur.

Example:
Display("Le bord droit de la pièce est à %d.", Room.RightEdge);

Voir aussi : Room.BottomEdge, Room.LeftEdge, Room.TopEdge

TopEdge

readonly static int Room.TopEdge
Retourne la coordonnée Y du bord haut du cadre de la pièce, tel que défini dans l'onglet Room Settings (Réglages de la Pièces) de l'éditeur.

Exemple :
Display("Le bord haut de la pièce est à %d.", Room.TopEdge);

Voir aussi : Room.BottomEdge, Room.LeftEdge, Room.RightEdge

Width

(Anciennement game.room_width, désormais obsolète)

readonly static int Room.Width

Retourne la largeur de la pièce, en coordonnées 320×200. Correspond à ce qui est affiché comme “Relative size” (”Taille relative”) dans l'éditeur.

Exemple :

Display("La pièce actuelle est de dimension %d x %d.", Room.Width, Room.Height);

Voir aussi : Room.Height

,


screen

Table des matières
    • Fonctions de l'Écran (Screen)
      • FadeIn
      • FadeOut
      • FlipScreen
      • SetFadeColor
      • SetNextScreenTransition
      • SetScreenTransition
      • ShakeScreen
      • ShakeScreenBackground
      • TintScreen

Fonctions de l'Écran (Screen)

FadeIn

FadeIn (int vitesse)
Affiche en fondu l'écran selon la palette, depuis un écran noir. Ceci est utilisé pour réafficher l'écran après avoir appelé un FadeOut. La VITESSE est comprise entre 1 (le plus lent) et 64 (le plus rapide).

NOTE : Ceci est une fonction bloquante.

Exemple :
FadeOut(30);
Wait(40);
FadeIn(10);

fondra l'écran vers le noir, attendra 1 seconde (40 cycles) puis fera réapparaître l'écran en fondu.

Voir Aussi : CyclePalette, FadeOut, SetFadeColor

FadeOut

FadeOut (int vitesse)
Noircit totalement l'écran en fondu. VITESSE est la vitesse de fondu, allant de 1 (le plus lent) à 64 (instantanné). Vous pouvez restaurer l'écran avec FadeIn.

NOTE : Ceci est une fonction bloquante.

Exemple :
FadeOut(30);
Wait(40);
FadeIn(10);

fondra l'écran vers le noir, attendra 1 seconde (40 cycles) puis fera réapparaître l'écran en fondu.

Voir Aussi : CyclePalette, FadeIn, SetFadeColor

FlipScreen

FlipScreen (int maniere)
Retourne l'écran selon un axe horizontal, vertical, ou les deux. Cette fonction est faite seulement pour les effets spéciaux - toutes les coordonnées restent les mêmes et cela n'a aucun effet sur les autres fonctions du script.

Les valeurs de MANIERE peuvent être :
0  affichage normal
1  flip horizontal (inversion haut-bas)
2  flip vertical (inversion gauche-droite)
3  les deux (haut-bas ET gauche-droite)

NOTE : Cette fonction a encore quelques bugs - les zones noires de l'écran peuvent ne pas s'afficher correctement, et les messages pop-up qui s'afficheront retourneront l'écran pour l'afficher normalement.

Exemple :

FlipScreen(1);

retournera l'écran selon l'axe horizontal.

SetFadeColor

SetFadeColor(int rouge, int vert, int bleu)
Change la couleur vers laquelle l'écran se fond, dans la valeur RGB spécifiée. Chaque paramètre est compris entre 0 et 255. La valeur par défaut est le noir : (0, 0, 0).

La couleur que vous définissez ici sera utilisée dans tous les appels futurs de FadeIn/FadeOut, ainsi que dans les écrans de transition s'ils utilisent les Fade In/Out.

Exemple :
SetFadeColor(200, 0, 0);

signifiera que la prochaine fois que l'écran se fondra, la couleur virera vers le rouge plutôt que vers le noir.

Voir aussi : FadeIn, FadeOut, SetScreenTransition

SetNextScreenTransition

SetNextScreenTransition(TransitionStyle)
Définit le type de transition entre les pièces à TransitionStyle, mais SEULEMENT pour le prochain changement de pièces. Après cela, le type de transition reviendra au type normal spécifié dans l'éditeur ou spécifié avec SetScreenTransition.

Les différentes valeurs possibles pour TransitionStyle sont listées ici : SetScreenTransition.

Exemple :
SetNextScreenTransition(eTransitionBoxout);
cEGO.ChangeRoom(10);

ira à la pièce numéro 10 en utilisant un effet box-out, et retournera ensuite au type de transition normal.

Voir aussi : SetScreenTransition

SetScreenTransition

SetScreenTransition(TransitionStyle)
Change le type de transition d'écrans par défaut. TransitionStyle peut valoir :
eTransitionFade          Transition en fondu
eTransitionInstant       Transition instantannée
eTransitionDissolve      Transition en défragmentation ('pointillés')
eTransitionBoxout        Transition en zoom rectangulaire
eTransitionCrossfade     Transition en superposition transparente

La meilleure façon de comprendre le rendu de ces modes est de les tester.

Toutes les transitions futures seront faites en respectant la valeur que vous avez passez, jusqu'à ce que vous réutilisiez cette fonction.

Exemple :

SetScreenTransition(eTransitionFade);

changera les transitions d'écrans pour le mode Fade (Fondu).

Voir aussi : SetNextScreenTransition

ShakeScreen

ShakeScreen (int force)
Secoue l'écran pour simuler, par exemple, un tremblement de terre. FORCE est la force des secousses de l'écran : 1 est presque imperceptible, et 25 est très fort.

Exemple :
ShakeScreen(5);

secouera un peu l'écran.

Voir Aussi : ShakeScreenBackground

ShakeScreenBackground

ShakeScreenBackground (int delai, int force, int longueur)
Secoue l'écran pour simuler, par exemple, un tremblement de terre. Le jeu n'est durant les secousses de l'écran - l'effet continuera en arrière-plan.

DELAI définit le temps que durera chaque secousse - 2 est la plus petite valeur que vous pouvez passer, et donnera des secousses très fréquentes.

FORCE définit la force des secousses - c'est-à-dire à quel point l'écran se déplace lorsque les secousses ont lieu. La valeur va de 1, qui est un tremblement très faible, jusqu'à 30 qui représente de très fortes secousses.

LONGUEUR définit combien de temps le tremblement durera, en cycles de jeu. Par exemple, 80 secouera l'écran 2 secondes, à la vitesse de jeu par défaut.

Vous pouvez stopper toute secousse d'arrière-plan en cours en appelant cette commande en passant 0 pour le paramètre LONGUEUR.

Exemple :
ShakeScreenBackground (4, 10, 80);

secouera faiblement l'écran pendant 2 secondes.

Voir Aussi : ShakeScreen

TintScreen

TintScreen (int rouge, int vert, int bleu)
Teinte l'écran avec les valeurs RGB spécifiées. ROUGE, VERT et BLEU vont de 1 à 100.

Passez (0, 0, 0) pour annuler toute teinte et revenir à l'aspect normal de l'écran.

NOTE : Cette commande reste pour le moment expérimentale, puisqu'elle ralentit sensiblement la machine, particulièrement à de hautes résolutions. Si vous l'utilisez, vous devriez prévoir une option qui permette au joueur de la désactiver.

NOTE : Ceci ne fonctionne que dans les jeux hautes-couleurs.

Exemple :
TintScreen (100, 50, 50);

teintera l'écran d'une certaine dose de rouge.


string

Table des matières
    • Fonctions de Texte (String)
      • Append
      • AppendChar
      • CompareTo
      • Copy
      • EndsWith
      • Format
      • IndexOf
      • IsNullOrEmpty
      • LowerCase
      • Replace
      • ReplaceCharAt
      • StartsWith
      • Substring
      • Truncate
      • UpperCase
      • AsFloat
      • AsInt
      • Chars
      • Length

Fonctions de Texte (String)

Append

(Anciennement fonction globale StrCat, désormais obsolète)

String.Append(string str2)

Accolle la chaîne de caractères (string) STR2 à la fin de la chaîne de caractères (string) spécifiée, et retourne le résultat de l'opération.

IMPORTANT : Le résultat de ce collage est retourné en tant qu'une nouvelle chaîne de caractères (string) par cette commande. La chaîne originale NE SERA PAS modifiée. Par exemple, le script suivant ne fera rien :

montexte.Append("World");

ce que vous désireriez plutôt serait :

montexte = montexte.Append("World"); \\ \\

Exemple :

String montexte = "Hello";
montexte = montexte.Append("World");
Display(montexte);

ce qui affichera “HelloWorld”.

Voir aussi : String.AppendChar, String.Substring, String.Truncate

AppendChar

String.AppendChar(char extraChar)
Ajoute un simple caractère à la fin du texte spécifié, et retourne le résultat.

IMPORTANT: Le nouveau texte est retourné comme une nouvelle chaîne de caractère par cette commande. La chaîne originale restera inchangée . Par exemple, le script suivant n'aura aucun effet : montexte.AppendChar('o'); ce que vous voudriez plutôt est : montexte = montexte.AppendChar('o');

Exemple :
String montexte = "Hell";
montexte = montexte.AppendChar('o');
Display(montexte);

ce qui affichera “Hello”.

Voir aussi : String.Append

CompareTo

(Anciennement fonction globale StrCaseComp, désormais obsolète)

(Anciennement fonction globale StrComp, désormais obsolète)

String.CompareTo(string str2, optional bool caseSensitive)

Compare le texte spécifié à STR2. caseSensitive détermine si “Chien” et “chien” sont équivalents ; par défaut, la sensibilité à la casse n'est pas prise en compte.

Retourne 0 si les textes sont identiques, un nombre inférieur à 0 si la chaîne précède STR2 dans l'ordre alphabétique, et un nombre supérieur à 0 si la chaîne se trouve plus loin dans l'alphabet que STR2.

ASTUCE : Pour effectuer une comparaison susceptible à la casse de deux textes, il est plus facile d'utiliser simplement l'opérateur ==.

Exemple :

String montexte = "Bonjour";
if (montexte.CompareTo("bonjour") == 0) {
  Display("Les textes correspondent avec insensibilité à la casse !");
}
else {
  Display("Les textes ne correspondent pas avec insensibilité à la casse !");
}

if (montexte == "bonjour") {
  Display("Les textes correspondent avec sensibilité à la casse !");
}
else {
  Display("Les textes ne correspondent pas avec sensibilité  à la casse !");
}

ce qui affichera “Les textes correspondent avec insensibilité à la casse !”, puis “Les textes ne correspondent pas avec sensibilité à la casse !”.

Copy

(Anciennement fonction globale StrCopy, désormais obsolète)

String.Copy()

Retourne une copie de la chaîne spécifiée. En temps normal, vous n'en aurez pas l'utilité, puisque les chaînes peuvent être définies en utilisant l'opérateur =.

Exemple :

String machaine = "Ceci est une chaîne-test.";
String nouvellechaine = machaine.Copy();
Display(nouvellechaine);

affichera “Ceci est une chaîne-test.”.

EndsWith

bool String.EndsWith(string texteRecherche, optional bool caseSensitive)
Retourne true si la chaîne se termine par texteRecherche , ou false sinon.

caseSensitive vaut false par défaut, mais vous pouvez passer true de façon à ce que la fonction ne retourne true lors d'une correspondance susceptible à la casse.

Exemple :
String maChaine = "Bonjour depuis le script !";
if (maChaine.EndsWith("script !"))
{
  Display("Finit par script !");
}

affichera le message “Finit avec script !”.

Compatibilité : Supporté par AGS 3.1.0 et les versions plus récentes.

Voir aussi : String.IndexOf, String.StartsWith

Format

(Anciennement fonction globale StrFormat, désormais obsolète)

static String.Format(string fmt, ...)

Traite la chaîne FMT de la même façon que le fait la fonction Display mais plutôt que de l'afficher à l'écran, retourne le résultat comme une nouvelle chaîne.

Vous pouvez ainsi insérer des valeurs de variables dans la chaîne. Pour plus d'informations, voir la section syntaxe des chaînes de caractères.

NOTE : Cette fonction est statique, ce qui signifie que vous ne devez pas l'appeler depuis une variable chaîne existante, mais plutôt en utilisant directement String.Format().

Exemple :

int sante=10;
String texte = String.Format("%d", sante);

créera une chaîne de texte contenant “10”.

Voir aussi : Display

IndexOf

(Anciennement fonction globale StrContains, désormais obsolète) (Anciennement String.Contains, désormais obsolète)

String.IndexOf(string aiguille)

Verifie si AIGUILLE est contenue dans la chaîne de texte testée. Retourne la position du caractère correspondant si c'est le cas, ou -1 s'il n'y a pas de correspondance.

Cette fonction ne prend pas la casse en compte ; c'est-à-dire que chercher “cHaInE” dans “chaine de test” retournerait bien une correspondance.

Exemple :

String botte = "Il y a une aiguille dans la botte de foin.";
int resultat = botte.IndexOf("une aiguille");

if (resultat == -1) {
  Display("La chaîne ne contenait pas une aiguille.");
}
else {
  Display("une aiguille a été trouvée au caractère numéro %d dans la chaîne.", resultat);
}

Voir aussi : String.EndsWith, String.StartsWith

IsNullOrEmpty

static bool String.IsNullOrEmpty(String chaineTestee)
Renseigne si la chaîne est vide ou nulle. C'est un simple raccourci pour le test suivant :
if ((chaineTestee == null) || (chaineTestee == ""))

autrement dit, vous pouvez l'utiliser facilement pour vérifier si une chaîne contient du texte ou non.

NOTE : Cette fonction est statique, ce qui signifie que vous ne devez pas l'appeler à partir d'une variable chaîne de caractère. Utilisez plutôt directement String.IsNullOrEmpty(). Voir l'exemple.

Exemple :

String maChaine;
if (String.IsNullOrEmpty(maChaine))
{
  maChaine = "Du texte";
}

donnera la valeur “Du texte” à la variable maChaine si celle-ci est nulle ou vide (ce qui est le cas en l'occurrence).

Compatibilité : Supporté par AGS 3.0.1 et les versions plus récentes.

LowerCase

(Anciennement fonction globale StrToLowerCase, désormais obsolète)

String.LowerCase()

Retourne une version minuscule de la chaîne de texte spécifiée.

NOTE : Cette fonction retourne une nouvelle chaîne ; elle NE MODIFIE PAS la chaîne originale.

Exemple :

String maChaine = "CECI est une chaîne de test";
String minuscule = maChaine.LowerCase();
Display("Ancienne : %s, nouvelle : %s", maChaine, minuscule);

affichera “Ancienne : CECI est une chaîne de test, nouvelle : ceci est une chaîne de test”.

Voir aussi : String.UpperCase

Replace

String.Replace(string lookForText, string replaceWithText,
               optional bool caseSensitive)
Crée une copie de cette chaîne, où toutes les occurrences de lookForText sont remplacées par replaceWithText .

caseSensitive vaut false par défaut, mais vous pouvez le passer comme true de façon à ce que seules les occurrences dont la casse est la même que celle de lookForText soient remplacées.

NOTE : Cette fonction retourne une nouvelle chaîne ; l'ancienne chaîne N'EST PAS MODIFIÉE par cette fonction. Exemple :
String original = "Hello from the script!";
String changed = original.Replace("hello", "goodbye");
Display("Old: %s, new: %s", original, changed);

affichera “Old: Hello from the script!, new: goodbye from the script!”.

Compatibilité : Supporté par AGS 3.1.0 et les versions plus récentes.

Voir aussi : String.ReplaceCharAt

ReplaceCharAt

(Anciennement fonction globale StrSetCharAt, désormais obsolète)

String.ReplaceCharAt(int index, char newChar)

Remplace le caractère à la position INDEX dans la chaîne par NEWCHAR.

INDEX correspond à l'index du caractère dans la chaîne (où 0 renvoie au premier caractère, et où la plus haute valeur possible correspond à la longueur de la chaîne moins 1).

NOTE : Cette fonction retourne une nouvelle chaîne ; l'ancienne chaîne N'EST PAS MODIFIÉE par cette fonction.

Exemple :

String mystring = "Hello";
String changed = mystring.ReplaceCharAt(2, 'm');
Display("Old: %s, new: %s", newstring, changed);

affichera “Old: Hello, new: Hemlo”.

Voir aussi : String.Chars, String.Replace

StartsWith

bool String.StartsWith(string lookForText, optional bool caseSensitive)
Retourne true si la chaîne commence par lookForText , ou false si ce n'est pas le cas.

caseSensitive vaut false par défaut, mais vous pouvez le passer comme true pour que la fonction ne retourne true que lorsque la correspondance est sensible à la casse.

Exemple :
String myString = "Hello from the script!";
if (myString.StartsWith("hello"))
{
  Display("Starts with hello!");
}

affichera le message “Starts with hello!”.

Compatibilité : Supporté by AGS 3.1.0 et les versions plus récentes.

Voir aussi : String.EndsWith, String.IndexOf

Substring

String.Substring(int index, int length)
Retourne une partie de la chaîne, depuis le caractère index sur une longueur de length .

index correspond à la position du caractère initial de la sous-chaîne que vous voulez récupérer, où 0 représente le tout premier caractère et (Longueur - 1) le dernier.
// length //  spécifie combien de caractères vous voulez récupérer depuis cette position.\\ \\

Exemple :

String mystring = "Hello World!";
String substring = mystring.Substring(3, 5);
Display("Original: %s, Substring: %s", mystring, substring);

affichera “Original: Hello World!, Substring: lo Wo”.

Voir aussi : String.Append, String.Chars

Truncate

String.Truncate(int length)
Retourne une version de la chaîne qui aura été coupée à length caractères.

NOTE : Cette fonction retourne une nouvelle chaîne ; l'ancienne chaîne N'EST PAS MODIFIÉE par cette fonction.

Exemple :
String mystring = "Hello World!";
String truncated = mystring.Truncate(4);
Display("Original: %s, Truncated: %s", mystring, truncated);

affichera “Original: Hello World!, Truncated: Hell”.

Voir aussi : String.Append, String.Substring

UpperCase

(Anciennement fonction globale StrToUpperCase, désormais obsolète)

String.UpperCase()

Retourne une version majuscule de la chaîne spécifiée.

NOTE : Cette fonction retourne une nouvelle chaîne ; l'ancienne chaîne N'EST PAS MODIFIÉE par cette fonction. Exemple :

String mystring = "THIS is a test string";
String uppercased = mystring.UpperCase();
Display("Old: %s, new: %s", mystring, uppercased);

affichera “Old: THIS is a test string, new: THIS IS A TEST STRING”.

Voir aussi : String.LowerCase

AsFloat

readonly float String.AsFloat;
Convertie une chaîne en nombre flottant, et retourne cette valeur. Retourne 0.0 si la chaîne ne contient pas un nombre.

Exemple :
String text1, text2;
float number1,number2;
text1 = "57.362";
text2 = "Hello";
number1 = text1.AsFloat;
number2 = text2.AsFloat;

définira la valeur de number1 à 57.362 et de number2 à 0.0. Cette fonction est pratique pour traiter le texte entré par l'utilisateur.

NOTE : Pour convertir un flottant en chaîne de caractères, vous pouvez utiliser la commande String.Format.

Voir aussi : Game.InputBox, String.AsInt, String.Format

AsInt

(Anciennement fonction globale StringToInt, désormais obsolète)

readonly int String.AsInt;

Convertie la chaîne de texte en nombre entier, et retourne cette valeur. Retourne 0 si la chaîne ne contient pas un nombre.

Exemple :

String text1, text2;
int number1,number2;
text1 = "53";
text2 = "Hello";
number1 = text1.AsInt;
number2 = text2.AsInt;

définira la valeur de number1 à 53 et celle de number2 à 0. Cette fonction est utile pour traiter le texte entré par l'utilisateur.

NOTE : Pour convertir un entier en chaîne de texte, vous pouvez utiliser la commande String.Format.

Voir aussi : Game.InputBox, String.AsFloat, String.Format

Chars

(Anciennement fonction globale StrGetCharAt, désormais obsolète)

readonly char String.Chars[position];

Retourne le caractère à POSITION dans la chaîne.

POSITION est la position du caractère dans la chaîne (où 0 correspond au tout premier caractère, et où la plus haute valeur possible correspond à la longueur de la chaîne moins 1)

Si POSITION vaut plus que la longueur de la chaîne, la fonction retourne 0.

NOTE : Le tableau Chars est en lecture seule. Si vous désirez changer l'un des caractères dans la chaîne, utilisez String.ReplaceCharAt.

Exemple :

String text = "This is my string.";
Display("The 4th character is: %c", text.Chars[3]);

affichera “The 4th character is: s”.

Voir aussi : String.Length, String.ReplaceCharAt

Length

(Anciennement fonction globale StrLen, désormais obsolète)

readonly int String.Length;

Retourne la longueur de la chaîne, c'est-à-dire le nombre de caractères qu'elle contient.

Exemple :

String text = "This is my string.";
Display("Length: %d", text.Length);

affichera “Length: 18”.


system

Table des matières
    • Fonctions et propriétés du système (System)
      • CapsLock
      • ColorDepth
      • Gamma
      • HardwareAcceleration
      • NumLock
      • OperatingSystem
      • ScreenHeight
      • ScreenWidth
      • ScrollLock
      • SupportsGammaControl
      • Version
      • ViewportHeight
      • ViewportWidth
      • VSync
      • Windowed

Fonctions et propriétés du système (System)

CapsLock

readonly static bool System.CapsLock;
Retourne si Caps Lock (majuscules) est actif sur le système de l'utilisateur.

Vous pouvez l'utiliser par exemple pour empêcher le joueur de passer en majuscules avant de taper un mot de passe.

Exemple:
if (System.CapsLock)
{
  Display("La lumière CAPS LOCK est allumée.");
}

affichera un message si les majuscules sont activées.

Compatibilité : Supporté par AGS 3.0.1 et les versions plus récentes.

Voir aussi : System.NumLock, System.ScrollLock

ColorDepth

(Anciennement system.color_depth, désormais obsolète)

readonly static int System.ColorDepth;

Retourne la profondeur de couleur à laquelle le jeu est exécuté. Correspond à la profondeur de couleur générale, il est possible que des sprites ou des arrière-plans particuliers en aient une différente.

Exemple :

Display("Le jeu a l'aspect suivant : %d x %d, %d-bit colour", System.ScreenWidth,
                                  System.ScreenHeight, System.ColorDepth);

affichera la résolution actuelle et la profondeur de couleurs.

Voir aussi : System.ScreenHeight, System.ScreenWidth

Gamma

static int System.Gamma;
Retourne/définit le niveau Gamma de l'écran en cours. Vaut 100 par défaut, et vous pouvez donner tout valeur entre 0 (noir complet) et 200 (brillance normale doublée).

System.SupportsGammaControl doit retourner true pour que cette propriété ait un effet.

Puisque chaque joueur possède un moniteur différent, vous devriez normalement lier cette propriété à un Slider GUI qui permettra au joueur de l'ajuster à son système.

Exemple :
if (System.SupportsGammaControl) {
  System.Gamma = 150;
}

définira la brillance de l'écran à 50% de plus que la normale.

Voir aussi : System.SupportsGammaControl

HardwareAcceleration

readonly static bool System.HardwareAcceleration;
Retourne si le jeu est en mode accélération matérielle (par exemple Direct3D). Si c'est le cas, alors les DrawingSurface risquent d'être ralenties, mais le canal alpha et les sprites larges devraient être traités plus rapidemen que lorsque le pilote non-accélérateur est utilisé.

Support selon les plateformes

Windows: pilote Direct3D
MS-DOS: Non supporté
Linux: Non supporté
MacOS: Non supporté

Exemple :

if (System.HardwareAcceleration) {
  Display("Hourra, on peut dessiner des sprites avec canal alpha rapidement !");
}

affichera un message si le jeu est en mode accélération matérielle.

Voir aussi : Choix du pilote graphique

NumLock

readonly static bool System.NumLock;
Retourne si Num Lock (touches numériques) est activé sur le système du joueur.

Vous pourrez par exemple utiliser cela pour empêcher le joueur de le désactiver avant d'utiliser les flèches d'un pavé numérique.

Exemple :
if (System.NumLock)
{
  Display("La lumière NUM LOCK est allumée.");
}

affichera un message si Num Lock est activé.

Compatibilité : Supporté par AGS 3.0.1 et les versions plus récentes.

Voir aussi : System.CapsLock, System.ScrollLock

OperatingSystem

(Anciennement system.os, désormais obsolète)

readonly static eOperatingSystem System.OperatingSystem;

Retourne le système d'exploitation (OS) sous lequel tourne le jeu actuellement. Peut prendre les valeurs suivantes :

eOSDOS
eOSWindows
eOSLinux
eOSMacOS

Exemple :

if (System.OperatingSystem == eOSWindows) {
  Display("Exécution sous Windows!");
}
else {
  Display("Exécution hors Windows!");
}

ScreenHeight

(Anciennement system.screen_height, désormais obsolète)

readonly static int System.ScreenHeight;

Retourne la hauteur véritable de l'écran du jeu. Peut valoir 200, 240, 400, 480 ou 600.

Notez que si un filtre graphique est actif, la résolution retournée correspondra à celle précédant l'application de redimensionnement du filtre.

NOTE : Cette information est fournie pour permettre d'optimiser votre jeu, toutefois ne forcez pas le joueur à exécuter le jeu dans une résolution spécifique. AGS est conçu pour permettre aux joueurs de choisir différentes résolutions afin de faire marcher le jeu sur leurs PC.

Exemple :

Display("Le jeu a l'aspect suivant : %d x %d, %d-bit colour", System.ScreenWidth,
                                  System.ScreenHeight, System.ColorDepth);

affichera la résolution actuelle et la profondeur de couleurs.

Voir aussi : System.ColorDepth, System.ScreenWidth

ScreenWidth

(Anciennement system.screen_width, désormais obsolète)

readonly static int System.ScreenWidth;

Retourne la hauteur véritable de l'écran du jeu. Peut valoir 320, 640, ou 800.

Notez que si un filtre graphique est actif, la résolution retournée correspondra à celle précédant l'application de redimensionnement du filtre.

NOTE : Cette information est fournie pour permettre d'optimiser votre jeu, toutefois ne forcez pas le joueur à exécuter le jeu dans une résolution spécifique. AGS est conçu pour permettre aux joueurs de choisir différentes résolutions afin de faire marcher le jeu sur leurs PC.

Exemple :

Display("Le jeu a l'aspect suivant : %d x %d, %d-bit colour", System.ScreenWidth,
                                  System.ScreenHeight, System.ColorDepth);

affichera la résolution actuelle et la profondeur de couleurs.

Voir aussi : System.ColorDepth, System.ScreenHeight

ScrollLock

readonly static bool System.ScrollLock;
Retourne si Arrêt Défilement (Scroll Lock) est actuellement activée sur le système du joueur.

Notez que lorsque vous exécutez le jeu en mode Debug, la touche Arrêt Défil. lancera le débogueur, il ne vaut donc mieux pas l'utiliser dans un autre but dans le jeu.

Exemple :
if (System.ScrollLock)
{
  Display("La lumière ARRET DEFIL est allumée.");
}

affichera un message si Arrêt Défil. est activée.

Compatibilité : Supporté par AGS 3.0.1 et les versions plus récentes.

Voir aussi : System.CapsLock, System.NumLock

SupportsGammaControl

readonly static bool System.SupportsGammaControl;
Retourne si le PC du joueur supporte la reconfiguration du gamma.

Doit retourner true avant tout changement par la propriété System.Gamma. Les situations qui présentent ce support sont lisées ci-après.

Support selon les plateformes

Windows: Plein écran seulement MS-DOS: Non supporté Linux: Non supporté MacOS: Non supporté

Exemple :
if (System.SupportsGammaControl) {
  Display("Il est possible de changer le niveau de gamma du système !");
}

affichera un message si le système supporte la reconfiguration du gamma.

Voir aussi : System.Gamma

Version

(Anciennement system.version, désormais obsolète)

readonly static String System.Version;

Retourne le numéro de version du moteur d'AGS. Peut être particulièrement utile pour les modules de script, afin d'utiliser des aspects propres à certaines versions, ou pour gérer d'éventuels bugs spécifiques.

La chaîne retournée correspond au numéro complet de version, par exemple “2.71.833 The string returned is the full version number, for example “2.71.833”.

Exemple :

Display("Version d'AGS : %s", System.Version);

affichera le numéro de la version d'AGS.

ViewportHeight

(Anciennement system.viewport_height, désormais obsolète)

readonly static int System.ViewportHeight;

Retourne la hauteur actuelle de la fenêtre, en unités de résolution 320×200. Cela vous permet de déterminer les coordonnées maximum que vous pouvez passer à des fonctions comme Mouse.SetPosition.

Exemple :

Display("Fenêtre du jeu : %d x %d", System.ViewportWidth, System.ViewportHeight);

affichera les dimensions actuelles de la fenêtre.

Voir aussi : System.ViewportWidth

ViewportWidth

(Anciennement system.viewport_width, désormais obsolète)

readonly static int System.ViewportWidth;

Retourne la largeur actuelle de la fenêtre, en unités de résolution 320×200. Cela vous permet de déterminer les coordonnées maximum que vous pouvez passer à des fonctions comme Mouse.SetPosition.

Exemple :

Display("Fenêtre du jeu : %d x %d", System.ViewportWidth, System.ViewportHeight);

affichera les dimensions actuelles de la fenêtre.

Voir aussi : System.ViewportHeight

VSync

(Anciennement system.vsync, désormais obsolète)

static bool System.VSync;

Retourne/définit si AGS attend le retraçage vertical avant d'afficher chaque image. Désactivé par défaut.

Si vous l'activez, cela peut réduire l'effet “déchirure” parfois visible lorsque l'écran défile. Toutefois, cela aura pour effet de limiter la fréquence d'affichage des images du jeu à la fréquence de rafraîchissement du moniteur, ce qui signifie que vous ne pourrez pas définir une vitesse de jeu supérieure à 60 fps.

NOTE : Cette propriété n'a aucun effet avec le pilote Direct3D.

Exemple :

if (System.VSync) {
  Display("La synchronisation du retraçage vertical est activée !");
}

affichera un message si vsync est activée.

Windowed

(Anciennement system.windowed, désormais obsolète)

readonly static bool System.Windowed;

Retourne si le jeu tourne actuellement en mode fenêtré (true) ou en plein écran (false).

Exemple :

if (System.Windowed) {
  Display("Le jeu est fenêtré !");
}

affichera un message si le jeu tourne en mode fenêtré.


speech

Table des matières
    • Fonctions d'affichage de texte (Speech)
      • Display
      • DisplayAt
      • DisplayAtY
      • DisplayMessage
      • DisplayMessageAtY
      • DisplayTopBar
      • SetSkipSpeech
      • SetSpeechStyle

Fonctions d'affichage de texte (Speech)

Display

Display (string message, ...)
Affiche un message à l'écran. Il sera affiché dans une boîte de messages standard, et centré au milieu de l'écran.

Vous pouvez insérer la valeur de variables dans le message. Pour plus d'information, voyez la section Syntaxe des chaînes de caractères (String).

Exemple :
int mon_compteur;
Display ("Le compteur vaut actuellement %d.", mon_compteur);

affichera le texte où '%d' sera remplacé par la valeur de la variable “mon_compteur”.

NOTE : Display est une fonction bloquante - cela signifie que l'exécution du script sera mise en pause jusqu'à ce que le joueur ait fait disparaître la fenêtre de texte (en appuyant sur une touche ou sur la souris). Tant que la fenêtre est affichée, tous les autres processus, comme les animations et l'affiche des interfaces, seront suspendus.

Cette fonction peut être utilisée en réponse lorsque le joueur observe quelque chose.

Voir Aussi : DisplayAt, DisplayMessage, Character.Say, DisplayTopBar, String.Format

DisplayAt

DisplayAt(int x, int y, int largeur, string message, ...)
Identique à la fonction “Display”, celle-ci vous permet cependant de définir la position et la taille de la fenêtre dans laquelle le texte sera affiché. Les variables X et Y définissent les coordonnées du coin haut-gauche de la fenêtre.

La variable LARGEUR définit la largeur maximale de la fenêtre. La hauteur est ensuite automatiquement calculée de façon à ce que le message soit inséré dans la fenêtre.

Vous pouvez insérer des valeurs de variables dans le message. Pour plus d'information, voyez la section Syntaxe des chaînes de caractères (String).

Note : Ceci est une fonction bloquante. Voyez l'aide de “Display” pour plus d'information.

Exemple :
DisplayAt (50,50,100, "Ceci est un message");

affichera le message aux coordonnées (50,50) dans une boîte de 100 pixels de largeur.

Voir Aussi : Display, DisplayAtY

DisplayAtY

DisplayAtY (int y, string message)
Similaire à la fonction Display, celle-ci vous permet toutefois d'afficher la boîte de message à la coordonnée d'écran Y spécifiée. La coordonnée Y correspond au haut de la boîte de messsage. La position horizontale sera alors automatiquement calculée, comme d'habitude.

Exemple :
DisplayAt (50, "Ceci est un message.");

affichera le message à la coordonnée Y 50.

Voir Aussi : Display, DisplayAt

DisplayMessage

DisplayMessage (int numero_message)
Identique à la fonction Display, celle-ci utilise par contre comme texte un message défini dans l'Editeur de Pièce (Room Editor). Le message peut être un message propre à la pièce actuelle, ou un message global (si numero_message Identical to the Display function, but this uses a message text defined in the Room Editor rather than in the script. It will either use a message &gt;= 500).

Exemple :
DisplayMessage(220);

affichera le message 220 de l'éditeur des messages de la Pièce.

Voir Aussi : Display, DisplayMessageAtY

DisplayMessageAtY

DisplayMessageAtY (int numero_message, int yposition)
Identique à la fonction DisplayMessage, mais cette fois le haut de la boîte de texte est positionné à la coordonnée YPOSITION, de la même façon qu'avec DisplayAtY.

Ceci est utile si vous avez une image importante au milieu de l'écran que la boîte de texte couvrirait en temps normal - avec cette fonction vous pouvez ainsi placer le message sous ou au-dessus de cette image.

Exemple :
DisplayMessageAtY(527, 200);

affichera le message global 527, dans la moitié basse de l'écran.

Voir Aussi : DisplayAtY, DisplayMessage

DisplayTopBar

DisplayTopBar(int y, int couleur_texte, int couleur_fond, string texteTitre, string message, ...)
Affiche un message dans une fenêtre texte, avec une barre de titre au dessus d'elle.

Cette fonction affiche MESSAGE d'une façon similaire à la commande Display, mais au-dessus de la fenêtre de texte, une barre de titre sera affichée contenant le texte “TEXTETITRE”. Cette méthode était utilisée dans certains jeux Sierra des débuts pour indiquer qui était en train de parler en affichant leur nom dans le titre, et elle peut être utile si vous ne voulez pas dessiner une vue de discours pour le personnage.

Vous pouvez insérer la valeur de variables dans le message. Pour plus d'information, voir la section Syntaxe des chaînes de caractères (String).

Le paramètre Y spécifie la coordonnée Y à l'écran où la boîte de message sera affichée. La valeur par défaut est 25.

Le paramètre COULEUR_TEXTE spécifie la couleur du texte de la barre de titre, et COULEUR_FOND spécifie la couleur d'arrière-plan de la barre de titre.

Vous pouvez passer 0 pour Y, COULEUR_TEXTE ou COULEUR_FOND - si vous faîtes ceci, la fonction utilisera les réglages qui lui auront été passés la dernière fois.

Il y a quelques variables de jeu disponibles afin de personnaliser l'aspect de la barre. Vous pouvez les modifier avant d'appeler DisplayTopBar.

game.top_bar_bordercolor définit la couleur utilisée pour la bordure de la barre (donnez la même couleur que l'arrière-plan si vous ne voulez pas de bordure). game.top_bar_borderwidth définit la largeur de la bordure de la barre, en pixels (1 par défaut).

game.top_bar_font définit la police utilisée dans la barre. La valeur par défaut est -1, ce qui signifie que la police Normale actuelle est utilisée. Définissez cette variable à un numéro de police spécifique pour utiliser cette police à la place.

Exemple :

DisplayTopBar(25, 8, 7, "Mage chaotique", "Sortez de ma demeure et ne revenez jamais !");

affichera “Sortez de ma demeure et ne revenez jamais !” dans la boîte de message, avec une barre de titre contenant “Mage chaotique”. Le texte de la barre de titre sera d'un gris sombre, sur un fond gris vif.

Voir Aussi : Display, DisplayAt

SetSkipSpeech

SetSkipSpeech (int nouveau_mode)
Définit si le joueur peut ou non passer le discours en cliquant avec la souris. Cette option est initialement définie par une case à cocher dans l'onglet d'accueil de l'éditeur (General Settings/Réglages généraux), mais cette fonction vous permet de la modifier en cours de jeu. La valeur de NOUVEAU_MODE peut être :
0  le joueur peut passer le texte en cliquant ou en appuyant sur une touche
1  le joueur peut passer le texte uniquement en appuyant sur une touche, et non en cliquant
2  le joueur ne peut passer le texte ni avec la souris ni avec le clavier
3  le texte ne s'efface pas automatiquement ; le joueur doit cliquer ou appuyer sur une touche à chaque fois
4  le joueur peut passer le texte uniquement en cliquant, et non en appuyant sur une touche

Exemple :

SetSkipSpeech(2);

fera que le joueur ne pourra passer le texte ni en appuyant sur un bouton de souris, ni sur une touche.

SetSpeechStyle

SetSpeechStyle(SpeechStyle)
Change la façon dont le texte de discours est affiché. Ceci modifie le réglage initialement défini dans l'éditeur. SpeechStyle peut valoir :
eSpeechLucasarts
    texte au-dessus de la tête des personnages
eSpeechSierra
    avec portrait du personnage
eSpeechSierraWithBackground
    avec portrait du personnage + fenêtre de fond pour le texte
eSpeechFullScreen
    style QFG4 : images de dialogue sur tout l'écran

Exemple :

SetSpeechStyle(eSpeechSierra);

changera le style du discours pour l'afficher à côté d'un portrait du personnage.


viewframe

Table des matières
    • Fonctions et propriétés de ViewFrame
      • Flipped
      • Frame
      • Graphic
      • Loop
      • Sound
      • Speed
      • View

Fonctions et propriétés de ViewFrame

Flipped

(Anciennement compris dans GetGameParameter, désormais obsolète)

readonly bool ViewFrame.Flipped

Retourne si l'image a été retournée (Flipped) dans l'éditeur.

Exemple:

ViewFrame *frame = Game.GetViewFrame(MARCHE, 2, 4);
if (frame.Flipped) {
  Display("Cette image est inversée");
}
else {
  Display("Cette image n'est pas inversée");
}

Voir aussi : Game.GetViewFrame, ViewFrame.Graphic

Frame

(Anciennement compris dans GetGameParameter, désormais obsolète)

readonly int ViewFrame.Frame

Retourne le numéro d'image représentée par cette ViewFrame.

Exemple :

ViewFrame *frame = Game.GetViewFrame(MARCHE, 2, 4);
Display("Cette ViewFrame est la vue numéro %d, séquance %d, image %d",
  frame.View, frame.Loop, frame.Frame);

Voir aussi : Game.GetViewFrame, ViewFrame.Loop, ViewFrame.View

Graphic

(Anciennement compris dans GetGameParameter, désormais oboslète)

int ViewFrame.Graphic

Retourne/définit le numéro de sprite qu'affiche cette ViewFrame.

Exemple :

ViewFrame *frame = Game.GetViewFrame(MARCHE, 2, 4);
Display("Cette image utilise la sprite numéro %d", frame.Graphic);

Voir aussi : Game.GetViewFrame

Loop

(Anciennement compris dans GetGameParameter, désormais oboslète)

readonly int ViewFrame.Loop

Retourne le numéro de séquence représenté par cette ViewFrame.

Exemple :

ViewFrame *frame = Game.GetViewFrame(MARCHE, 2, 4);
Display("Cette ViewFrame est la vue numéro %d, séquence %d, image %d",
  frame.View, frame.Loop, frame.Frame);

Voir aussi : Game.GetViewFrame, ViewFrame.Frame, ViewFrame.View

Sound

(Formerly known as SetFrameSound, désormais obsolète) (Anciennement compris dans GetGameParameter, désormais oboslète)

int ViewFrame.Sound

Retourne/définit le numéro de son du son qui est lié à cette image. Si aucun son n'y est lié, vaudra 0.

Exemple :

ViewFrame *frame = Game.GetViewFrame(MARCHE, 2, 4);
Display("Le son numéro %d est lié à cette ViewFrame.", frame.Sound);

Voir aussi : Game.GetViewFrame

Speed

(Anciennement compris dans GetGameParameter, désormais oboslète)

readonly int ViewFrame.Speed

Retourne la vitesse définie pour cette ViewFrame. Vaut 0 par défaut mais peut être changé dans l'éditeur AGS.

Exemple :

ViewFrame *frame = Game.GetViewFrame(MARCHE, 2, 4);
Display("Cette image a une vitesse de %d.", frame.Speed);

Voir aussi : Game.GetViewFrame

View

(Anciennement compris dans GetGameParameter, désormais oboslète)

readonly int ViewFrame.View

Retourne le numéro de vue représenté par cette ViewFrame.

Exemple :

ViewFrame *frame = Game.GetViewFrame(WALKING, 2, 4);
Display("This ViewFrame is view %d, loop %d, frame %d",
  frame.View, frame.Loop, frame.Frame);

Voir aussi : Game.GetViewFrame, ViewFrame.Loop, ViewFrame.Frame


scumm_verbcoin_gui

Table des matières
    • Fonctions du module SCUMM_VERBCOIN_GUI
      • Deselect
      • DisableVerbCoinGUI
      • DoubleClickSpeed
      • GoInventory
      • Item_Count
      • InvScroll_Left
      • InvScroll_Right
      • Inv_Border_active
      • Inv_Border_SetPos
      • Inventory_GUI
      • RunInteraction
      • Select
      • Verbcoin_GUI
      • verbgraphic
      • doubleclick

Fonctions du module SCUMM_VERBCOIN_GUI

SCUMM_VERBCOIN_GUI est un module du script qui est inclu avec le modèle Verb Coin. Les fonctions de cette section ne sont disponibles que si vous avez créé votre jeu en utilisant ce modèle.

Deselect

static SCUMM_VERBCOIN_GUI.Deselect()
Désélection un objet s'il est actif ou quitte l'inventaire. Utilisé pour le support du clavier.

NOTE : Cette fonction fait partie du modèle Verb Coin et n'est disponible que si vous avez choisi ce modèle pour créer votre jeu.

Voir aussi : SCUMM_VERBCOIN_GUI.RunInteraction, SCUMM_VERBCOIN_GUI.Select

DisableVerbCoinGUI

static SCUMM_VERBCOIN_GUI.DisableVerbCoinGUI(bool desactive)
Active/Désactive le système SCUMM Verbcoin GUI. Cela peut être utilisé pour permettre au joueur d'activer/désactiver le système SCUMM VerbCoin lors de l'exécution du jeu.

NOTE : Cette fonction fait partie du modèle Verb Coin et n'est disponible que si vous avez choisi ce modèle pour créer votre jeu.

Exemple :
SCUMM_VERBCOIN_GUI.DisableVerbCoinGUI(true);

désactivera tout code traitant le système VerbCoin.

DoubleClickSpeed

static SCUMM_VERBCOIN_GUI.DoubleClickSpeed(int vitesse)
Définit l'intervalle durant lequel un double-clic peut être détecté. Augmentez cette valeur pour des double-clics plus lents, et diminuez-la pour des double-clics plus rapides.

NOTE : Cette fonction fait partie du modèle Verb Coin et n'est disponible que si vous avez choisi ce modèle pour créer votre jeu.

Exemple :
SCUMM_VERBCOIN_GUI.DoubleClickSpeed(GetGameSpeed()/4);

définira la vitesse de double-cli à un quart de seconde. (C'est une bonne valeur par défaut)

Voir aussi : SCUMM_VERBCOIN_GUI.doubleclick

GoInventory

static SCUMM_VERBCOIN_GUI.GoInventory()
Cette fonction ouvre ou ferme votre inventaire.

NOTE : Cette fonction fait partie du modèle Verb Coin et n'est disponible que si vous avez choisi ce modèle pour créer votre jeu.

Item_Count

static SCUMM_VERBCOIN_GUI.Item_Count(int combien)
Détermine le nombre d'objets que le défilement de l'inventaire utilisera pour afficher la prochaine quantité x d'objets.

Cette valeur devrait être égale au nombre d'objets qui entrent dans le cadre de votre fenêtre d'inventaire.

NOTE : Cette fonction fait partie du modèle Verb Coin et n'est disponible que si vous avez choisi ce modèle pour créer votre jeu.

Exemple :
SCUMM_VERBCOIN_GUI.Item_Count(10);

assurera qu'au prochain défilement de l'inventaire seront affichés les objets 11, 21, 31, …

Voir aussi : SCUMM_VERBCOIN_GUI.InvScroll_Left, SCUMM_VERBCOIN_GUI.InvScroll_Right

InvScroll_Left

static SCUMM_VERBCOIN_GUI.InvScroll_Left()
Fait défiler l'inventaire vers la gauche, du nombre d'objets défini par Item_Count.

NOTE : Cette fonction fait partie du modèle Verb Coin et n'est disponible que si vous avez choisi ce modèle pour créer votre jeu.

Voir aussi : SCUMM_VERBCOIN_GUI.Item_Count, SCUMM_VERBCOIN_GUI.InvScroll_Right

InvScroll_Right

static SCUMM_VERBCOIN_GUI.InvScroll_Right()
Fait défiler l'inventaire sur la droite, du nombre d'objets défini par Item_Count.

NOTE : Cette fonction fait partie du modèle Verb Coin et n'est disponible que si vous avez choisi ce modèle pour créer votre jeu.

Voir aussi : SCUMM_VERBCOIN_GUI.Item_Count, SCUMM_VERBCOIN_GUI.InvScroll_Left

Inv_Border_active

static SCUMM_VERBCOIN_GUI.Inv_Border_active(bool bordures_x, bool bordures_y)
Détermine quelles bordures de l'inventaire le font disparaître.

Ces bordures déterminent quelles lignes la souris doit franchir pour que l'inventaire s'efface.

NOTE : Cette fonction fait partie du modèle Verb Coin et n'est disponible que si vous avez choisi ce modèle pour créer votre jeu.

Exemple :
SCUMM_VERBCOIN_GUI.Inv_Border_active(false, true);

fera que le jeu quittera l'inventaire lorsque la souris passera soit le haut soit le bas de l'inventaire.

Voir aussi : SCUMM_VERBCOIN_GUI.Inv_Border_SetPos

Inv_Border_SetPos

static SCUMM_VERBCOIN_GUI.Inv_Border_SetPos(int haut, int bas,
                                            int gauche, int droite)
Définit les positions des bordures d'effacement de l'inventaire.

Ces bordures déterminent quelles lignes la souris doit franchir pour que l'inventaire s'efface.

NOTE : Cette fonction fait partie du modèle Verb Coin et n'est disponible que si vous avez choisi ce modèle pour créer votre jeu.

Exemple :
SCUMM_VERBCOIN_GUI.Inv_Border_SetPos(20, 220, 20, 295);

placera la bordure du haut à la coordonnée y 20, la bordure du bas à la coordonnée y 220, la bordure de gauche à la coordonnée x 20 et la bordure de droite à la coordonnée x 295.

Voir aussi : SCUMM_VERBCOIN_GUI.Inv_Border_active

Inventory_GUI

static SCUMM_VERBCOIN_GUI.Inventory_GUI(int gID_Inventaire,int gID_InvDessous)
Définit les ID des GUI d'inventaire, de façon à ce que le module sache quel GUI est votre inventaire et lequel est votre inventaire de fond.

Ceci vous permet de changer vos GUI d'inventaire durant l'exécution, ce qui est particulièrement intéressant si vous avez un jeu avec plusieurs personnages joueurs. Vous pouvez alors avoir différents inventaires pour chaque personnage !

Si le jeu est en 32-bit et utilise des boutons de GUI avec canal alpha (tranparents) sur l'inventaire, vous devez utiliser un GUI de fond qui contient l'arrière-plan de l'inventaire, et l'interface normale vite exceptée en ce qui concerne la fenêtre d'inventaire et les boutons du GUI.

Si votre jeu n'utilise pas de boutons de GUI avec canal alpha, laissez l'inventaire de fond vide. (utilisez la sprite 0 en tant que fond)

NOTE : Cette fonction fait partie du modèle Verb Coin et n'est disponible que si vous avez choisi ce modèle pour créer votre jeu.

Exemple :
SCUMM_VERBCOIN_GUI.Inventory_GUI(2, 3);

informera le module que votre GUI d'inventaire est le numéro 2 et que le GUI de fond est le numéro 3.\

RunInteraction

static SCUMM_VERBCOIN_GUI.RunInteraction(CursorMode)
Lance l'interaction choisie. Utilisé pour le support clavier.

NOTE : Cette fonction fait partie du modèle Verb Coin et n'est disponible que si vous avez choisi ce modèle pour créer votre jeu.

Exemple :
SCUMM_VERBCOIN_GUI.RunInteraction(eModeTalkto);

Voir aussi : SCUMM_VERBCOIN_GUI.Deselect, SCUMM_VERBCOIN_GUI.Select

Select

static SCUMM_VERBCOIN_GUI.Select()
Sélectionne un objet, ou si un objet est actif, tente de l'utiliser. Utilisé pour le support clavier.

NOTE : Cette fonction fait partie du modèle Verb Coin et n'est disponible que si vous avez choisi ce modèle pour créer votre jeu.

Voir aussi : SCUMM_VERBCOIN_GUI.Deselect, SCUMM_VERBCOIN_GUI.RunInteraction

Verbcoin_GUI

static SCUMM_VERBCOIN_GUI.Verbcoin_GUI(int gID_Verbal)
Définit l'ID du GUI verbal, de façon à ce que le module sache quel GUI utiliser.

Ceci est particulièrement pratique si vous avez un jeu avec plusieurs personnages joueurs, où vous pouvez avoir des GUI verbaux différents pour chaque personnage.

NOTE : Cette fonction fait partie du modèle Verb Coin et n'est disponible que si vous avez choisi ce modèle pour créer votre jeu.

Exemple :
SCUMM_VERBCOIN_GUI.Verbcoin_GUI(1);

informera le module que votre GUI verbal est le numéro 1.

verbgraphic

static SCUMM_VERBCOIN_GUI.verbgraphic(ButtonChoice, int numero_sprite)
Attache une sprite à un bouton. Cette sprite sera affichée lorsque la souris survolera le bouton.

La seule exception est le bouton 'bIdle', qui n'est pas un bouton mais l'image par défaut avec aucun bouton activé.

NOTE : Cette fonction fait partie du modèle Verb Coin et n'est disponible que si vous avez choisi ce modèle pour créer votre jeu.

Exemple :
SCUMM_VERBCOIN_GUI.verbgraphic(bParler, 2);

utilisera la sprite 2 pour le bouton Parler lorsque la souris le survolera.

doubleclick

global bool doubleclick
Utilisée pour déterminer si un double-clic a eu lieu.

NOTE : Cette variable fait partie du modèle Verb Coin et n'est disponible que si vous avez choisi ce modèle pour créer votre jeu.

Exemple :
  if (doubleclick == false){
    Display("Vous avez fait un clic simple");
  }
  else{
    Display("Vous avez fait un double-clic !");
  }

affichera le message “Vous avez fait un clic simple” lorsque vous faire un clic simple sur un objet/hotspot/personnage/…

Voir aussi : SCUMM_VERBCOIN_GUI.DoubleClickSpeed


references

Références

Cette section contient une référence pour les différentes parties du système, sauf le langage script, qui a sa propre section Script.

Événements d'interaction (Interaction events)

Limites du système

Raccourcis Clavier

Table de codes ASCII


evenements_d_interaction

Table des matières
    • Événements d'interaction (Interaction events)
      • Interaction des Zones Interactives (Hotspot)
      • Interaction des Objets
      • Interaction de la pièce (Room)
      • Interactions des objets de l'inventaire (Inventory Items)
      • Interaction des personnages (Character)
      • Interaction des régions (Region)

Événements d'interaction (Interaction events)

Les événements suivants sont disponibles dans la fenêtre “Interaction”.

Interaction des Zones Interactives (Hotspot)

  • Player stands on hotspot (le joueur marche sur la zone interactive)
Ce qui se produit en permanence lorsque le joueur se trouve sur la zone interactive (hotspot).
  • Look at hotspot (regarder la zone interactive)
Ce qui se produit lorsque le joueur clique sur la zone en mode “Look at” (regarder)(curseur mode 1).
  • Interact with hotspot (interagir avec la zone interactive)
Ce qui se produit lorsque le joueur clique sur le hotspot (zone interactive) en mode “Interact” (interagir) (cursor mode 2).
  • Use inventory on hotspot (utiliser un objet de l'inventaire sur la zone interactive)
Ce qui se produit lorsque le joueur clique sur la zone interactive (Hotspot) en mode “Use inventory” (Utiliser Inventaire, mode de curseur 4). Vous pouvez utiliser la condition “If inventory item was used” (Si cet l'objet de l'inventaire est utilisé) afin de distinguer quel objet a été utilisé.
IMPORTANT : Quand la condition “If inventory item was used” (Si cet l'objet de l'inventaire est utilisé) est cochée, le joueur perdra cet objet, SAUF SI “Do not lose inventory items” (Ne pas perdre les objets d'inventaire…) est cochée dans le panneau des “General Settings” (Réglages Généraux).
  • Speak to hotspot (parler à la zone interactive)
Ce qui se produit lorsque le joueur clique sur la zone interactive (Hotspot) en mode “Talk” (Parler, mode de curseur 3).
  • Any click on hotspot (n'importe quel clic sur la zone interactive)
Ce qui se produit lorsque le joueur clique sur la zone interactive (Hotspot) avec n'importe quel mode du curseur (excepté Walk – Marcher).
Cela vous permet d'ajouter des modes comme l'odorat, le goût, pousser, tirer, et ainsi de suite. Cet événement se déclenche n'empêche pas les événements ”Look at hotspot” (Regarder Zone Interactive) et ”Talk to hotspot” (Parler à Zone Interactive) de se produire.
  • Mouse moves over hotspot (la souris passe sur la zone interactive)
Ce qui se produit en permanence lorsque la souris survole la zone interactive (Hotspot). Vous pouvez l'utiliser pour mettre en évidence le curseur, et pour divers autres effets.

Interaction des Objets

  • Look at object (regarder l'objet)
Ce qui se passe lorsque le joueur clique sur l'objet en mode “Look” (Observer, mode de curseur 1).
  • Interact with object (interagir avec l'objet)
Ce qui se passe lorsque le joueur clique sur l'objet en mode “Interact” (Interagir, mode de curseur 2).
  • Speak to object (parler à l'objet)
Ce qui se passe lorsque le joueur clique sur l'objet en mode “Talk” (Parler, mode de curseur 3).
  • Use inventory on object (utiliser un objet de l'inventaire sur l'objet)
Marche comme “Use inventory on hotspot” (Utiliser un objet de l'inventaire sur la zone interactive) - voir cette description (ci-dessus) pour plus d'information.

Interaction de la pièce (Room)

  • Walk off left
Ce qui se produit lorsque le joueur marche sur le bord à gauche de l'écran.
  • Walk off right
Ce qui se produit lorsque le joueur marche sur le bord à droite de l'écran.
  • Walk off bottom
Ce qui se produit lorsque le joueur marche sur le bord en bas de l'écran.
  • Walk off top
Ce qui se produit lorsque le joueur marche sur le bord en haut de l'écran.
  • First time enters room (première fois que le joueur entre dans la pièce)
Ce qui se passe quand c'est la première fois que le joueur entre dans la pièce.
Ces événements se passent après le fondu d'entrée (fade-in), et vous permettent par exemple d'afficher un message décrivant la scène.
  • Player enters room (before fadein) (joueur entre dans la pièce (avant le fondu))
Ce qui se produit lorsque la pièce est chargée en mémoire.
Cet événement se produit chaque fois que le joueur affiche une nouvelle pièce, avant le fondu d'entrée (fade-in) de l'écran, et cela vous permet de changer par exemple l'apparence d'un objet et de faire d'autres choses à l'écran sans que le joueur ne le remarque.
NOTE: Cet événement est seulement là pour le réglage des choses comme le placement d'objets et des personnages. NE PAS utiliser cet événement pour toutes sortes de systèmes automatisés d'introduction à la pièce - utiliser l'événement “Enters Room After Fade In” (après le fondu d'entrée) pour cela.
  • Repeatedly execute (exécution répétée)
Ce qui se produit à chaque cycle de jeu
La vitesse normale du jeu est de 40 cycles par seconde, cet événement se produit donc toutes les 25 millisecondes.
  • Player enters room (after fadein) (le joueur entre dans la pièce (après le fondu)
Ce qui se produit à chaque fois que le joueur entre dans la pièce, APRÈS le fondu de l'écran.
Convient pour l'affichage du texte de descriptions et autres, ce que vous voulez que le joueur voie.
  • Player leaves room (le joueur quitte la pièce)
Ce qui se passe quand le joueur va quitter l'écran, juste avant le fondu de sortie (fade-out) de la pièce.

Interactions des objets de l'inventaire (Inventory Items)

  • Look at inventory (regarder l'objet dans l'inventaire)
Ce qui se passe lorsque le joueur clique sur l'objet dans l'inventaire en mode “Look” (Observer)
  • Interact with inventory (interagir avec l'objet dans l'inventaire)
Actuellement, comme le mode “Interact” (Interagir) sélectionne seulement l'objet de l'inventaire, cette interaction ne peut pas être déclenchée manuellement sauf avec la fonction du script InventoryItem.RunInteraction (vous devez activer l'option “Handle Inv Clicks” – Gérer les clics dans l'inventaire – dans les options du script – Script Options).
  • Speak to inventory (parler ) l'objet dans l'inventaire)
Ne fonctionne qu'avec les inventaires de style Lucasarts
Ce qui se passe quand le joueur utilise le mode “Talk” (Parler) sur un objet de l'inventaire.
  • Use inventory on inv (Utiliser un objet de l'inventaire sur un autre objet dans l'inventaire)
Ce qui se passe quand le joueur utilise un objet de l'inventaire sur un autre objet dans l'inventaire.
Activer l'option “if inventory item was used” (Si un objet de l'inventaire est utilisé) pour savoir quel objet est utilisé.
Cet événement permet au joueur de combiner des objets et autres. Par exemple, si vous avez un ordinateur portable et une batterie séparée, vous pouvez utiliser cet événement pour insérer la batterie dans l'ordinateur.
  • Other click on inventory (autre clic sur l'objet dans l'inventaire)
Ne fonctionne qu'avec les inventaires de style Lucasarts
Ce qui se passe quand le joueur clique dans un autre mode de curseur sur l'objet (en dehors d'Observer, Parler et Utiliser Inventaire).

Interaction des personnages (Character)

  • Look at character (regarder le personnage)
Ce qui se passe quand le joueur clique sur le personnage en mode “Look” (Observer).
  • Interact with character (interagir avec le personnage)
Ce qui se passe quand le joueur clique sur le personnage en mode “interact” (Interagir).
  • Speak to character (parler au personnage)
Ce qui se passe quand le joueur clique sur le personnage en mode “Talk” (Parler).
  • Use inventory on character (utiliser un objet de l'inventaire sur le personnage)
Ce qui se passe quand le joueur utilise un objet de l'inventaire sur le personnage.
Cet événement peut être utilisé pour permettre au joueur à donner un objet à un autre personnage.
  • Any click on character (tout clic sur le personnage)
Ce qui se passe quand le joueur clique sur le personnage dans n'importe quel mode de curseur (en dehors d'Observer, Parler et Utiliser Inventaire).

Interaction des régions (Region)

  • While player stands on region (le joueur se trouve sur la région)
Ce qui se passe en boucle tant que le joueur se trouve sur la région
  • Player walks onto region (le joueur arrive et entre sur cette région)
Ce qui se passe quand le joueur vient d'arriver sur la région.
Cet événement se déclenchera aussi si le joueur se trouve sur la région à l'arrivée dans la pièce.
  • Player walks off region (le joueur quitte la région)
Ce qui se passe quand le joueur quitte la région.
Cet événement ne se déclenche pas lorsque le joueur quitte la pièce alors qu'il se trouvait encore sur la région.


limites_du_systeme

Limites du système

Cette section vous indique les valeurs maximales pour les différentes parties du système. Si vous vous êtes demandé “combien de pièces je peux avoir ?” ou quelque chose de similaire, cette section peut contenir votre réponse.

Il peut y avoir au maximum…

      40  objets par pièce
     100  messages locaux par pièce (en excluant le script)
     299  points de sauvegarde dans les pièces de votre jeu
     300  objets d'inventaire
   30000  sprites (images) importées
      30  contrôles sur chaque GUI
     500  dialog topics (thèmes de dialogue)
    3000  messages de dialog-script
      30  options par sujet (topic)
      20  superpositions de calque à la fois
     500  variables GlobalInts (n'incluant pas vos propres variables)
      50  variables GlobalStrings (n'incluant pas vos propres variables)
       5  background frames (images d'animation arrière plan) par pièce.
      20  curseurs de souris
personnages illimités
Views (vues) illimitées
GUIs illimités
Loops (séquences) illimitées par vue
Frames (images d'animation) illimitées par séquence (loop)

Si vous pensez que l'une de ces limites est un problème important, contactez-moi et je verrai si je peux les augmenter.


raccourcis_clavier

L'éditeur d'AGS offre plusieurs raccourcis clavier pour vous permettre de faire votre travail rapidement. Ils sont listés ci-dessous :

F1 | Aide
F2 | Statistiques du Jeu
F3 | Résultat suivant
Ctrl+F4 | Fermer l'onglet
F5 | Éxécuter avec le débogueur
Ctrl+F5 | Éxécuter sans le débogueur
F7 | Compiler l'EXE
F9 | Placer/Enlever le point d'arrêt d'exécution
F11 | Étape suivante
Ctrl+A | Tout sélectionner
Ctrl+B | Trouver l'accolade correspondante
Ctrl+C | Copier
Ctrl+D | Dupliquer la ligne
Ctrl+E | Remplacer
Ctrl+F | Rechercher
Ctrl+G | Ouvrir GlobalScript.asc
Ctrl+H | Ouvrir GlobalScript.ash
Ctrl+L | Ouvrir un Projet
Ctrl+Q | Quitter
Ctrl+R | Sauvegarder la Pièce
Ctrl+S | Sauvegarder le Projet
Ctrl+V | Coller
Ctrl+W | Fermer l'Onglet
Ctrl+X | Couper
Ctrl+Y | Rétablir
Ctrl+Z | Annuler
Ctrl+Space | Afficher l'Autocomplétion
Ctrl+Tab | Onglet suivant
Ctrl+Shift+Tab | Onglet précédent
Tab | Indenter les lignes sélectionnées
Shift+Tab | Annuler l'indentation des lignes sélectionnées


codes_ascii

Table de codes ASCII

Cette section énumère les principaux codes qui peuvent être passés en raccourcis clavier et les touches qu'ils représentent :

 1..26     Ctrl+A .. Ctrl+Z
 8         Effacer (Ctrl+H est comme Effacer)
 9         Tab (Ctrl+I est comme Tab)
 13        Entrée (Ctrl+M est comme Entrée)
 27        Escape (Échap.)
 32        Space (espace)
 48..57    touches '0' à '9'
 65..90    'A' .. 'Z'  (les lettres sont toujours en majuscules)
 359..368  F1 .. F10
 371       Home (flèche diagonale haut gauche) (incluant le paver numérique 7)
 372       Flèche du haut
 373       PgUp (incluant le paver numérique 9)
 375       Flèche de gauche
 376       '5' (5 du paver numérique)
 377       Flèche de droite
 379       Fin(incluant le paver numérique 1)
 380       Flèche du bas
 381       PgDn (incluant le paver numérique 3)
 382       Inser
 383       Suppr
 433..434  F11 .. F12

Codes supplémentaires, marchant seulement avec IsKeyPressed (note : on_key_press n'est jamais appelée avec ces codes):

 403       Shift gauche
 404       Shift droit
 405       Ctrl gauche
 406       Ctrl droit
 407       Alt


questions_frequemment_posees_faq

Questions Fréquemment Posées (FAQ)

Cette section du manuel est très rarement mise à jour. S'il vous plaît consultez les Forums d'AGS sur le site – en particulier, le “Beginners Technical Forum” (forum technique pour les débutants) qui a une excellente FAQ (la “BFAQ”), plus complète, et qui est régulièrement mise à jour qui traite de toutes sortes de problèmes.

Q. Quel est le problème avec la licence ? Qu'est-ce que cela signifie en bon français ?
A. Adventure Game Studio est à peu près un freeware. Cela signifie que vous pouvez l'utiliser librement pour des jeux NON-COMMERCIAUX, et vous n'avez rien a m'envoyer en retour. C'est une des exigences - si vous voulez vendre votre jeu, pour faire du profit, alors vous devez me contacter au préalable car il y a certaines questions relatives à la licence dont vous devriez prendre connaissance. Quand vous aurez fini votre jeu, s'il vous plaît, postez-le sur le “Forum des Annonces” (Anouncements Forums) et sur la “Liste des Jeux” (Games Database) afin que tout le monde puisse en prendre connaissance.

Q. Pourquoi une licence “swapware” ? Pourquoi ne pas en changer ?
A. Car je n'en ai pas envie. Il n'est pas nécessaire de se méfier, le fait que c'est gratuit ne signifie pas nécessairement que c'est mauvais.

Q. Sur mon écran, je ne peux pas déplacer le personnage principal. Où que je clic, il ne bouge pas.
A. Si le personnage n'est pas sur une “zone de déplacement” (walkable area), il ne pourra pas bouger. Chargez la pièce dans l'éditeur, et vérifiez que l'endroit où commence le personnage correspond bien à une “zone de déplacement” (walkable area).

Q. Quand j'entre dans certaines pièces, j'ai juste un écran noir.
A. Assurez-vous que vous n'avez pas utilisé la commande “Display Message” (afficher message) dans “Enters room before fade-in” (entrer dans la pièce avant le fondu) dans les événements de cette pièce. Rappelez-vous que cet événement se produit avant le “fade in” (fondu d'entrée dans la pièce).
Pour vous en assurer, lorsque vous obtenez un écran noir, essayez d'appuyer sur ENTRÉE, ou cliquer sur le bouton gauche de la souris. Si rien ne se passe c'est que quelque chose de plus sérieux est survenu. Si c'est le cas, appuyez sur Alt+X, cela devrait sortir du programme et vous permettra de retrouver la ligne de script où le jeu s'est bloqué.

Q. Le personnage ne passe pas derrière ma zone “walk-behind” (zone de plan intermédiaire) !
A. Vous devez définir la ligne de base (baseline) de cette zone, qui définit si les personnages passent devant ou derrière la zone selon qu'ils se trouvent sous ou au-dessus de cette ligne. Voir le tutoriel pour plus d'informations.

Q. Le fichier EXE de mon jeu semble avoir disparu.
A. Parce que ce fichier est l'ensemble de votre jeu, incluant les fichiers room , lorsque vous enregistrez une nouvelle pièce dans l'éditeur il supprimera le fichier exécutable (car les pièces contenues dans l'EXE ne sont plus à jour). Pour y remédier, re-construisez simplement le jeu en utilisant la commande “Build EXE” (construire l'EXE) dans le menu “Build” (construire).


passer_a_ags_3.0

Passer à AGS 3.0

Si vous avez déjà utilisé AGS avant, vous serez probablement troublé et peut-être même décontenancé par ce nouvel éditeur. Mais ne vous inquiétez pas, une fois que vous l'utiliserez, je suis sûr que vous accepterez les énormes améliorations par rapport à l'ancienne version.

La meilleure façon pour commencer est sans doute par le biais du tutoriel, qui a été mis à jour pour AGS 3 et par la suite, vous devriez devenir plus familier avec le fonctionnement de l'éditeur.

Les principaux changements sont expliqués ci-dessous :

Éditeur d'interaction

L'éditeur d'interaction a été supprimé de AGS 3.0. Quand vous importez votre jeu, AGS tentera de convertir toutes vos interactions dans les scripts. Ceux-ci devraient généralement marcher, cependant il existe certaines choses dont vous devriez être au courant :

1. Problèmes de conflit – C'était quand, si un script exécuté en 2.72 se bloquait, il était encore possible pour les interactions de s'exécuter en même temps même si elles n'étaient pas incluses dans les scripts. Maintenant ce n'est plus le cas. 2. Interactions bloquantes – dans la version 2.72, une interaction “Run Dialog” (lancer un dialogue), par exemple, attendait que le dialogue soit terminé avant d'aller vers la prochaine action. Si vous aviez un “Run Dialog” (lancer un dialogue) suivi d'un “Change Room” (changer de pièce), alors le dialogue se finissait avant que le changement de pièce n'arrive. Avec le script, vous devez faire attention car la commande “dialog[x].Start()” ne bloque pas ; au lieu de cela, il attend que le script en cours d'exécution finisse avant de lancer la boîte de dialogue. Ca veut dire que le changement de room n'arrivera pas nécessairement après le dialogue. Afin d'atténuer ces types de problèmes, vous pouvez utiliser une autre solution telle qu'une commande “run-script” (lancer le script) à la fin du dialogue pour lancer le changement de pièce.

Global Messages (messages globaux)

Les messages globaux ne sont plus utilisés et doivent être considérés comme obsolètes – il n'y a plus besoin d'eux maintenant que l'éditeur d'interaction a été supprimé. Tous les messages que vous aviez seront encore retenus et fonctionneront, bien que l'éditeur AGS 3 ne donne aucun moyen de les éditer. Si vous voulez en changer un, remplacez juste la commande “DisplayMessage” (afficher message) par un simple “Display()” (afficher).

Dans AGS 3.0.2, il y a maintenant un “Global Variables editor” (Éditeur de Variables Globales) dans lequel vous pouvez créer des “global string variables” (variables globales de type string), qui offrent toutes les fonctionnalités des Messages Globaux, et même plus.

Sauvegarder et tester votre jeu

AGS 3.0 fonctionne légèrement différemment des versions précédentes dans la manière de sauvegarder et tester vos jeux en cours. L'option “Save” (sauvegarder) (Ctrl+S) est l'équivalent de l'ancienne option “Quick Save” (sauvegarde rapide) – elle permettra de sauver vos modifications, mais sans compiler le fichier EXE.

L'option “Test game” (tester le jeu) est devenu “Run” (lancer) dans le menu “Build” (construire). Cela lance votre jeu avec le nouveau Débogueur de script, qui vous permet de faire une pause dans le script afin de traquer les problèmes.

Le débogueur lancera toujours votre jeu dans une fenêtre, donc si vous voulez tester en plein écran, il y a l'option “Run without debugger” (lancer sans débogueur) (Ctrl+F5).

Utilisez la commande “Build EXE” (construire l'EXE)(F7) quand vous voudrez créer les fichiers compilés pour distribuer votre jeu.

NOTE : Quand vous utilisez la commande Run (lancer), le fichier EXE de votre jeu N'EST PAS construit. La commande “Run” (lancer) d'AGS 3 est plus rapide que l'ancienne commande “Test Game” (tester jeu) parce qu'elle charge les fichiers directement dans le dossier du jeu. Si vous voulez créer le fichier EXE de votre jeu, vous devez utiliser la commande “Build EXE” (construire EXE).

Changements des fonctions RawDraw

La famille des fonctions RawDraw ont finalement été adaptées à la programmation orientée objets, et les anciennes versions sont maintenant obsolètes. Vous pouvez désormais utiliser RawDraw sur les sprites dynamiques ainsi que sur les arrière-plans (background). De fait, les nouvelle commandes vous sembleront plus compliquées que les anciennes, car vous ne pouvez plus simplement faire “RawDrawImage” pour dessiner quelque chose sur l'arrière-plan (background) de la pièce.

Au lieu de cela, il y a une nouvelle fonction DrawingSurface qui vous permet de dessiner sur une surface. Vous en récupérerez une en appelant la commande DynamicSprite.GetDrawingSurface ou Room.GetDrawingSurfaceForBackground, cela dépend de la surface sur laquelle vous voulez dessiner ; et vous pouvez alors utiliser différentes méthodes pour faire votre dessin.

Vous devez appeler une commande Release sur la surface une fois que vous avez fini le dessin, cela dit à AGS de mettre à jour les données en mémoire.

Pour voir des exemples, regardez l'aide pour la fonction DrawingSurface.

Autres changements pour le script

Le script n'a pas réellement changé dans AGS 3. Deux nouvelles fonctionnalités (fonctions d'extension et tableaux dynamiques) ont été ajoutées, mais cela n'affecte aucun code existant.

Les seules grosses modifications sont les suivantes : 1. “new” (nouveau) est maintenant un mot réservé. Cela signifie que si vous aviez des variables appelées “new”, alors votre script ne pourra pas compiler. Renommez juste la variable en autre chose. 2. A cause de la suppression de certaines limites du système, certaines des constantes d'AGS_MAX_ ont été supprimées (car il n'existe plus de valeur raisonnable pour elles maintenant que les limites sont enlevées). Cela ne va sans doute affecter que les auteurs de modules, mais probablement pas votre jeu. Plus précisément, les éléments suivants ont été retirés : AGS_MAX_GUIS, AGS_MAX_CHARACTERS, AGS_MAX_VIEWS, AGS_MAX_LOOPS_PER_VIEW, AGS_MAX_FRAMES_PER_LOOP.


passer_a_ags_3.1

Passer à AGS 3.1

AGS 3.1 contient des changements majeurs par rapport aux versions précédentes. Le principal changement est le support des coordonnées haute-résolution.

Que sont les coordonnées haute-résolution ?

Dans les versions précédentes d'AGS, toutes les coordonnées passées dans le jeu allaient de 0 à 319 pour la valeur X, et de 0 à 199 (ou 239) pour la valeur Y.

Cela avait un sens si le jeu était en 320×200 ou 320×240, mais si votre jeu tournait en 640×480 ou 800×600, c'était plus contraignant car vous ne pouviez pas manipuler les véritables coordonnées dans lesquelles votre jeu était fait.

Pourquoi était-ce comme cela ?

Lorsque le premier AGS a été écrit, il supportait seulement du 320×200, et des résolutions supplémentaires ont ensuite été “greffées” dessus plus tard. Mais les coordonnées fondamentales du système n'ont jamais été changées. Cela avait l'avantage de fournir la possibilité d'exécuter un jeu en 320×200 à 640×400 ou vice & versa, car cela ne fesait aucune différence une fois le jeu lancé.

Pourquoi avoir changé cela ?

Un des plus gros problèmes avec un systeme de coordonnées en 320×200 était que si vous faisiez un jeu en 640×480, vous ne pouviez jamais placer des objets et des personnages sur ces coordonnées. Aligner proprement des objets avec un arrière plan pouvait être difficile et aussi vous conduire à ajouter une colonne de pixels transparents à un sprite pour obtenir un alignement correct.

A l'origine ce fut jugé comme une gêne mineure, mais avec le temps de plus en plus de gens ont commencé à faire des jeux en haute résolution et c'est devenu une des limites majeures d'AGS.

Qu'est-ce qui a changé ?

Si votre jeu est en 320×200 ou 320×240, vous ne noterez aucune différence. Tout continuera comme avant.

Cependant, si votre jeu est en 640×400 ou plus, la première chose que vous remarquerez quand vous importerez votre jeu dans AGS 3.1, c'est que toutes les coordonnées dans l'éditeur seront doublées. Dorénavant, l'éditeur affichera toujours les vraies coordonnées de la haute résolution.

Dans vos scripts, si vous avez beaucoup de commandes player.Walk où vous passez dans des coordonnées en basse résolution, par défaut AGS importera votre jeu en mode “backwards-compatible”, où vos scripts continueront à marcher comme avant. Cela veut dire que toutes les commandes du script et les propriétés seront encore acceptées et retourneront des valeurs en basse résolution. Cela signifie également que les limitations de placer des objets dans cette résolution restent.

Si vous voulez permettre la nouvelle haute résolution, il y a une option dans la section “Script” dans les réglages généraux (”General Settings”) appelée “Use low-res co-ordinates in script”. Si vous la désactivez, AGS autorisera la nouvelle résolution native de coordonnées à être utilisée dans votre script.

De toute évidence, la conversion de tous vos scripts pour utiliser les coordonnées haute résolution serait une tâche colossale, alors préférez continuer d'utiliser les coordonnées basse résolution pour votre jeu, et la prochaine fois, commencez votre jeu avec les coordonnées de haute résolution. C'est à vous de voir.

L'installation a changé, je ne peux pas choisir la haute résolution !

Oui, c'est dû au support des coordonnées natives, vous n'êtes plus autorisé à lancer un jeu en 320×200 à 640×400, et vice & versa.

Si vous avez développé un jeu en 320×200 qui utilise les options du 640×400 pour agrandir la fenêtre, vous pouvez activer le filtre graphique 2x ou 3x dans la configuration, le résultat obtenu sera similaire.


passer_a_ags_3.2

Passer à AGS 3.2

AGS 3.2 contient certains changements majeurs, le principal étant une nouvelle façon de scripter la partie audio du jeu.

Pourquoi un nouveau système audio ?

Dans les précédentes versions d'AGS, le son et la musique étaient difficiles à utiliser. Même si des commandes comme PlayMusic(5) et PlaySound(10) étaient simples d'utilisation, le fait qu'elles étaient si basique constituait en soi une limitation.

A quoi correspond la musique 5 ? Quel est l'effet sonore 10 ? Comment s'en rappeler ? Ceci était un peu chaotique et obsolète. De plus, manipuler le volume impliquait d'utiliser différentes commandes, devenant ainsi une gageure.

Alors qu'est-ce qui a changé ?

Les vieilles commandes comme PlayMusic et PlaySound sont désormais obsolètes et ont été remplacées par un nouveau système audio orienté objet. Cela signifie que les fichiers audio sont désormais représentés par des éléments de scripts dans le jeu.

Par exemple, dans AGS 3.1.2, vous auriez dû faire cela :

PlaySound(10); // Bruit d explosion

Désormais, avec AGS 3.2, vous pouvez faire ceci :

aExplosion.Play();

Comment j'appelle mes fichiers audios du coup ?

L'arborescence du projet contient un nouvel onglet “Audio” qui vous permet de gérer l'audio de votre jeu. Par défaut, lorsque vous importez votre jeu depuis une précédente version d'AGS, des éléments audios nommés “aMusic5” ou “aSound30” seront automatiquement créés, correspondant aux noms qu'ils avaient dans la version précédente. Si vous voulez que les anciennes commandes comme PlayMusic ou PlaySound soient encore utilisables, alors ne renommez pas ces éléments audios. AGS gère la rétro-compatibilité en traduisant la commande PlayMusic(X) pour qu'elle lance l'élément audio appelé ”aMusicX”, et la commande PlaySound(X) lance l'élément audio ”aSoundX”.

Sinon, si vous voulez convertir vos scripts au niveau système audio, vous pouvze simplement faire un clic droit et renommer ces éléments audios comme vous le sentez.

Je vois un dossier AudioCache, ai-je toujours besoin des dossiers Sound et Music ?

Lorsque vous importez un fichier audio dans AGS, une copie est créée dans le dossier AudioCache, mais le logiciel se souvient d'où le fichier vient. Si le fichier original est modifié, AGS copiera automatiquement le fichier mis à jour dans le dossier AudioCache.

Lorsque vous mettez à jour un jeu ancien, AGS estime que l'emplacement d'origine de vos fichiers audios sont les dossiers ”Sound” et ”Music”. Ainsi, il est préférable de garder initialement ces dossiers puisque cela vous permet de mettre à jour les fichiers existants de la même façon qu'avant, et AGS repérera automatiquement les changements.

Mais ensuite, lorsque vous importez de nouveaux fichiers audios, vous n'avez aucunement besoin de les placer dans les dossiers Sound et Music ; importez-les d'où vous voulez.

Et pour contrôler le volume ?

Ravi que vous le demandiez ! A la place de ces vieilles commandes comme SetMusicVolume, SetDigitalMasterVolume, etc, il y a maintenant un système de volume général (System.Volume) et le volume de chaque son peut alors être contrôlé séparément. Il vous suffit de manipuler la propriété Volume du canal audio (voir la page Audio pour plus de détails).

Enfin, vous pouvez mettre à jour le volume d'un type audio spécifique (par exemple les sons ou la musique) en utilisant la commande Game.SetAudioTypeVolume

Attends, c'est quoi un canal audio ?

AGS utilise deux nouveaux concepts – les éléments Audios (qui correspondent à des fichiers sons), et les canaux audios (qui correspondent à un élément sonore en cours de lecture). Cette distinction est nécessaire car vous pouvez vouloir jouer le même effet sonore plusieurs fois en simultané, et vouloir manipuler individuellement le volume de chacun grâce aux canaux audios. La page audio décrit ces fonctionnalités.

PlayAmbientSound est obsolète ! Comment j'intègre des sons ambiants alors ? Les sons ambiants formaient un type d'éléments étrange dans AGS du fait que vous ne pouviez pas jouer un son en boucle avec la commande PlaySound. Avec le nouveau système audio, la commande Play propose un paramètre optionnel Repeat qui vous permet de spécifier si le son doit être ou non joué en boucle.

L'aspect directionnel X/Y de PlayAmbientSound se définit par la commande SetRoomLocation du canal audio.

Y a-t-il d'autre nouveaux trucs que je peux faire ?

Vous pouvez désormais ajuster la diffusion gauche-droite d'une séquence en utilisant la propriété AudioChannel.Panning. Vous disposez aussi d'un contrôle affiné sur la synchronisation audio à travers la possibilité de définir et de récupérer la position dans la séquence de façon plus précise.

Le système de voix a-t-il changé ?

Non, les fichiers voix s'utilisent de la même façon que dans les précédentes version d'AGS. Il vous faut toujours un dossier Speech dans le dossier de votre jeu, et nommer les fichiers qu'il contient en utilisant la même convention qu'avant.

Où je cherche pour plus d'informations ?

Consultez l'aide audio pour plus d'informations.

,


utilisation_anonyme_d_informations

Utilisation anonyme d'informations

AGS contient une option permettant d'envoyer des informations anonymes vers le site web d'AGS. Mais de quoi s'agit-il et pourquoi voudriez-vous le faire?

Quelles informations sont envoyées ?

On trouvera ci-après les informations que AGS envoie actuellement au serveur.

  • La version d'AGS.
  • La version de Windows (exemple : XP, Vista)
  • La version de .NET Framework
  • La résolution de votre écran

C'est cela. Rien de plus n'est envoyé. Pas de détail personnel , de scripts de vos jeu ou autres choses comme cela.

Pourquoi devrais-je activer cela ?

En ayant une vision plus claire des types de systèmes en cours d'exécution, nous pouvons prendre de meilleures décisions concernant les futures versions d'AGS. Voici quelques exemples de cas où cela serait utile :

  • Un sérieux bug est trouvé, il touche une ancienne version d'AGS. En sachant combien de personnes utilisent encore cette version, nous pouvons décider de réparer ou non ce bug.
  • Nous voulons ajouter une fonctionnalité à la version d'AGS qui ne fonctionne que sur Vista. En sachant combien de personnes sont sous Vista, nous nous faisons une idée claire de combien de personnes sont susceptibles d'en bénéficier, et donc si cela vaut la peine d'être fait.
  • Les GUI d'AGS sont conçus pour fonctionner avec les résolutions d'écran que la plupart des gens utilisent. En connaissant la résolution minimale que les gens utilisent toujours, cela guide la façon dont l'éditeur est conçu.

Si vous vous opposez à la transmission de ces information très basiques à AGS, vous pouvez la désactiver dans la fenêtre Préférences. Cependant, en faisant cela vous pourrez y perdre à long terme au cas où une fonctionnalité est ajoutée à AGS qui ne fonctionne pas sur votre système.

Quand envoie-t-il ces informations ?

L'éditeur contacte le site web d'AGS une fois par mois pour envoyer ces informations.

Est-ce que les jeux que je fais contactent le site web d'AGS ?

Non, seul l'éditeur le fait.


contacter_l_auteur

Contacter l'auteur

Si vous avez des commentaires ou des suggestions, le premier endroit où aller est le forum d'AGS. Lié au site principal d'AGS, c'est l'endroit ou la communauté se rencontre et vous y trouverez beaucoup de réponses a vos questions.

Si vous pensez avoir trouvé un bug, si vous avez besoin d'aide ou n'arrivez pas à vous en sortir, veuillez vérifier :

  • Que votre question n'a pas déjà de réponse dans ce manuel. AGS a été minutieusement documenté, S'IL VOUS PLAÎT lisez ce manuel avant de me poser une question.
  • Si elle n'est pas dans le manuel, consultez le fichier CHANGES.txt. Si une nouvelle fonctionnalité a été ajoutée, elle y sera décrite, si elle n'a pas encore été ajoutée à ce manuel.
  • Que vous utilisez la version la plus récente d'AGS. Utilisez la fonction “Vérifier les mises à jour” dans le menu Aide pour vous assurer que vous êtes à jour.
  • Si vous recevez un message d'erreur, s'il vous plaît notez le message EXACT et toute autre information que vous pensez être appropriée. S'IL VOUS PLAÎT écrivez EXACTEMENT le texte du message d'erreur, ne dites pas seulement « je reçois un message comme quoi le logiciel ne peut pas trouver un fichier ».
  • Si vous avez un blocage ou un crash technique, s'il vous plaît, essayez de nous donner une situation de ce qui provoque le problème. Par exemple, si vous remarquez qu'il ne se produit que sur certains écrans, ou qu'en présence d'un objet, etc… Une bonne description et la réponse sera beaucoup plus facile et beaucoup plus rapide à fournir.

Quel que soit le problème, si vous n'arrivez pas à le résoudre, postez le dans le Forum Technique pour obtenir de l'aide. Veuillez y inclure tous les détails du problème – il y a un bon nombre de gens qui essayeront de vous aider.

S'il vous plaît ne pas m'envoyer de e-mail ou de messages privés sur les problèmes d'aide AGS. Postez-les sur le forum, là où d'autres peuvent aussi vous aider, afin que les gens dans l'avenir puisse trouver la réponse sans avoir à demander de nouveau !

IMPORTANT : ne m'envoyez pas votre jeu par e-mail. Quand vous aurez une démo ou un jeu complet a présenter, postez-les dans le forum approprié.

NOTE : Si vous voulez m'envoyer une pièce jointe comme preuve d'un problème, S'IL VOUS PLAÎT compressez-le à l'aide de WinZip, PKZip, etc.. et envoyez-le moi en tant que fichier zip. Aussi, s'il vous plaît, demandez la permission à l'avance avant de m'envoyer toute pièce jointe, ou votre message sera automatiquement supprimé.

N'oubliez pas : Si vous postez une question sur le forum, attendez 24 heures avant de poster à nouveau pour dire “POURQUOI PERSONNE NE M'AIDE?!?!?”. Nous ne somme pas tous 24h/24h ou 7jours/7 à lire le forum, « tout vient à point à qui sait attendre. »

Le site d'AGS : http://www.adventuregamestudio.co.uk

Le forum officiel d'AGS : http://www.adventuregamestudio.co.uk/forum/

Le forum français (non-officiel) d'AGS : http://adventuregamestudio.fr-bb.com/


credits

Crédits

  • Adventure Game Studio a été programmé par Chris Jones.
  • Port Linux par Shawn Walker (drevil@warpcore.org).
  • Port Mac par Steve McCrea.
  • Demo Quest III mis à jour par RickJ.
  • Les graphismes de la barre d'icônes par défaut ont été réalisés par Teemu Eramaa (teemue@nic.fi)
  • Editeur d'icônes Windows par Klaus.
  • Modèle de jeu vide créé par AGA.
  • Modèle du jeu par défaut amélioré par Rui “Trovatore” Pires
  • Modèle de GUI verbal par Electroshokker, graphismes par Misj
  • Filtres graphiques Hq2x et Hq3x par Maxim Stepin.
  • Routines de fondus en hautes couleurs par Matthew Leverton.
  • Code d'anti-aliasing de sprites par Michael Bukin.
  • Le moteur DOS utilise DJGPP, un compileur 32-bit C/C++ gratuit de DJ Delorie, que vous trouverez ici http://www.delorie.com/djgpp/
  • Les graphismes et les sons viennent de la bibliothèque de graphismes Allegro de Shawn Hargreaves et d'autres. Vous les trouverez ici http://alleg.sourceforge.net/
  • L'éditeur de script est scintilla, de Neil Hodgson. Vous le trouverez ici http://www.scintilla.org
  • Chargeur de GIF animés par Kevin Weiner.
  • L'affichage des font “TrueType” utilise ALFont de Javier Gonzalez et de l'équipe.
  • Le moteur Windows utilise “libcda CD player” de Peter Wang.
  • Le lecteur de MP3 est almp3 de Javier Gonzalez et de l'équipe FreeAmp. Il utilise le décodeur MP3 mpg123.
  • Le lecteur de OGG est alogg de Javier Gonzalez. Il utilise le décodeur Ogg Vorbis, que vous trouverez ici http://www.xiph.org/
  • Le lecteur Windows de “MOD/XM/S3M/IT” est DUMB, (C) 2001-2003 Ben Davis, Robert J Ohannessian et Julien Cugniere. Vous le trouverez ici http://dumb.sf.net/
  • Le moteur DOS/Linux utilise le module joueur JGMOD de Guan Foo Wah. Vous le trouverez ici http://surf.to/jgmod
  • Exécutables compressés avec UPX v1.22w © 1996-2002 de Laszlo Molnar&amp;Markus F.X.J. Oberhumer

Crédits du Jeu Demo AGS II :

  • Écrit par Relight, cornjob, Chrille, Spyros et Dark Stalkey.
  • Matériel supplémentaire de Kairus.
  • Musique d'introduction de Mods.
  • Arrière-plans et personnages dessinés par D281@aol.com.

Merci à tous les bêta-testeurs pour leurs suggestions et leurs rapports de bugs - Cornjob, AGC2, AGA, Relight, c_leksutin, Spyros et le reste de l'équipe.


Getting Started with AGS

So, you've downloaded AGS. You want to make an adventure game. But where do you start?

(NOTE: before we start, this tutorial was made using v3.0 of AGS. If you have a newer version, there may be minor inconsistencies in the screenshots where extra options have been added and so forth, but most of what's here should still apply).

Creating the game

Start up the AGS Editor by double-clicking the AGSEditor.exe file, and you should be greeted by the following screen:

The "Welcome to AGS" dialog

Make sure that "Start a new game" is selected, and click Continue. You'll be presented with the Create New Game wizard:

Create New Game dialog

So, without further ado, click Next, and you'll see the Select Template screen:

Select Template dialog

Here, you need to choose which template you're going to use for your new game. AGS comes with three, and you can find others for download on the AGS Forums.

The "Default Game" template is what we'll be using, as it comes with some default graphics to get you started quickly. The "Empty Game" template is something you may want to use later on when you're familiar with AGS - it comes with no default graphics at all.

So, select "Default Game" and click Next.

Game Name dialog

Finally, you need to decide on what to call your game. In the first box you can type the full name for your game. This is what will be displayed in the game title bar when it's running in a window, and it's used for a couple of other things too. For the purposes of this tutorial, I'm going to call it the incredibly lame "Roger's Adventure", but you can use whatever you like.

The second box asks you for the game file name. This is only used for the name of the folder that your game is created in, and the name of the final EXE file you compile.

The third box allows you to choose where AGS should put the game files -- the default is your My Documents folder, and I'm going to stick with that.

Click the Finish button, and after a short wait you should be presented with the main AGS Editor window:

The main editor window

So, there's your new game, ready and waiting for you to create it!

Starting off

The main way that you navigate around the editor is using the project tree in the top-right corner, which allows you to access all the various parts of your game. Let's start by scrolling to the top of the tree, and double-clicking the "General Settings" node:

The General Settings pane

This screenshot demonstrates three of the main editor features. The project tree, as we've already discussed, gives you access to the various parts of your game. The property grid, in the bottom-right, is where item-specific properties are accessed. It's not used in the Game Settings window, but we'll see it in action soon!

Finally, the AGS editor allows you to have several windows open at once, and they are "tabbed" across the open windows bar at the top so that you can easily switch between them. Use the Close button to close a window once you're finished with it.

Now, since we're on the Settings pane, let's briefly examine the various options we have in front of us. Make sure these options are enabled to begin with:

  • Enable Debug Mode - Since we are going to be developing the game, we want the assistance of the debug features in the engine. This allows you to do things like teleport to different rooms, give yourself all the inventory items, and so forth. You would un-check this before compiling the final version of the game when it's complete.
  • Enable 'anti-glide' mode - without it, the character movement can look somewhat silly.
  • Pixel-perfect click detection - improves the game playability by making sure that clicking transparent regions of objects won't trigger them.
  • Characters turn before walking - if the character is facing right, and you click to move him left, he'll rotate round before starting to move. This is what the Sierra and Lucasarts point-and-click games did, and looks a bit more professional.

Personally, I would always enable these four options when starting a new game. As you get a feel for AGS, you can decide what suits you best, and change these options again later.

Colour choices

Now, at this stage we really need to decide whether we want to create a palette-based (8-bit, 256-colour) game, or a hi-color (16- or 32-bit) game. It's highly recommended that you go with 16-bit colour, or 32-bit if you want to use alpha transparency.

256-colour games are much more complicated to make due to having to deal with the palette, they are not supported by the Direct3D driver, and may not run well on some modern graphics cards. Although they can give you the authentic retro feel, unless you really need to use palette-cycling effects, it's recommended that you stay away from making new 256-colour games.

Still, I'll cover both methods briefly below; if you're not really sure which to choose, go for Hi-color (16-bit) since it provides a good balance of performance and ease-of-use. If you want to be able to use alpha-channel image transparency, use 32-bit colour.

(NOTE: We need to decide now because when you import graphics, they will be set to the game's colour depth. Should you change your mind later, you would have to re-import all the graphics).

Creating a 256-colour game

Double-click the "Colours" node in the project tree. You should see this:

The Palette Editor

The palette display has a grid with the 256 colour slots on it. The first 40 colours are game-wide colours, which means that those palette slots have a fixed colour throughout the game, in every single room.

The remaining slots, marked "X", are background colours and vary from room to room. This allows for different types of background to use different ranges of colours.

The default palette setup is a little badly weighted. Your GUI and main character graphics will have to use just the game-wide colours, since they are shown in more than one room. Therefore, unless you want a greyscale main character, the colours displayed are probably not enough.

So, let's swap some background colours for some game-wide ones. Select the first "X" slot, then hold shift and click on the last slot in the row marked "80". The screen should look as follows:

We have selected colours 42-95

We can now see the Property Grid in action. Change the "ColourType" setting from "Background" to "Gamewide", and you'll see the selected "X"s turn into various colours.

If you select one of these colours you'll see its RGB colour values in the property grid, where you can adjust the colour of that slot. If you don't want to do this manually for every colour, you can set up slots 42-95 in another paint package, save a BMP file, and then right-click on the selected slots and choose the "Replace selected slots from file" option.

What colours you use is up to you, and depends on what sort of colour scheme you're going for with your graphics.

You should set up the palette as well as you can now, because changing it later may require you to re-import some graphics.

Creating a 16-bit or 32-bit colour game

Back on the Game Settings pane, check out the very top option in the list. It's called "Colour depth", and all you have to do is change it to your desired colour depth. A warning message will prompt you to make sure. Confirm it, and you're done.

Game Resolution

Having decided on our colour depth, the other important decision to make at this stage is what resolution we want the game to run at. Higher resolutions allow you to have more detailed graphics, but they need more memory and run slower than lower resolutions.

Go back to the General Settings pane, and select your chosen resolution from the "Resolution" drop-down list.

Go to part 2: Creating your first room

Tutorial created 26 August 2002; updated 11 August 2007. Copyright (c) 2001-2007 Chris Jones.


Getting Started with AGS - Part 2

In AGS, games are made up of several rooms, which the player moves between in order to play the game. Each room is one screen that has its own background, hotspots and objects.

Creating your first room

Scroll down to the bottom of the project tree, and you'll see a node called "Rooms". Right-click it, and choose "New room". You'll see a "1:" node appear underneath. This shows us that we've created room number 1, and we can give it a name in a moment.

The Rooms list in the project tree

Expand the "1:" node, and double-click the "Edit room" node underneath to open the room. You'll see a new window open up, with a big black area in it. This is the room background, which is currently blank. The room editor looks like this:

The Rooms list in the project tree

There are four main parts to this window:

  • The Background Selection area allows you to import and manage the room's backgrounds.

  • The Room Parts drop-down list is the way that you switch between seeing different aspects of the room.

  • The Room Background Preview area is where you see the room's background image, along with various things on top of it, depending on what's selected in the Room Parts option.
  • The Properties window allows you to set up various properties and events for the room.

Naming the Room

As a first step, let's give the room a description. This is just to help us easily remember which room it is, and this description isn't used at all by the game engine. Click in the "Description" property in the property grid, and type in something appropriate. You'll notice that the project tree updates to include this description.

The Background

Now, the first thing you need to do is draw the background for the room. This needs to be an image of at least the same size as your game resolution (that we set earlier on the General Settings pane); if it's bigger than the game resolution then it'll become a scrolling room.

Draw the image in your favourite paint package, and once done, save it as a BMP or PNG file. Then, return to the AGS Editor, and press the "Change" button. Find the file you just created, and click Open.

You should see the black area in the editor replaced by your image. For this tutorial, I'm going to shamelessly steal a background from Space Quest 4. Obviously, you should draw your own!

I've imported my background

Edges

Open up the combobox that says "Nothing" in it, and select "Edges". You'll see four yellow lines drawn across your image in various places. These are the room edges, and they define how far the character needs to walk to be considered to have left the room. Click and drag them to position them appropriately. Bear in mind that it's the character's feet that are compared with these lines when positioning.

I've lined up the top and right edges correctly

At the moment, walking past the edge won't actually cause anything to happen, but we'll deal with that later. In my example, the character can only walk off the top and right edges, so they're the only ones that I've dragged into position. I've left the others as they are, since we won't be needing them.

Walkable Areas

Next, we need to define the room's walkable areas, which define where characters are allowed to walk within the room. Open up the drop-down list again, and select "Walkable areas":

Walkable areas mode

In the toolbar you'll notice that some new buttons have appeared. These are the drawing tools, and work in a similar way to most paint packages. AGS provides Line, Freehand, Rectangle and Fill tools. Alternatively, you can draw your walkable area mask in a paint package and import it (we'll cover that later).

What we need to do is to fill in the areas of the room where the player is allowed to walk. In the game, the bottom middle of the character is checked against these areas, so it's probably wise to make the walkable areas slightly smaller than they need to be, to allow the character's feet to spill outside the area.

The best way to start off is with the Line tool. Draw some lines to encompass the area that you want to be walkable. Make sure they are all joined up, and then choose the Fill tool and click in the middle of the area, and it should be filled blue. If the whole screen goes blue, click Undo, then use the Line tool to make sure all the edges of the area are properly connected up, and try again.

You can use the right mouse button with the drawing tools to erase areas in the same way that you use the left button to add them.

I've drawn a walkable area where I want the player to be able to go.

Walk-behind areas

The next job we need to do is to define the walk-behind areas. These areas (called "priorities" by some other adventure game tools) tell the game where the character needs to be drawn behind the background. For example, on my screen here, the player needs to walk in from behind the curved wall on the right.

Choose "Walk-behinds" from the combobox. Your walkable area will disappear and you'll be back to just seeing the room background.

Now, we draw on the walk-behind area in the same way as we did the walkable area - in fact, all the same drawing tools are available. My result looks like this:

The walk-behind area painted over the pillar

Notice that I haven't bothered to make the whole of the pillar a walk-behind from top to bottom - using my knowledge of the walkable areas and the height of the character, I can just draw a walk-behind in the places where it's possible for the character to be.

Now that we've done that, there's a very important next step in order to make the area work - the baseline. The baseline is a horizontal line, which tells the game where the character has to be in order to be drawn behind the area. For example, if you had a table in the middle of the room, you'd only want him drawn behind the table if he was standing behind it.

You normally place a baseline at the lowest point of the walk-behind area. Move the mouse cursor to the bottom of the walk-behind area, and look at the "Mouse Position" display above the room background. These are the X and Y co-ordinates of where the mouse cursor currently is. We're only interested in the Y co-ordinate, so type it in to the Baseline setting in the property grid.

By default, we've been drawing blue areas onto the screen. But what if we had two pillars, in different places? We wouldn't want the same baseline to apply to both. Never fear, AGS allows you to have several different areas on each screen. Above the property grid, there's a combobox that says "Walk-behind area ID 1". You can change this to draw in another colour, and each area has its own baseline.

Selecting a different walk-behind area

Trying out the game

Ok, we've slogged away at making our room - now it's about time to give it a go. Press F5, or click "Run" on the Build menu. This will save your work and launch the game! Once loaded, you should see your room with the character in it.

When you use the Run command, the game will always run in a window. If you want to test the game full-screen, use the Ctrl+F5 ("Run without debugger") option.

Try to move the character around. If he won't move, he probably didn't start on a walkable area. If this is the case, expand the "Characters" node in the project tree, and double-click "cEgo". Then, look in the property grid for two properties called "StartX" and "StartY". You can find out what these co-ordinates should be by going back to your room background, positioning the mouse cursor at the place where you want the character to start, and reading the "Mouse co-ordinates" display.

Once you've got that working, have a play walking the character around the screen, testing out the walkable and walk-behind areas.
The normal way of exiting the game is to press Ctrl+Q. It's possible that during development of your game, you may create a script that causes the game to lock up - in this case, the emergency break key Alt+X will exit the game for you.

Go to part 3: Adding interaction

Tutorial created 9 November 2002; updated 12 August 2007. Copyright (c) 2001-2002 Chris Jones.


Getting Started with AGS - Part 3

Adding some interaction

Ok, so we now have a working room. The player can walk around it as much as they like. However, our game so far is pretty boring - the player can't actually do anything of value yet!

AGS provides you with three types of things that the player can interact with - hotspots, objects and characters:

  • A hotspot is an area of the background image that the player can look at and interact with. Hotspots are generally used for parts of the screen such as a tree or the grass which won't change as the game progresses.
  • An object is an item in the room that can move around the screen, and be switched on and off at will. Objects must stay within the room that they are created in.
  • A character is like an object, except that it can move between rooms and therefore appear all over the game. Characters also have special properties such as talking animations and so forth, which means you will usually use one to represent each NPC (non-player character) in the game.

Hotspots

The easiest thing to start off with is hotspots. Make sure you've got the room editor open, and select "Hotspots" from the drop-down list box (the same place where we selected "Walkable areas" earlier).

Hotspots are drawn in exactly the same way as walk-behind and walkable areas. You'll probably want to use several different Hotspots for different areas of the screen. After drawing your first hotspot, change the Selected Hotspot using the drop-down list above the property grid, and you can draw in a different colour. All the other hotspots will be greyed out.

I've drawn four types of hotspot onto my screen

Once you've drawn a hotspot, there are two other fields to set:

  • The hotspot's description. This sets a player-friendly name for the hotspot, which is vital if you are going to use a Lucasarts-style interface where the player can move the mouse over the screen to see what's where. If you're using a Sierra-style interface then this name will never be displayed to the player, but it's useful to fill it in anyway for your own benefit. By default this is "Hotspot 1", "Hotspot 2", etc.

  • The hotspot's Name: This is a name by which the hotspot can be referred to in the room script. This name cannot have any spaces or special characters -- just the letters a to z. The convention in AGS is to start the script names for hotspots with an h, for example hDoor. The name must be unique within the room.

In the Areas editor, all the hotspots except the currently selected one are drawn in grey. This is to emphasise which hotspot you have selected to edit. You can change this behaviour by toggling the "show non-selected masks greyed out" button at the right hand end of the toolbar.

Interactions

Right, now it's time to make something happen! Make sure the first hotspot is selected, and click the Events button:

The events list

You'll see that the property grid changes to list all the events for this hotspot. Events occur when the player does certain things in the game. At the moment, nothing is set to happen in response to any of the events, so whatever the player does to the hotspot, they will get no reply.

Right, let's start with something simple. When the player looks at my hotspot, I want to display a message telling them what they can see. Click on the "Look at hotspot" row, and a "..." button will appear.

The "..." button

Click the "..." button. This will create an entry in the script for this event, and you'll find yourself taken to the script editor. If instead you get a message telling you that the hotspot needs a name, read back up for how to set a name for the hotspot, earlier in this article.

So, you're now in the script editor. It all looks a bit bare and intimidating, but you should have something like this:

Script editor after adding a hotspot event

The "function hDoor_Look" line defines that the script underneath will be run when this event occurs. In AGS, the curly brackets { and } are used to mark the start and end of a block of script. Anything that you type in between them will be run as part of this event.

There's a seperate tutorial giving you an introduction to the scripting language, so I won't attempt to explain it here. But we can start with something very simple, using the Display command, which displays a message to the player. Type in something like this:

A simple script

Once you're done, click on the "Room 1" tab to return to the main room editor.

Walk-to points

Ok, since we're back editing hotspots, let me quickly explain the "Walk-to point" option in the property grid. This allows you to set a position for each hotspot that the character will walk to whenever the player interacts with the hotspot - just like the way the Lucasarts games like Monkey Island worked.

If you set a walk-to point, then whenever the player clicks interact or talk on the hotspot, the main character will first walk to the walk-to point before the relevant event is triggered. If you want, the character can also walk there when the LOOK mode is used - this option is configurable in the game General Settings pane.

To remove a walk-to point, simply set it to 0,0.

Edges revisited

Ok, so we've covered the basics of creating a room. However, there's one thing that we did a while back that we need to clear up - yes, the edges.

Select "Edges" again in the list box. Now, click the Events button in the property grid and this time we'll see the events for the room itself. Among the events listed, you'll see "Walks off left edge", "Walks off right edge", and so on. These are fired when the player character crosses the edges that we defined back in part 2. Normally, you'll use the player.ChangeRoom script command for these events, to take the player to a different room.

Now, hit F5 to try out our latest additions! Make sure that when you look at hotspot 1 the game displays the message that you typed into the script.

Scripting tutorial

Now might be a good time to check out the scripting tutorial to get a better understanding of what your script code is doing. Alternatively, finish off this tutorial first and then check out the scripting tutorial.

Go to part 4: Objects and inventory

Tutorial created 21 November 2002; updated 12 August 2007. Copyright (c) 2001-2002 Chris Jones.


Getting Started with AGS - Part 4

Objects

Objects are items on the screen which, unlike hotspots, can move, change and disappear. You use objects for things in the room that the player can take (since they can disappear), and for things which need to animate.

So, let's revisit the age-old "key" inventory item. Let's say we've got a locked door, and the player can pick up a key from another room to open it with. Please don't use this puzzle when you're making a proper game, it's been done far too many times ;-)

From the same list as we chose "Walkable areas" and "Hotspots" earlier, let's return there and select "Objects". Now, to add an object to the room, simply right-click on the background where you want to add it, and choose "New object here" from the menu which appears.

As if by magic, a blue cup appears! This is the default sprite in AGS, and will appear anywhere that you haven't selected a proper image yet. Notice that the property grid has changed to display the details of this new object -- one of which is a property called Image. Select this property, and a "..." button appears.

Adding an object to the room

Click the "..." button, and you'll be presented with the Sprite Manager. We'll explain this in more detail later, but basically it is the focal point in AGS where you import and export all your graphics except for room backgrounds. You should see a small key picture as sprite number 2. Double-click that for now, we'll import our own graphics later.

You should now see that the blue cup has changed into a key. You can move it around by left-clicking and dragging the sprite within the background image. Place it somewhere sensible on your screen.

The next thing we should do is give the object a name. Similar to what we did with hotspots, since the object will be referred to in the script it'll need a name that we can call it by. Scroll down the property grid and find the "Name" property, and set it to something sensible. The convention in AGS is to have object names start with an "o", for example oKey.

I've placed the key cunningly in the middle of the walkway ;-)

Before we enable the key to be taken by the player, let me quickly go over a couple of propertes in the property grid:

  • Baseline - normally, the baseline for an object is set to the bottom of the object graphic (baselines are used to calculate which items on the screen are drawn in front and which are drawn at the back). However, in some cases you might want to override this.
    What you'll notice with our key is that if the player walks just behind it, the key will appear in front of his feet. This is not what we want, since the key is supposed to be lying flat on the ground. To correct this, change the Baseline property to 5 (this means that it will be drawn behind everything that has a baseline lower down the screen than Y=5). This will make sure that the player is always drawn in front of the key.

  • Visible - this toggles whether the object is switched on at the beginning of the game or not. For our key we want it to be True, but sometimes you'll have objects which you don't want the player to see until they've done something else in the game.
The game speed is directly related to the number and size of objects on-screen. AGS imposes a limit of 20 objects per room, but even if you use all of these and have them visible at the same time, the game speed could suffer.

Right, now back to the pressing matter at hand - letting the player pick up the key.

Inventory

Now wait, there's one more step we need to do first. At the moment we could let the player pick up the key, but then what would happen to it? Where would it go? We need to define the player's inventory.

Select the "Inventory Items" node in the project tree. You'll see that there are already two items defined - "Key" and "Pink poster". These are just defaults to help you get started. Double click "1: iKey", and you should see a window open with the key image in it. But that picture's a bit small for an inventory item, I'm sure I saw something better in the sprite list earlier.

Find the "Image" property in the property grid, select it, and then click the "..." button. The sprite manager re-appears, so find sprite number 5, and you should see that it's a much larger picture of a key. Let's use that as our inventory icon. Double-click the sprite to select it.

Yay, we've got a big inventory icon for the key

Ok, there are a few other settings on this screen, but let's return to our objective - letting the player pick up the key. Remember that the script name is iKey, as we'll need it later.

Back to the events

Go back to the Objects pane of the Room Editor, and click on, yes you've guessed it, the Events button. The events here are very similar to the ones we had for the hotspot:

The events list for the object

Notice there are two obvious possibilities here: "Interact object" and "Pick up object". We actually want to use the "Interact object" event, because we are using the default Sierra-style interface which doesn't have a specific Pick Up mode. The "Pick up", "Usermode1" and "Usermode2" events are useful if you go for a lucasarts-style interface which has more verb types available to the player.

So, select "Interact object" and click the "..." button. When the player picks up the key we want two things to happen - firstly, the object on-screen needs to disappear, and secondly, the inventory item needs to be added to the player's inventory.

Here's my script solution. As an added bonus, I've also given the player 5 points for their trouble, but you don't need to have that third command:

Script for taking the key

Note that our solution is not perfect - the player can click the hand icon on the key from anywhere in the room and it will disappear. We are also not displaying a message informing the player of what happened. But, the functionality is there, and this will do fine for now.

Okey, so we now have a fully-working first room. Test the game as before, and try it out. Once the player has taken the key, call up his inventory and you should see the large key picture there.

Room Settings

Finally, let's just quickly go over the available properties for the room itself (available when in Nothing mode):

  • PlayMusicOnRoomLoad - you can type a music number in the box and that background music will start playing when the player enters the room. For more about music and sound, see later in the manual.

  • SaveLoadEnabled - if disabled, then if the player tries to save or load the game while in this room, a message ("Sorry, not now") is displayed instead. .

  • ShowPlayerCharacter - if checked, the player character will not be visible in this room, and the Walk mode will be disabled. Useful for close-up displays of control panels and so forth.

  • PlayerCharacterView - you can type a number in here to override the player character's graphic for this room. For example, if you have an overhead map screen, you will probably want a different image of the character from an overhead perspective.

  • MusicVolumeAdjustment - this allows you to modify the background music volume for this screen.

Go to part 5: Managing Inventory

Tutorial last updated 12 August 2007. Copyright (c) 2001-2007 Chris Jones.


Getting Started with AGS - Part 5

Managing Inventory

Each character in the game can carry their own set of inventory items. Inventory items are totally separate from room objects, and you must explicitly set up every item which the player can carry at some point in the game.

Go to the "Inventory items" node in the project tree. We visited this briefly in part 4, but it's time to go into a bit more detail.

The inventory editor, another look

Every inventory item that the player can carry at some point during the game is listed in the project tree. All the items there also have a number beside them - this is the inventory item ID, which is largely for backwards compatibility with older versions of AGS.

To edit an inventory item, double-click it in the project tree, and a new window will open up with the item's properties in the property grid. If you want the player character to start off carrying the selected item, set the "PlayerStartsWithItem" option to True. Remember, if you want to change which image is used for the item, select the "Image" property and click the "..." button.

Now, you may have noticed that once the player had picked up the key in our game, they could see it in their inventory window but not actually do anything to it - clicking Look or Use on the item did nothing.

In order to give the inventory item some interactivity, we once again need to call on the Events List. Click the "Events" (lightning) button to bring it up:

The events list... this time for inventory

Now, the important point to note here is that if you are using the built-in inventory window (which we are), the only events which can occur are "Look at inventory item" and "Use inventory on this item". This is because the default inventory window only has Look and Select options. The other modes are all available if you design your own inventory GUI (but that's quite complex so we'll leave it for later).

So, select the "Look at inventory item" event, and click the "..." button. You'll be taken to the script editor once more, but this time you'll notice that there's already some existing script as well as our new method:

Script for looking at the key

We are now editing the global script. This has all the script for handling events on game-wide things like inventory items and characters. Previously we were working with hotspots and objects, so they were confined to their own room script.

Anyway, for now I've just added a simple Display command to show the player a message when they look at the key. Feel free to do something similar.

Inventory item hotspots

By default, when the player selects an inventory item as their mouse cursor and clicks on the screen with it, the centre of the item will be used to decide what to activate. However, with some items you may well not want this behaviour - for example, we might want the end of our key to be the activation spot.

To set the cursor hotspot, simply click on the spot within the image. You should see a crosshair appear where you clicked.

The "Draw crosshair" option, if activated, will draw a spot on this part of the item in-game so that the player can easily tell which bit of the cursor is active. You can set the inner and outer colours for the crosshair.

Recap

  • Inventory items are not objects. The two are totally seperate, although often picking up an object will give the player an inventory item.
  • Each character has their own inventory. If you are making a game like Day of the Tentacle, where the player can switch between characters, then they will each have their own set of inventory items. Usually, you'll use inventory commands to operate on the current player character.

  • To give the player an inventory item, use the player.AddInventory command.

Go to part 6: Using your own graphics

Tutorial last updated 17 August 2007. Copyright (c) 2001-2007 Chris Jones.


Getting Started with AGS - Part 6

Using your own graphics

When you were choosing the graphics for the object earlier in this tutorial, you probably noticed that the images available didn't look up to much. This is no problem, because you can import your own graphics using the Sprite Manager.

Double-click "Sprites" near the top of the project tree. This opens up the Sprite Manager, where you can see the complete sprite set for the game.

AGS uses these sprites for all game graphics, except room backgrounds. The Sprite Manager is the central place where you do all your graphics importing. Whenever you want to use images in the game (for mouse cursors, views, objects, etc), you select an image to use from here.

There are two ways to import your graphics - either overwrite an existing sprite with your graphic, or create a new slot for it. To overwrite an existing sprite, right-click the sprite and select "Replace sprite from file". To import a new slot, right-click on the background of the window and choose "Import new sprite from file". If your game is hi-colour, you'll also have options to paste from the clipboard.

Note that the sprite graphics you import must be the same colour depth as your backgrounds - ie. if you have a 256-colour game, you must import 256-colour sprites.

Right-clicking to replace existing sprite

So, let's replace the default key image with something of our own. Right-click on it and choose "Replace sprite from file". Select the file that you want in the dialog, and then you'll be presented with this:

The "Import Sprite" window

This is the Import Sprite window. You'll see the image from the file that you chose, along with various options. The Zoom slider on the left allows you to zoom in on the image (very useful for 320x200-resolution graphics), and the "Transparent colour" option allows you to choose how AGS decides which colour is the image's transparent colour.

Now, you have two choices. If you want to import the whole image, just click the "Import Whole Image" button, and you're done. If on the other hand you only want to import a portion of the image, then you need to right-drag the mouse within the image to select the area that you want to import. Once you've got it right, left-click to confirm and the selected area of the image will be imported.

NOTE: For character graphics, make sure you import graphics that are a suitable size for the game backgrounds. For example, don't import a 320x200-sized image for your character, since it will take up the whole screen. A good size would be about 20x50 pixels. This will look really small in the Import window, but your game runs at a much lower resolution so it'll look much larger.
NOTE (256-colour only): You may well find that the colours on your graphic look slightly strange once you've imported the image. This is because by default only the first 41 of the palette colours are allocated to sprites, so your graphic will be remapped to this much smaller palette. If you find that many of your imported sprites look strange, you can increase the number of colours assigned to sprites, at the expense of background colours (see the earlier part of the tutorial for palette setup).

Tiled sprite import

This feature allows you to import a grid of sprites into separate slots - for example, if you have several frames of a character animation side by side in the source bitmap. To do this, simply check the "Tiled sprite import" box, and align your rectangle on the top left sprite. When you click the left mouse button, you will get an extra step which allows you to size the grid:

Click the left button again once you are happy with the grid. Each of the cells will be imported as a separate sprite.

NOTE: Tiled sprite import only works if you selected "Import new sprite from file". If you used the "Replace sprite" option, only the first tile will be imported.

Go to part 7: Animations

Tutorial last updated 17 August 2007. Copyright (c) 2001-2007 Chris Jones.


Getting Started with AGS - Part 7

Animations

A graphical adventure game would be no good without animations. These range from commonly-used animations such as the main character walking, to a flag waving in the background in one particular screen.

Animations in AGS are managed using Views. A view is a set of one or more loops. A loop is a set of frames which, when played in sequence, give the illusion of movement. Expand the "Views" node in the project tree, and double-click the view 1:

The View Editor showing view 1

This is the View Editor where you will put together all your animations. You'll notice lots of frames of Roger's walking animation in this window.

Each loop is displayed as a row of images (one for each frame), going from left to right. To change the image for a frame, double-click the image, and you'll be presented with the sprite manager where you can select the image to use. All images for use with views are imported as usual via the sprite manager before they can be inserted into a frame.
At the right hand end of each loop, you'll see a "Create new frame" button, which you can click to create a new extra frame at the end of the loop. You can also right-click a frame to insert a new one before or after it.

Left-click a frame to select it. When you do so, the property grid will be updated with the frame's details:

Property Grid showing frame properties

  • Delay is the frame's relative speed. This number adds a delay to the amount of time which the frame is displayed for, therefore a larger number makes it stay longer. You can use negative numbers to specifically shorten the frame's display time.

  • Sound allows you to assign a sound number that will get played when this frame comes around in the animation. This feature is designed for footstep sounds, but has many other uses as well. Using sound will be covered later in the tutorial.

  • Flipped toggles whether the frame is displayed normally or mirrored left-right. This feature allows you to just create animations for your character walking right, and then use the same images for the walking left loop and AGS will automatically flip them.

Views aren't only used for character walking animations -- they're used for all types of animations in the game. How you actually run an animation in the game will be explained later on.

Characters

If you remember back to part 3 of this tutorial, we talked about three types of thing that the player can interact with - hotspots, objects and characters. We've covered the first two, so now it's time to take a look at characters.

Put simply, a character is similar to an object, except that it can move between different rooms in the game, take part in conversations, carry its own inventory and more.

Expand the "Characters" node in the project tree. You'll see that so far you only have one character in the list, labelled "0: cEgo". You can create a new character by right-clicking the "Characters" node. For now, double-click the "cEgo" character:

The Character Editor

The first thing you'll notice is the text "This character is the player character" at the top of the window. This shows that the currently selected character is the initial player character when the game starts up. The game will start off in whatever room number the Starts in room option is set to for the player character. To change it, simply open up the character that you want to use instead and click the "Make this the player character" button.

There are quite a few properties available in the property grid. Rather than explain them all here, we'll just cover the most important ones - you can find a full description of all the options in the manual.

  • StartingRoom - this sets which room number the character starts off in at the beginning of the game.

  • NormalView - sets which view is used for the normal walking animation of the character. The view specified here must have 4 or 8 loops, and the first frame of each loop is the standing still frame.
    For a 4-loop character, when walking diagonally the closest straight direction is chosen for display. With an 8-loop character, all 8 directions are displayed depending on the character's direction.
    Which loop represents which direction is shown in the Views editor (eg. "Loop 0 (down)").

  • Clickable - if this is not checked, then this character will be see-through to mouse clicks. This is similar to the way the player character worked in Lucasarts games - you cannot actually click on Guybrush, it will always activate whatever is behind him.

The character's "RealName" field simply gives you an easy way to identify the character in the editor, and can also be accessed from the game script if desired.

The "ScriptName" field is very important, as it sets the name by which the character will be referred to in the game scripts. The reason for having this as well as the RealName is that the script name can only contain the letters A-Z, whereas the RealName field can contain any spaces, numbers, etc.

Game starting point

Just in case you missed it, I'll repeat what was just said in the Characters section - the "Starts in room" setting of the player character is used to determine which room the game starts off in.

TIP: This feature can be handy for testing various parts of your game. For example, when you're working on room 16, set the starting room to room 16 so that you can get to it instantly when you run the game to test it.

Cutscenes

You can easily add intro, outro and cutscene sequences to your game. There is no specific feature to do this - you simply use the provided animation and movement commands to do whatever you like.

A cutscene is simply the name given to a sequence of actions over which the player has no control. This usually applies to the entire introduction sequence, as well as far simpler in-game events. For example, if the player goes to pick up a rock from the ground, you may wish to use a bending-down animation to show him picking it up. During this bending down and standing back up, the player cannot control proceedings, so it is a cutscene.

Right, firstly let's do something very simple. When the player goes to pick up the key from the floor of our room, we want him to walk over to it first rather than it just disappearing from wherever he's standing.

So, we want to add something extra to picking up the key. How do we do this? Yes, that's right, we need to return to the Event Script for the key object. Go back to the Events List for the key object (remember, you open the room, select the "Objects" mode, then click on the key to select it):

Remember this?

The main difference you'll notice now is that the "Interact object" event already has a name. This "oKey_Interact" is the name of the script function that we created earlier. So, just select it and click the "..." button to return to the script editor.

Now, we want the player to walk across to the key before it disappears, so we need to add a new line of script before the existing command that makes the key invisible. We want to do an action on the player character (ie. move him), so type "player." and auto-complete will pop up with the available commands. See if you can work out which one we need.

The Walk command needs X and Y co-ordinates

Eeek! It wants a destination X and Y location! We don't know that, but we can find out! Click the "Room 1" tab on the tab bar at the top of the editor, and move the mouse cursor to where the key is on the background. Look just above the background image, and you should see "Mouse Position: 158, 108" or something similar. These are the X and Y co-ordinates, respectively, of the key's location. So, note them down, and click the "room1.asc" tab to return to the script.

Now, we can type in those co-ordinates to our script. We also need to pass in the BlockingStyle as eBlock, which tells the game to wait for Roger to get to those co-ordinates before continuing the script. If we didn't do this, he would start to walk but the key would disappear before he got there! The final script should look like this:

Our new command is run before the existing ones

Now, hit F5 and try it out!

OK, I think we've had enough of animations and cutscenes for now. We'll return later to explore actual animations and more complex cutscenes.

Go to part 8: Conversations

Tutorial last updated 18 August 2007. Copyright (c) 2003-2007 Chris Jones.


Getting Started with AGS - Part 8

Conversations

What fun would an adventure be if there were no other characters to talk to? Probably not much!

How much you go into dialog depends of course on your game style. Generally, Sierra games used to just have one fixed line of dialog which the characters would talk about, possibly changing if you talked to the same person again.
Lucasarts games (and some Sierra titles such as Quest for Glory) on the other hand, had complete dialog trees through which you could choose your topics to talk about.

AGS lets you do it whichever way you want. We'll start off by looking at the complete dialog tree approach, and then see how easy it is to cut it down to get a Sierra-style system.

Now, before we go any further, let's consider for a moment what conversation structure we want. It's going to be a lot easier to implement if we have this planned in advance. For this tutorial, we'll go for a structure like this:

Our planned dialog tree

In other words, when we first speak to the other character, we will say "Greetings!". After he replies, we will then be presented with three options to choose from.
The "Tell me more about your wares" option will then lead us to be able to ask a different set of questions.

Before we begin, we need to create a second character - we can't just have Roger talking to himself! Go to the "Characters" node, right-click it and choose "New Character". Double-click the new "cChar1" entry to open him up.

In the property grid, give the new character a RealName -- I'll call him Merchant. Now - and this bit is vital - you also need to set this new character's script name. This is the name by which we refer to him when creating our dialogs. I'll just use "cMerchant" as the script name. I'd recommend you set it to something sensible like this, and don't just leave it as "cChar1" or else your dialog scripts will get very confusing!

Ok, all done? Expand the "Dialogs" node in the editor, and you'll see one existing "0" entry. We'd may as well use it since it's there, so double-click it. (If not, you can always right-click the Dialogs node and choose "New dialog" to make a new one). You'll see this rather empty window:

The dialog editor

Conversations in AGS are made up of topics. A topic consists of a set of options that the player can talk about - not all of which are necessarily available to the player at the start of the game. When the player selects an option from a topic, the topic's dialog script is run.

Each topic can contain some start-up text, which is displayed before the options are presented to the player. Our "Greetings" line qualifies for this, so we don't need to make a special topic for it. A topic is also referred to as a dialog in AGS -- the two words are one and the same thing.

Right, let's make our first dialog. Click the "Create new option" button three times, and three new rows will appear in the window. You'll also notice some new lines being added to the script on the right hand side. Make sure that the "Show" checkbox is ticked for all the options -- this determines whether the options are initially available to the player or not.

Also, this dialog currently has no name, but we'll need to give it one so that we can access it later. The convention in AGS is for dialogs to start with "d", so I'm going to call this "dMerchant". Use the property grid to set the name, as usual.

Now, type in some text to the three new text boxes:

We've inserted three options for topic 0

While we're at it, let's create the next set of options too. Right click the "Dialogs" node in the project tree, and select "New Dialog". A new blank Dialog 1 is created. Double-click on this, and again, create three new options and type them in. In the property grid, change the Name from "dDialog1" to "dWares".

Now, go back to the first dialog (select it in the tab bar), and let's have a look at the script. This is not the same type of script that we've used for our events like picking up the key. It's a much simpler dialog-only scripting language.

Each of the "@" lines is an entry point. These define the different places where your script can start. The "@S" entry point happens when the topic is first started - and so this is where we want our "Greetings" text to be displayed.

Dialog scripting is very simple. It takes the form:

SCRIPTNAME: "Text to say"

So, in between the "@S" and the "@1" lines, insert a couple of new lines, and type the following:

EGO: "Greetings!"
MERCHANT: "Hello there!"
return

Remember, these are the script names of the characters (but without the initial "c"). The "return" is essential, because it tells AGS to stop running the script at that point and to display the options to the player.

The numbered entry points will be run when the player selects the appropriate option - for example, if the player clicks the "Who are you?" option, then entry point @1 will run.

Here's a finished script for this topic:

Our finished dialog script

The goto-dialog command takes the player to another dialog - in this case, the new "dWares" dialog we just created (with questions about the merchant's wares).
The stop command tells AGS to end the conversation and return to the game (whereas return returns them to the list of options to talk about).

Now, we're not quite done ... we've got to deal with our second dialog too! In the tab bar, click the "Dialog: dWares" tab to return to the main topic. Fill in the script however you like. You can use the goto-previous command to take the player back to the first list of options when they get bored of talking about his wares.

Here's my completed script for dWares:

Dialog script for dWares

As you can see, it's done very similarly to the first one. Notice the use of "return" in the startup entry point, to make sure that it doesn't go on and run the next bit of script straight away.

We're almost done! All we've got to do now is add a way for the player to initiate the conversation.

Open up the Character editor for the new cMerchant character. Change his StartingRoom to room 1 (ie. the same as the player character), and position him at let's say X:260, Y:130. You can always change this later.

Now, still with the Merchant open, go to his Events list. Using your skills from earlier on in this tutorial, add a command to initiate the dialog when the player talks to the Merchant. Now, we're all set!

Event script to launch the dialog

Test the game, talk to the Merchant, and try out the conversation.

More on conversations

You may have noticed the "Show" and "Say" check-boxes in the dialog editors. You'll have noticed that when the player selects an option, the player character will say the option text. However, there are times when you won't want this to happen, and if you un-tick the "Say" box for an option, the character won't repeat the text when the player selects it.

The "Show" box determines whether the option is initially available to the player. If you uncheck it, then that option won't appear to start with. You can enable it later using the option-on dialog script command, or the dDialogName.SetOptionState script command.

There is also a dialog script command called option-off, which you can use to stop a particular option from appearing once the character has found out all the vital information. See the manual reference for more.

If there is only one option enabled for a topic, then the game selects it automatically. You can use this to make Sierra-style conversations, because the options will never be shown to the player in this case.

Go to part 9: Cursors and fonts

Tutorial last updated 18 August 2007. Copyright (c) 2003-2007 Chris Jones.


Getting Started with AGS - Part 9

Cursors

It's easy to overlook mouse cursors, but they provide the essential interface between the player and the game world. In AGS, each mouse cursor provides a different mode of interaction to the player.

The Cursors list

Unlike most of AGS, mouse cursors modes are not generic - that is, AGS has special coded behaviour for some of the cursors. This means that you are unable to customize what some of the cursor modes do - let's list these ones briefly:

  • Mode 0 (Walk to) - this will always move the player character to the co-ordinates at which the mouse was clicked

  • Mode 4 (Use inventory) - AGS will only allow this mode to be selected if the player character has an active inventory item, and it will always invoke the "Use inventory" event.

  • Mode 6 (Pointer) - this is used whenever a normal Windows-style mouse pointer is required. For example, when the user is prompted to select a dialog option; when a popup GUI is displayed, and so forth.
  • Mode 7 (Wait) - this cursor is shown whenever the player cannot interact with the game world (ie. during a cutscene). It is automatically shown during blocking script functions.

All the other cursors are 'normal' cursors, in that you can use them for whatever purposes you want.

If you want to create a Lucasarts-style game where the mouse cursor disappears during cutscenes, the easiest way to do it is simply to import a blank image over the Wait mouse cursor.

The Cursors editor pane is fairly self-explanatory. Use the property grid to set a graphic for the cursor; and click inside the graphic to set the cursor's hotspot, as we did for inventory items. (The hotspot sets which spot under the cursor will be activated when you click with it).

There are a couple of other options you can set for cursors, let's cover them briefly:

  • Standard Mode tells AGS that this is a normal user-selectable cursor. It is used when cycling through mouse cursors, to determine whether to use the cursor or skip over it. For example, if during the game you disable the current cursor, AGS will change to the next available Standard Mode.
  • Animate allows you to make an animated mouse cursor. If you check the box, then you need to set the View property to the view that you want to use for the animation (loop 0 of the view will be cycled continuously). You can also select "AnimateOnlyOnHotspot" to make the cursor only animate while it is over something that the player can interact with; and "AnimateOnlyWhenMoving" to do a QFG4-style cursor which only animates while the player is moving it around.

You can right-click the "Mouse cursors" tree node and choose "New Cursor" to create additional cursors to the standard 10. If you do so however, any extra cursors you create will not have events created for them, so you will have to handle their clicks using the "Any Click" events.

Fonts

The default blank game comes with a couple of basic fonts, but you don't have to use them - you can import your own.

The Font Editor

By default, you'll see three fonts are available. Font 0 is the standard font used in message boxes. Font 1 is the speech font, used with lucasarts-style speech; and font 2 is an outline font for the speech font.

Outlines are pretty much essential for lucasarts-style speech. Since the text is drawn directly onto the screen and not onto a message box, without an outline it could be very hard to read the text, depending on what colour the screen happened to be behind it.

There are two ways to do outlines - AGS can do an automatic outline, or you can import a special outline font. They both have advantages:

  • Automatic outlining is easy to use - just set the option, and it works with any font.
  • Using an outline font is faster in the game, since it is just drawn once (whereas automatic outlining has to redraw the line of text 8 times).

Importing fonts

AGS supports both TrueType (TTF) and SCI (Sierra's format) fonts. To overwrite an existing font, simply open up its editor and click the "Import over this font" button. To create a new font slot, right-click the Fonts tree node, and select "New font".

The advantage of SCI fonts is that they are significantly faster to render than TTF fonts; but the disadvantage is that they only support 128 characters, which means that they are only useful for English. If you want to support other languages then you'll need to import a TTF font in order for the extended characters such as é, í and ñ to work.

Where can you get a SCI font? Well, there are three ways:

  • Create your own font and save it in SCI Font format, using Radiant's FontEdit application.

  • Extract the font from a Sierra game, using the SCI Decoder program available on the internet (note however that this will have copyright implications for your game).
  • You can get a Sierra SCI Font Pack on the AGS website.
If you go to your Windows Fonts folder to try and import a TTF font, you will not be able to do so (double-clicking them will open them up in the Windows Font Viewer). Unfortunately there is nothing I can do about this - you must either type the filename in manually, or copy the font to another folder and import it from there.
By default, font 0 is used as the normal text font, and font 1 is used as the speech font. To use any additional fonts, the script properties Game.NormalFont and Game.SpeechFont can be used to change the active fonts.

Conclusion

That's it for the "Getting Started" tutorials. I hope they've helped you to get a grasp of the AGS basics. If there's anything you didn't really understand or that you think should be covered but wasn't, please let us know on the Beginners Technical Forum, so that the tutorials can be improved to explain it better.

Return to tutorials index

Tutorial last updated 18 August 2007. Copyright (c) 2004-2007 Chris Jones.