Tutorial 13 Toboggan 1/3

Les tutoriaux que je vous ai proposés jusque là n’incluaient pas trop d’éléments d’animation, juste quelques portes qui s’ouvrent ou se ferment et un avatar qui dort ou qui danse. Nous allons essayer maintenant de déplacer un avatar. Je me suis intéressé ces derniers temps aux toboggans. J’en ai rencontré plusieurs sur sl, la plupart situés au bord d’une piscine. La technique de déplacement de l’avatar me semblait être pratiquement toujours la même. Une ball en haut du toboggan prend en charge l’avatar pour initier une animation et permettre à l’avatar de glisser. Vous avez sans doute remarqué que la gravité sur sl agit sur tous les objets « physiques », dont les avatars font partie. Lorsque vous marchez sur un terrain en pente vous avez tendance à courir. Lorsque vous sautez d’un toit vous vous écrasez lamentablement au sol. On pourrait donc penser qu’un toboggan n’est après tout qu’un plan incliné et que l’avatar ne peut rien faire d’autre que glisser. Mais vous n’avez qu’à faire l’expérience pour constater que le problème n’est pas aussi simple. La première difficulté est qu’un avatar est en principe debout, il faut donc dans un premier temps l’obliger à s’asseoir. Nous avons déjà abordé cette question de l’animation dans de précédents tutoriaux. Il suffit de prévoir une ball avec un SitTarget et une animation., demander l’autorisation et lancer l’animation. Mais ce n’est pas parce qu’un avatar s’assoit qu’il va pour autant glisser dans la pente, il faut un peu l’aider. Pour cela il faut lui donner une impulsion vers l’avant. Il existe pour cela une fonction nommée llApplyImpulse qui va nous permettre de propulser l’avatar dans la pente. Avec cette pichenette l’avatar commence à glisser mais si nous lui laissons la totale liberté dans les rotations il y a de grandes chances pour qu’il bascule d’une façon pour le moins inélégante. C’est pour cette raison que nous allons verrouiller les rotations. De cette façon l’avatar n’a d’autre choix que de glisser sagement dans le toboggan. Mais que se passe-t-il lorsqu’il atteint le sol ? Il serait bien qu’arrivé là il se relève et que la ball aille sagement reprendre sa place en haut du toboggan pour une nouvelle glissade. Nous devons donc détecter l’arrivée au sol, ce qui se fait grâce à l’événement land_collision.

Pour ce tutorial il va vous falloir créer un toboggan, ce qui est après tout un bon exercice de build, vous pouvez voir sur la photo celui que j’ai réalisé pour l’occasion, en bois et en verre. Prévoyez une pente de 45% pour favoriser la glissade. Vous devez aussi créer une ball pour loger le script et l’animation. Pour cette dernière j’ai utilisé une free qui s’appelle « sit knees up2 », si vous voulez essayer la même vous devriez pouvoir la trouver facilement dans les boutiques free, je peux aussi vous la donner en ligne en m’envoyant un IM (Bestmomo Lagan), je peux aussi vous montrer le toboggan en action… Le positionnement de la ball doit être relativement bien ajusté pour que votre toboggan fonctionne. Voici le script à mettre dans la ball :

vector position; // Position de depart
string animation; // Nom de l'animation
key AgentKey; // Clef de l'avatar

initialisations()
{
// Memorisation position de depart;
position = llGetPos();
// Rotation à 0
llSetRot(ZERO_ROTATION);
// Animation
animation = "sit knees up2";
// Changement du texte du menu
llSetSitText("Glisser");
// Positionnement de l'animation
llSitTarget(<0.0,0.0,.5>, ZERO_ROTATION);
}

depart()
{
// Boule visible
llSetAlpha(1.0, ALL_SIDES);
// Passage en non physique
llSetStatus(STATUS_PHYSICS, FALSE);
// Retour de la boule au depart
llSetPos(position);
// Rotation à 0
llSetRot(ZERO_ROTATION);
}

default
{
// Entree dans l'etat
state_entry()
{
initialisations();
state attente;
}

// Reset du script
on_rez(integer start_param)
{
initialisations();
state attente;
}

}

