(Anciennement AnimateObject, désormais obsolète) (Anciennement AnimateObjectEx, désormais obsolète)

Object.Animate(int sequence, int delai, optionnel Repetition,
optionnel Blocage, optionnel Direction)

Anime l'objet, en utilisant la séquence (loop) numéro SEQUENCE de sa vue actuelle. La vitesse générale de l'animation est définie par DELAI, où 0 signifie rapide, les nombres supérieurs ralentissant l'animation. Le délai pour chaque vignette se calcule par DELAI + DELAI_VIGNETTE (vitesse propre à la vignette), donc la vitesse de chaque vignette influe sur la vitesse générale.

Le paramètre Repetition définit si l'animation répétera le cycle des images continuellement ou non. Il peut valoir eOnce (ou zéro), auquel cas l'animation débutera à la première vignette de la séquence, et fera défiler jusqu'à atteindre la dernière avant d'arrêter l'animation. S'il vaut eRepeat (ou 1), alors lorsque la dernière vignette arrivera, l'animation reprendra à partir de la première vignette de la séquence et ainsi de suite. Si RepeatStyle vaut 2 alors l'animation sera jouée une fois, mais retournera ensuite à la première vignette de la séquence avant de s'arrêter (tandis que si le paramètre vaut 0, l'image de l'objet inanimé sera la dernière vignette de la séquence).

Pour Blocage vous pouvez passer eBlock (auquel cas la fonction attendra la fin de l'animation pour reprendre l'exécution), ou eNoBlock (auquel cas l'animation commencera à jouer, mais le script continuera de s'exécuter). La valeur par défaut est eBlock.

Direction spécifie la façon dont est jouée l'animation. Vous pouvez lui donner la valeur eForwards (par défaut), auquel cas l'animation est jouée dans l'ordre normal de la séquence, ou eBackwards, auquel cas la séquence est jouée à l'envers.

Vous devez utiliser SetView avant d'utiliser cette commande, pour pouvoir définir la vue actuelle de l'objet.

Exemple :

object[0].Animate(2, 5);
object[1].Animate(1, 3, eOnce, eBlock, eBackwards);

animera l'objet 0 en utilisant la séquence 2 de sa vue courante, à la vitesse 5, et ne jouera l'animation qu'une seule fois. Tout ceci exécuté en arrière-plan. Ensuite, l'objet 1 sera animé dans l'ordre inverse de la séquence 1 de sa vue actuelle, à la vitesse 3. La fonction ne permettra au script de poursuivre son exécution qu'une fois l'animation terminée.

Voir Aussi : Character.Animate, Animating, Object.SetView, StopAnimating

---

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

static Object* Object.GetAtScreenXY(int x, int y)

Vérifie s'il y a un objet dans la pièce aux coordonnées (X,Y) de l'ECRAN. Retourne l'objet s'il y en a un, ou null s'il n'y en a pas.

Voyez la description de GetLocationName pour plus de détails sur les coordonnées à l'écran.

Exemple :

if (Object.GetAtScreenXY(211,145) == oRocher) {
// code ici
}

n'exécutera le code que s'il y a l'objet oRocher aux coordonnées propre à l'écran (211,145).

Voir Aussi : Hotspot.GetAtScreenXY, Game.GetLocationName

---

(Anciennement GetObjectProperty, désormais obsolète)

Object.GetProperty(string propriete)

Retourne la valeur de la propriété personnalisée PROPRIETE pour l'objet spécifié.

Cette commande fonctionne avec les propriétés numériques (retourne le nombre), et avec les propriétés booléennes (retourne 1 si la case est cochée, sinon 0).

Utilisez la fonction équivalente GetTextProperty pour obtenir une propriété textuelle.

Exemple :

if (object[0].GetProperty("Valeur") > 200)
Display("La valeur de l'objet 0 est supérieure à 200 !");

affichera le message si la propriété “Valeur” de l'objet 0 est supérieure à 200.

Voir Aussi : Object.GetTextProperty

---

(Anciennement GetObjectPropertyText, désormais obsolète) (Anciennement Object.GetPropertyText, désormais obsolète)

String Object.GetTextProperty(string propriete)

Retourne la valeur de la propriété personnalisée PROPRIETE pour l'objet spécifié.

