Fonctions et Propiétés des Personnages

Fonctions et Propiétés des Personnages

AddInventory

(Anciennement fonction globale AddInventory, désormais obsolète)
(Anciennement fonction globale AddInventoryToCharacter, désormais obsolète)

Character.AddInventory(InventoryItem *item, optionnel int ajoutALIndex)

Ajoute l'objet spécifié à l'inventaire du personnage. Cela assure que l'objet soit ajouté à la liste de l'inventaire du personnage, et que tout affichage de l'inventaire à l'écran affichera l'objet.

Le premier paramètre est le Script O-Name de l'objet de l'inventaire que l'on trouve dans l'éditeur (par exemple, iPoster).

Par défaut, le nouvel objet est ajouté à la fin de la liste de l'inventaire du personnage. Cependant, vous pouvez l'insérer à une position en particulier dans la liste en entrant le deuxième paramètre. Le nouvel objet est inséré avant l'objet se trouvant à la position ajoutALIndex. Les index sont numérotés depuis 0, donc pour ajouter l'objet au tout début de la liste, mettez 0 en second paramètres.

Exemple :

character[EGO].AddInventory(iKey);

donnera l'objet iKey à l'inventaire du personnage EGO.

Voir Aussi : Character.LoseInventory, UpdateInventory

AddWaypoint

(Anciennement MoveCharacterPath, désormais obsolète)

Character.AddWaypoint(int x, int y)

Dit au personnage de se rendre directement aux coordonnées (X,Y), après avoir terminé son déplacement en cours. Cette fonction vous permet de définir une série de déplacements que le personnage devra effectuer, si vous voulez lui faire prendre un chemin prédéfini à l'écran. Notez que tout mouvement effectué à l'aide de cette commande ignore les zones de déplacement libre.

Ceci est pratique pour les situations dans lesquelles vous voudriez qu'un personnage figurant arrive d'un côté de l'écran, prend un chemin prédéfini puis quitte l'écran.

Exemple :

character[UNTYPE].Walk(160, 100);
character[UNTYPE].AddWaypoint(50, 150);
character[UNTYPE].AddWaypoint(50, 50);

dit au personnage UNTYPE de marcher jusqu'au centre de l'écran normalement (en respectant les zones de déplacement libre), puis d'aller jusqu'au coin en bas à gauche pour se rendre enfin au coin en haut à gauche.

Voir Aussi : Character.Walk

Animate (personnage)

(Anciennement AnimateCharacter, désormais obsolète)
(Anciennement AnimateCharacterEx, désormais obsolète)

Character.Animate(int sequence, int delai, optionnel Repetition,
                  optionnel blocking, optionnel Direction)

Déclenche l'animation du personage, en utilisant la séquence numéro SEQUENCE de la vue actuelle du personnage. La vitesse d'animation sera de DELAI, où 0 est la plus rapide, plus le nombre étant haut, plus la vitesse étant basse. Le délai entre chaque image se calcule ainsi : DELAI + FRAME SPD, donc l'attente sur chaque image individuellement influe sur la vitesse finalement obtenue à l'écran.

Avant d'utiliser cette commande, vous devriez utiliser LockView pour sélectionner la vue que vous voulez animer et empêcher les animations automatiques (comme celle de marche ou d'attente) de se lancer.

Le paramètre Repetition définit si l'animation se répètera continuellement suivant le cycle des images. Il peut prendre les valeurs eOnce (ou zéro), auquel cas l'animation commencera de la première image de la séquence SEQUENCE, et fera défiler chaque image jusqu'à la dernière, puis s'arrêtera. Si Repetition vaut eRepeat (ou 1), alors lorsque l'animation arrivera à la dernière image, elle retournera à la première de la séquence et recommencera à la jouer.

direction définit la manière dont l'animation est jouée. Vous pouvez entrer eForwards (par déafut, l'animation dans le sens normal) ou eBackwards (auquel cas l'animation est jouée dans l'odre inverse de la séquence).

