Les scripts de Second life

Suite du tutorial 14 (je viens de découvrir les limites de ce blog en étant obligé de découper ce tutorial en deux parties)...

Voyons maintenant le code de la ball :

vector position; // Position de depart
string animation; // Nom de l'animation
key AgentKey; // Clef de l'avatar
integer ecoute; // ecoute du chat
integer canal; // canal d'ecoute
integer canal_de_ball;  // Canal de reponse
rotation rot; // rotation initiale

initialisations () {

    // Animation
    animation = "sit knees up2";
    // Changement du texte du menu
    llSetSitText("Glisser");
    // Positionnement de l'animation
    llSitTarget(<0.0,0.0,.5>, ZERO_ROTATION);
    // Canaux
    canal = 37;
    canal_de_ball = 38;
    // Memorisation de la position
    position = llGetPos();
    rot = llGetRot();
}

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
    llSetRot(rot);
}

default {

    on_rez(integer start_param) {
        // Initialisations
        initialisations();
        // Memorisation du canal d'ecoute
        canal = start_param;
        // Changement d'etat
        state attente;
    }
}

state attente {

    // Entree dans l'etat
    state_entry() {
        // Activation de l'ecoute du toboggan
        ecoute = llListen(canal,"",NULL_KEY,"");
        // Mise en route du timer
        llSetTimerEvent(120);
        // Depart
        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 interdiction des rotations
                llSetStatus (STATUS_PHYSICS , TRUE);
                llSetStatus(STATUS_ROTATE_Y | STATUS_ROTATE_X | STATUS_ROTATE_Z, FALSE);
                // 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);
        }
    }

    // Ecoute
    listen(integer channel, string name, key id, string message) {
        if (message == "Meurs")
            llDie();
        else if (message == "Vis")
            llSetTimerEvent(120);
        else if (message == "Positions") {
          // Memorisation de la position
        position = llGetPos();
        rot = llGetRot();
            // Envoi des positions au toboggan
            llSay (canal_de_ball, (string)position + "|" + (string)rot);
        }
    }

    // Delai ecoule
    timer ( ) {
        // Suicide
        llDie();
    }
}

Une grande partie de ce code a déjà été décrit dans le tutorial précédent. Je vais donc me contenter de commenter les nouveautés.

On va s’intéresser en particulier l’événement on_rez qui se déclenche lors de la création de la ball. On procède alors aux initialisations, en particulier la mémorisation de la position et de la rotation. On récupère également le canal d’écoute qui se retrouve dans le paramètre de l’événement. Ensuite on passe à l’état attente.

A l’entrée dans cet état on active l’écoute du toboggan. On déclenche un timer réglé à 120 secondes. S’il ne se produit aucun changement au bout de ce délai l’événement timer se produit et la fonction llDie supprime la ball. Ensuite on appelle la méthode depart qui est identique à celle du précédent tutorial.

Comme nouveauté nous trouvons l’écoute du toboggan. Le message « Meurs » entraine l’exécution de la fonction llDie pour suicider la ball. Le message « Vis » réinitialise le timer pour une nouvelle durée de 120 secondes. Enfin le message « Positions » provoque l’envoi des coordonnées au toboggan dans le format qu’il s’attend à recevoir.

Mode opératoire : commencez par créer le toboggan et son script. Ensuite créez la ball, en la nommant bien « ball », et son script et mettez là dans votre inventaire. Faites enfin glisser la ball de votre inventaire dans le contenu du toboggan. A la première touche du toboggan activez l’option « Glissade » pour créer la ball. Ajustez ensuite celle-ci correctement. Touchez alors le toboggan et choisissez l’option « Position » pour mémoriser la position de la ball. Votre toboggan est prêt à l’emploi J.

Dans le précédent tutorial je vous ai proposé un toboggan et je vous avais promis une version plus élaborée qui pallie les défauts les plus évidents. En particulier le fait que la ball ne soit pas solidaire du toboggan peut poser quelques problèmes lors des déplacements. Sans parler de la perte éventuelle de la ball.

Je vous propose donc une version plus élégante dans laquelle la ball est contenue dans le toboggan. Un clic sur celui-ci fait apparaître un menu avec trois options :

D’autre part la ball ne peut survivre sans le toboggan. Celui-ci envoie une information cyclique, sans cette information la ball se suicide.

On se retrouve avec deux scripts : un dans le toboggan et un dans la ball.

Le toboggan doit savoir effectuer les opérations suivantes :

Ø      créer une ball en la positionnant correctement,

Ø      supprimer la ball,

Ø      demander à la ball sa position et sa rotation et mémoriser ces informations,

Ø      envoyer une information cyclique à la ball pour lui demander de survivre.

Voici le code correspondant à ces objectifs pour le toboggan :

integer canal_ball ; // Canal pour parler a la ball
integer canal_de_ball ; // Canal pour parler au toboggan
integer canal_menu ; // Canal pour le menu
integer ecoute ; // Ecoute
list menu;  // Options du menu
vector offsetPos ; // Offset de positionnement
rotation offsetRot ;    // Offset de rotation

// Initialisation du script
initialisations () {

    canal_ball = 37;
    canal_de_ball = 38;
    canal_menu = 47;
    menu =["Glissade" , "Stop" , "Position" ];
    offsetPos = <0.0,0.0,1.0>;
}

// Initialisation de la ball

rez_ball( ) {

    // Suppression eventuelle
    llSay ( canal_ball , "Meurs" );
    // Calcul du deplacement et de la rotation
    vector tobPos = llGetPos ();
    rotation tobRot = llGetRot ();
    vector DestPos = (offsetPos * tobRot ) + tobPos ;
    rotation DestRot = offsetRot * tobRot ;
    // Creation de la ball
    llRezObject ( "ball", DestPos , ZERO_VECTOR , DestRot , canal_ball );
    // Activation du timer
    llSetTimerEvent ( 60.0);
}

// Etat par defaut
default {

    // Entree de l'etat
    state_entry( ) {
        initialisations ();
    }

    // Reinitialisation
    on_rez( integer start_param ) {
        initialisations ();
    }

    // Touche
    touch_start (integer total_number ) {
        // Suppression de l'ecoute eventuelle
        llListenRemove ( ecoute );
        // Mise en place de l'ecoute
        ecoute = llListen (canal_menu , "", NULL_KEY , "");
        // Affichage du dialogue
        llDialog ( llDetectedKey (0), "Choisissez une option", menu, canal_menu );
    }

    // Stimulation reguliere de la ball
    timer ( ) {
        // Message pour la ball
        llSay ( canal_ball , "Vis" );
    }

    // Ecoute
    listen (integer channel, string name, key id, string message ) {
        // Affichage de l'option choisie
        llWhisper ( 0, name + " a choisi l'option '" + message + "'." );
        // Suppression de l'ecoute
        llListenRemove ( ecoute );
        // Selection selon l'option
        if (message == "Glissade" ) {
            // Affichage d'initialisation
            llWhisper ( 0, "Initialisation du toboggan");
            // Initialisation de la ball
            rez_ball( );
        }
        else if (message == "Stop" ) {
            // Suppression de la ball
            llSay ( canal_ball , "Meurs" );
            // Arret du timer
            llSetTimerEvent ( 0.0);
        }
        else if (message == "Position" ) {
            // Ecoute de la ball
            ecoute = llListen (canal_de_ball , "", NULL_KEY , "");
            // Demande positions
            llSay (canal_ball, "Positions" );
        }
        else if (llGetSubString (message, 0, 0) == "<" ) {
            // Reception des positions
            list pos = llParseString2List (message, ["|"], []);
            offsetPos = (vector )llList2String (pos , 0) - llGetPos ();
            offsetRot = (rotation )llList2String (pos , 1) / llGetRot ();
            llWhisper ( 0, "Memorisation de la position " + (string )offsetPos + " " + (string )offsetRot );
        }
    }
}

