Veuillez ne pas poster ICI. En cas de problème allez sur Au Secours ! Merci

SOMMAIRE :

Introduction

Niveau 1
1 - Créer son premier scrïpt
2 - Evènements et Etats

Niveau 2
3 - Les Variables et Opérateurs
4 - Les Boucles et Gestions du Temps

Niveau 3
5 - Les prims au pays des scrïpts...
6 - Les Permissions (Garde à vous !)


Introduction :

Tout d'abord bonjour et bienvenue au Cours de scrïpt.

Le cours se déroulera selon deux axes :

- Un axe Théorique via des Notecard (comme celle-ci)
- Un axe Pratique ou vous mettrez en application ce que l'on aura vu en théorie.

La Discipline est simple :

Si vous avez une question poser la moi par IM. Cela évitera de polluer le Chat inutilement. Et me permettra de terminer mon explication sans quelle soit coupée...


----------------------------------


Maintenant passons aux choses sérieuses...

Qu'est ce que le LSL : Le LSL (Linden scrïpting Language) est le langage de programmation des scrïpts de Second Life. C’est un mélange de JAVA et langage C.

Un scrïpt dans Second Life est une série d’instructions placées dans un « Prim » (objet simple) qui va permettre d’animer un Objet ou un Avatar et d’interagir avec lui. Le Prim ainsi créé peut être porté par l’Avatar ou posé sur le sol si vous y êtes autorisé (construction autorisée).

Le point essentiel avec le LSL c’est que ce langage ce base sur des « Etats ».
Par exemple : une porte peut être ouverte ou fermée et, suivant son état, n’aura pas le même comportement et surtout nous interagirons avec elle différemment. En LSL c’est pareil.

Voilà pour l'histoire, alors si vous êtes prêt pour devenir Enchanteur alors passons à la suite...

--Message edité par Mathew Cazalet le 2007-06-07 17:24:53--

1 - Créer son premier scrïpt :

Il y a 3 manières de créer un scrïpt :

1. Faites un clic droit sur le sol, et choisissez "Créer" dans le menu radial. Un cube va apparaître ainsi que la fenêtre "Edition". Cliquez sur le bouton "Plus >>" puis choisissez l'onglet "Content" et cliquez sur le bouton "Nouveau scrïpt". La fenêtre de l'éditeur devrait alors s'ouvrir.

2. Cliquez sur Construire en bas à coté de l’inventaire et la fenêtre Edition devrait apparaitre, cliquez sur le sol, un cube apparaît. Cliquez sur le bouton "Plus >>" puis choisissez l'onglet "Content" et cliquez sur le bouton "Nouveau scrïpt". La fenêtre de l'éditeur devrait alors s'ouvrir.

3. Faites un clic droit sur un répertoire de votre inventaire et choisissez "Nouveau scrïpt". Double cliquez sur le fichier de scrïpt qui est apparut et la fenêtre de l'éditeur devrait alors s'ouvrir.

4. Créez votre scrïpt dans un éditeur externe puis copiez/collez le dans SL selon l'une des méthodes ci dessus.


Dans le cadre de ce cours nous allons passer par les manières 1 ou 2. L’intérêt de ce cours est de faire quelque chose d’interactif et de pouvoir voir au fur et a mesure l’évolution du scrïpt. Or, le scrïpt n’est actif que lorsqu’ il est lié à un Objet. Donc …


----------------------------------

Alors voici la première surprise : « J’ai créé mon objet et mon scrïpt et du code LSL est apparu tout seul comme un grand dans mon Editeur ». Ne paniquez pas, ceci est normal. C’est en fait une aide de départ pour créer vos scrïpt.

Il ressemble à cela :

default
{
   state_entry()
   {
   llSay(0, "Hello, Avatar!");
   }

   touch_start(integer total_number)
   {
   llSay(0, "Touched.");
   }
}

Nous allons décortiquer ce petit scrïpt.

Il est composé de 1 Etat (default), 2 Evènements (state_entry() et touch_start()) et 2 fonctions (llSay())