Pour le paramètre blocking vous pouvez entrer eBlock (auquel cas la fonction attendra que l'animation soit finie pour continuer l'exécution), ou eNoBlock (auquel cas l'animation commencera à jouer sans empêcher le script de continuer l'exécution). La valeur par défaut est eBlock.

Si le personnage était en train de se déplacer, il s'arrêtera.

Exemple :

character[EGO].LockView(5);
character[EGO].Animate(3, 1, 0, eBlock, eBackwards);
character[EGO].UnlockView();

animera le personnage une fois en utilisant la séquence numéro 3 de la 5ème vue, qui défilera à l'envers, puis l'exécution reprendra à la fin de l'animation.

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 numero_piece, optionnel int x, optionnel int y)

Change la pièce dans laquelle se trouve le personnage.

Si vous appelez cette fonction pour le personnage joueur, alors la pièce actuelle est ôtée de la mémoire et ROOMx.CRM est chargée à la place, où X est numero_piece.

IMPORTANT : Cette commande ne change pas immédiatement la pièce ; la pièce sera redéfinie uniquement à la fin de l'exécution du script. (Ceci afin d'empêcher de quitter le script alors qu'il est encore en exécution) Cela signifie que vous ne devriez pas utiliser de commande censée opérer sur la nouvelle pièce (positionner les objets, ou autres) après cette commande dans la même fonction.

Si vous appelez cette fonction à propos d'un personnage non-joueur, alors il est instantanément transporté dans la nouvelle pièce.

Vous pouvez optionnellement ajouter des coordonnées X et Y (soit les deux, soit aucune). Si vous le faîtes, le personnage arrivera dans la nouvelle pièce aux coordonnées spécifiées.

Exemple :

player.ChangeRoom(4, 100, 50);

tranportera le joueur à la pièce 4, aux coordonnées 100,50. Cela signifie que le jeu aussi se déplace en pièce 4.

ChangeView

(Anciennement ChangeCharacterView, désormais obsolète)

Character.ChangeView(int view)

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 :

character[EGO].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 fonction globale FaceCharacter, désormais obsolète)

Character.FaceCharacter(Character* autre, optionnel Blocking)

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

fera que le personnage EGO se retournera vers HOMME

Voir Aussi : Character.FaceLocation, Character.FaceObject, Character.Walk

FaceLocation

(Anciennement fonction globale FaceLocation, désormais obsolète)

Character.FaceLocation(int x, int y, optionnel Blocking)

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

Exemple :

character[EGO].FaceLocation(character[EGO].x + 50, character[EGO].y);

et le personnage EGO se tournera vers la droite.

Voir Aussi : Character.FaceCharacter

FaceObject

Character.FaceObject(Object* objet, optionnel Blocking)

Semblable à la fonction FaceCharacter, mais cette fois le personnage se tournera en direction de l'objet OBJET dans la pièce courante.

Exemple :

player.FaceObject(oPorte);

fera que le personnage joueur se tournera en direction de l'objet oPorte.

Voir Aussi : Character.FaceCharacter

FollowCharacter

(Anciennement fonction globale FollowCharacter, désormais obsolète)
(Anciennement fonction globale FollowCharacterEx, désormais obsolète)

Character.FollowCharacter(Character* persoasuivre, optionnel int dist,
                          optionnel int marge)

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.

MARGE 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 MARGE=97.

En particulier, si vous mettez DIST=0 et MARGE=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 à MARGE 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 MARGE 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 (personnage)

(Anciennement fonction globale 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("La souris se trouve sur le personnage principal.");
}

affichera le message si le curseur de la souris se situe sur le personnage EGO.

Voir Aussi : Hotspot.GetAtScreenXY, Object.GetAtScreenXY, Game.GetLocationName

GetProperty (personnage)

