Archivio

Posts Tagged ‘Scripting LSL’

Notecard configurazione LSL

12 gennaio 2009 9 commenti

Uno dei primi problemi che affronta uno scripter LSL non esperto (ma anche uno esperto!) è quello di creare un file di testo esterno allo script, dove salvare i valori iniziali di una variabile.

Questa operazione è estremamente utile per aumentare la modularità di uno script e per attuare delle modifiche senza dover modificare e ricompilare il codice.

In script aventi una complessità medio-alta, la tecnica di salvare informazioni in un file di testo esterno è estremamente diffusa.

Il presente articolo si prefigge l’obiettivo di semplificare e rendere automatica una operazione di questo tipo. Lo script prevede una fase di impostazione delle variabile ed una fase di validazione delle stesse.

Inizio con il postare il codice completo del template per poi discutere le parti essenziali con un esempio.

// ReadConfiguration
//
// Il seguente template viene usato per leggere un file di configurazione.
// Il file di configurazione può essere formattato nel seguente modo:
// <var>        Singola variabile
// <var>=<var>    Variabile <var> che deve essere inizializzata con il valore in <var>
// # line        Linea di commento
//
// @version 1.0
// @author MarcoDuff Palen (http://www.marcoduff.com/)

// Variabili
string configNotecard;
integer line;
key requestId;

// Legge i singoli comandi di configurazione.
//
// @param var    Nome della variabile letta (sempre totalmente maiuscola).
// @param val    Valore della variabile associata o una stringa vuota in caso di nessuna inizializzazione.
readConfig(string var, string val) {
}

// Valida la configurazione.
//
// @return    Restituisce TRUE se la configurazione è valida, FALSE altrimenti.
integer validateConfig() {
    return TRUE;
}

// Stato di inizializzazione.
default {
    state_entry() {
        configNotecard = llGetScriptName()+".config";
        line = 0;
        requestId = llGetNotecardLine(configNotecard,line);
    }

    state_exit() {
        line = -1;
        requestId = NULL_KEY;
    }

    dataserver(key request_id, string data) {
        if(requestId==request_id) {
            if(data!=EOF) {
                data = llStringTrim(data,STRING_TRIM);
                if(llSubStringIndex(data,"#")!=0&&llStringLength(data)>0) {
                    list dataList = llParseString2List(data,["="],[]);
                    string var = llToUpper(llStringTrim(llList2String(dataList,0),STRING_TRIM));
                    string val = "";
                    if(llGetListLength(dataList)==2) val = llStringTrim(llList2String(dataList,1),STRING_TRIM);
                    readConfig(var,val);
                }
                line++;
                requestId = llGetNotecardLine(configNotecard,line);
            }
            else {
                integer validate = validateConfig();
                if(validate == TRUE) state ConfigOkState;
                else state ConfigErrorState;
            }
        }
    }
}

// Stato se la configurazione è andata a buon fine.
state ConfigOkState {
    changed(integer change) {
        if(change & CHANGED_INVENTORY) llResetScript();
    }
}

// Stato se la configurazione è errata.
state ConfigErrorState {
    changed(integer change) {
        if(change & CHANGED_INVENTORY) llResetScript();
    }
}

Lo script non fa altro che cercare il file di testo nel contents dell’oggetto chiamato come lo script e con estenzione .config, leggere tutte le righe del file ignorando le linee vuote e le linee che iniziano con il carattere #, validare le variabili lette e portarsi nello stato ConfigOkState se tutto è andato a buon fine o nello stato ConfigErrorState in caso di errori.

Questo significa che lo stato di default della nostra applicazione diventa ConfigOkState. Le uniche righe di codice da modificare nel template sono, infatti, l’inserimeto delle variabili utili al problema, il contenuto delle due funzioni readConfig e validateConfig e gli stati ConfigOkState e ConfigErrorState.

Facciamo un esempio che spiega il funzionamento del template.

