Getting started with LSL/it

From Second Life Wiki
Jump to: navigation, search


Incominciamo a scriptare con il linguaggio LSL in Second Life

LSL sta per "Linden Scripting Language" (Linguaggio di Programmazione Linden) ed è usato per programmare gli oggetti che incontrerete e che farete in SecondLife.


A CHI E' RIVOSTO QUESTO TUTORIAL:

Questo tutorial è pensato per coloro che non hanno mai programmato prima, in Second Life o da altre parti. Questo tutorial ha molto poco senso al di fuori di Second Life. LSL è molto specifico per Second Life.

Comincerai facendo girare il programmino standard "ciao mondo" ed alla fine riuscirai a produrne uno scritto di tuo pugno. Devi però conoscere i principi base di Second Life e possedere le conoscenze di build di base prima di poter utilizzare a pieno questo tutorial.

Cos'è il linguaggio LSL?

LSL è il linguaggio di programmazione (scripting) Linden. Questo è il linguaggio con cui sono scritti tutti gli script in SecondLife. La struttura è basata su Java e C. Uno script in Second Life è un insieme di istruzini che possono essere messi dentro un prim, ma non dentro un avatar. Gli Avatar possono indossare oggetti scriptati. Gli script LSL sono scritti usando un editor/compilatore precostruito nel vostro viewer che vedremo nel capitolo "Come lanciare il tuo primo script".

NOTA: LSL è interpretato ed eseguito nei server di Second Life servers (chiamati sim), non nel client (Viewer). Sebbene l'editor degli script sia parte del viewer, lo script risiede nel server, che manda i risultati sulla rete al Viewer, dove alla fine li osservi.

Una cosa che rende il linguaggio LSL "speciale" è la sua enfasi sugli "Stati" e sugli "Eventi". Una porta può essere "aperta" o "chiusa" e una lampadina può essere "accesa" o "spenta". Una persona può essere "eccitata", "calma", o "annoiata". Molti comportamenti della nostra vita reale possono essere modellati attraverso degli "stati" e lo stesso vale per i programmi LSL. Uno script avrà come minimo uno stato, lo stato di "default" (o stato iniziale).

Un evento può essere pensato come un "Grilletto" o "Interruttore" qualcosa che scatta in certe condizioni predefinite. Gli Eventi non sono definibili dagli utenti in SecondLife, ma sono predefiniti. Sono fatti scattare quando gli oggetti o gli avatar interagiscono con il mondo, oppure possono essere scatenati esplicitamente dentro uno script. Gli eventi fanno scattare i gestori degli eventi (che vengono chiamati a loro volta "eventi"). Per esempio, quando un avatar tocca un oggetto, un messaggio touch_start è inviato all'oggetto, il che mette in esecuzione il gestore di eventi touch_start() che inizia a girare. Il programma minimale LSL deve avere uno stato e un gestore eventi. Ecco come appare un programma minimale scritto in LSL che a grandi linee può essere tradotto come.... "Quando sono nello stato iniziale e sono toccato, dico "Ciao Mondo" sul canale 0".


<lsl> default {

    touch_start(integer total_number)
    {
         llSay(0,"Ciao Mondo");
    }

} </lsl>

COSA POSSO FARE CON GLI SCRIPT?

Gli script possono far sì che un oggetto si muova, ascolti, parli, funzioni come veicolo oppure come un'arma, cambi colore, dimensione o forma. Uno script può fare sì che un oggetto ascolti le tue parole e te le ripeta a pappagallo, ci sono degli script che fanno parlare addirittura gli oggetti uno con l'altro.

L'oggetto più fondamentale in Second Life è il Prim (il cubo), il blocco basilare per costruire tutti gli oggetti costruibili nel mondo virtuale. Quando tanti prim sono collegati (linkati), ognuno di essi può contenere uno script che può parlare con tutti gli altri prim attraverso dei "messaggi link" (linked message). Questi sono più veloci e più privati rispetto agli oggetti che "parlano" nei canali pubblici o si inviano email. Queste comunicazioni sono oltre l'intento di questo tutorial mentre invece ci concentreremo sugli script contenuti in un unico cubo.

Scriptare è più difficile che imparare la manipolazione di base degli oggetti, ma è veramente gratificante non appena fate qualche progresso.

Se hai già costruito in Second Life, sappi che tutto quello che definisci nella finestra di edit può anche essere pilotato dagli script. Tutte le interazioni che vedi fra gli oggetti o tra avatar e oggetti avviene attraverso gli script.

Imparare di più sul mondo 3D e sul modello di building è vitale per alcuni aspetti dello scripting, per questo è raccomandabile avere delle cognizioni di base di building prima di imparare a scriptare.

Lancia il tuo primo script