Cette commande ne fonctionne qu'avec les propriétés textuelles. Elle retourne le texte de la propriété.

Utilisez la fonction équivalente GetProperty pour obtenir une propriété non-textuelle.

Exemple :

String description = object[0].GetTextProperty("Description");
Display("La description de l'objet 0 : %s", description);

récupérera la propriété “description” de l'objet 0 et l'affichera.

Voir Aussi : Object.GetProperty

---

(Anciennement AreObjectsColliding, désormais obsolète)

bool Object.IsCollidingWithObject(Object* obj2)

Vérifie si l'objet spécifié et OBJ2 se touchent. Retourne true si c'est le cas, sinon false.

NOTE : Cette fonction effectue une vérification rectangulaire, même si la détection au pixel près est activée.

Exemple :

if (object[2].IsCollidingWithObject(object[3])) 
{
Display("Les objets 2 et 3 se touchent !");
}

affichera le message si les objets 2 et 3 se touchent.

Voir Aussi : AreThingsOverlapping

---

(Anciennement MergeObject, désormais obsolète)

Object.MergeIntoBackground()

Passe l'objet en tant qu'élément d'arrière-plan pour la pièce. En faisant cela, l'objet devient une partie de l'arrière-plan et ainsi ne réduit pas la vitesse du jeu. C'est une opération à sens unique - une fois que l'objet a été incorporé, ça ne peut pas être annulé et l'état de la pièce est définitivement altéré. Ainsi, vous ne devriez utiliser cette fonction que si un événement du jeu signifiant que la pièce est définitivement changée est survenu.

NOTE : après avoir appelé cette fonction, vous ne pouvez plus utiliser l'objet et il est devient définitivement inaccessible dans le jeu.

NOTE : les objets ne peuvent être incorporés que si l'image qu'ils utilisent a été importée à la même profondeur des couleurs que l'image d'arrière-plan.

Exemple :

object[3].MergeIntoBackground();

incorporera l'image de l'objet à l'image d'arrière-plan de la pièce et rendra l'objet inutilisable.

---

(Anciennement MoveObject, désormais obsolète) (Anciennement MoveObjectDirect, désormais obsolète)

Object.Move(int x, int y, int vitesse, optional BlockingStyle,
optional WalkWhere);

Commence à déplacer l'objet depuis sa position actuelle vers (X,Y). Il se déplacera à la vitesse VITESSE, qui utilise la même échelle que pour les valeur Walk Speed (Vitesse Déplacement) dans l'Editeur AGS.

Si BlockingStyle vaut eNoBlock (par défut), alors le script reprend immédiatement son exécution, et l'objet se déplacera en arrière-plan.

Si BlockingStyle vaut eBlock, alors cette commande attendra que l'objet ait fini son mouvement avant de rendre le contrôle au script.

Si WalkWhere vaut eWalkableAreas (par défaut), alors l'objet tentera de se rapprocher le plus possible de (X,Y) en respectant les zones de déplacement libre de la pièce.

Si WalkWhere vaut eAnywhere, alors l'objet se rendra directement de sa position actuelle à (X,Y), en ignorant toute zone de déplacement.

Exemple :

object[2].Move(125, 40, 4, eBlock);

déplacera l'objet 2 vers (125,40) et ne rendra le contrôle au joueur qu'une fois que l'objet y sera rendu.

Voir Aussi : Object.Moving, Character.Walk, Object.StopMoving

---

(Anciennement RemoveObjectTint, désormais obsolète)

Object.RemoveTint()

Annule les effets de la commande Tint, et réutilise la teinte ambiante de la pièce sur l'objet.

Exemple :

object[1].Tint(0, 250, 0, 30, 100);
Wait(40);
object[1].RemoveTint();

teintera l'objet 1 en vert pendant une seconde, puis le rendra à la normale.

Voir Aussi : Object.Tint

---

(Anciennement RunObjectInteraction, désormais obsolète)

Object.RunInteraction(CursorMode)

Lance la liste d'interactions propres à l'objet comme si le joueur avait cliqué dessus dans la pièce, en utilisant le mode spécifié de curseur.

Exemple :

object[3].RunInteraction(eModeInteract);

exécutera le code placé dans l'interaction “Interact with object” de l'objet 3.

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

