Script per le porte

//Script Base per le porte

//============================================

// Dichiara le costanti globali.
//
integer SW_OPEN = FALSE; // usato per apire la porta
integer SW_CLOSE = TRUE; // usato per chiudere la porta
integer SW_NORMAL = FALSE; // usato per una apertura normale
integer SW_REVERSE = TRUE; // usato per la chiusura

// Notate che è difficile dare uno swing verso l'esterno
//o verso l'interno in quanto ha a che fare
//con la rotazione e l'orientamento della porta,
//in quanto deve essere riferita non solo alla

//direzione corretta/desiderata, ma anche se vi riferite
//al fatto che la porta debba andare verso

//l'interno o l'esterno.
//Per questo è più facile denominare lo swing normal e reverse.

//============================================
// Dichiara i campi globali.
//
key gfOwnerKey; // Proprietario dell'oggeto
integer gfDoorClosed; // Stato attuale della porta (Aperto, Chiuso)
integer gfDoorSwing; // Determina in quale verso va la porta
//(Interno, Esterno)

//============================================
// gmInitFields
//
gmInitFields()
{
//
// trova il prorietario della porta.
//
gfOwnerKey = llGetOwner();

//
// La porta è chiusa di default.
//
gfDoorClosed = TRUE;

//
// La port.a apre e chiude.
//
gfDoorSwing = SW_NORMAL;

return;
}
//
// fine del gmInitVars
//============================================

// gmSwingDoor
//
gmSwingDoor(integer direction)
{
//-----------------------
//Definisce le varianti locali

rotation rot;
rotation delta;
float piVal;


// Prima di tutto dobbiamo decidere se stiamo applicando
//un PI negativo o positivo
//all'algoritmo della porta.
//Il parametro positivo negativo è determinate per sceglire la direzione
// in cui si muoverà la porta.
// Abbiamo quindi due variabili da considerare: aperto/chiuso e direzione
// interna/esterna. Iniziamo con aperto/chiuso. Presumiamo il
// seguente:

// SW_OPEN: +PI
// SW_CLOSE: -PI
// Presumiamo inoltre la direzione normale:
// SW_NORMAL.

// Una porta con una direzione diversa avrebbe i valori rovesciati:
// SW_OPEN: -PI
// SW_CLOSE: +PI

// La variabile di questo metodo detrmina se l'intento sia
//di aprire o chiudere la porta

// Il campo globale gfDoorSwing sarà usato per modificare
//il PI basato su una porta che ha
//come direzione un dentro/fuori normale.

if (direction == SW_OPEN)
{

// La porta si apre.. Assegnamole un valore +PI al piVal.

piVal = PI/4;

// Ora controlliamo se la porta fa il contrario.

if (gfDoorSwing == SW_REVERSE)
{
piVal = -PI/4;
}
} else
{
piVal = -PI/4;

if (gfDoorSwing == SW_REVERSE)
{
piVal = PI/4;
}
}
rot = llGetRot();
delta = llEuler2Rot(<0,0,pival> );
rot = delta * rot;
llSetRot(rot);
llSleep(0.25);
rot = delta * rot;
llSetRot(rot);

return;
}

// Fine di gmSwingDoor
//============================================

// gmCloseDoor

// Questo comando serve a chiudere la porta.
//Se le porte sono bloccate,
// la porta non può essere chiusa.
//Se la porta è chiusa non può essere richiusa.


gmCloseDoor()
{

// Prima di tutto controliamo che la porta sia già chiusa.
//Se lo è facciamo in modo che l'utente lo sappia.

if (gfDoorClosed == TRUE)
{

// E' già chiusa.

llSay (0, "Questa porta è già chiusa.");
return;
}

// Chiamiamo il metodoC gmSwingDoor con l'argomentoSW_CLOSE

gmSwingDoor(SW_CLOSE);


// Ora la porta è chiusa, settiamo lo stato.

gfDoorClosed = TRUE;

return;
}

// Fine di gmCloseDoor

//============================================
// gmOpenDoor

// Questo comando serve per aprire.
//Se la porta è già apertanon si riaprirà.
//Stesso vale se la porta è bloccata.

gmOpenDoor()
{
//Controlliamo che non sia già aperta, e avvisiamo l'utente.

//
if (gfDoorClosed == FALSE)
{

// E' già aperta.

llSay (0, "La porta è già aperta.");
return;
}


//Chiamiamo il metodo di apertura gmSwingDoor
//con l'argomento SW_OPEN .

gmSwingDoor(SW_OPEN);


// Ora che la porta è aperta, settiamo lo stato.

gfDoorClosed = FALSE;
return;
}

// fine di gmOpenDoor
//============================================

// Stato di default
//Questo stato si setta automaticamente quando rezzate la porta.

default
{

// state_entry() è l'inizio dell'azione.

state_entry()
{

// Campi globali di inizio

gmInitFields();


// Stiamo settando due comandi.
//La porta reagisce ai comandi vocali del proprietario.

llListen(0, "", "", "aperto");
llListen(0, "", "", "chiuso");
}

listen(integer channel, string name, key id, string msg)
{
//-----------------------
// Variabili definite

string operName;
string ownerName;

//Controllo id proprietario.


operName = llKey2Name(id);
ownerName = llKey2Name(gfOwnerKey);


// Trova il proprietario.

if (ownerName != operName)
{


llSay(0, "I comandi vocali sono a disposizione solo del proprietario.");
return;
}

//----------------------------------------
// APERTURA

if(msg == "aperto")
{
gmOpenDoor();
}

//----------------------------------------
// CHIUSO

if (msg == "chiuso")
{
gmCloseDoor();
}
}

touch_start(integer i)
{


if (gfDoorClosed == FALSE)
{
gmSwingDoor(SW_CLOSE);
gfDoorClosed = TRUE;
return;
} else
{

gmSwingDoor(SW_OPEN);
gfDoorClosed = FALSE;
return;
}
}
}