Hello, Avatar!

Second Life et Programmation Créative

Aller au contenu | Aller au menu | Aller à la recherche

Keyword - LSL Assez Facile

Fil des billets - Fil des commentaires

Lire une notecard avec LSL : faciiile...

Il arrive souvent qu'un script contienne une palanquée de variables globales, initialisées avec des valeurs par défaut, utilisées afin d'éviter de parsemer son code de ce qu'on appelle des magic numbers.

Les variables globales sont utilisées pour stocker des valeurs-clé qui serviront tout le long du script. Il peut s'agir, par exemple, du numéro de canal utilisé pour communiquer entre plusieurs prims, de la vitesse maximale d'un véhicule, de la couleur donnée à un élément... etc...

Lire la suite...

Téléportation s'il vous plaît !

[00:45] Forest's friend - Forest, t oqp la ?
[00:46] Forest - ZZZzzzz... hein ? non, non pas du tout je range mon inventaire !
[00:46] Forest's friend - tu pourrais venir aider un pote a configurer un teleport pour son magasin ?
[00:46] Forest - ok, tu me tp ?


J'ai toujours utilisé des téléporteurs un peu partout, sans m'être jamais penché sur la problématique du problème... Mais ça ne doit pas être bien compliqué.

Arrivée dans le magasin, ou se trouve la copine, avec son pote. J'ai dit Magasin ? Au vu la taille du bâtiment, on pourrait carrément parler de galerie commerciale... Le pote en question me montre une boîte noire, mais sans documentation, avec juste un script no copy no modify à l'intérieur.

Bref, sans possibilité de visualiser le script, et sans explications, le téléporteur est unutilisable.


[00:50] Forest's friend - autant en fabriquer un
[00:50] Forest's friend's pote - cool, je te paye si tu veux


Mhh, l'ennui, c'est que j'ai jamais fabriqué de téléporteur de ma (seconde) vie. Et je vais pas faire payer le copain d'une copine... Si on est là pour jouer, alors jouons !


[00:50] Forest - vais voir si j'ai des scripts de tp en cuisine...

Lire la suite...

Jet de dé (pauvre Newton)

L'esprit inventif des frères Linden ne connait pas de limites. Déja, les prims transparents sur un seul côté, c'était pas mal.

Mais le moteur de physique, bonjour... Jugez-vous même : ce gros dé a tout de même trouvé le moyen de retomber en équilibre sur une arête :

de.png

Et ce, devant témoins. Vous entendez ce bruit ? C'est Newton qui se retourne dans sa tombe.

Script pour faire bondir un dé

Un simple prim cube suffira, si vous n'avez pas de dé. Faites-le de taille X=.5, Y=.5,. Z=5.

Quand on touche le dé, ce script le fait bondir en l'air, puis le laisse retomber après l'avoir fait tourner.

Si plusieurs dés sont présent et portent le même nom, ils sauteront également !

// Ce script fait sauter un dé en l'air, et le fait tourner quand on le touche
// Si plusieurs dés sont dans un rayon de 10 mètres et portent le même nom, ils sauteront en même temps.

// max de la force appliquée pour faire tourner le dé
float gMaxRotForce = .2;

// Déviation latérale max de la force appliquée pour faire sauter le dé
float gMaxLateralForce = 1;
float gMaxUpForce = 6;
float gMinUpForce = 3;

// Canal de communication et signal envoyé aux autres dés dans les parages
integer gChannel = -41354;
string  gSignal = "JUMP!";

Hop()
{
    llSetStatus(STATUS_PHYSICS, TRUE);

    // Calcule une poussée rotative aléatoire
    float Rx = llFrand(gMaxRotForce);
    float Ry = llFrand(gMaxRotForce);
    float Rz = llFrand(gMaxRotForce);
   
    // Calcule une force aléatoire qui poussera le dé vers le haut
    float Px = llFrand(gMaxLateralForce);
    float Py = llFrand(gMaxLateralForce);
    float Pz = (llFrand(gMinUpForce) + gMaxUpForce - gMinUpForce) * llGetMass();

    llApplyImpulse(<Px, Py, Pz>, FALSE);
    llApplyRotationalImpulse(<Rx, Ry, Rz> * llGetMass(), TRUE);
}