---

(Anciennement SetObjectPosition, désormais obsolète)

Object.SetPosition(int x, int y)

Change la position de l'objet pour (X,Y). Ces coordonnées déterminent la position du coin bas-gauche de l'objet.

Cette commande est équivalente à définir object.X et object.Y séparemment, mais offre une façon plus pratique de le faire.

NOTE : Cette commande ne peut pas être utilisée lorsque l'objet est en déplacement.

Exemple :

object[2].SetPosition(50, 100);

changera la position de l'objet 2 pour (50,100).

Voir Aussi : Object.X, Object.Y

---

(Anciennement SetObjectFrame, désormais obsolète) (Anciennement SetObjectView, désormais obsolète)

Object.SetView(int vue, optionnel int sequence, optional int vignette)

Définit la vue de l'objet à VUE, et change la vignette (Frame) de l'objet pour la vignette numéro VIGNETTE de la séquence numéro SEQUENCE de la VUE. Si vous n'entrez pas la séquence ou la vignette, alors elles seront inchangées.

Vous devez utiliser cette commande avant d'appeler Animate, de façon à ce que AGS puisse savoir avec quelle vue animer l'objet.

Exemple :

object[3].SetView(14);
object[1].SetView(5, 2, 0);

changera la vue de l'objet 3 pour la vue numéro 14, et changera la vue de l'objet 5 pour la vue 1, en utilisant la vignette 0 de la séquence 2.

Voir Aussi : Object.Animate

---

Object.StopAnimating()

Stoppe l'animation de l'objet. Il utilisera alors l'image sur laquelle l'animation s'est arrêtée jusqu'à ce que vous la changier ou que vous lancier une nouvelle animation.

Exemple :

if (object[2].Animating) {
object[2].StopAnimating();
}

stoppera l'animation de l'objet 2 s'il était animé.

Voir Aussi : Object.Animate, Object.Animating

---

(Anciennement StopObjectMoving, désormais obsolète)

Object.StopMoving()

Stoppe le déplacement de l'objet. Il restera à la position où il était rendu jusqu'à ce qu'une commande la change plus loin.

Exemple :

if (object[2].Moving) {
object[2].StopMoving();
}

stoppera le déplacement de l'objet 2 s'il se déplaçait.

Voir Aussi : Object.Moving, Object.Move, Character.StopMoving

---

(Anciennement SetObjectTint, désormais obsolète)

Object.Tint(int rouge, int vert, int bleu,
int saturation, int luminosite)

Teinte l'objet à l'écran avec les couleurs (ROUGE, VERT, BLEU) avec une saturation de SATURATION pourcents.

Cette fonction applique une teinte à l'objet spécifié. Pour savoir le sens de tous les paramètres, voyez SetAmbientTint.

La teinte définie par cette fonction prend le dessus sur toute teinte ambiante définie pour la pièce. Pour cette raison, passer une SATURATION de 0 dans cette fonction n'annule pas toute saturation sur l'objet - cela assure plutôt qu'aucune teinte ne sera appliquée à l'objet (même si une teinte ambiante est définie).

Pour annuler la teinte définie par cette fonction et réutiliser la teinte ambiante sur l'objet, appelez RemoveTint.

NOTE : Cette fonction ne fonctionne qu'avec les jeux hautes-couleurs et avec les sprites hautes-couleurs.

Exemple :

object[1].Tint(0, 250, 0, 30, 100);

teintera l'objet 1 avec du vert.

Voir Aussi : Object.RemoveTint, SetAmbientTint

---

(Anciennement IsObjectAnimating, désormais obsolète)

readonly bool Object.Animating

Retourne 1 si l'objet spécifié est actuellement animé. Retourne 0 si l'objet a fini son animation.

Cette propriété est en lecture seule. Pour changer l'animation de l'objet, utilisez la commande Animate.

Exemple :

object[2].Animate(5, 0);
while (object[2].Animating) Wait(1);

animera l'objet 2 et attendra que l'animation soit finie.

En réalité, vous utiliseriez simplement le paramètre Blocking de Animate, vous n'avez donc pas besoin de faire ceci.

Voir Aussi : Object.Animate, Object.Moving, Object.StopAnimating, Object.X, Object.Y