Supponiamo di voler creare un oggetto che visualizzi un testo sopra di esso. Il testo ed il colore dell’oggetto devono essere specificati in un file di testo esterno allo script. Il testo deve sempre specificato, mentre il colore, se non specificato, deve essere nero.

Il modo più semplice per lavorare con questo template è creare prima il file di testo di configurazione. Suppunendo di voler visualizzare il testo “Prova riuscita!!!” di colore blu, il file di testo risulta essere il seguente:

# Questa è una prova di configurazione dello script ReadConfiguration

# Text indica il testo da visualizzare
text = Prova riuscita!!!

# Color è opzionale, fai i tentativi commentando o impostando la variabile!
color = <0.0,0.0,1.0>

Notate il massiccio uso di commenti (righe che iniziano con il carattere #) che verranno ignorati, insieme alle righe vuote, dallo script.

Come possiamo notare dal file di testo, per soddisfare questo problema abbiamo sicuramente bisogno di due variabili: la prima di tipo string per salvare il testo da visualizzare, la seconda di tipo vector per il colore.

Questo significa che al template bisogna aggiungere in testa il seguente codice:

string text;
vector color;

l’impostazione di queste due variabili viene fatto all’interno della funzione readConfig. Questa funzione, infatti, riceve in input due variabili chiamate var e val che contengono rispettivamente la parte sinistra e quella destra rispetto al simbolo = di ogni riga letta nel file di configurazione (se non è presente il simbolo = allora viene valorizzata solo la variabile var). La variabile var ha la particolarità di essere sempre in maiuscolo, mentre la variabile val mantiene i caratteri originali.

Per fare un esempio, quando lo script leggerà la riga “text = Prova riuscita!!!” richiamerà la funzione readConfig passando per var il valore “TEXT” mentre per val il valore “Prova riuscita!!!”.

Detto questo, modifichiamo l’interno della funzione readConfig per impostare le nostre variabili text e color in questo modo:

readConfig(string var, string val) {
    if(var=="TEXT") text = val;
    else if(var=="COLOR") color = (vector)val;
    else llOwnerSay("[WARNING] Variabile "+var+" alla linea "+(string)(line+1)+" non prevista.");
}

in questo modo quando verranno letti i due valori dal file di testo, questi verranno opportunamente impostati nelle variabili. Notate che in questa particolare implementazione, se viene letto un comando non previsto viene dato un warning all’owner dello script che ha un utile feedback (pensate a quante volte avete perso tempo inutile per un semplice errore di battitura come scrivere “calor” invece di “color” o simili… mettere feedback di questo tipo è sempre molto utile e assolutamente consigliato). Notate anche come ho utilizzato la variabile line che indica la linea corrente di lettura del file (p.s.: ho dovuto incrementarla di 1 visto che la prima riga di un file di testo parte da 0!).

Se vogliamo inserire una validazione o vogliamo mettere dei valori di default per una variabile, dobbiamo modificare il contenuto della funzione validateConfig (se non vogliamo farlo, ci basta lasciare il return TRUE;). Nel nostro esempio dobbiamo controllare che il testo sia stato inserito, visto che lo consideriamo obbligatorio, mentre dobbiamo controllare che se il colore non è stato inserito dobbiamo impostarlo a Nero. La modifica da attuare è la seguente:

integer validateConfig() {
    if(color == ZERO_VECTOR) color = <0.0,0.0,0.0>;

    if(llStringLength(text)==0) llOwnerSay("[ERROR] Non hai impostato la variabile TEXT");
    else return TRUE;

    return FALSE;
}

se noto che la variabile color non è stata impostato, lo imposta io a nero. Se noto che la variabile text non è stata impostata stampo un messaggio di errore. Notare che la funzione restituisce TRUE esclusivamente nel caso in cui la variabile text viene impostata, in tutti gli altri casi restituisce FALSE. Il risultato della funzione TRUE o FALSE impone il passaggio di stato rispettivamente a ConfigOkState a ConfigErrorState.

A questo punto non ci resta che riempire lo stato ConfigOkState con il codice che avremmo scritto nello stato default di un normale script ma supponendo che le variabili a noi utili siano già state impostate, mentre lo stato ConfigErrorState con eventuali messaggi di errore. Ad esempio:

state ConfigOkState {
    state_entry() {
        llSetText(text,color,1.0);
    }

    changed(integer change) {
        if(change & CHANGED_INVENTORY) llResetScript();
    }
}

state ConfigErrorState {
    state_entry() {
        llOwnerSay("Errore di configurazione nel file "+configNotecard);
    }
    changed(integer change) {
        if(change & CHANGED_INVENTORY) llResetScript();
    }
}

Notate che tutti e due gli stati gestiscono l’evento changed in modo da captare eventuali modifiche del file di configurazione e resettarsi in automatico (ovviamente se non si vuole questa estenzione basta cancellare l’evento!).

Per chiarezza posto il codice completo dell’esempio:

// ReadConfiguration
//
// Il seguente template viene usato per leggere un file di configurazione.
// Il file di configurazione può essere formattato nel seguente modo:
// <var>        Singola variabile
// <var>=<val>    Variabile <var> che deve essere inizializzata con il valore in <val>
// # line        Linea di commento
//
// @version 1.0
// @author MarcoDuff Palen (http://www.marcoduff.com/)

// QUI INSERISCO LE VARIABILI DA RIEMPIRE TRAMITE IL FILE DI CONFIGURAZIONE
string text;
vector color;

// Variabili
string configNotecard;
integer line;
key requestId;

// Legge i singoli comandi di configurazione.
//
// @param var        Nome della variabile letta (sempre totalmente maiuscola).
// @param val        Valore della variabile associata o una stringa vuota in caso di nessuna inizializzazione.
readConfig(string var, string val) {
    // QUI INSERISCO I SETTAGGI DELLE VARIABILI
    llOwnerSay("[INFO] Reading "+var+" = "+val+" on line "+(string)(line+1));
    if(var=="TEXT") text = val;
    else if(var=="COLOR") color = (vector)val;
    else llOwnerSay("[WARNING] Variabile "+var+" alla linea "+(string)(line+1)+" non prevista.");
}

// Valida la configurazione.
//
// @return            Restituisce TRUE se la configurazione è valida, FALSE altrimenti.
integer validateConfig() {
    // QUI INSERISCO L'EVENTUALE VALIDAZIONE DELLE VARIABILI

    // Il colore non è una variabile richiesta, se non viene impostata la imposto a nero
    if(color == ZERO_VECTOR) color = <0.0,0.0,0.0>;

    // Il testo è una variabile fondamentale, mando un messaggio di errore
    if(llStringLength(text)==0) llOwnerSay("Non hai impostato la variabile TEXT");
    else return TRUE;

    return FALSE;
}

// Funzione per la visualizzazione dell'output.
//
// @param message    Messaggio da visualizzare.
// @param color        Colore di visualizzazione.
showOutput(string message, vector color) {
    llSetText(message,color,1.0);
}

// Stato di inizializzazione.
default {
    state_entry() {
        configNotecard = llGetScriptName()+".config";
        showOutput("Reading "+configNotecard,<0.0,1.0,0.0>);
        line = 0;
        requestId = llGetNotecardLine(configNotecard,line);
    }

    state_exit() {
        line = -1;
        requestId = NULL_KEY;
        showOutput("",ZERO_VECTOR);
    }

    dataserver(key request_id, string data) {
        if(requestId==request_id) {
            if(data!=EOF) {
                data = llStringTrim(data,STRING_TRIM);
                if(llSubStringIndex(data,"#")!=0&&llStringLength(data)>0) {
                    list dataList = llParseString2List(data,["="],[]);
                    string var = llToUpper(llStringTrim(llList2String(dataList,0),STRING_TRIM));
                    string val = "";
                    if(llGetListLength(dataList)==2) val = llStringTrim(llList2String(dataList,1),STRING_TRIM);
                    readConfig(var,val);
                }
                line++;
                requestId = llGetNotecardLine(configNotecard,line);
            }
            else {
                integer validate = validateConfig();
                if(validate == TRUE) state ConfigOkState;
                else state ConfigErrorState;
            }
        }
    }
}

// Stato se la configurazione è andata a buon fine.
state ConfigOkState {
    state_entry() {
        // SE TUTTO E' ANDATO BENE VISUALIZZO IL TESTO SULL'OGGETTO CON I PARAMETRI DEL FILE DI CONFIGURAZIONE
        llSetText(text,color,1.0);
    }

    changed(integer change) {
        if(change & CHANGED_INVENTORY) llResetScript();
    }
}

// Stato se la configurazione è errata.
state ConfigErrorState {
    state_entry() {
        // SE TUTTO E' ANDATO MALE VISUALIZZO UN ERRORE
        llOwnerSay("Errore di configurazione nel file "+configNotecard);
    }
    changed(integer change) {
        if(change & CHANGED_INVENTORY) llResetScript();
    }
}

Buono Scripting LSL a tutti!

Categorie:Lezioni LSL Tag:

Nuove Funzioni LSL

29 agosto 2008 Nessun commento

Sono state implementate 8 nuove funzioni lsl (disponibili con dal client 1.21).

Vediamo di esaminarle una per una.

Sei di queste sono di tipo llDetected* applicabili esclusivamente in un contesto di tipo Touch e che accettano in ingresso il solito indice che tiene conto dei click multipli.

integer llDetectedTouchFace(integer index);
Restituisce il numero della faccia toccata.

vector llDetectedTouchPos(integer index);
Posizione del punto toccato in coordinate globali (regione).

vector llDetectedTouchST(integer index);
Posizione del punto toccato nella faccia in percentuale.

vector llDetectedTouchUV(integer index);
Posizione del punto toccato nella faccia in coordinate UV.

vector llDetectedTouchNormal(integer index);
Vettore normale alla superficie nel punto toccato.

vector llDetectedTouchBinormal(integer index);
Vettore tangente alla superficie nel punto toccato.

Una funzione riguarda le informazioni su un agent.

string llGetAgentLanguage(key agentKey);
Restituisce il codice della lingua dell’agent rappresentato dalla key.

Una funzione riguarda la regione.

integer llGetRegionAgentCount();
Restituisce il numero degli agent nella regione in cui gira lo script.

Se volete provarle tutte quante con un click, ecco un codice di esempio:

default {
    touch_start(integer total_number) {
        integer i;
        for(i=0;i<total_number;i++) {
            key agentKey = llDetectedKey(i);
            string agentName = llDetectedName(i);
            string agentLanguage = llGetAgentLanguage(agentKey);
            
            llOwnerSay("*** Informazioni Agent ***");
            llOwnerSay("Nome: "+agentName);
            llOwnerSay("Key: "+(string)agentKey);
            llOwnerSay("Lingua: "+agentLanguage);

            integer faceIndex = llDetectedTouchFace(i);
            vector posVec = llDetectedTouchPos(i);
            vector posSTVec = llDetectedTouchST(i);
            vector posUVVec = llDetectedTouchUV(i);
            vector normalVec = llDetectedTouchNormal(i);
            vector tangentVec = llDetectedTouchBinormal(i);
            
            llOwnerSay("*** Informazioni Tocco ***");
            llOwnerSay("Faccia: "+(string)faceIndex);
            llOwnerSay("Posizione toccata (Regione): "+(string)posVec);
            llOwnerSay("Posizione toccata (ST): "+(string)posSTVec);
            llOwnerSay("Posizione toccata (UV): "+(string)posUVVec);
            llOwnerSay("Vettore normale: "+(string)normalVec);
            llOwnerSay("Vettore tangente: "+(string)tangentVec);
            
            
        }            
        integer agentInRegion = llGetRegionAgentCount();
            
        llOwnerSay("*** Informazioni Region ***");
        llOwnerSay("Numero agent: "+(string)agentInRegion);
    }
}
Categorie:Second Life Tag:

Compilare con Mono

21 agosto 2008 2 commenti

Finalmente il giorno è arrivato! Finalmente è possibile compilare i nostri script LSL per farli eseguire con la macchina virtuale Mono.
Questo mini-tutorial vi spiegherà come effettuare la vostra prima compilazione!

I Viewer abilitati alla compilazione Mono sono esclusivamente quelli con versione uguale o maggiore alla 1.21. Per il momento, l’unico viewer compatibile è il Preview Grid Viewer, quindi se fate girare Second Life tramite il Viewer Ufficiale o tramite il Release Candidate non sarete abilitati alla compilazione Mono.

La prima cosa da fare è quindi scaricare dal sito ufficiale la versione Preview Grid Viewer.

La Preview Grid Viewer di norma si connette alla Beta Grid di Second Life. Per accedere alla Main Grid dobbiamo forzare il Viewer. Facciamolo partire e prima di effettuare il login premiamo i tasti Ctrl-Shift-G. Ci appare, come mostrato nella seguente figura, un menù a tendina. Selezioniamo “agni” che sta ad indicare la Main Grid (di default è selezionato “aditi”, ovvero la Beta Grid). Fatto questo possiamo effettuare normalmente il login.

Login a Second Life

Una volta dentro Second Life dobbiamo assicurarci di essere in una Land con server compatibile con Mono. Dal menù “Help” selezioniamo “About Second Life…”, ci verrà visualizzata la seguente immagine.

About Second Life

Tra tutte le scritte presenti facciamo caso alla prima “Second Life 1.21.0 (94415)” che indica la versione del Viewer (che ricordo deve essere maggiore o uguale alla 1.21 per far compilare in Mono) e la scritta “Second Life Server 1.24.0.94778” che indica la versione del server.

Per far girare e per far compilare gli script con Mono, il server deve avere la versione maggiore o uguale a 1.24. Server più vecchi non sono compatibili con Mono.

Cerchiamo quindi una Land con installata una versione del server compatibile con Mono (io sono andato a Sandbox Island). Notiamo subito che quando cambiamo versione del server il viewer ci avvisa con un messaggio:

Popup cambio server

Adesso non ci resta che creare un oggetto, aggiungere uno script e verificare che la spunta sulla casella Mono sia abilitata come mostrato in figura

Mono abilitato

Ed ecco che il nostro script è pronto!

Dopo aver testato il nostro oggetto, portiamolo in una land non compatibile con Mono (versione del server minore a 1.24)… noteremo che il nostro script non funziona più, e se proviamo ad aprire in modifica la casella Mono è disabilitata.

Mono non abilitato

Concludendo, Mono risulta essere estremamente più veloce della vecchia macchina virtuale. I primi test che ho fatto dimostrano una velocità di esecuzione più che raddoppiata. L’unica pecca è una mancata segnalazione di script Mono non funzionanti in zone non compatibili (non viene visualizzato nessun errore nemmeno nella consolle di debug!)… ma è un problema da poco visto che il Viewer ufficiale sarà rilasciato esclusivamente dopo che tutte le sim saranno coperte dalla nuova macchina virtuale e che la copertura dovrebbe essere abbastanza rapita!

Enjoy with Mono!

Quarta Lezione di LSL

17 giugno 2008 Nessun commento

Quarta lezione di LSL sempre alla Land del Forum!

Argomento della lezione, questa volta, la comunicazione interna in un oggetto. Come già detto in passato, un oggetto in Second Life è formato da uno o più prim linkati tra di loro. L’ordine dell’operazione di link, effettuata selezionando tutti i prim e premento CTRL + L, imposta il numero del link. In particolare, l’ultimo link selezionato sarà il prim root, ovvero il prim con il numero di link uguale ad 1, tutti gli altri saranno i prim child, con il numero di link decrescente rispetto alla selezione (il penultimo linkato ha valore 2, il precedente 3, e cosi via).

Per scoprire il numero di link abbiamo creato un oggetto formato da tre prim:

  • Un cubo come prim root;
  • Due piramidi con le basi adiacenti a due facce opposte del cubo come child.

Per fare delle prove abbiamo applicato a questi tre prim il seguente script:

default {
	touch_start(integer total_number) {
		string agentName = llDetectedName(0);
		integer linkNumber = llGetLinkNumber();
		llSay(PUBLIC_CHANNEL, agentName+" ha toccato il prim con il link number uguale a "+(string)linkNumber);
	}
}

La funzione llGetLinkNumber() ci restituisce infatti il numero del link in cui sta girando lo script.

Effettuando la separazione dei link, ovvero premento CTRL + SHIFT + L, abbiamo ripetuto il test ed abbiamo notato che il numero di link è pari a 0.

Quindi siamo arrivati alla seguente conclusione: se un oggetto è formato da un unico prim, questo ha numero prim uguale a 0, mentre, se l’oggetto è formato da due o più prim, l’ultimo oggetto selezionato ha valore 1 ed è il prim root, tutti gli altri hanno valore maggiore di 1, in base alla selezione, e sono i prim child.

Detto questo abbiamo posto la nostra attenzione verso un’altra funzione di sistema: llMessageLinked, la cui firma è llMessageLinked(integer linknum, integer num, string str, key id).

Questa funzione viene utilizzata per fare comunicare i prim che formano un oggetto. Il primo parametro, infatti, indica il numero del link del prim destinatario del messaggio. Il primo parametro, oltre al numero secco del prim, accetta anche le seguenti costani:

  • LINK_ROOT: per comunicare con il prim root (ovviamente, come abbiamo visto, questa costante assume valore 1);
  • LINK_SET: per comunicare con tutti i prim che costituiscono l’oggetto;
  • LINK_ALL_OTHERS: per comunicare con tutti i prim diversi da quello in cui sta girando lo script;
  • LINK_ALL_CHILDRENS: per comunicare con tutti i prim child;
  • LINK_THIS: per comunicare con lo stesso link in cui sta girando lo script.

I rimanenti tre paramentri della funzione llMessageLinked servono appunto per passare il messaggio. Possiamo passare contemporaneamente un intero, una stringa e una key rispettivamente nelle variabili num, str e id.

Il nostro obiettivo è creare tre script da inserire nei tre prim che costituiscono il nostro oggetto. Due script molto simili da applicare nelle piramidi per simulare delle frecce, ed uno script nel cubo (il prim root) che riceve i messaggi.

Il particolare, gli script delle piramidi devono essere sensibili al tocco di un agent e devono inviare al prim root il numero 1 o -1 in caso sia la freccia Indietro o Avanti, il nome dell’agent che ha toccato il prim e la key dello stesso.

Lo script per la freccia indietro risulta quindi essere il seguente:

default {
	state_entry() {
		llSetText("Indietro",<1.0,1.0,1.0>,1.0);
	}

	touch_start(integer total_number) {
		key agentKey = llDetectedKey(0);
		string agentName = llDetectedName(0);
		llMessageLinked(LINK_ROOT,-1,agentName,agentKey);
	}
}

mentre lo script per la freccia avanti è il seguente:

default {
	state_entry() {
		llSetText("Avanti",<1.0,1.0,1.0>,1.0);
	}

	touch_start(integer total_number) {
		key agentKey = llDetectedKey(0);
		string agentName = llDetectedName(0);
		llMessageLinked(LINK_ROOT,1,agentName,agentKey);
	}
}

Notate che la prima manda come intero il messaggio -1, mentre la seconda 1.

Lo script posizionato nel cubo, invece, non fa altro che leggere l’input del messaggio e visualizzarlo come testo.

Ogni volta che viene ricevuto un messaggio inviato tramite llMessageLinked, viene sollevato l’evento link_message(integer sender_num, integer num, string str, key id).

Se notate bene, i parametri di ingresso sono del tutto analoghi a llMessageLinked, fatta eccezione per il primo. Questa volta, infatti, il primo paramentro identifica il numero del link del prim mittente del messaggio. I restanti parametri contengono rispettivamente il numero, la stringa e la key inviata dal prim mittente.

Lo script risultante, da inserire nel prim cubo, risulta quindi essere:

default {
	state_entry() {
		llSetText("In attesa che qualcuno tocchi le freccie!",<1.0,1.0,1.0>,1.0);
	}

	link_message(integer sender_number, integer number, string message, key id) {
		llSetText("Il link numero "+(string)sender_number+" mi ha mandato il messaggio ("+(string)number+","+message+","+(string)id+")",<1.0,1.0,1.0>,1.0);
	}
}

Questo oggetto sarà molto utile la prossima lezione, dove lo utilizzeremo per spiegare le liste!

Alla prossima lezione!

Categorie:Lezioni LSL Tag:

Il Secondo Mondo cambia in Mono!

12 giugno 2008 Nessun commento

Mono

Finalmente siamo vicini alla transazione verso Mono. Questa è prevista con la versione 1.21 del viewer.

Vediamo di capire nel dettaglio come funziona l’architettura di Second Life sotto il punto di vista degli Script, i motivi del cambiamento, cosa c’è attualmente, cosa cambierà.

Ogni volta che scriviamo uno script questo viene compilato in un linguaggio particolare, tecnicamente chiamato bytecode, che deve essere interpretato da una entità chiamata “Macchina Virtuale”. A questa spetta l’onere di eseguire lo script.

Il Server che si occupa dell’esecuzione del bytecode è sempre il server della regione in cui si trova attualmente lo script.
Quindi, nel caso di attachment scriptati, dopo un teleport o un passaggio tra due regioni adiacenti c’è un passaggio di consegna tra due server. Il primo impacchetta le informazioni e le passa al secondo che continua l’esecuzione.

Come già accennato, su ogni server è presente una Macchina Virtuale, il cui unico scopo è interpretare il bytecode ed eseguirlo.

In questo momento, l’unica macchina virtuale esistente è quella nativa della Linden. Questa è stata pensata per un basso numero di script in esecuzione e per script relativamente semplici.

Con l’evoluzione di Second Life, gli script sono diventati sempre più complessi, pesanti e quindi la macchina virtuale esistente risulta essere inadeguata. A complicare il tutto si è aggiunto il nuovo motore fisico, sicuramente più preciso e realistico del precedente, ma anche più pesante.

Il pensiero è quindi quello di cambiare totalmente lo strato della macchina virtuale. Sostituirla, quindi, con una più efficiente e dalle prestazioni maggiori. La scelta è ricaduta su Mono, attualmente disponibile nella versione Beta del client di Second Life (ovvero il client che fa girare Second Life sulla BETA Grid e non sulla Main Grid).

La difficoltà nel passaggio tra le due macchine virtuali sta, ovviamente, nella incompatibilità tra i due bytecode. L’obiettivo di Linden è quello di creare un compilatore capace di generare un bytecode compatibile sia con la vecchia versione sia con la versione mono.

Nel periodo di transizione sarà utilizzata la tecnica chiamata Het Grid. Ovvero una griglia capace di far girare alcune regioni sotto un simulatore (attualmente Havok 4) e altre regioni sotto Mono. Ad ogni teleport, verrà segnalato all’agent l’eventuale passaggio di simulatore.
A poco a poco verranno coperte tutte le regioni dalla macchina virtuale mono ed, appena il passaggio verrà ultimato, la vecchia macchina virtuale verrà definitivamente deprecata.

Secondo i primi benchmarck della Linden, la macchina virtuale Mono risulta essere ben 220 volte più veloce della vecchia macchina virtuale. Se questo fosse vero, diciamo che il lag sarà un lontano ricordo almeno per qualche mese (il tempo di sfruttare al massimo le nuove potenzialità).

Permettetemi una critica al numero 220… il test prestazionale è stato fatto sicuramente sulla Beta Grid, notoriamente meno affollata della Main Grid, quindi l’unico dubbio è vedere come si comporta sotto sforzo Mono.

Per provare i nostri vecchi script sotto la nuova macchina virtuale Mono, ci basta:

  • Scaricare la versione BETA del client
  • Teletrasportarci su una regione abilitata a Mono, Linden segnala le seguenti:
    – Sandbox Cordova MONO;
    – Sandbox Goguen MONO;
    – Sandbox Newcomb MONO;
    – Sandbox Wanderton MONO.
  • Editare lo script ed abilitare la casella Mono e salvare, come già accennato, infatti, il vecchio bytecode NON è compatibile, quindi dobbiamo ricompilare tutti i nostri script affinché possano girare correttamente sotto Mono (se la casella è oscurata, vuol dire che non siamo in una regione compatibile con mono);
    – Attenzione che dopo aver compilato il codice sotto Mono, quegli script funzioneranno esclusivamente in regioni compatibili con questo!

Andiamo adesso nel dettaglio le differenze di Mono rispetto alla vecchia macchina virtuale LSL:

  • La sintassi, gli stati, le funzioni, gli eventi del Linguaggio LSL sono le stesse nelle due macchine virtuali, quindi continueremo a scrivere gli script esattamente come abbiamo fatto fino ad adesso, quello che cambia è il compilatore (quindi il bytecode generato) e la macchina virtuale. In poche parole, il programmatore non si rende conto di nulla, visto che tutti i cambiamenti concentrati dopo il click al pulsante Save degli script;
  • Maggiore velocità di esecuzione, Linden dichiara che la macchina virtuale Mono è fino a 220 volte più veloce della vecchia macchina virtuale;
  • Maggiore memoria nei nostri script, fino a 64Kb rispetto ai vecchi 16Kb;
  • Gestione dinamica della memoria, probabilmente verrà incrementata la potenza della funzione llGetFreeMemory che potrà restituire lo stato effettivo della memoria e non soltanto il picco;
  • Tutti gli script compilati con il vecchio compilatore dovranno essere ricompilati sotto Mono (semplicemente aprendoli e cliccando su Save dopo aver selezionato la casella Mono, o utilizzando il Tool messo a disposizione del nuovo client per compilare contemporaneamente più tool). Di contro, gli script compilati sotto Mono non funzioneranno in regioni in cui gira la vecchia macchina virtuale e viceversa.
  • I vecchi script continueranno a funzionare ancora per lungo tempo, la vecchia macchina virtuale verrà dismessa, alleggerendo l’architettura, solo dopo che Mono avrà coperto tutta la Main Grid;
  • La macchina virtuale Mono è capace di interpretare e compilare codice proveniente anche da altri linguaggi come lisp, javascript, phyton. Ma,per il momento, non è prevista una espansione per linguaggi diversi dall’LSL.
  • Il codice verrà compilato direttamente dai server Linden, non dal client come avviene adesso. Questo significa un alleggerimento dei client ed una maggiore sicurezza nel controllo del codice scritto (non sarà più possibile infatti inviare bytecode dal client).

Concludendo non posso che darvi un consiglio: per il momento ignorate Mono!
Sicuramente questo è più veloce e performante, ma ci vorrà del tempo affinché tutta la Main Grid sarà coperta dalla macchina virtuale Mono e quindi si corre il rischio di avere degli script che funzionano in pochissime regioni e non funzionano nella maggior parte.
Inoltre, le potenzialità di Mono non sono attualmente disponibili, il linguaggio è lo stesso e le librerie di sistema non sono ancora state adattate per sfruttare al massimo tutte le potenzialità offerte.

Quindi, meglio attendere un poco!

Maggiori informazioni si possono trovare nel wiki ufficiale della Linden.

Categorie:Second Life Tag: