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

Ceci est une ancienne révision du document !



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

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 nom de script (script o-name) de l'objet (par exemple, iAffiche ).

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 “ajouterAPosition”. Les positions sont numérotées à partir de 0, donc pour ajouter l'objet au début de la liste d'objets, mettez 0 au second paramètre.

Exemple :

cEgo.AddInventory(iClef);

Ceci donnera à EGO l'objet nommé iClef.
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 zones de déplacement (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:

cUnType.Walk(160, 100);
cUnType.AddWaypoint(50, 150);
cUnType.AddWaypoint(50, 50);

Indique au personnage UNTYPE de marcher en premier lieu jusqu'au milieu de l'écran (zones de déplacement respectées), puis d'aller vers le coin inférieur gauche de l'écran et ensuite le coin supérieur (sans se soucier des zones de déplacement).

Voir aussi : Character.Move Character.Walk


Animate

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

Character.Animate(int sequence, int delai, optional Repetition,
                  optional Blocage, optional Direction)

Démarre l'animation d'un personnage, assignant le numéro de la séquence (loop) de la vue (view) actuelle. La vitesse de l'animation est définie par l'argument DELAI, où 0 est le plus rapide ; les nombres supérieurs rendront la vitesse lente. Le temps entre chaque vignette (frame) est calculé selon DELAI + VITESSE_DE_VIGNETTE, donc la durée d'affichage des vignettes est calculée par rapport à la vitesse générale.

Mais avant d'utiliser cette commande, vous devriez utiliser celle-ci en premier : LockView dans le but de sélectionner la vue que vous voulez animer et empêcher toutes animations automatiques (ex. animation de marche ou celle d'attente) du jeu.

Le paramètre Repetition 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 vignette affichée. Il peut valoir eOnce (ou zéro), auquel cas l'animation sera jouée depuis la première vignette (frame) de la séquence (loop), et passera par chaque vignette jusqu'à la dernière, puis elle s'arrêtera. Si RepeatStyle vaut eRepeat (ou 1), alors lorsque la dernière vignette sera atteinte, l'animation retournera à la première vignette de la séquence et recommencera 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 Blocage 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). 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 nouvellePosition)
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 nouvellePosition 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. nouvellePosition peut valoir 1000 pour le bord gauche, 2000 pour le bord droit, 3000 pour le bord du bas et 4000 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 normale 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. Cette commande (ChangeView) change définitivement la vue normale 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.

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 rafraîchi 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 personnages possédant la propriété “No interaction” (Aucune interaction) ne seront pas détectés par cette fonction.

Exemple :

if (Character.GetAtScreenXY(mouse.x, mouse.y) == player) {
  Display("La souris se trouve au-dessus du personnage principal");
}

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

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") > 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 la vignette en cours du personnage à la première vignette dans la SEQUENCE de la VUE.

L'intérêt principal de cette commande est de pouvoir aligner la nouvelle vignette 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 vignette de façon à ce que son côté gauche soit exactement à la même coordonnée X que l'ancienne.
eAlignCentre Centre les vignettes 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 vignette 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 vignette de l'animation, donc pour tirer un véritable profit de cette option, toutes les vignettes de votre séquence d'animation devraient être de la même taille. Toutes les vignettes 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 VIGNETTE)

Change l'apparence du personnage pour utiliser l'image de la vignette VIGNETTE 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 celle de la vignette 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.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 Valid et 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 personnage, 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 globale game.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éplacements du personnage et lui donne l'apparence de l'image standard de la séquence actuelle.

Exemple :

if (cEgo.x > 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 zonesEmpruntables);

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

Si vous ne voulez pas que le personnage soit animé avec la vue de marche lors du déplacement, vous pouvez utiliser la commande Move à la place.

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 la vignette (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 affiche actuellement la vignette %d.", cEgo.Frame);

affiche le numéro de la vignette 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 (loop) 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);
}

animera le personnage avec la séquence 3 lorsqu'il parle (utile uniquement avec le réglage de discours Sierra).

Voir aussi : Character.Animating, Character.Moving, Character.Say, Character.SpeakingFrame


SpeakingFrame

readonly int Character.SpeakingFrame
Retourne le numéro de la vignette (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 essayez 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(cHomme.x + 10, cHomme.y, eNoBlock, eAnywhere);
  }
}

déplacera cHomme vers la droite chaque fois que l'animation de dialogue passe sur la vignette (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é de façon interne lors du stockage de la transparence – ainsi, si vous la récupérez juste après l'avoir définie, la valeur retournée peut être supérieure à la valeur 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 < 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, et correspond au bas 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. Vous pouvez aussi entrer une valeur négative, ce qui est utile si les pieds du personnage ne sont pas situés tout en bas de ses sprites.

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


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

 
character.1438727606.txt.gz · Dernière modification: 05/08/2015 00:33 par 165.123.197.228
 
Recent changes RSS feed Creative Commons License Donate Powered by PHP Valid XHTML 1.0 Valid CSS Driven by DokuWiki