---

(Anciennement GetObjectBaseline, désormais obsolète) (Anciennement SetObjectBaseline, désormais obsolète)

int Object.Baseline

Retourne/Définit la baseline de l'objet. Ceci vous permet de modifier la ligne que vous manipulez dans l'éditeur. Vous pouvez désactiver la baseline (et ainsi réutiliser la base de l'image de l'objet à l'écran) en donnant la valeur 0 à cette propriété.

Sinon, donnez-lui la coordonnée d'écran Y que vous voulez utiliser, normalement de 1 à 200 à moins que vous soyez dans une pièce plus grande qu'habituellement.

Si vous voulez récupérer la baseline et que la valeur retournée est 0, alors la baseline est la coordonnée Y de l'objet.

Exemple :

object[4].Baseline = 100;

utilisera une ligne horizontale à la coordonnée Y = 100 comme baseline pour l'objet 4.

Voir Aussi : Character.Baseline, Object.Y, SetWalkBehindBase

---

int Object.BlockingHeight

Retourne/Définit la hauteur de blocage de l'objet.

La hauteur de blocage détermine la dimension du rectangle qu'occupera l'objet dans la pièce, auquel les personnages se percuteront. Si cette propriété vaut 0 (par défaut), alors le rectangle de blocage est automatiquement défini en fonction de la largeur de l'objet, avec une hauteur de 5 pixels.

Vous pouvez changer manuellement la valeur en entrant une hauteur de blocage en pixels, qui définira la dimension de la zone de déplacement qu'occupera l'objet.

NOTE : Cette propriété n'a d'effet que si la propriété Solid vaut true.

Exemple :

oRocher.BlockingHeight = 20;

fera que l'objet Rocher bloquera 20 pixels de hauteur (10 au-dessus et 10 sous sa basline).

Voir Aussi : Object.BlockingWidth, Object.Solid

---

int Object.BlockingWidth

Retourne/Définit la largeur de blocage de l'objet.

La largeur de blocage détermine la dimension du rectangle qu'occupera l'objet dans la pièce, auquel les personnages se percuteront. Si cette propriété vaut 0 (par défaut), alors le rectangle de blocage est automatiquement défini en fonction de la largeur de l'objet, avec une hauteur de 5 pixels.

Vous pouvez changer manuellement la valeur en entrant une largeur de blocage en pixels, qui définira la dimension de la zone de déplacement qu'occupera l'objet.

NOTE : Cette propriété n'a d'effet que si la propriété Solid vaut true.

Exemple :

oRocher.BlockingWidth = 50;

fera que l'objet Rocher bloquera 50 pixels de hauteur (25 pixels à sa gauche et 25 à sa droite, à partir du centre).

Voir Aussi : Object.BlockingHeight, Object.Solid

---

(Anciennement SetObjectClickable, désormais obsolète)

bool Object.Clickable

Retourne/Définit si l'objet est considéré comme un élément avec lequel le joueur peut interagir.

Si cette propriété vaut 1, alors le joueur peut le regarder, lui parler, etc. Si elle vaut 0, alors l'objet ne réagira pas aux clics et la souris cliquera sur ce qui se trouve derrière l'objet. Ceci est utile si vous utilisez l'objet comme un effet visuel et que vous ne voulez pas que le joueur puisse cliquer dessus.

Exemple :

object[2].Clickable = 0;

fera que l'objet 2 ignorera les clics du joueur.

Voir Aussi : Character.Clickable, Object.IgnoreWalkbehinds

---

readonly int Object.Frame

Retourne le numéro de la vignette (Frame) qui correspond actuellement à l'objet. Si aucune vue ne lui est actuellement associée, vaudra 0 (auquel cas la propriété Graphic correspondra au numéro de sprite).

Cette propriété est en lecture seule. Pour changer la vignette (Frame), utilisez les fonctions d'animation.

Exemple :

Display("L'image de l'objet est actuellement la vignette numéro %d.", oPorte.Frame);

affichera le numéro de la vignette actuelle de l'objet oPorte.

Voir aussi : Object.Graphic, Object.Loop, Object.View

---

(Anciennement GetObjectGraphic, désormais obsolète) (Anciennement SetObjectGraphic, désormais obsolète)

int Object.Graphic

Retourne/Définit le numéro de la sprite que l'objet utilise actuellement. Vous pouvez trouver le numéro de sprite dans le Sprite Manager. Si l'objet est actuellement animé (grâce à une commande Animate) et que vous changez son image, alors l'animation sera stoppée.

Exemple :

object[2].Graphic = 100;

changera l'image de l'objet 2 pour utiliser l'image contenue à l'emplacement 100 du sprite manager.

Voir Aussi : Object.SetView

---

readonly int Object.ID

Retourne le numéro ID de l'objet. Ceci est le numéro de l'objet dans l'éditeur, ce qui est utile si vous devez gérer du code qui requiert l'utilisation du numéro de l'objet plutôt que son nom.

Exemple :

MoveObject(oRocher.ID, 100, 50, 5);

utilise la fonction obsolète MoveObject pour déplacer l'objet Rocher à (100, 50) à une vitesse de 5.

---

bool Object.IgnoreScaling

Retourne/Définit si l'objet est concerné par le zoom des zones de déplacement. Ceci revient, bien que les valeurs soient inversées, à cocher ou non la case “Use walkable area scaling” dans la fenêtre Objets de l'éditeur.

Si la valeur est true, l'objet conservera toujours sa taille. Si elle vaut false, alors l'objet sera réduit ou agrandi selon sa position sur la zone de déplacement.

Exemple :

oPorte.IgnoreScaling = true;

empêchera l'objet Porte d'être redimensionné en fonction des zones de déplacement libre.

Voir Aussi : Object.IgnoreWalkbehinds

---

(Anciennement SetObjectIgnoreWalkbehinds, désormais obsolète)

bool Object.IgnoreWalkbehinds

Définit si l'objet est affecté ou non par les zones “par-dessus”. Donner la valeur 0 à ce paramètre (par défaut) signifie que l'objet sera placer derrière toute zone “par-dessus” en fonction des baselines.

Si la valeur est de 1, alors l'objet ne sera jamais placé derrière une zone “par-dessus”. Ceci est utile si par exemple vous voulez qu'un objet représente une photo sur un mur, et que le mur correspond à une zone “par-dessus” - mais dans le même temps, vous voulez garder une concordance avec les personnage, et changer la baseline ne fonctionnerait alors pas.

Exemple :

object[1].IgnoreWalkbehinds = 1;

fera que l'objet 1 ignorera les zones “par-dessus”.

Voir Aussi : Character.IgnoreWalkbehinds, Object.Clickable, Object.IgnoreScaling

---

readonly int Object.Loop

Retourne la séquence correspondant actuellement à l'objet. Si aucune vue n'est actuellement assignée à l'objet, cela vaudra 0 (auquel cas la propriété Graphic correspondra à son numéro de sprite).

Cette propriété est en lecture seule. Pour changer de séquence, utiliser les fonctions d'animation.

Exemple :

Display("La séquence de l'objet oPorte est la séquence numéro %d.", oDoor.Loop);

affichera le numéro de séquence courante de l'objet oPorte.

Voir aussi : Object.Frame, Object.Graphic, Object.View

---

(Anciennement IsObjectMoving, désormais obsolète)

readonly bool Object.Moving

Retourne 1 si l'objet se déplace actuellement, sinon 0.

Cette propriété est en lecture seule ; pour modifier le déplacement de l'objet, utilisez les commandes Move et StopMoving.

Exemple :

object[2].Move(125,40,3);
while (object[2].Moving) Wait(1);

déplacera l'objet 2 aux coordonnées (125,40) et rendra le contrôle au joueur lorsque l'objet y sera rendu.

Voir Aussi : Object.Animating, Object.StopMoving

---

(Anciennement GetObjectName, désormais obsolète) (Anciennement Object.GetName, désormais obsolète)

readonly String Object.Name;

Retourne le nom de l'objet.

NOTE : Cette propriété est en lecture seule. Il n'est pour le moment pas possible de changer le nom d'un objet lorsque le jeu est en exécution.

Exemple :

Display("Le nom de l'objet 0 est %s", object[0].Name);

récupérera puis affichera le nom de l'objet 0.

Voir Aussi : Game.GetLocationName

---

bool Object.Solid

Retourne/Définit si l'objet peut être traversé ou non par les personnages.

Si la valeur est true, alors l'objet est solide et bloquera le chemin des personnages solides. Si la propriété vaut false, alors l'objet peut être traversé par les personnages.

NOTE : les objets solides ne bloquent que les personnages, ils n'empêchent pas les autres objets de les traverser.

Exemple :

oPetitrocher.Solid = 1;

signifiera que l'objet Petitrocher bloquera le chemin des personnages.

Voir Aussi : Object.BlockingHeight, Object.BlockingWidth

---

(Anciennement SetObjectTransparency, désormais obsolète)

int Object.Transparency

Retourne/Définit le niveau de transparence de l'objet.

Si la valeur est 100, cela signifie que l'objet est totalement invisible, et des valeurs inférieures font varier le niveau de transparence. Définissez la propriété à 0 pour rendre l'objet totalement opaque.

NOTE : La transparence ne fonctionne pour le moment qu'avec les jeux hautes-couleurs, et l'image de l'objet doit avoir été importée en hautes-couleurs pour que la transparence s'applique.

NOTE : Rendre un grand objet transparent peut ralentir sensiblement la machine.

Des arrondissements sont faits pour appliquer la transparence – c'est pourquoi, si vous récupérez la transparence après l'avoir définie, la valeur que vous obtiendrez peut être différente. Ainsi, utiliser une boucle avec object[0].Transparency++; n'est pas recommandé puisqu'elle s'achèvera probablement trop vite.

Pour afficher/faire disparaître un objet en fondu, la meilleure façon de faire est celle-ci :

Exemple :

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

fera graduellement disparaître l'objet en fondu depuis son niveau de transparence actuelle, jusqu'à ce qu'il soit totalement invisible.

Voir Aussi : Character.Transparency, GUI.Transparency

---

readonly int Object.View

Retourne la vue actuellement définie pour l'objet. Ceci est soit le numéro de la vue, soit 0 si l'objet n'est pas actuellement assigné à une vue (auquel cas la propriété Graphic contiendra plutôt son numéro de sprite).

Cette propriété est en lecture seule. Pour changer la vue, utilisez la fonction SetView. Pour annuler la vue, définissez la propriété Graphic à un emplacement de sprite.

Exemple :

Display("La vue de l'objet Porte est actuellement la vue numéro %d.", oPorte.View);

affichera le numéro de vue actuelle de l'objet oPorte.

SeeAlso: Object.SetView, Object.Graphic

---

(Anciennement IsObjectOn, désormais obsolète) (Anciennement ObjectOff, désormais obsolète) (Anciennement ObjectOn, désormais obsolète)

bool Object.Visible

Retourne/Définit si l'objet est visible ou non. Si la valeur est 1 (true), l'objet est activé et visible dans la pièce. Si vous passez la valeur 0 (false), l'objet disparaît et n'apparaît plus dans la pièce.

Exemple :

object[5].Visible = false;

fera disparaître l'objet numéro 5 de la pièce actuelle.

---

(Anciennement GetObjectX, désormais obsolète)

int Object.X

Retourne/Définit la coordonnée X de l'objet.

NOTE : Cette propriété ne peut pas être modifiée tant que l'objet est en déplacement.

Exemple :

Display("La coordonnée X de l'objet 1 est %d", object[1].X);

affichera la coordonnée X de l'objet 1.

Voir Aussi : Object.Y, Object.Animating, Object.Visible, Object.SetPosition

---

(Anciennement GetObjectY, désormais obsolète)

int Object.Y

Retourne/Définit la coordonnée Y de l'objet, qui correspond au bas de l'image de l'objet.

NOTE : Cette propriété ne peut pas être modifiée tant que l'objet est en déplacement.

NOTE : Si vous tentez d'utiliser cette coordonnée avec Objet.GetAtScreenXY, vous trouverez que l'objet n'est pas détecté. La sprite de l'objet est dessinée de la coordonnée Y (Objet.Y - Hauteur) à (Object.Y - 1).

Exemple :

Display("La coordonnée Y de l'objet 1 est %d", object[1].Y);

affichera la coordonnée Y de l'objet 1.

Voir Aussi : Object.Animating, Object.Baseline, Object.X, Object.SetPosition