Nous allons les voir individuellement.

Etat ou State :

Tout d'abors un scrïpt contient toujours un Etat "default"

noté :

default
{
   //Instructions
}


Comme son nom l'indique un état est une situation du scrïpt. Seulement 1 état peut être actif a la fois (une porte peut être ouverte ou fermée pas les deux… au pire elle est peut être à moitié ouverte mais c’est un 3ème état alors).
A l’exception de l’état « default » tous les autres états doivent commencer par "state" suivi du nom de l’état.
Un état est toujours délimité par deux accolades { }. Tant que nous sommes entre elles nous sommes dans l'état.
Nous verrons plus loins comment passer d'un état a un autre.

Exemple d'un autre état (le nom est arbitraire) :

state suite
{
   //Instructions
}


Evènement ou Event :

Un état contient toujours un évènement sinon il sert a rien...

noté :

    évènement()
    {
        //Instructions
    }

Comme son nom l'indique, un évènement est quelque chose qui va déclencher une action.
Les évènements sont situés à l’intérieur et exclusivement a l'intérieur des états.
Comme pour les états, un évènement est délimité par deux accolades.


Fonctions ou Functions :  

Un évènement contient toujours une fonction sinon il sert a rien...

noté :

    fonction(paramètres);   // sans oublier le ; en fin de fonction

Les fonctions sont écrites dans et uniquement dans les évènements.
Elles sont soit prédéfinies dans le LSL soit créées par vous.
Les fonctions prédéfinies commencent toutes par « ll ».
Nous aborderons plus tard la création de fonctions.

Pour résumer voici un schéma du squelette d'un scrïpt:

state etat1
{
   évènement1()
   {
        fonction1();
        fonction2();
   }
   évènement2()
   {
        fonction3();
        fonction4();
   }
}
state etat2
{
   évènement3()
   {
        fonction5();
        fonction6();
   }
   évènement4()
   {
        fonction7();
        fonction8();
   }
}
----------------------------------------

Maintenant nous allons voir comment fonctionne le petit scrïpt du début qui est apparu tout seul... vous vous souvenez ?

A présent suivez moi bien car je me transforme en M. scrïpt...

[
-Ah chouette on cherche a m'étudier...
-alors le scrïpteur ma sauvegardé ou réinitialisé : je rentre dans l'état default...
-Oh y'a pas grand monde là dedans... Ah si y'a un évènement state_entry() ; si je me souviens bien, je viens de rentrer dans default donc elle me concerne...
-Hop je rentre dedans... Que vois-je une fonction llSay(0,"Hello Avatar!"); alors je dis "Hello Avatar!" sur le canal 0 (le chat) et puis c'est tout
-Tiens je viens de voir un autre évènement touch_start(integer total_number) mais tant que l'utilisateur ne clique pas sur l'objet je ne suis pas intéressé...
-Mais qu'est ce qui se passe ; l'utilisateur viens de me cliquer dessus ; alors je vais voir touch_start(integer total_number) et dedans il y a llSay(0,"Touched!"); alors je dis "Touched!" sur le chat.
]

Voilà ce qui se passe dans votre scrïpt

Maintenant vous allez me dire : « Mais m’sieur, je ne suis pas devin, j’ai pas le vocabulaire LSL dans le sang… et encore moins la syntaxe » et là je vous répondrais : « Tanpis,…. Lol ».

En fait l’éditeur de scrïpt sous SL est intelligent (et oui c’est possible) ; en bas à gauche de l’éditeur il y une liste déroulante avec tout le vocabulaire du LSL.

Ensuite lorsque vous saisissez des mots qui sont des commandes LSL, les mots changent de couleur et ce en fonction de leur type (Attention à respecter la casse)…