Sept variables nous sont nécessaires :

La méthode initialisations permet de renseigner la valeur des canaux du chat et les données du Dialog. Les offset ont au départ une valeur nulle et l’écoute sera renseignée au moment nécessaire, c’est-à-dire lors de la création de l’écoute.

Une méthode intéressante est rez_ball qui permet de créer la ball. On commence par supprimer une ball éventuellement présente en envoyant un message de suicide. On calcule ensuite la position et la rotation de la future ball en se basant sur les informations de positionnement et de rotation du toboggan et de la valeur des offset. Je laisse les formules mathématiques aux amateurs de quaternions et autres fantaisies de ce genre pour en venir directement à l’importante fonction llRezObject. Celle-ci permet de créer un objet, ou plus exactement une instance d’un objet, parce que l’objet correspondant doit déjà exister dans l’objet qui contient le script. En d’autres termes dans notre cas la ball est déjà contenu dans le toboggan, on se contente d’en créer une instance. Observez les paramètres de cette fonction :

Dans notre cas le premier paramètre correspond au nom de la ball contenue dans le toboggan. Le second et quatrième paramètres nous permettent d’ajuster la position et la rotation de la ball. Nous ignorons le troisième paramètre parce que nous voulons une ball immobile. Enfin nous profitons du dernier paramètre pour transmettre le canal d’écoute.

Tous les Rezzers que vous rencontrez sur sl sont fondés sur cette fonction ou sa sœur llRezAtRoot. Par exemple une maison imposante est découpée en morceaux et recréée sur place avec un Rezzer. Vous pouvez aussi imaginer un aménagement d’appartement modulable…

Je dois toutefois préciser que ce rezzer m’a passablement occupé ces derniers temps et mes amis sur sl s’amusaient de me voir en train de m’énerver sur mon toboggan. J’avais beau analyser mon code je ne trouvais pas la faille. Jusqu’au moment où j’ai eu l’idée de faire un essai avec des objets simples plutôt qu’avec les prims torturées de mon toboggan. Et là grosse surprise : tout fonctionnait parfaitement ! J’avais passé beaucoup de temps à chercher des erreurs qui n’existaient pas… Moralité : si vous voulez créer un rezzer utilisez plutôt une prim sans trop de modifications sinon vous risquer de galérer comme je l’ai fait avec des positionnements aléatoires. Il m’a suffit d’ajouter un cube à mon toboggan et de le définir comme root et tout s’est bien passé ensuite…

La dernière action de la méthode initialisations est de déclencher un timer réglé à 60 secondes pour envoyer une impulsion régulière à la ball pour lui demander de vivre. Ce que vous retrouvez dans la fonction timer avec le message « Vis » sur le canal de la ball.

Le reste du code ne présente pas de nouveauté. L’événement touch_start commence par supprimer une écoute éventuelle, mets en route l’écoute pour le dialog, et affiche le dialog.

L’événement listen récupère l’action de l’utilisateur :

Lors de l’écoute de la ball le seul message qui peut revenir est celui qui contient les coordonnées. On teste le message avec la fonction llGetSubString qui permet d’extraire une sous-chaîne d’une chaîne en transmettant l’index du caractère de début et l’index du dernier à extraire. Pour extraire le premier caractère il faut mettre 0 pour les deux paramètres. Les coordonnées sont transmises sous le format string séparées par le caractère « | ». La fonction llParseString2List permet de récupérer dans une list les éléments séparés par le caractère passé en paramètre (en fait une liste de séparateurs au format string). Il suffit ensuite d’extraire les coordonnées avec un cast (transformation de type) et de les combiner aux coordonnées du toboggan pour obtenir les offset et les mémoriser.

Suite au tutorial suivant...

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.