default
{
    state_entry()
    {
        llSetStatus(STATUS_BLOCK_GRAB, TRUE);
        llSetStatus(STATUS_PHYSICS, TRUE);
        llListen(gChannel, llGetObjectName(), NULL_KEY, gSignal);
    }

    touch_start(integer count)
    {
        Hop();
        llSay(gChannel, gSignal);
    }
   
    listen(integer channel, string name, key id, string message)
    {
        Hop();
    }
}
  • Si le dé ne saute pas, vérifiez si par hasard s'il ne chevauche pas un autre objet, ou s'il n'est pas enfoncé dans le sol : sortez-le de là, puis touchez-le à nouveau ou réinitialisez le script.
  • Pour créer des groupes de dés, donnez-leur des noms différents.

Si vous voulez un vrai dé beau comme tout avec des coins arrondis, vous le trouverez ici pour une misère, tout modifiable et copiable à volonté avec le code source disponible.

Fabriquez une belle lampe qui marche !

lampes.png

Aujourd'hui, petit tuto sur la réalisation d'une belle lampe. Mais attention... pas n'importe quoi ! Parce qu'on va la munir d'un interrupteur variable, comme les vraies.

Comment faire ?

Il nous faut :

  • Une lampe (ou plusieurs...);
  • Un interrupteur.

On va commencer par fabriquer la lampe, avec dedans un petit script qui va servir à faire varier son intensité en fonction des signaux reçus de l'interrupteur.

La lampe...

Vous pouvez donner à votre lampe l'apparence qui vous convient. Je vais tout de même vous guider pas à pas pour construire une petite lampe de jardin cylindrique pas trop vilaine en deux prims : le pied, et la partie lumineuse.

Pour faire le pied de la lampe :

  • Rezzez un simple cube;
  • Dans l'onglet objet, changez le type de bloc de construction en Cylindre;
  • Donnez à ce cylindre la taille suivante : X=0.250, Y=0.250, Z=2.000;
  • Remontez légèrement ce cylindre de façon à ce qu'il ne reste pas planté dans le sol...;
  • Changez la texture de ce cylindre en Vierge via l'onglet Texture. Donnez-lui une couleur gris métal et une brillance élevée;

A ce stade, votre réalisation devrait ressembler à peu près à ceci :

step1.png

Maintenant, la partie lumineuse :

  • Faites une copie du pied de la lampe :
    • Appuyez sur shift, gardez le doigt dessus...;
    • Tout en maintenant cette touche enfoncée, faites-le remonter via l'axe des Y (flèche bleue du haut) suffisamment haut pour qu'un deuxième cylindre apparaisse, aligné au dessus de l'autre;
    • Lâchez la touche shift. Voilà !
  • Donnez à cette nouvelle partie la taille suivante : X=0.260, Y=0.260, Z=0.750;
  • Changez la texture de cette nouvelle partie en Vierge, à l'aide de l'onglet Texture, puis donnez lui une couleur jaune pâle;
  • Dans l'onglet Attributs, Activez la case Lumière, puis donnez les valeurs Rayon=20.00, Fallof=0.000. La propriété Intensité n'a pas d'importance pour le moment.
  • Descendez ce prim sur le pied de la lampe à la hauteur qui vont convient !

Voilà, vous y êtes presque :

step2.png

A présent, créez un nouveau script dans la partie lumineuse, et copier/coller-y le code suivant :

// Lampe - Auteur: http://lslblog.free.fr

// Canal de communication entre l'interrupteur et la lampe
integer gCanal = -1500;

// Adresse d'écoute de l'interrupteur
integer gListener;

// Donne à la lampe l'intensité lumineuse passée en paramètre
AllumeLampe(float intensite)
{
    llSetPrimitiveParams([PRIM_POINT_LIGHT] + llListReplaceList(llGetPrimitiveParams([PRIM_POINT_LIGHT]), [intensite], 2, 2));
}

default
{
    state_entry()
    {
        // Active l'écoute de l'interrupteur
        gListener = llListen(gCanal, "", NULL_KEY, "");
    }
   
    // Ecoute et analyse les messages reçus
    listen(integer channel, string name, key id, string message)
    {
        AllumeLampe((float) message / 100.);
    }
}