Enfin, comme vous avez pu le constater avec llSay(...) ou touch_start(...); certaines fonctions ou évènements ont besoin d’arguments entre les parathèses. Pour les connaitre, laissez votre curseur sur un mot dans le scrïpt et une bulle d’aide s’ouvrira pour vous donner les arguments et leur format respectif pour que le mot soit utilisé correctement.
Pour les fonctions, il faut lui donner des paramètres.
Pour les évènement, il suffit de recopier ce qu'il y a dans la bulle.
Pourquoi ? Ben les fonctions ont besoin de paramètres pour fonctionner alors que les évènements renvoient des infos ou paramètres.

Voilà c'est fini et surtout n’oubliez pas de sauvegarder votre scrïpt pour qu’il prenne effet sans oublier de vérifier la case Running en bas a gauche de l’éditeur…

--Message edité par Mathew Cazalet le 2007-04-25 14:25:12--

2 - Evènements et Etats :

Nous allons commencer par travailler sur les évènements pour voir les différences et surtout quand ils s’appliquent…

Voici la liste des évènements nécessaires pour réaliser le scrïpt.

state_entry : lu quand vous entrez dans un état
on_rez : lu quand un objet apparait physiquement
touch_start : lu quand l’objet est touché
state_exit : lu quand vous sortez d’un état
listen : lu quand une message est écrit

Voici la liste des fonctions nécessaires pour réaliser les scrïpts de ce chapitre.

llSay : Parler à tout le monde sur le canal choisi (20 mètres de rayon).
llWhisper : Parler à tout le monde sur le canal choisi (10 mètres de rayon)
llShout : à tout le monde sur le canal choisi (100 mètres de rayon)
Le canal pour le chat est 0… Et oui cela signifie que vous pouvez parler sur d’autres canaux. A quoi ça sert ? Ben simplement à ce que des objets puissent parler entre eux sans utiliser le chat…
llOwnerSay : Parle uniquement au propriétaire de l’objet
llListen : démarre l'écoute du canal sélectionné (pour écouter tout le monde, llListen(0, "" ,NULL_KEY, "") ; pour écouter uniquement le propriétaire : llListen(0, "" ,llGetOwner(), "")
state : appel un autre état.

Je ne vous ai pas donné la syntaxe car vous savez normalement comment la trouver maintenant… (petit rappel : laissez votre souris sur l'élément dans l'éditeur)

Nous allons prendre un scrïpt complètement vide pour faire ces exercices...

Exercice 1 :

Le scrïpt doit :

- Dire à tout le monde quand il est réinitialisé ou Sauvegardé "state_entry"
- Dire à tout le monde quand il est touché "touch_start"

Comment faire :

- Créer un état default
- dans cet état créer deux évènements state_entry et touch_start convenablement paramétrés
- dans ces évènements mettre les fonctions appropriées llSay convenablement paramétrées


Exercice 2 :

Le scrïpt doit :

- Dire à tout le monde quand il est réinitialisé ou Sauvegardé « default state_entry »
- Dire à tout le monde quand il est touché « default touch_start » et qui aille dans un autre état nommé « suite »
- Dire au propriétaire quand il entre dans l’état « suite » :  « suite state_entry »
- Dire à tout le monde quand il est par la suite touché « suite touch_start »

Comment faire :

- Créer un état default et un état suite
- dans ces états créer deux évènements state_entry et touch_start convenablement paramétrés
- dans ces évènements mettre les fonctions appropriées llSay ou llOwnerSay convenablement paramétrées
- dans l'évènement touch_start de l'état default appeler l'état suite.


Exercice 3 :

Le scrïpt doit :

- Dire à tout le monde quand il est réinitialisé ou Sauvegardé « default state_entry »
- Dire à tout le monde quand il est touché « default touch_start » et qui aille dans un autre état nommé « suite »
- Dire au propriétaire quand il entre dans l’état « suite » :  « suite state_entry »
- Dire à tout le monde quand il est par la suite touché « suite touch_start »
- Et enfin qui revienne à l’état default lorsque le propriétaire tape du texte dans le chat…

Comment faire :