Tradizionalmente si comincia sempre scrivendo il più piccolo programma possibile che scriva "Ciao Mondo". Dato che LSL gira solo all'interno di oggetti, devi conoscere come creare un oggetto e come metterci dentro uno script.

Devi essere in una terra che consenta il building. Può essere una tua terra, oppure una terra dove ti viene concesso di costruire come ad esempio una sandbox. Clicca con il tasto destro del mouse per terra e scegli create (crea) (se hai il mouse con un solo bottone del Mac devi cliccare command+click).

Di default, dovresti vedere una icona a forma di bacchetta cliccando con questa icona per terra dovresti vedere creato un cubo ai tuoi piedi.


Entrerai automaticamente nella modalità edit (modifica) e vedrai apparire la finestra di modifica. Per inserire invece uno script in un oggetto già esistente devi cliccarlo con il tasto destro del mouse e scegliere edit (modifica) per aprire la finestra di edit.

Nella finestra di edit potresti vedere un bottone marcato more>>> se lo vedessi, cliccalo per rivelare 5 linguette marcategeneral, object, features, content, e texture. Clicca su content.

Questa finestra mostra il contenuto di un oggetto che può contentere script, notecard o persino altri oggetti. Premi new script per aggiungere un nuovo script.

Questa operazione aprirà l'editor LSL con uno script iniziale. L'editor colorerà le righe dello script evidenziando la sintassi e se ti soffermi con il mouse cerca di aiutarti dandoti alcune informazioni aggiuntive. Esegue anche un rudimentale test della sintassi.

Prima di spiegare il codice, lanciamolo. Clicca save e chiudi la finestra di edit dello script. Non quella di editing dell'oggetto.

Dovresti vedere le parole "Hello Avatar" da "object"

Se tocchi l'oggetto dirà "Touched." La finestra di modifica edit di building dell'oggetto deve essere chiusa perchè il tocco funzioni.

Congratulazioni! Hai compilato e lanciato il tuo primo script LSL!

Ciclo di sviluppo

(anche noto come Lava / Asciuga / Ripeti)

Adesso abbiamo uno script che gira, ma ricorda che la maggior parte degli script che farai NON gireranno la prima volta che tenterai di lanciarli. Ci vogliono molti tentativi mentre correggi i vari errori e fai migliorie. Quando clicchi "save" su uno script, l'editor LSL "compila" il codice in qualcosa che il motore LSL possa capire. Si fermerà però se trova un errore.

Le parentesi graffe, tonde e i ";" devono tutti esssere PERFETTAMENTE messi nei posti giusti prima che uno script possa girare. Se è la prima volta che programmi questo può essere uno dei momenti che ti faranno infuriare e che ti faranno imprecare FQCTD (Fai quello che ti dico, stupido!). Una parte delle capacità richieste per programmare in QUALUNQUE linguaggio è di imparare come precisamente definire i passi e come correttamente scriverli nel linguaggio in cui stai lavorando. Perciò ti ritroverai a scrivere, lanciare, e RI-scrivere il tuo programma parecchie volte.