state attente
{
// Entree dans l'etat
state_entry()
{
depart();
}

// Atteinte du bas du toboggan determine avec la collision avec le sol
land_collision(vector position)
{
// Avatar debout
llUnSit(AgentKey);
}

// Detection d'un changement
changed(integer change)
{
// Test de changement dans les liaisons
if (change & CHANGED_LINK)
{
// Determination de la clef de l'avatar
AgentKey = llAvatarOnSitTarget();
// Un avatar est present ?
if (AgentKey)
{
// Permission d'animation
llRequestPermissions (AgentKey, PERMISSION_TRIGGER_ANIMATION);
// Passage en physique et autorisation des rotations
llSetStatus(STATUS_PHYSICS, TRUE);
llSetStatus(STATUS_ROTATE_Y | STATUS_ROTATE_X | STATUS_ROTATE_Z, FALSE);
// Memorisation position de depart;
position = llGetPos();
// Impulsion
llApplyImpulse(llGetMass()*<3.0,0.0,0.0>, TRUE);
// Boule invisible
llSetAlpha(0, ALL_SIDES);
}
else
{
// Determination de l'animation en cours
string anim = llGetAnimation(AgentKey);
// Arret eventuel de l'animation
if(anim == "animation")
llStopAnimation(anim);
// Depart
depart();
}
}
}

// Permission accordee
run_time_permissions(integer permissions)
{
if(permissions == PERMISSION_TRIGGER_ANIMATION)
{
// Arret de l'animation par defaut
llStopAnimation("sit");
// Animation
llStartAnimation(animation);
}
}
}

Voyons le fonctionnement de ce code. Nous avons trois variables globales :

Ø position pour mémoriser la position initiale de la ball

Ø animation pour conserver le nom de l’animation

Ø AgentKey pour loger la clef de l’avatar.

J’ai prévu comme d’habitude une méthode d’initialisation qui permet de :

Ø mémoriser la position de départ de la ball grâce à la fonction llGetPos

Ø fixer la rotation par défaut de la ball

Ø déterminer l’animation à utiliser

Ø changer le texte du menu pour afficher « Glisser »

Ø positionner l’avatar pour l’animation

Après cette initialisation on passe dans l’état attente. Une méthode nommée depart qui est appelée au démarrage du script et à chaque fois qu’un avatar libère la ball en fin de glissade. Dans cette méthode nous prévoyons de :

Ø rendre la ball visible avec la fonction llSetAlpha

Ø passer la ball en mode physique avec la fonction llSetStatus

Ø positionner la ball à son emplacement initial

Ø mettre la rotation par défaut

Le mode physique est indispensable pour mettre en jeu la gravité et permettre la glissade. Par contre il faut désactiver cette propriété lorsque la ball attend en haut du toboggan sinon elle n’aura pas trop envie de rester en place J . Il est également judicieux de plus voir la ball lors de la glissade.

Arrivé à ce stade le script attend un changement. Celui-ci est détecté avec l’événement changed. Nous avons déjà abordé ce sujet précédemment et je n’insisterai pas. On récupère la clef de l’avatar avec la fonction llAvatarOnSitTaget, on demande la permission pour animer avec la fonction llRequestPermissions La fonction llSetStatus permet ensuite de passer en mode physique et de verrouiller les rotations. Ensuite on mémorise la position de départ avec llGetPos.

Ensuite on propulse l’avatar avec la fonction llApplyImpulse. Voyons ses paramètres. Le premier fixe la valeur de l’impulsion. Un vecteur permet de fixer sa direction, ici juste sur l’axe X. J’ai rendu la valeur dépendante de la masse de l’avatar (récupérée avec la fonction llGetMass) pour avoir une impulsion uniforme quel que soit son poids. Le second paramètre défini si les coordonnées sont globales ou locales. Dans notre cas nous choisissons évidemment local. Il ne reste plus qu’à rendre la boule invisible et c’est parti J.

Lorsque l’avatar arrive en bas il touche le sol, ce qui déclenche l’événement land_collision. L’avatar se remet alors debout grâce à la fonction llUnSit. Ce qui a pour effet également de déclencher l’événement changed mais cette fois aucun avatar n’est détecté. Nous stoppons alors l’animation en cours et appelons à nouveau la méthode depart pour réinitialiser le toboggan. Et ainsi de suite…

Tel quel ce toboggan fonctionne très bien. Mais il est présente quelques imperfections. La ball est forcément non liée au toboggan. En cas de déplacement de celui-ci il ne faut pas oublier cette particularité J. En cas de perte de la ball il faut également en recréer une a la main, la ball perdue ne se détruit pas automatiquement. Mais je réserve ces améliorations pour le prochain tutorial. Vous pouvez aussi faire des suggestions sur la direction que pourrait prendre cette réalisation. En attendant bonnes glissades J.