(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 (character[EGO].GetProperty("Valeur") > 200)
  Display("La valeur d'EGO dépasse 200!");

affichera le message si la propriété "Valeur" d'EGO est supérieure à 200.

Voir Aussi : Character.GetTextProperty

GetTextProperty (personnage)

(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("La description d'EGO est : %s", description);

récupérera la valeur (textuelle) de la propriété "description" d'EGO et l'affichera.

Voir Aussi : Character.GetProperty

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 (character[EGO].IsCollidingWithChar(cHomme) == 1) {
  // Code de 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 (personnage)

(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 (character[EGO].IsCollidingWithObject(object[3]) == 1) {
  // Code de collision ici
}

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 :

character[EGO].LockView(12);
character[EGO].Animate(0, 0, eOnce, eBlock, eForwards);
character[EGO].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, Alignement)

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.

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 :

character[EGO].LockViewAligned(12, 1, eAlignLeft);
character[EGO].Animate(1, 5, eOnce, eBlock, eForwards);
character[EGO].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 :

character[EGO].LockViewFrame(SIDERE, 2, 4);
Wait(40);
character[EGO].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.

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 640x400, 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 fonction globale LoseInventory, désormais obsolète)
(Anciennement LoseInventoryFromCharacter, désormais obsolète)

Character.LoseInventory(InventoryItem *objet)

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 :

character[EGO].LoseInventory(iKey);

fera que le personnage EGO perdra l'objet d'inventaire iKey de son inventaire.

Voir Aussi : Character.AddInventory

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 :

character[EGO].x = Random(320);
character[EGO].y = Random(200);
character[EGO].PlaceOnWalkableArea();

placera le personnage EGO à une position aléatoire mais s'assurera qu'il se trouve sur une zone de déplacement libre.

RemoveTint (personnage)

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.Tint

RunInteraction (personnage)

(Anciennement RunCharacterInteraction, désormais obsolète)

Character.RunInteraction(CursorMode)

Exécute la liste d'interactions comme si le joueur avait ciqué avec la souris sur le personnage avec le mode de curseur spécifié, prédéfini dans la fenêtre Curseurs de l'éditeur.

Exemple :

character[HOMME].RunInteraction(eModeTalk);

exécutera le code placé dans l'interaction "TALK TO CHARACTER" de HOMME.

Voir Aussi : ProcessClick, Hotspot.RunInteraction, InventoryItem.RunInteraction

Say

(Anciennement DisplaySpeech, désormais obsolète)

Character.Say(string message)

Affihce 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 "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 le format string.

Exemple :

character[EGO].Say("Mon nom est 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 de QFG4.

Exemple :

character[EGO].SayAt(220, 20, 100, "Mon nom est 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.IsValid 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é (à moins que vous définissiez une variable globale game.bgspeech_stay_on_display à 1).

Exemple :

character[HOMME].SayBackground("Eh, 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 :

character[MAN].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 :

character[EGO].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 :

character[EGO].StopMoving();
character[EGO].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 (personnage)

(Anciennement fonction globale 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 (character[EGO].x > 299) {
  character[EGO].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 "Le joueur peut passer les dialogues".

La manière d'afficher le texte dépend de quelques petites choses : les réglagles du Style de Dialogues, les réglages de l'option "Penser utilise une bulle GUI", et si le personnage a une animation ou non.

Si l'option "Penser utilise une bulle 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 "Penser utilise une bulle 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 format string.

Exemple :

character[EGO].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 (personnage)

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 srpites en hautes-couleurs.

Exemple :

cEgo.Tint(0, 250, 0, 30, 100);

teintera le personnage EGO en vert.

Voir Aussi : 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 :

character[EGO].LockView(12);
character[EGO].Animate(0, 0, eOnce, eBlock, eForwards);
character[EGO].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, optionnel Blocking,
                             optionnel MarcheIci);

Déplace le personnage depuis sa position actuelle jusqu'aux coordonnées (X,Y).

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.

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 variables pour plus d'information.

Exemple :

character[EGO].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.Walk, MoveCharacterToObject, Object.Move, Character.StopMoving

WalkStraight

(Anciennement MoveCharacterStraight, désormais obsolète)

Character.WalkStraight(int x, int y, optionnel Blocking);

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érer 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.

Blocking 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 :

character[EGO].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 propriété

(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.

Pour déselectionner tout objet d'inventaire actif, définissez la valeur à null.

Exemple :

character[EGO].ActiveInventory = iKey;

rendra l'objet d'inventaire iKey actif (avant d'utiliser cela assurez vous que le joueur dispose de l'objet d'inventaire).

Animating propriété (personnage)

(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 :

character[EGO].Animate(5, 0);
while (character[EGO].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 propriété

(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 propriété (personnage)

(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 :

character[MAN].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 propriété

(Formerly part of 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 :

character[EGO].BlinkView = 10;
character[EGO].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 propriété

(Formerly part of 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 :

character[EGO].BlinkView = 10;
character[EGO].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 propriété

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 propriété (personnage)

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 1.

Exemple :

character[EGO].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 propriété (personnage)

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 1.

Exemple :

character[EGO].BlockingWidth = 50;

fera que le personnage bloquera 50 pixels de largeur (25 sur sa gauche, 25 sur sa droite, depuis sa coordonnée X).

Voir Aussi : Character.BlockingHeight, Character.Solid

Clickable propriété (personnage)

(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 correspond à modifier la case "No interaction" à cocher dans l'éditeur.

Si vous donnez la valeur 1, 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 0, 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 :

character[HOMME].Clickable = 0;

fera que le jeu ignorera les clics sur le personnage HOMME.

Voir Aussi : Object.Clickable

DiagonalLoops propriété

(Formerly part of 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 :

character[EGO].DiagonalLoops = true;

activera les séquences de déplacement en diagonale pour le personnage EGO.

Frame propriété

(Anciennement character[].frame, désormais obsolète)

int Character.Frame

Retourne/Définit le numéro de l'image 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 utilise actuellement l'image numéro %d.", cEgo.Frame);

affiche le numéro de l'image qu'utilise actuellement EGO dans sa vue.

SeeAlso: Character.Animate, Character.Loop, Character.View

ID propriété (personnage)

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 propriété

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 d'EGO est actuellement la vue numéro %d.", character[EGO].IdleView);

affichera le numéro de la vue d'attente actuelle de EGO.

SeeAlso: SetIdleView

IgnoreLighting propriété

(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 :

character[EGO].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 propriété (personnage)

(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 de 1, 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.

Exemple :

character[EGO].IgnoreWalkbehinds = 1;

fera que le personnage EGO ingorera les zones "par-dessus".

Voir Aussi : Object.IgnoreWalkbehinds

InventoryQuantity propriété

(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.

Exemple :

Display("Le joueur a %d €.", player.InventoryQuantity[iCash.ID]);

affichera le nombre d'objets d'inventaire de type iCash dont le joueur dispose.

Voir Aussi : UpdateInventory, Character.AddInventory, Character.LoseInventory

Loop propriété

(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.

SeeAlso: Character.Animate, Character.Frame, Character.View

ManualScaling propriété (personnage)

(Anciennement Character.IgnoreScaling, désormais obsolète)
(Formerly part of 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 libre où se trouve le personnage, ou s'il est manuellement défini par le script. Ceci est équivalent à l'option "Ignore room area scaling" 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.

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.

SeeAlso: Character.Scaling

Moving propriété (personnage)

(Anciennement character[].walking, désormais obsolète)

readonly bool Character.Moving

Retourne 1 si le personnage est actuellement en train de se déplacer, sinon 0.

Cette propriété est en lecture seule, pour agir sur le déplacement du personnage, utilisez les commandes Walk et StopMoving.

Exemple :

character[EGO].Walk(125, 40);
while (character[EGO].Moving) Wait(1);

déplacera le personnage jusqu'aux coordonnées (125,40) et rendra le contrôle au joueur lorsqu'il y sera rendu.

Voir Aussi : Character.Animating, Character.Speaking, Character.StopMoving, Character.Walk

Name propriété (personnage)

(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 propriété

(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'a pas d'animation particulière, 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 propriété

(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.", character[EGO].PreviousRoom);

affichera la pièce précédente de EGO.

Room propriété

(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 automatiquement redéfinie par ChangeRoom.

Exemple :

Display("EGO se trouve dans la pièce numéro %d.", character[EGO].Room);

affichera la pièce dans laquelle se trouve actuellement le personnage EGO.

ScaleMoveSpeed propriété

(Formerly part of 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 "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 propriété

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 "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 propriété (personnage)

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'ignore le zoom des zones de déplacement et fixera son niveau de zoom à 50%.

SeeAlso: Character.ManualScaling

Solid propriété (personnage)

(Formerly part of SetCharacterProperty, désormais obsolète)

bool Character.Solid

Retourne/Définit si les autres personnages peuvent passer à travers celui-ci.

Si la valeur est de 1, alors le personnage est solide et bloquera le chemin des autres personnages. Si la valeur est de 0, alors le personnage agira comme un hologramme, et les autres personnages pourront marcher sans se cogner à lui.

Exemple :

character[EGO].Solid = 1;

signifie que EGO bloquera le passage des autres personnages.

Voir Aussi : Character.BlockingHeight, Character.BlockingWidth

Speaking propriété

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, cette propriété ne sera probablement utile à manipuler que dans repeatedly_execute_always.

Exemple :

if ((cEgo.Speaking) && (!cEgo.Animating)) {
  cEgo.Animate(3, 5, eRepeat, eNoBlock);
}

animera le personnage EGO en utilisant la séquence 3 lorsqu'il parlera (utile uniquement avec le style de dialogues Sierra).

Voir Aussi : Character.Animating, Character.Moving, Character.Say

SpeechColor propriété

(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 :

character[EGO].SpeechColor = 14;

changera la couleur du texte du personnage EGO en jaune.

Voir Aussi : Character.SpeechView

SpeechView propriété

(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 :

character[EGO].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 propriété

(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 :

character[EGO].ThinkView = 14;

utilisera la vue numéro 14 pour animer le personnage EGO lorsqu'il pensera.

Voir Aussi : Character.Think

Transparency propriété (personnage)

(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 pour le moment que dans les jeux en hautes-couleurs, et les sprites des personnages doivent avoir été importées en hautes-couleurs pour que la transparence fonctionne.

NOTE : Utiliser la transparence sur un gros personnage peut ralentir significativement la machine.

Pour considérer la transparence, AGS l'arrondit -- c'est pourquoi si vous essayer de récupérer la valeur du paramètre après l'avoir définie, elle risque d'être sensiblement différente. Utiliser une boucle sur character[EGO].Transparency++; n'est donc pas recommandé puisqu'elle risque de finir trop tôt.

Si vous voulez faire un fondu sur un personnage, la meilleure solution serait de faire comme dans l'exemple qui suit :

Exemple :

int trans = character[EGO].Transparency;
while (trans < 100) {
  trans++;
  character[EGO].Transparency = trans;
  Wait(1);
}

fondra graduellement le personnage depuis sa transparence actuelle pour le rendre totalement invisible.

Voir Aussi : Object.Transparency

TurnBeforeWalking propriété

(Formerly part of 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 "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 :

character[EGO].TurnBeforeWalking = 1;

dira à EGO de se retourner avant de marcher.

View propriété (personnage)

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 d'EGO est actuellement la vue numéro %d.", character[EGO].View);

affichera le numéro de la vue dans laquelle EGO est actuellement affiché.

SeeAlso: Character.ChangeView, Character.Frame, Character.LockView, Character.Loop, Character.NormalView

WalkSpeedX propriété

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("La vitesse de déplacement horizontal du joueur vaut : %d", player.WalkSpeedX);

affichera la vitesse de déplacement sur l'axe X du joueur.

Voir Aussi : Character.SetWalkSpeed, Character.WalkSpeedY

WalkSpeedY propriété

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("La vitesse de déplacement vertical du joueur vaut : %d", player.WalkSpeedY);

affichera la vitesse de déplacement sur l'axe Y du joueur.

Voir Aussi : Character.SetWalkSpeed, Character.WalkSpeedX

x propriété (personnage)

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 propriété (personnage)

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 propriété (personnage)

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 < 20) {
  player.z++;
  Wait(1);
}

fera graduellement léviter le personnage à 20 pixels de haut.

Voir Aussi : Character.x, Character.y

SetCharacterProperty

SetCharacterProperty (CHARID, PROPERTY, int new_value)

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

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.