- Créer un état default et un état suite
- dans ces états créer deux évènements state_entry et touch_start convenablement paramétrés
- dans ces évènements mettre les fonctions appropriées llSay ou llOwnerSay convenablement paramétrées
- dans l'évènement touch_start de l'état default appeler l'état suite.
- dans l'évènement state_entry de l'état suite, lancé l'action d'écouter llListen convenablement paramétrée
- dans l'état suite créez l'évènement listen convenablement paramétré
- dans cet évènement appeler l'état default.


Exercice 4 :

Le scrïpt doit :

- Dire à tout le monde quand il est retiré de SL puis remis dans SL (via l’inventaire « default on_rez »
- Dire à tout le monde quand il est réinitialisé ou Sauvegardé « default state_entry »
- Dire au propriétaire quand il est touché « default touch_start » et qui aille dans un autre état nommé « suite »
- Dire au propriétaire quand il entre dans l’état « suite » :  « suite state_entry »
- Dire à tout le monde quand il est par la suite touché « suite touch_start »
- Et enfin qui revienne à l’état default lorsque le propriétaire tape du texte dans le chat après avoir été touché…

Comment faire :

- Créer un état default et un état suite
- dans ces états créer deux évènements state_entry et touch_start convenablement paramétrés
- dans ces évènements mettre les fonctions appropriées llSay ou llOwnerSay convenablement paramétrées
- dans l'évènement touch_start de l'état default appeler l'état suite.
- dans l'évènement touch_start de l'état suite, lancé l'action d'écouter llListen convenablement paramétrée
- dans l'état suite créez l'évènement listen convenablement paramétré
- dans cet évènement appeler l'état default.
- dans l'état default créez un évènement nommé on_res avec à l'intérieur l'action approprié.


Voilà c’est fini pour ce petit travail. Maintenant vous êtes capable d’interagir avec un objet et connaissez les éléments clés d’un scrïpt…

--Message edité par Mathew Cazalet le 2007-04-25 14:24:53--

3 - Les Variables et Opérateurs :


En LSL il existe 8 types de variables :

Float = nombre décimal compris entre 1.175494351E-38 et 3.402823466E+38

Integer = nombre entier compris entre -2 147 483 648 et +2 147 483 647

Key = c’est une série de caractère (0-9 a-z) qui est unique a chaque élément de SL que ce soit objet ou avatar… il permet de parler d’une seule et unique chose dans SL (exemple : "a822ff2b-ff02-461d-b45d-dcd10a2de0c2")

List = comme son nom l’indique, c’est une liste du type : [0,1,2,3,4] ou ["Oui","Non","Peut-être"], [1,14.154,"Génial?",<0,0,0>]

Quaternion et Rotation = ce sont des outils pour la 3D que nous verrons plus tard : <0,0,0,0>

String = c’est une phrase délimité par des guillemets (ex : "Hello Avatar!")

Vector = c’est une variable composé de 3 axes x,y,z (ex : <1.0, 2.0, 3.0>)

Pour pouvoir utiliser une variable il faut obligatoirement la déclarer. C'est à dire définir le type de la variable.

Exemple :

llSay(0,phrase) ;
Le scrïpt emettra une erreur car phrase doit être défini avant utilisation

string phrase;
llSay(0,phrase) ;

Là vous avez le droit d'utiliser la variable phrase car elle est déclarée.


Integer nombre=10 ;
llSay(0,nombre) ;
Là, le scrïpt retournera une erreur. Pourtant la variable est déclarée mais son type n'ai pas adapté a la fonction llSay.
En effet la fonction llSay veut une phrase (string) en paramètre pas un nombre (integer)!!!

Il va donc falloir faire une conversion. Pour convertir une variable il suffit de lui écrire devant et entre paranthèse le type voulu :

Integer nombre=10 ;
llSay(0,(string)nombre) ;

Ici nombre est toujours un Integer mais (string)nombre est une phrase (string)

Si le type est incompatible le résultat sera nul :

string phrase = "test";
llSay(0,(string)(integer)phrase);
Ici, la conversion de "test" en un nombre entier (integer) donne 0 puis la conversion de ce nombre entier en texte donne "0".


Autre exemple :

String phrase = "[1,2,3,4]";
List liste=[];
liste = (list)phrase ;   //assigne (list)phrase à la variable liste.

Par contre si phrase= "1,2,3,4" alors ce n’est plus une liste potentielle (il manque [ et ])… Et oui il faut respecter la mise en forme sinon vous aurez un résultat nul, il en va de même avec les vecteurs <x,y,z> et les < et >.

Toutes variables doit être déclarées avant utilisation mais là encore il existe deux types de variable.
Les variables globales qui sont toujours valables et les variables Locales valables uniquement dans un évènement.

Les variables Locales sont déclarées dans l’évènement tandis que les variables Globales sont déclarées en début de scrïpt avant default (sans oublier le ; après).

Exemple :

string variable_globale;

default
{
  state_entry()
  {
      string variable_locale;
      llSay(0, variable_locale); // tout ce passe bien car tout est déclaré.
      llSay(0, variable_globale);
  }

  touch_start(integer total_number)
  {
      llSay(0, variable_globale);
      llSay(0, variable_locale);  //Erreur !!! cette variable n'est pas déclaré. Elle n'existe pas dans cet évènement.
  }
}

}