Lo script che scrivi va in esecuzione (gira) nel momento esatto in cui tu premi save. Se lo prendi nel tuo inventario, "sospenderà" quello che che stava facendo ma riprenderà immediatamente a farlo nel momento in cui lo rirezzi (risorge). (Se i concetti di "prendere nell'inventory", di "rezzare" un oggetto non ti sono familiari, temo che tu debba rivisitare le tue conoscenze di building :( ).

Ogni volta che ri-scrivi il tuo script, lo script si resetta (re-inizializza). Prova a resettare lo script anche nei seguenti modi:

  1. Premi "Reset" nella finestra di edit dello script.
  2. Selezionando l'oggetto e scegli Select the object and choose TOOLS>RESET SCRIPTS IN SELECTION (Strumenti->reimposta script in selezione)
  3. Se togli e rimetti l'opzione "running"
  4. Scegliendo TOOLS>SET SCRIPTS TO NOT RUNNING IN SELECTION e poi TOOLS>SET SCRIPTS TO RUNNING IN SELECTION.

Non appena ti sentirai a tuo agio con i concetti di "stop", "start", "reset" di uno script, prova a cambiare le parole "Hello Avatar" e vedere cosa altro puoi fargli dire.... Per amor di Dio mantieniti educato (non siamo in un'area adulta!)

PERCHE' FERMARE E RI-LANCIARE?

Scriptare in SecondLife è un po' come cercare di aggiustare la vostra macchina.... mentre sta correndo a 120 Km/h sull'autostrada. Devi avere dei sistemi per bloccare i programmi dato che possono influenzarsi fra di loro.

Gli oggetti possono contenere molti script e tutti partono insieme nello stesso istante. Pensate a come questo possa essere sfruttato: supponiamo che si scriva uno script che faccia cambiare colore all'oggetto ogni qualche secondo. Possiamo anche scriverne un altro che faccia sì che l'oggetto ti segua. Se li metti tutti e due insieme nell'oggetto lui ti seguirà e nello stesso tempo cambia colore!

Per amore di semplicità, gli esempi seguenti saranno tutti fatti con UN SOLO script fate quindi attenzione a non metterne più di uno dentro lo stesso oggetto.

Anatomia di "Ciao Mondo"

Diamo un'occhiata al codice iniziale.

<lsl> default {

    state_entry()
    {
        llSay(0, "Hello, Avatar!");
    }
    touch_start(integer total_number)
    {
        llSay(0, "Touched.");
    }

} </lsl>

Il codice mostrato contiene 1 stato, 2 eventi e 2 funzioni. Guardiamo attentamente ognuna di queste componenti.

Tutte le righe che iniziano con due barre sono dei commenti. Non sono operativi e servono solo ad aiutare a documentare il tuo codice.

// Questo è un commento

STATI

Uno "Stato" in LSL è una sezione che è in esecuzione, aspettando gli eventi. Ad ogni dato momento soltanto UNO stato può essere attivo per ogni script. Ogni script deve avere uno stato iniziale (default) contenente almeno un evento. Con l'unica eccezione dell'evento iniziale (default) ogni stato deve essere definito con la parola STATE seguita con il nome dello stato. Il contenuto dello stato è racchiuso fra DUE parentesi graffe una aperta e una chiusa (shift-altgr-[ e shift-alt-gr-] nelle tastiere italiane.

<lsl> default { // il contenuto dello stato va qua }

state suona { // questo è uno stato che si chiama suona } </lsl>

EVENTI

Gli eventi sono dentro gli stati. Per "dentro" si intende che stanno fra la graffa aperta e la graffa chiusa che rappresentano il corpo dello stato. Quando quello stato è attivo, questi eventi aspettano di scattare e di mettersi in esecuzione il codice definito al loro interno. Abbiamo visto "state_entry" che scatta quando il programma inizia o viene resettato, e "touch_start" che scatta quando qualcuno tocca l'oggetto.

Guardiamo il codice "iniziale" (New Script).

<lsl> // Lo script inizia default {

    touch_start(integer total_number)  // questo è un evento
    {
    // questo è il contenuto dell'evento (fra parentesi graffe)
    }

} // fine dello stato iniziale (default) </lsl>

FUNZIONI

Le funzioni stanno dentro gli eventi e sono di due tipi: quelle definite da te oppure quelle predefinite. Tutte quelle predefinite cominciano con una doppia l. Abbiamo visto finora llSay(). Le funzioni usano degli "argomenti" che sono i valori fra parentesi tondeche la seguono. Se ti soffermi per qualche attimo sulla funzione mentre sei nell'editor, si aprirà una finestra che ti informa sui parametri che la funzione si aspetta. Nel caso di llSay si aspetta un numero e una stringa. Gli diamo il numero zero e la stringa "Ciao Mondo!" separati da virgole. La funzione si aspetta un numero e una stringa e non prenderà nessun altro tipo di valori.

Mettiamo tutto insieme

Ecco finalmente, riga per riga, lo script Hello Avatar.

<lsl>

default // Tutti gli script hanno bisogno di uno stato iniziale

{ // questa parentesi graffa definisce l'inzio dello stato default

   state_entry() // un evento
   {
       llSay(0, "Ciao Mondo!"); // una funzione dentro la coppia di parentesi graffe
   }
   // la parentesi graffa chiusa definisce la fine dell'evento
   touch_start(integer total_number)  // un secondo evento dentro lo stato
   {
       llSay(0, "Touched."); // un'altra funzione dentro il secondo evento
   }
   // fine del touch_start

} // fine dello script </lsl>

Nel momento in cui salvi il tuo script, lui entra nello stato iniziale, che a sua volta lancia l'evento "state_entry" che a sua volta lancia la funzione llSay() che fa parlare l'oggetto.

Dopo di ciò, il programma si mette quieto ad aspettare nello stato di default finchè non scatta un nuovo evento.

Toccare il cubo fa scattare l'evento "touch_start" che fa anch'esso parlare l'oggetto.

Introduzione degli Stati e degli Eventi

Gli script LSL non girano partendo dalla prima riga e terminando all'ultima riga. Invece cercheranno lo stato iniziale (default) e aspetteranno per un evento. Dentro questi eventi potrebbero esserci delle funzioni che chiedono di cambiare stato.

Tutti i programmi devono contenere lo stato iniziale (default), dentro il quale deve esserci almeno un evento. Gli eventi scattano o se accadono delle azioni specifiche all'oggetto o attorno all'oggetto in cui lo script vive, oppure sono fatti scattare dall'oggetto stesso.

Esempio Acceso/Spento Usando gli Stati

Osserviamo ora uno script che contiene due stati con due eventi in ognuno di essi.

<lsl> default //lo stato iniziale default è obbligatorio {

   state_entry() // viene eseguito ogni volta che lo stato diventa attivo
   {
       llSay(0, "mi accendo!"); //l'oggetto parla!
       llSetColor(<1.0, 1.0, 1.0>, ALL_SIDES); // imposta tutti i lati dell'oggetto in modo che siano luminosi
       // notate i ; alla fine di ogni istruzione.. Non metteteli però alla fine delle istruzioni if
   }
 
   touch_start(integer total_number) // altro evento con solo una funzione
   {
       state spento; // imposta lo script in un nuovo stato (spento) e lo mette in esecuzione 
   }

} // questa parentesi graffa chiusa finisce il corpo dello stato iniziale default

state spento // un secondo stato oltre a quello iniziale {

   state_entry() // va in esecuzione non appena si entra in questo stato
   {
       llSay(0, "mi spengo!");
       llSetColor(<0.0, 0.0, 0.0>, ALL_SIDES); // Imposta tutti i lati al colore nero
   }

   touch_start(integer total_number)
   {
       state default;
   }

} </lsl> Una versione semplificata potrebbe essere


<lsl>

default
{
//imposta il colore bianco e se toccato va nello stato "spento"
}

state spento
{
//imposta il colore nero e se toccato entra nello stato iniziale
}

</lsl>

Fai attenzione che a parte "default" tutti i nuovi stati cominciano con la parola "state". Also, while the object has a texture, the color will affect the "tint" more than the true color.

Default State

Let us examine the default state.

First we see the "state_entry" event, which gets triggered each time the default state is entered. Which is this case in entered the first time the script is run.

SPEAK TO ME!

The first line in the event state_entry is...

<lsl>llSay(0, "turning on!");</lsl>

This makes the object speak "turning on!" on channel zero. What is channel zero? It is the same channel you see all public chat on.

A semicolon ends the line and yet another instruction follows.

<lsl>llSetColor(<1.0, 1.0, 1.0>, ALL_SIDES);</lsl>

This turns the prim to its brightest tint. If you take the texture off the prim, you would see it as bright white but with a texture, it looks "normal." The three ones stand for the Red, Green, and Blue values of the tint.

At this point the event is finished with the two lines of commands. Then the script waits idle in the default state for more events to happen.

TOUCHED BY AN AVATAR

While idle in the default state a touch will trigger the "touch_start" event.

Inside of the "touch_start" event is only one command:

<lsl>state off;</lsl>

This is a command to move immediately to a new state named "off".

This state is defined after the default state and nearly mirrors the default state, except that it turns the prim dark and, when touched, will put the script back into default mode, thus creating a loop.

  1. Enters default state
  2. Runs code in "state entry"
  3. Waits to be touched
  4. When touched enters "state off"
  5. Enters "state off"
  6. Runs code in "state entry" (note in the "off" state's body)
  7. Waits to be touched
  8. When touched enters "default" state

Then the whole thing starts over.

A final word on words

Making your object speak is a great way to know what a script is doing, but everyone can hear it for 20m all around you. As you get into more complex scripts this can get pretty noisy! Three alternative ways to see what is going on exist.

SHHHH WHISPER

llWhisper( ) is just like llSay( ) but only broadcasts at half the distance (10m). You still must state what channel. So...

<lsl>llWhisper(0,"turning on!");</lsl>

...might work a bit to save the sanity of your neighbors.

Using llShout( ) increases the distance heard to a radius of 100m, but can cut the amount of friends you have in half.

llOwnerSay( ) uses no channel and is heard only by the owner of the object. Very useful and can triple the amount of friends you have!

<lsl>llOwnerSay("turning on!");</lsl>


THE SOUND OF SILENCE

You can make a totally silent message via llSetText( ) like this.

<lsl>llSetText("I am on", <1.0, 1.0, 1.0>,1.0);</lsl>

What do the numbers mean? The <1.0, 1.0, 1.0> we have seen before. It represents the values for red, green, and blue. For now just know that <1.0, 1.0, 1.0> means "white" and <0.0, 0.0, 0.0> means "black". Replace the llSay(0,"turning off!"); with...

<lsl>llSetText("I am off", <0.0, 0.0, 0.0>,1.0);</lsl>

The 1.0 is the alpha setting. 1.0 means fully opaque, and 0.0 would be completely transparent (invisible).


Next steps

Now than you can edit and run LSL code, move on to one of the more advanced LSL Tutorials.