Hello, Avatar!

Second Life et Programmation Créative

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

Keyword - llSetTimerEvent

Fil des billets - Fil des commentaires

Jour, nuit, jour, nuit...

ampoule.pngCatherine Pfeiffer a envoyé un petit script via le groupe Constructeurs et Scripteurs : c'est un script qui allume et éteint une ampoule en fonction de l'heure qu'il est.

Catherine m'a expliqué qu'il était plus précis de se baser sur l'horloge SL plutôt que sur la position du soleil. C'est surtout bien plus simple, et ça permet de découvrir llGetGMTclock. Notez que l'emploi de llSetPrimitiveParams est nécessaire pour changer les attributs de luminosité.

// This script is licensed under GPL license version 2
//
// In short: feel free to redistribute and modify it, as long as
// any copies of it can be redistributed and modified as well.
//
// The official text of the licence is available at
// http://www.gnu.org/licences/gpl.html
//
// (c) The owner of Avatar Catherine Pfeffer, 2006-2007

integer old_value = -1;

// Set the light
setLight()
{
    integer time;
    integer value;

    time = (integer) llGetGMTclock();
    time = time % 14400;                // 4 hours is the length of the day

    if (8700 < time && time < 12900)    // night is between 2:30 and 3:30 GMT
        value = 0;
    else value = 1;

    if (value != old_value)
    {
        old_value = value;
        if (value == 0)
        {                              // night: switch on
            llSetPrimitiveParams( [ PRIM_FULLBRIGHT, ALL_SIDES, TRUE ] );
            llSetPrimitiveParams( [ PRIM_POINT_LIGHT, TRUE,
              <1, 1, 0>, 1.0, 20.0, 0.75 ] );
        }
        else
        {                              // day: switch off
            llSetPrimitiveParams( [ PRIM_FULLBRIGHT, ALL_SIDES, FALSE ] );
            llSetPrimitiveParams( [ PRIM_POINT_LIGHT, FALSE,
              <1, 1, 1>, 1.0, 20.0, 0.75 ] );
        }
    }    
}

// Event manager
default
{
    state_entry()
    {
        setLight();
        llSetTimerEvent(300);         // each 5 minutes
    }

    timer()
    {
        setLight();
    }
}

En gros : toutes les cinq minutes, on regarde l'heure; si on est entre 2:30 et 3:30 GMT et que la lumière est allumée, on l'éteint. Sinon, si la lumière est éteinte en dehors de cette tranche horaire, on l'allume.

Profitez-en pour aller voir le wiki naissant de ce nouveau groupe d'entraide dont je fais partie.

Construisez votre Tetris dans Second Life - Deuxième partie

Suite et fin de la première partie :

sltris2.png

Avoir un Tetris qui fait tourner une démo, c'est bien, mais à présent il faut lui ajouter la possibilité de jouer pour de bon, et c'est bien ce qu'on va faire !

Lire la suite...

Construisez votre Tetris dans Second Life - Première partie

Dans le monde des z'ordinateurs et des jeux vidéos, Tetris est connu comme le houblon.
Pourtant, à part Gint et quelques bornes d'arcades fictives qui nous redirigent vers des sites de jeux en flash, je n'ai encore pas vu de vrai Tetris en 3D dans Second Life !

Amis lecteurs, il est temps de remédier à ça : on va se retrousser les manches et fabriquer nous-même notre Tetris en 3D !

SLTRis_3D_LSLBlog_Edition.png

Lire la suite...

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.