En d'autre termes lorsque vous sortez d'un évènement toutes les variables qui ne sont pas globales sont détruites en emportant avec elles leurs valeurs...
Alors quel est l'intérêt des variables locales ? C'est juste qu'il permet au scrïpt de tourner plus vite et d'avoir moins de choses a garder en mémoire c'est tout. En effet lors d'un retour dans l'inventaire vos variables globales ainsi que leurs valeurs restent.


-------------------------------------------------------------

Les Opérateurs :


A = 10, assigne 10 à la variable A
+, addition
-, soustraction
*, multiplication
/, division

A == 10, compare si A égal à 10
A != 10, compare si A différent à 10
A <= 10, compare si A est inferieur ou égal à 10
A >= 10, compare si A est supérieur ou égal à 10
A < 10, compare si A est inférieur à 10
A > 10, compare si A est supérieur à 10
A > 10 && 10 <=9, comparaison de A>10 ET 10 <= 9
A > 10 || 10 <=9, comparaison de A>10 OU 10 <= 9 ; | correspond à ALT-GR + 6

A++, incrémemente A de 1
A--, décrémente A de 1

Exemple :

A doit bien évidemment être déclaré du type correcte avant de faire des calculs sinon : "ERREUR"

A = 10 + 5 on a : A=15
A = "10" + "5" on a : A="105"
A = <1,1,1> + <1,2,3> on a A=<2,3,4> avec A.x=2 A.y=3 et A.z=4
A = 1 et A++ on a A=2 (c'est une simplification de language mais je pense qu'il vaut quand même mieux tout écrire soit A = A + 1)

A=1 et A += 2 correspond a A=1 et A= A+2 on a A = 3 (c'est une simplification de language mais je pense qu'il vaut quand même mieux tout écrire)
A=1 et A *= 2 correspond a A=1 et A= A*2 on a A = 2 (idem que précedemment)

Un dernier plus compliqué mais complet :

string A = "10";
integer B = 2;
string C = "<1,2,3>";
vector D=<1,0,0>;

D = D + (vector)C ; //on a alors D = <2,2,3>
D.x = (float)((string)B+A); //on a D.x = 210
//Au final on obtient D = <210,2,3>


Avec tous ces symbols et variables, on a bien mérité un petit exercice…

----------------------------

Nouvelle fonction : llSetText permet d’écrire quelque chose sur l’objet

Le but va être de créer un scrïpt capable de modifier à la voix certains paramètres de l’objet…

Exercice 5 :

Le scrïpt doit :

1 se mettre à écouter la voix du propriétaire quand on le touche et dise alors «J’écoute ».
2 une fois qu’il écoute répète ce qu’on lui dis.

Comment faire :

- Créer un état default
- dans cet état créer un évènement touch_start et listen convenablement paramétrés
- dans cet évènement mettre les fonctions appropriées llSay et llListen convenablement paramétrées
- dans l'évènement listen y placé un llSay convenablement paramétré


