Getting started with LSL/it

From Second Life Wiki
Jump to navigation Jump to 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 incontrerai e che farai in SecondLife.


A CHI E' RIVOLTO 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 Second Life è 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 agli 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". Inoltre, mentre un oggetto ha una "texture", il colore influenzerà la "tinta" più che il colore effettivo.

Stato iniziale (default)

Esaminiamo ora lo stato iniziale.

Per prima cosa vediamo l'evento "state_entry", che scatta ogni volta che si entra nello stato iniziale. Questo accade nel nostro caso quando lo script viene lanciato.

PARLAMI!

La prima riga nello state_entry è...

<lsl>llSay(0, "Mi accendo!");</lsl>

Questo fa sì che l'oggetto dica "Mi accendo!" sul canale zero. Che cos'è il canale zero? E' lo stesso canale dove vedi tutto il giorno la chat pubblica.

Un punto e virgola ";" termina la riga e abbiamo un'altra istruzione che segue.

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

Questo modifica il prim chiedendogli di assumere la sua "tinta" più chiara. Se togliessi la texture dal prim vedresti un bianco puro ma se hai una texture vedrai qualcosa di "normale". I tre valori stanno per la percentuale di Rosso, Verde e Blu che volete che siano nella "tinta" dell'oggetto.

A questo punto l'evento finisce con queste due righe di comandi. Dopo di che lo script si mette quieto ad aspettare nello stato di default che accadano altri eventi.

TOCCATO DA UN AVATAR

Mentre è lì quieto nello stato di default un "tocco" farà scattare l'evento "touch_start".

Dentro l'evento "touch_start" c'è solo un comando:

<lsl>state spento;</lsl>

Questo comando chiede di cambiare immediatamente verso lo stato che si chiama "spento".

Questo stato è definito subito dopo lo stato iniziale default ed è molto simile allo stato iniziale, eccetto che scurisce il prim e, se toccato rimette lo script di nuovo nello stato iniziale, creando una specie di ciclo.

  1. Entra nello stato iniziale
  2. Esegue il codice nello "state entry"
  3. Aspetta di essere toccato
  4. Se toccato entra nello stato "spento"
  5. Entra nello "state spento"
  6. Esegue il codice nello "state entry" (attenzione però siamo nel corpo dello stato "spento")
  7. Aspetta di essere toccato
  8. Se toccato entra nello stato iniziale

Tutto si ripete dall'inizio

Una parola finale sulle parole

Far parlare il tuo oggetto è un ottimo modo per sapere cosa sta facendo lo script, ma tutti lo sentono in un raggio di 20m. Man mano che vi addentrate in script più complessi tutto ciò può diventare molto rumoroso! Esistono almeno 3 modi alternativi per vedere quello che accade.

SHHHH SUSSURRA

llWhisper( ) è molto simile a llSay( ) ma trasmette ad una distanza inferiore (10m). Devi sempre specificare su quale canale. Quindi...

<lsl>llWhisper(0,"Mi accendo!");</lsl>

...potrebbe aiutare a salvare la sanità mentale dei tuoi vicini.

Se invece usi llShout( ) la distanza fino alla quale si può essere sentiti aumenta fino a 100m, ma può dimezzare la quantità dei tuoi amici.

llOwnerSay( ) Non usa nessun canale e può essere sentita soltanto dal proprietario dell'oggetto. E' estremamente utile e può triplicare la quantità di amici!

<lsl>llOwnerSay("Mi accendo!");</lsl>


IL SUONO DEL SILENZIO

Puoi mandare un messaggio totalmente silenzioso usando llSetText( ) come in questo esempio.

<lsl>llSetText("Sono acceso", <1.0, 1.0, 1.0>,1.0);</lsl>

Cosa significano i numeri? La terna <1.0, 1.0, 1.0> l'abbiamo già vista prima. Rappresenta i valori per le componenti rosso, verde e blu. Per il momento sappiate solo che <1.0, 1.0, 1.0> significa "bianco" mentre <0.0, 0.0, 0.0> significa "nero". Sostituite llSay(0,"Mi spengo!"); con...

<lsl>llSetText("Sono spento", <0.0, 0.0, 0.0>,1.0);</lsl>

Il terzo numero 1.0 è l'impostazione alfa (trasparenza). 1.0 significa completamente opaco, e 0.0 sarebbe completamente trasparente (invisibile).


Prossimi passi

Ora che puoi modificare e lanciare script LSL, vai avanti verso uno dei tutorial più avanzati LSL Tutorials.

Retrieved from "https://wiki.secondlife.com/w/index.php?title=Getting_started_with_LSL/it&oldid=878122"