Voilà, la lampe est prête à fonctionner. Il nous faut à présent fabriquer l'interrupteur.

L'interrupteur ! L'interrupteur !

Pour le fabriquer, un prim suffit amplement. Il faudra simplement toucher ce prim pour faire varier la luminosité de la lampe.

  • Rezzez un prim, donnez lui la taille et l'apparence que vous voudrez;
  • Ajoutez un nouveau script à ce prim, et copier/collez à l'intérieur le code qui suit :
// Lampe - Auteur: http://lslblog.free.fr

// Canal de communication entre l'interrupteur et cette lampe
integer gCanal = -1500;
integer gIntensite;

default
{
    // Quand on touche, on fait varier l'intensité lumineuse...
    touch(integer count)
    {
        gIntensite += 25;
        if (gIntensite > 100)
            gIntensite = 0;

        // On affiche l'intensité de l'éclairage
        llSetText("Luminosite: " + (string) gIntensite + "%", <0,0,1>, 1);

        // ... et on envoie l'information à toutes les lampes à 100 mètres à la ronde
        llShout(gCanal, (string) gIntensite);
       
        llSetTimerEvent(2);
    }    
   
    // Ce timer ne sert qu'à effacer l'intensité affichée au bout de deux secondes
    timer()
    {
        llSetText("", <0,0,0>, 1);
        llSetTimerEvent(0);
    }
}

Je crois que c'est tout bon, vous voilà fin prêt !

Et maintenant ?

Faites un test : forcez le soleil en mode Minuit (Monde / Forcer le soleil / Minuit), puis touchez l'interrupteur plusieurs fois.

lampes.png

C'est beau, non ? (Oui : le gros truc orange, c'est l'interrupteur : j'avoue que je ne me suis pas foulé...)

A présent, vous pouvez lier la lampe et son pied, la copier autant de fois que vous le souhaitez et agrémenter ainsi vos extérieurs !

Vent et primitives flexibles...

bettyhouse.png Lorsqu'on veut créer un objet flexible, bercé par le doux vent de SL, on est soumis aux caprices de celui-ci, notamment à ses changements de direction.

Bettyboop Bingyi, créatrice de talent, et accessoirement co-propriétaire de l'île France Pittoresque en a fait les frais : en accrochant un rideau composé d'un prim flexible texturé pour séparer deux pièces d'une splendide maison japonaise (voir snapshot), elle a remarqué que le vent SL donnait à celui-ci un aspect et un mouvement quelque peu bizarre, du fait de son caractère complètement aléatoire.

BettyBoop voudrait bien que son rideau ondule doucement, animé par un vent d'intensité variable qui souffle toujours dans la même direction !

L'idée... ?

Le principe est le suivant :

  • Annuler les effets du vent SL (mettre 0 au parametre Vent des attributs flexibles);
  • Exercer une force dans une direction constante, mais d'une intensité aléatoire, donc qui varie au cours du temps.

Le script !

ChangeIntervalleTimer()
{
    llSetTimerEvent(llFrand(.5) + .5);
}

// Le vent souffle sur un vecteur dont l'intensité varie entre -.1 et +.1
// Ici, il est perpendiculaire à l'axe des X du prim.
// En supposant que le rideau de Bettyboop a été créé à partir d'un cube qu'on aura "aplati" sur l'axe des X, c'est à dire dont la taille X=0.010
vector Vent()
{
    return <1, 0, 0> * llGetRot() * (llFrand(.2)-.1);
}

default
{
    state_entry()
    {
        // Change la force du vent tout les .5 à 1 secondes au hasard...
        ChangeIntervalleTimer();
    }
   
    timer()
    {
        list PrimParams = llGetPrimitiveParams([PRIM_FLEXIBLE]);

        llSetPrimitiveParams([PRIM_FLEXIBLE] + llListReplaceList(PrimParams, [Vent()], 6, 6));

        ChangeIntervalleTimer();
    }
}

Une petite précision : le script agit sur les paramètres "Force" des attributs flexible du prim : il faut garder à l'esprit que ceux-ci ne sont pas locaux, mais globaux contrairement à ce que je supposais, ce qui m'a valu une bonne migraine.