Exercice 6 :

Le scrïpt doit :

1 se mettre à écouter la voix du propriétaire quand on le touche et dise alors «J’écoute ».
2 une fois qu’il écoute répète ce qu’on lui dis.
3 écrive sur lui ce qu’on vient de lui dire (paramètre vector couleur=<1,1,1> ; et float alpha=1 globaux )

Comment faire :

- Créer un état default
- dans cet état créer un évènement touch_start et listen convenablement paramétrés
- dans cet évènement mettre les fonctions appropriées llSay et llListen convenablement paramétrées
- dans l'évènement listen y placé un llSay convenablement paramétré ainsi qu'un llSetText avec comme paramètre le message ainsi que la couleur et l'alpha définis en variables globales


Exercice 7 :

Le scrïpt doit :

1 se mettre à écouter la voix du propriétaire quand on le touche et dise alors «J’écoute ».
2 une fois qu’il écoute répète ce qu’on lui dis.
3 écrive sur lui ce qu’on vient de lui dire
4 transforme le texte en vecteur pour changer la couleur

Comment faire :

- Créer un état default
- dans cet état créer un évènement touch_start et listen convenablement paramétrés
- dans cet évènement mettre les fonctions appropriées llSay et llListen convenablement paramétrées
- dans l'évènement listen y placé un llSay convenablement paramétré
- dans l'évènement listen convertir le message en vector et assignez le à la variable globale couleur
- ensuite utilisez la fonction llSetText pour appliquer les changements.

Exercice 8 :

Le scrïpt doit :

1 se mettre à écouter la voix du propriétaire quand on le touche et dise alors «J’écoute ».
2 une fois qu’il écoute répète ce qu’on lui dis.
3 écrive sur lui ce qu’on vient de lui dire
4 transforme le texte en float pour changer alpha

Comment faire :

- Créer un état default
- dans cet état créer un évènement touch_start et listen convenablement paramétrés
- dans cet évènement mettre les fonctions appropriées llSay et llListen convenablement paramétrées
- dans l'évènement listen y placé un llSay convenablement paramétré
- dans l'évènement listen convertir le message en float et assignez le à la variable globale alpha
- ensuite utilisez la fonction llSetText pour appliquer les changements.

Attention à l’ordre des opérations si vous affectez les variables après les avoir appliquez alors vous ne verrez pas tout de suite le changement…

Voilà c’est fini pour ce petit travail. Maintenant vous êtes capable de modifier les paramètres d’un objet en lui donnant par la voix des informations et de réaliser des calculs et des opérations avec les variables.

4 - Les Boucles et Gestions du Temps :

En LSL il existe plusieurs manière de gérér le temps et d’éviter les actions répétitives
Pour cela plusieurs boucles qui se place dans les évènements existent :

for (A = 0 ; a < 10 ; A = A + 2) { //instructions } : est une boucle qui va se répeter jusqu'à se que A ne soit plus inférieur a 10 avec A qui s’incrémente de 2 après chaque exécution de la boucle.

do{  //instructions } while(continue) : est une boucle qui va se répeter tant que continue n'est pas égal a 0. L'instruction de fin est donc gérée dans la boucle

while(i--) { //instructions }: ce répète tant que i n'est pas égal à 0. Ici il n'y a pas besoin de gérer l'intruction de fin dans la boucle.

jump quelquepart; //instruction  @quelquepart; : cette sorte de boucle permet de sauter des blocs éléments par exemple lorsque qu'une condition n'est pas vérifié. Ces sauts ne sont opérationnels qu'a l'intérieur d'un même évènement ou fonction.

Voilà pour les boucles maintenant il existe une autre méthodes qui gère le temps mais qui peut être utilisée comme une boucle :
La fonction llSetTimerEvent(float SEC); cette fonction permet de déclencher un évènement appelé timer() toutes les SEC secondes. Le déclechement ne s'arrête que si on lui ordonne par la fonction : llSetTimerEvent(0); le fait de mettre SEC à 0 achève le redondance dans le temps de l'évènement.

Voilà c'est tout pour ce petit cours...

Avec tous ces quelques nouveaux acquis, on a bien mérité un petit exercice…


-------------------------


Le but va être de créer un scrïpt capable de modifier un paramètre de l'objet au cours du temps et bien évidemment de le voir évoluer...

Nouvelle fonction : ben aucune mis a part celle du dessus.

Exercice 9 :

Le scrïpt doit :

1 se mettre à écouter la voix du propriétaire quand on le touche et dise alors «J’écoute ».
2 une fois qu’il écoute répète ce qu’on lui dis.

Comment faire :

- Créer un état default
- dans cet état créer un évènement touch_start et listen convenablement paramétrés
- dans cet évènement mettre les fonctions appropriées llSay et llListen convenablement paramétrées
- dans l'évènement listen y placé un llSay convenablement paramétré


Exercice 10 :

Le scrïpt doit :

1 se mettre à écouter la voix du propriétaire quand on le touche et dise alors «J’écoute ».
2 une fois qu’il écoute répète ce qu’on lui dis.
3 écrive sur lui la valeur d'une variable global qui est un integer et qui est égale à 200

Comment faire :

- Créer un état default
- dans cet état créer un évènement touch_start et listen convenablement paramétrés
- dans l'évènement touch_start mettre les fonctions appropriées llSay et llListen convenablement paramétrées
- dans l'évènement listen y placé un llSay convenablement paramétré ainsi qu'un llSetText avec comme paramètre la variable globale integer ainsi que la couleur et l'alpha définis en variables globales


Exercice 11 :

Le scrïpt doit :

1 se mettre à écouter la voix du propriétaire quand on le touche et dise alors «J’écoute ».
2 une fois qu’il écoute répète ce qu’on lui dis.
3 écrive sur lui la valeur d'une variable global qui est un integer et qui est égale à 200
4 commence un décompte via un boucle For de 200 a 100 en l'affichant au fur et a mesure sur lui quand on lui clic dessus

Comment faire :

- Créer un état default
- dans cet état créer un évènement touch_start et listen convenablement paramétrés
- dans l'évènement touch_start mettre les fonctions appropriées llSay et llListen convenablement paramétrées
- dans l'évènement listen y placé un llSay convenablement paramétré ainsi qu'un llSetText, avec comme paramètre la variable globale integer ainsi que la couleur et l'alpha définis en variables globales, pris dans une boucle for.


Exercice 12 :

Le scrïpt doit :

1 se mettre à écouter la voix du propriétaire quand on le touche et dise alors «J’écoute ».
2 une fois qu’il écoute répète ce qu’on lui dis.
3 écrive sur lui la valeur d'une variable global qui est un integer et qui est égale à 200
4 commence un décompte toutes les secondes en l'affichant au fur et a mesure sur lui quand on lui clic dessus
5 recommencer a l'étape un si on lui clic dessus.

Comment faire :

- Créer un état default
- dans cet état créer un évènement touch_start et listen convenablement paramétrés
- dans l'évènement touch_start mettre les fonctions appropriées llSay et llListen convenablement paramétrées et remettre la variable globale à 200
- dans l'évènement listen y placé un llSay convenablement paramétré ainsi qu'un llSetText, avec comme paramètre la variable globale integer ainsi que la couleur et l'alpha définis en variables globales, pris dans une boucle for.


Attention à l’ordre des opérations…

Voilà c’est fini pour ce petit travail. Maintenant vous êtes capable de modifier un objet au cour du temps.

--Message edité par Mathew Cazalet le 2007-04-25 16:59:02--

5 - Les prims au pays des scrïpts...

En LSL il existe tout est possible où presque...

Nous allons voir pour ce cours la modification des prims et leur déplacements dans l'espace.

Voici un tableau récapitulant toutes les infos que l'on peut récupérer et donc modifier avec des scrïpts (il est en anglais mais simple a comprendre) :



Pour récupérer des données utilisez la fonction : llGetPrimiveParams(list paramètres query);
Pour modifier, llSetPrimitivParams(list paramètres result).

Bien évidement, en général on se sert des fonctions alternatives mais essayez de vous amuser avec, vous verrez, avec un peu d'imagination on peut builder sans toucher au prim...

Voilà c'est tout pour ce petit cours...

Avec tous ces nouveaux acquis, on a bien mérité un petit exercice…


-------------------------


Le but va être de créer une aiguille d'horloge qui tourne avec le temps...

Nouvelle fonction : ben aucune mis a part celle du dessus. llSetRot(), llGetRot(), llGetTimestamp( ) et llGetObjectName;

Les conditions :

if (truc == machin)
{
//si oui fait ça...;
}
else
{
//si non fait ça (else est optionnel);
}


Exercice 13 :

Le scrïpt doit :

1 extraire les secondes du Timestamp
2 Si on touch l'aiguille elle se met a suivre les secondes en tournant.
3 Si on reclic dessus elle revient à 0° = 0 seconde


Comment faire :

- a vous de me le dire à présent...


Exercice 14 :

Le scrïpt doit :

1 extraire les heures minutes et secondes du Timestamp
2 Si on touch l'aiguille elle se met a suivre les secondes ou les heures ou les minutes en tournant (Le choix sa fait via le nom de l'objet).
3 Si on reclic dessus elle revient à 0° = 0 seconde minute ou heure


Comment faire :

- a vous de me le dire à présent...

Voilà c’est fini pour ce petit travail. Maintenant vous êtes capable de modifier physiquement un prim au cour du temps.

--Message edité par Mathew Cazalet le 2007-05-04 13:58:12--

6 - Les Permissions (Garde à vous !)…

Nous allons voir pour ce cours les permissions et plus particulièrement la permission contrôles.

Voici un tableau récapitulatif des permissions pouvant être demandées (il est en anglais mais simple a comprendre) :



Pour demandée une permission il suffit d'utiliser la fonction : llRequestPermissions(nom de la permission );
Une seule permission peut être demandée par scrïpt !!!

Pour récupérer la réponse il suffit d'aller à l'évènement  "run_time_permissions()"


exemple :

default
{
   state_entry()
   {
       llRequestPermissions(llGetOwner(), PERMISSION_TRIGGER_ANIMATION);
   }
   run_time_permissions(integer perm)
   {
       if(PERMISSION_TRIGGER_ANIMATION & perm)
       {
           llStartAnimation("nyanya");
       }
   }
}


Voilà c'est tout pour ce petit cours...

Avec tous ces nouveaux acquis, on a bien mérité un petit exercice… Attention ils sont difficiles mais si vous y arrivez sans moi alors... venez me voir on ira boire un cannon et je vous passerai les clés.... Non, je le reconnais ils sont compliqués mais tellement interactifs que je pense que vous vous amuserez longtemps avec une fois la diffculté surmonté et comprise surtout...


-------------------------


Le but va être de créer un objet qui puisse être contrôlé à distance…

Nouvelle fonction : ben aucune mis a part celle du dessus. llGetPos(), llSetPos() ;

*** Exercice 15 :

Le scrïpt doit :

1 Demander la prise de controle de l'avatar et garde en mémoire la position initiale du prim
2 Si l'avatar refuse, il doit le dire
3 S'il accepte alors les touches seront lu dans l'évènement : control()
4 En fonction des touches saisies il définie un vecteur et incrémente sa position initiale de ce nouveau vecteur et affiche au dessus de lui la nouvelle position et enfin l'applique


Comment faire :

- a vous de me le dire à présent...


*** Exercice 16 :

Le scrïpt doit :

1 idem que précedemment
2 cette fois, en faisant gauche et droite, le prim devra tourner sur lui même et bien évidement respecter cette orientation lors des autres déplacement...

Comment faire :

- a vous de me le dire à présent...


Voilà c’est fini pour ce petit travail. Maintenant vous êtes capable de réaliser de pseudo véhicule et surtout vous modifierez des prim au cour du temps.