LSL Protocol/Restrained Love Relay/Other Implementations/DEM Relay HUD

From Second Life Wiki
Jump to navigation Jump to search

((work in progress))

Think Kink PBA (Personal Bondage Assistant)

((current release of the tkPBA is v30i))

The THINK KINK PBA (tkPAB) is our implementation of a multi-object, multi-restriction relay for the Restrained Life viewer in Second Life™. In addition to providing the interface between in-world furniture/toys, it implements some extensions to the RLV specs that allow for identification of WHO is operating a device trying to access the PBA (Relay) and functions to provide vision restrictions without another attachment/hud. These extensions and scripts are released under the following license:

©left 2009 Think Kink (Think Kink is Ilana Debevec & Lyssa Daehlie)

the Think Kink PBA (tkPBA for short) is released under a modified "CopyLeft" license. The short form without legalese.

This code is provided AS-IS, OPEN-SOURCE and holds NO WARRANTY of accuracy, completeness or performance. It may be distributed in its full source code with this header and disclaimer and is not to be sold without permission. Optionally it may be distributed in a 'no mod' from within Second Life™ PROVIDED that either a link to the full source IS provided (ie. this page or a .zip or .rar) within the object the code is contained AND/OR a off-world contact point (ie. email) that the source code may be requested from. This somewhat unusual (no-mod) distribution is allowed to maintain the integrity and reliability of the creator reference of in-world objects (scripts). Changes and improvement to this code must be shared with the community so that we ALL benefit.

Based on Maike Short's 1030b relay, with thanks to Tahni Taratal, RL Ansome, Nihal Quah and all of the staff of THINK KINK who helped with the shakedown and development of this device. Recursive thanks to everyone that has gone before on the development of the Restrained Life Relay, including (but not limited to) Maike Short, Felis Darwin, Chorazin Allen, Azoth Amat, Gregor Mougin, Nano Siemens, Cerdita Piek, Satomi Ahn, Marissa Mistwallow and she who started it all ... Marine Kelley. An extra special personal thanks to Chloe1982 Constantine who was able to help me put ideas into bits when I was buried whisker deep in both SL and RL issues.

In-world (no mod) copies of this relay may be picked up for free at THINK KINK🖈 or email to Ilana.Debevec@gmail.com for full source. --Ilana Debevec 19:53, 27 February 2009 (UTC)

Design Points

We went into the design of the tkPBA to be as flexible in it's handling of multiple objects as possible. Originally we looked at the single script concept but quickly discarded this as being rather unwieldy and subject to the whims of LSL to it's use of memory. With the all in one design, you can't reliably check on memory utilization, excessive garbage collection with list management and other quirks of LSL. It also left the script more vulnerable to the unexpected stack/heap overflow if you didn't put a limit to the number of devices it would control. Therefore, we split the relay into three parts -

- the DPU (Dominate Processing Unit) handling all the 'global' tasks of the relay (listens, dialogs, mode (off/ask/auto/hardcore), SAFEWORD and implementation of the !who and !vision commands.
- the SPU (Slave Processing Unit) handling 'object specific' tasks (what object and it's restrictions are in place).
- the GPU (Graphics Processing Unit)) the 'bare metal' interface for the !vision command.

Further, we took the actual architecture of the relay down to the 'prim' level. Since we have made this a HUD ONLY device (a. can't drop scripts in 'no mod' items that may already have their own touch events, b. not enough body attachment points as it is, c. keep it and it's status and control where you can get it at easily), we could divide the scripts among different prims to let them do part of the work.

- the DPU goes in the root, the SPU's go in separate prims (one per # of devices you want to control), the GPU lurks on the back of the root prim and gets prim modification to affect the vision of the user.
- the SPU keeps the UUID of the object currently controlling it and the UUID of the last AV that used it (if available) in it's description field. The DPU, instead of having to pass link messages back and forth, or keep updating an internal list, can find the current state of the object simply by reaching over with llGetObjectDetails(SPUn link number), [OBJECT_DESC]) and get the UUID's of the object/operator or if NULL_KEY see that the SPU is free to use.
- the GPU is a single tiny prim that is glued to the back of the tkPBA that can be manipulated in size, color, transparency, texture, etc... to affect the vision of the victim.

Logo's & Signage

Think Kink has developed logos to brand our products showing them as having the !who and !vision compatibility as well as overall Restrained Life compatibility that eliminates the SL "Eye in Hand" that has some restrictive usage rights. With the publication of these scripts, we are opening them for use by the community as long as attribution is given to Think Kink. Email Ilana.Debevec@gmail.com for a TGA pack of the logos. --Ilana Debevec 19:52, 27 February 2009 (UTC)

  • tlRLV logo

  • tlRLV !who

  • tlRLV !vision

  • tlRLV both

--Ilana Debevec 18:44, 5 March 2009 (UTC)

tkPBA Command Extensions

!who

Description
!who is implemented as a meta command to pass the UUID of WHO is trying to operate your relay, not just WHAT device and the OWNER of the device (more often than not, WHO's the operator and WHO's the owner are NOT the same avatar).
Background
Since the Restrained Life viewer was introduced to the grid, almost from day one we have people coming to our store wanting a way to know WHO is trying to control their relay, it's almost become a mantra "I don't care WHAT it is, I want to know WHO it is!". This gives the tkPBA the ability to give some useful information on the actions of someone that is attempting to 'use' your relay to help you make informed decisions when your relay is in ASK mode.
Syntax
!who/(key)
where (key) is the UUID of the AV that you wish to present to the relay.
Implementation
THINK KINK is implementing this in our devices with the following few caveats -
- !who must be the FIRST entry of a RL Command string that will RESTRICT or DIRECTLY EFFECT someone. So, anything that will (for example) 'lock', 'force', 'deafen', 'mute', etc somone will get a !who
- !who would not be required for things like !release, or anything that UNRESTRICTS someone.
- !who is not additive, only the last !who is tracked for any given SPU (object).
- !who/NULL_KEY is moot, if you don't know !who, don't sent it.
- If no !who is sent, normal object verification rules apply
- NOTE for builders.
On a 'self activated' device (such as an area effect device that, let's say, restricts chat or tp or flying), the !who would be the UUID of the VICTIM!. This makes possible the ASK text such as "You have activated Crafty Avatar's Area of Doom and it is attempting to control your relay, ALLOW/DENY?".
A TRAP device however would generally have someone that 'set' the device (in the case of THINK KINK devices, we have an AUTOLOCK setting) and if the device knows that, it will send the UUID of the PERSON THAT SET THE TRAP ... ie. "Crafty Avatar wants to control your relay using their Dasterdly Device, ALLOW/DENY?"
Further Points of Implementation
The ASK message should change if a !who command comes in, so instead of "Dastardly Device owned by Random Avatar wants to control your relay, ALLOW/DENY?"
- the message becomes "Crafty Avatar wants to control your relay using Random Avatar's Dastardly Device, ALLOW/DENY?"
- if the owner and the operator are the same, then a more succinct message could be "Crafty Avatar wants to control your relay using their Dasterdly Device, ALLOW/DENY?"
- if a !who is present, then should the victim DENY the request, an IM can go back to the 'clicker' "Sitting Duck has denied your attempt to control their relay".

--Ilana Debevec 19:54, 27 February 2009 (UTC)

!vision

Description
meta command to control what the victim can see while under restraint. This will allow a full range of vision control of the victim. Full blindness, partial, color, textures, etc..
Implementation
using a small microprim that hides on the back of our RelayHUD, we can expand and texture this to control the sight of the victim. Put them in a dark cell, they go blind. Or in a forcefield change the color, make it partially transparant, put up a texture, etc. We are/will also be using this as a "MouseLook" enforcer to punish a victim when they won't stay in mouselook (get out of mouselook, go totally blind). Currently being implemented in devices from THINK KINK.
Syntax
!vision/(color)/(alpha)/(texture)/(repeats)/(offsets)/(rotation)
(color) = color for the HUD covering prim in RGB format <r'g'b> 0-255 (NOTE: the ' is the seperator instead of , to avoid parsing issues with the rest of the RLV command string)
(alpha) = % transparent to make the HUD prim cover (in alpha format 0.0-1.0)
(texture) = UUID for a texture to apply to the prim
(repeats) = x/y repeats for the texture, same format as the texture tab on an prim 1.0'1.0
(offsets) = x/y offsets for the texture, same format as the texture tab on an prim 0.0'0.0
(rotation) = rotation of the texture
SPECIAL ENTRY, any of the parameters can be replaced with "*" for 'do not change existing value'
NOTE: the 'default' value of the HUD prim is 100% transparent, white, TEXTURE_BLANK. ie. !vision/0.0/<255'255'255>/TEXTURE_BLANK/1.0'1.0/0.0'0.0
if all you want to do is 'blind' someone, then !vision/<0'0'0>/1.0/*/*/*/*
Examples
Total blackout "!vision/<0'0'0>/1.0/TEXTURE_BLANK/1.0'1.0/0.0'0.0/0.0
Light fog "!vision/<128'128'128>/0.5/TEXTURE_BLANK/1.0'1.0/0.0'0.0/0.0"
In a plywood box no matter where they look "!vision/<255'255'255>/1.0/TEXTURE_PLYWOOD/1.0'1.0/0.0'0.0"
Compatibility
since this is a metacommand, relays that don't support this should ignore it

--Ilana Debevec 18:29, 5 March 2009 (UTC)

!visionclear

Description
complimentary command to !vision. Reset and remove all !vision restrictions.
Syntax
!visionclear
Compatibility
same as !vision, if the relay can't, then don't

--Ilana Debevec 18:29, 5 March 2009 (UTC)

tkPBA Implementation Scripts

The DPU

The DPU (Dominant Processing Unit) handles all the listens, menus, mode control and other GLOBAL functions.

version tk.RLV1030 DPU (090305.2) -- --Ilana Debevec 19:05, 4 March 2009 (UTC)

<lsl> // tk.RLV1030 DPU (090305.2)

// ©left 2009 Think Kink (Think Kink is Ilana Debevec & Lyssa Daehlie)

// the Think Kink Restained Life PBA Relay (tkPBA for short) is released under a modified "CopyLeft" license. // The short form without legalese.

// This code is provided AS-IS, OPEN-SOURCE and holds NO WARRANTY of accuracy, completeness or performance. // It may be distributed in its full source code with this header and disclaimer and is not to be sold without // permission. Optionally it may be distributed in a 'no mod' form within Second Life™ PROVIDED that either a // link to the full source IS provided (ie. this page or a .zip or .rar) within the object the code is contained // AND/OR a off-world contact point (ie. email) that the source code may be requested from. This somewhat unusual // (no-mod) distribution is allowed to maintain the integrity and reliability of the creator reference of in-world // objects (scripts). Changes and improvement to this code must be shared with the community so that we ALL benefit.

// Based on Maike Short's 1030b relay, with thanks to Tahni Taratal, RL Ansome, Nihal Quah and all of the staff of // THINK KINK who helped with the shakedown and development of this device. Recursive thanks to everyone that has // gone before on the devlopment of the Restraint Life Relay, including (but not limited to) Maike Short, Felis Darwin, // Chorazin Allen, Azoth Amat, Gregor Mougin, Nano Siemens, Cerdita Piek, Satomi Ahn, Marissa Mistwallow and she who // started it all ... Marine Kelley.

// An extra special personal thanks to Chloe1982 Constantine who was able to help me put ideas into bits when I // was buried whisker deep in both SL and RL issues.

// In-world (no mod) copies of this relay may be picked up for free at THINK KINK in LaSalle // or email to Ilana.Debevec@gmail.com for full source.

// Ilana Debevec 25 Feb 2009

// I couldn't have written this without both Ilana and Maike. // I wouldn't have written this without Jayne to whom this work is dedicated. // Chloe 14 February 2009

integer DEBUG = FALSE; integer mDEBUG = FALSE;

// make cheating (adding exceptions) a bit more difficult by not allowing // attachment to control the viewer as they are not subjected to land building // restrictions

integer ALLOW_CONTROL_BY_ATTACHMENTS = TRUE;

integer MENU_CHANNEL; // Randomize if we need it integer MENU_HANDLE; // We'll only turn this on when we need it

string mmOFF = "-OFF-"; string mmAUTO = "ON (Auto)"; string mmASK = "ON (Ask)"; string mmHARDCORE1 = "HARDCORE"; string mmHARDCORE2 = "CONFIRM HC"; string mmSAFE = "SAFEWORD"; string mmSAFE1 = "CONFIRM 1"; string mmSAFE2 = "CONFIRM 2"; string mmSAFE3 = "COMFIRM 3"; string mmSAFEOFF = "S-WORD OFF"; string mmSWOCONFIRM = "-CONFIRM-"; string mmSWOCANCEL = "-CANCEL-"; string mmRELEASE = "RELEASE ME"; string mmSCANCEL = "-CANCEL-"; string mmHCANCEL = "-STOP!!-"; string mmNULL = " ";


string mmMENUTEX1 = "\n-OFF- Turn Off/Disable Relay (Slashed)\nON (Auto) Relay On, Auto Accept (YELLOW)\nON (Ask) Relay On, Ask Permission (GREEN)"; string mmMENUTEX1a = "\nHARDCORE Hardcore Mode (RED)"; string mmMENUTEX2 = "\nSAFEWORD EMERGENCY SAFEWORD"; string mmMENUTEX2a = "\nS-WORD OFF DISABLE Safeword Option";


// --------------------------------------------------- // Constants // ---------------------------------------------------

string PREFIX_METACOMMAND = "!";

integer RLVRS_CHANNEL = -1812221819; // RLVRS in numbers integer DIALOG_CHANNEL; integer STATUS_OPEN_CHANNEL = -1373421300; integer STATUS_SAY_CHANNEL = -1373421301; integer DIALOG_HANDLE;

integer NO_COMMAND = 0; integer FREE_COMMAND = 1; integer HOLD_COMMAND = 2; integer DOIT_COMMAND = 3; integer TEST_COMMAND = 4;

integer MODE_OFF = 0; integer MODE_ASK = 1; integer MODE_AUTO = 2;

// --------------------------------------------------- // Variables // ---------------------------------------------------

integer mode;

// ddsg- A few extra variables and constants //

integer HARDCORE_ON = FALSE; // are we in HARDCORE Mode integer SAFEWORD_ENABLE = TRUE; // is the SAFEWORD enabled key whoDoing = NULL_KEY; // Who is operating the object integer askCount = 0; // # of open ask requests integer coreAskPrim = 0; // # of core currently using the dialog string ownerName; // who am I?


integer cores = 5;

list corePrims; // prim numbers of the core indicators


// --------------------------------------------------- // Core keys management functions // ---------------------------------------------------

key getControlObject(integer link) { 

   return (key)llGetSubString(llList2String(llGetObjectDetails(llGetLinkKey(link), [OBJECT_DESC]), 0), 0, 35);

}

string getCoreDesc(integer core) { 

   return (string)llGetObjectDetails(llGetLinkKey(llList2Integer(corePrims, core)), [OBJECT_DESC]);

}

integer isBusy() { 

   integer c;
   for (c = 0; c < cores; ++c)
       if (getControlObject(llList2Integer(corePrims, c)) != NULL_KEY)
       {
           lockON();
           return TRUE;
       }
   return FALSE;

}

integer findCoreKey(key id) { 

   integer c;
   integer cp;
   
   for (c = 0; c < cores; ++c)
       if (getControlObject(cp = llList2Integer(corePrims, c)) == id)
           return cp;
   
   return -1;

}


processStatusRequest(string message) { }

// --------------------------------------------------- // Helper functions // ---------------------------------------------------


debug(string x) { 

   if (DEBUG)
       llOwnerSay("DEBUG:Super: " + x);

}

// checks whether this object is an attachment of an avatar integer isAttachment(key id) { 

   vector objpos1 = llList2Vector(llGetObjectDetails(id, [OBJECT_POS]), 0);
   vector ownerpos = llList2Vector(llGetObjectDetails(llGetOwnerKey(id), [OBJECT_POS]), 0);
   vector objpos2 = llList2Vector(llGetObjectDetails(id, [OBJECT_POS]), 0);
   return (llVecMag(objpos1 - ownerpos) <= llVecMag(objpos1 - objpos2));

}


// --------------------------------------------------- // Permission Handling // ---------------------------------------------------

// do a basic check on the identity of the object trying to issue a command integer isObjectIdentityTrustworthy(key id) { 

   key parcel_owner=llList2Key (llGetParcelDetails (llGetPos (), [PARCEL_DETAILS_OWNER]), 0);
   key parcel_group=llList2Key (llGetParcelDetails (llGetPos (), [PARCEL_DETAILS_GROUP]), 0);
   key object_owner=llGetOwnerKey(id);
   key object_group=llList2Key (llGetObjectDetails (id, [OBJECT_GROUP]), 0);

   debug("owner= " + llKey2Name(parcel_owner) + " / " + llKey2Name(object_owner));
   debug("group= " + llKey2Name(parcel_group) + " / " + llKey2Name(object_group));

   if (object_owner==llGetOwner ()        // IF I am the owner of the object
     || object_owner==parcel_owner        // OR its owner is the same as the parcel I'm on
     || object_group==parcel_group        // OR its group is the same as the parcel I'm on
   )
   {
       return TRUE;
   }
   return FALSE;

}

// is this a simple atomar command // (a command which only queries some information or releases restrictions) // (e. g.: cmd ends with "=" and a number (@version, @getoutfit, @getattach) or is a !-meta-command) integer isSimpleAtomicCommand(string cmd) { 

   cmd = llToLower(llStringTrim(cmd, STRING_TRIM));
   
   // check right hand side of the "=" - sign
   integer index = llSubStringIndex (cmd, "=");
   if (index > -1) // there is a "=" 
   {
       // check for a number after the "="
       string param = llGetSubString (cmd, index + 1, -1);
       if ((integer)param!=0 || param=="0") // is it an integer (channel number)?
       {
           return TRUE;
       }

       // removing restriction
       if ((param == "y") || (param == "rem"))
       {
           return TRUE;
       }
   }

   // check for a leading ! (meta command)
   if (llSubStringIndex(cmd, PREFIX_METACOMMAND) == 0)
   {
       return llGetSubString(cmd, 0, 7) != "!vision/";
   }

   // check for @clear
   // Note: @clear MUST NOT be used because the restrictions will be reapplied on next login
   // (but we need this check here because "!release|@clear" is a BROKEN attempt to work around
   // a bug in the first relay implementation. You should refuse to use relay versions < 1013
   // instead.)
   if (cmd == "@clear")
   {
       return TRUE;
   }

   // this one is not "simple".
   return FALSE;

}


// Is this a simple request for information or a meta command like !release? integer isSimpleRequest(list list_of_commands) { 

   integer len = llGetListLength(list_of_commands);
   integer i;

   // now check every single atomic command
   for (i=0; i < len; ++i)
   {
       string command = llList2String(list_of_commands, i);
       if (!isSimpleAtomicCommand(command))
       {
          return FALSE;
       }
   }

   // all atomic commands passed the test
   return TRUE;

}

// not so simple function to generate the ask dialog text

string askDialogText(key id, integer trustworthy) { 

   string text;
   string objectName = llKey2Name(id);
   string objectOwner= llKey2Name(llGetOwnerKey(id));
   string whoDoingName = "";
   
   if (objectOwner == "") objectOwner = "(Name Unavailable)";
   
   if (whoDoing != NULL_KEY)  whoDoingName = llKey2Name(whoDoing) + ","; 
   vector pos = llList2Vector(llGetObjectDetails(id, [OBJECT_POS]), 0);

   string objectLocation = objectName + "\nlocated at "+llGetRegionName()
        +  " <" + (string) ((integer) pos.x)
        + ", " + (string) ((integer) pos.y)
        + ", " + (string) ((integer) pos.z) + "> ("
        + (string) ((integer) llVecDist(pos, llGetRootPosition())) + "m) ";
   
   if (whoDoing == llGetOwner())
   {
       text = "You have activated ";
       if (llGetOwnerKey(id) == llGetOwner())   text += "your ";
       else                                     text += objectOwner + "'s ";
   }
   else
   {
       if (whoDoing != NULL_KEY)                text = whoDoingName + " using ";

       if (llGetOwnerKey(id) == llGetOwner())   text += "your ";
       else if (llGetOwnerKey(id) == whoDoing)  text += "their ";
       else                                     text += objectOwner +"'s ";
    }

   text += objectLocation + "\nis attempting to control your viewer";

   if (!trustworthy)
       text += "\nWARNING: This object is not owned by the people owning this parcel.";

   text += "\n\nDo you accept ?";

   return text;

} // looks at a command to see if it is a Who command, // if so, returns the key, otherwise returns NULL_KEY key whoIsUsingMe(string command) { 

   list commandParts = llParseString2List(command, ["/"], []);
   if (llList2String(commandParts, 0) != "!who")
       return NULL_KEY;
   if (llList2Key(commandParts, 1))
       return llList2Key(commandParts, 1);
   else
       return NULL_KEY;

}


// verifies the permission. This includes mode // (off, permission, auto) of the relay and the // identity of the object (owned by parcel people). integer verifyPermission(key id, integer corePrim, string message) { 

   list tokens = llParseString2List (message, [","], []);
   if (llGetListLength (tokens) < 3)
   {
       return FALSE;
   }
   string commands = llList2String(tokens, 2);
   list list_of_commands = llParseString2List(commands, ["|"], []);

   // accept harmless commands silently
   if (isSimpleRequest(list_of_commands))
   {
       llMessageLinked(corePrim, TEST_COMMAND, message, id);
       return FALSE;
   }
   
   if (HARDCORE_ON)
       return TRUE;        // there is no hope

   integer trustworthy = isObjectIdentityTrustworthy(id);

   // ask in permission-request-mode and/OR in case the object identity is suspicious.
   //
   
   debug("Mode="+(string)mode+", trustworthy="+(string)trustworthy);
   
   if (IsMode(MODE_ASK) || !trustworthy)
   {
       debug("Sending to #"+(string)corePrim+": " +message);
       llMessageLinked(corePrim, HOLD_COMMAND, message, id);
       askCount += 1;
       if (askCount == 1)
       {
           whoDoing = whoIsUsingMe(llList2String(list_of_commands, 0));
           coreAskPrim = corePrim;
           llListenControl(DIALOG_HANDLE, TRUE);
           dialog(askDialogText(id, trustworthy));
       }
       return FALSE;
   }
   return TRUE;

}

// --------------------------------------------------- // Executing of commands // ---------------------------------------------------


// lift all the restrictions (called by !release and by turning the relay off) //

releaseRestrictions () { 

   llMessageLinked(LINK_ALL_OTHERS, FREE_COMMAND, "free", NULL_KEY);

}


// --------------------------------------------------- // mode and dialog handling // ---------------------------------------------------

// Make a dialog box and get the timer started

dialog(string message) { 

   llSetTimerEvent(30);
   llDialog (llGetOwner(), message, ["Allow", "Deny"], DIALOG_CHANNEL);

}

// process the Yes/No buttons of the permission dialog // Needs to be fixed to handle multiple simultaneous requests

processDialogResponse(string message) { 

   llSetTimerEvent(0);
   
   if (message == "Allow")                 // pending request authorized => process it
       llMessageLinked(coreAskPrim, DOIT_COMMAND, "", NULL_KEY);
       
   else if (message == "Deny")             // pending request denied
   {
       if (whoDoing)
           llInstantMessage(whoDoing, ownerName + " has denied your request for control.");
       llMessageLinked(coreAskPrim, FREE_COMMAND, "free", NULL_KEY);
   }
   
   askCount -= 1;
   
   if (askCount == 0)
   {
       llListenControl(DIALOG_HANDLE, FALSE);
       return;
   }
   
   integer i = llListFindList(corePrims, [coreAskPrim]);
   integer done = i;
   string iDesc;
   do
   {
       i = (i + 1) % cores;
       iDesc = getCoreDesc(i);
       debug("core #"+(string)i+" = " + iDesc);
   }
   
   while (i != done && llStringLength(iDesc) == 36);
   coreAskPrim = llList2Integer(corePrims, i);
   whoDoing = (key)llGetSubString(iDesc, 37, 72);
   key oid = llGetSubString(iDesc, 0, 35);
   dialog(askDialogText(oid, isObjectIdentityTrustworthy(oid)));

}

// get current mode as string and set the hud texture // ddsg- set the hud textures //

string getModeDescription() { 

   if (HARDCORE_ON)
   {
       llSetTexture ("81ba7946-0e5d-19b9-1ac2-33a36d473198",0);     // RED LOCK   - HARDCORE
       return "HARDCORE: Auto-Accept ON, Relay LOCKED, Buttons REMOVED.";
   }
   else if (IsMode(MODE_OFF))
   {
       llSetTexture ("f8b60e5a-010d-26bc-e927-6ee3854149ce",0);     // SLASH LOCK - Off
       return "RLV Relay is OFF";
   }
   else if (IsMode(MODE_ASK))
   {
       llSetTexture ("e9e20400-26b4-4054-8504-91d2ab7af1d7",0);     // GREEN LOCK - Ask (safe)
       return "RLV Relay is ON (permission needed)";
   } 
   else if (IsMode(MODE_AUTO))
   {
       llSetTexture ("cd126a08-945b-f9c5-99fa-90f3abed2f4b",0);     // YELLOW LOCK - Auto (caution)
       return "RLV Relay is ON (auto-accept)";
   }
   else                              
       return "FUBAR: Unknown State";

}

// ddsg- set the mode here and update status //

SetMode(integer vMode) { 

   mode = vMode;
   llOwnerSay (getModeDescription());
   if (IsMode(MODE_OFF))
   {
       llOwnerSay("@detach=y");
       llOwnerSay("Relay UnLOCKED");
   }
   else
   {
       lockON();
   }

}

// ddsg- what's the Mode? // integer IsMode(integer tMode) { 

   return tMode == mode;

}

// ddsg- clap on, clap... I mean lockON, lockOFF to lock/unlock the relay // lockON () { 

   llOwnerSay("@detach=n");
   llOwnerSay("Relay LOCKED.");

}


// --------------------------------------------------- // initialisation and login handling // ---------------------------------------------------

init() { 

   integer temp0;
   integer temp1;
   integer temp2;
   integer temp3;
   integer temp4;
   integer i;
   
   key owner = llGetOwner();
   ownerName = llKey2Name(owner);
   
   // Set up the listeners
   llListen (RLVRS_CHANNEL, "", "", "");
   
   MENU_CHANNEL = ((integer)(llFrand(99999.0) * -1) - 2); 
   MENU_HANDLE=llListen(MENU_CHANNEL, "", owner, "");
   llListenControl(MENU_HANDLE, FALSE);
   
   DIALOG_CHANNEL = MENU_CHANNEL - 2;  
   DIALOG_HANDLE = llListen(DIALOG_CHANNEL, "", owner, "");
   llListenControl(DIALOG_HANDLE, FALSE);

   llOwnerSay("@clear");
   SetMode(MODE_ASK);
       
   HARDCORE_ON = FALSE;
   SAFEWORD_ENABLE = TRUE;
   
   if (mDEBUG)
       llWhisper(0,"Free Memory: " + (string) llGetFreeMemory());

   integer n = llGetNumberOfPrims();
   string primname;
   for(i = 1; i <= n; ++i) 
   {
       primname = llGetLinkName(i);
       
       if (primname == "corestat:0")       temp0 = i;
       if (primname == "corestat:1")       temp1 = i;
       if (primname == "corestat:2")       temp2 = i;
       if (primname == "corestat:3")       temp3 = i;
       if (primname == "corestat:4")       temp4 = i;
   }
   corePrims = [temp0, temp1, temp2, temp3, temp4];
       
   releaseRestrictions();

}

// ================================================================================================== // // emergency procedure, the subbie is in trouble. SL had borked the system and they are not unlockable // any other way, short of logging out and loggin in with the normal viewer.

// Safeword will require confirmation before restrictions are lifted. After confirming - // // a !release will be executed to remove all restrictions // the relay will be turned OFF // // a future update will inform the person that did the restrictions that the subbe safeworded (I hope)

safeword() { 

   llListenControl(MENU_HANDLE,TRUE);
   
   llDialog(llGetOwner(),"\nSAFEWORD Start. Confirm THREE times you want to use your safeword."+
                         "\nClick CONFIRM 1 or CANCEL.",
                         [mmNULL,mmSCANCEL,mmNULL, mmSAFE1,mmNULL,mmNULL], MENU_CHANNEL);

}

safeword1() { 

   llListenControl(MENU_HANDLE,TRUE);
   
   llDialog(llGetOwner(),"\nSAFEWORD 1 confirmed, you must confirm two more times. "+
                         "\nClick CONFIRM 2 or CANCEL.",
                         [mmNULL,mmSCANCEL,mmNULL, mmNULL,mmSAFE2,mmNULL],MENU_CHANNEL);

}

safeword2() { 

   llListenControl(MENU_HANDLE,TRUE);
   
   llDialog(llGetOwner(),"\nSAFEWORD 2 confirmed, you must confirm one more time "+
                           "Click CONFIRM 2 or CANCEL.",
                           [mmNULL,mmSCANCEL,mmNULL, mmNULL,mmNULL, mmSAFE3],MENU_CHANNEL);

}

safeword3() { 

   llListenControl(MENU_HANDLE,TRUE);
   
   llDialog(llGetOwner(),"\nSAFEWORD 3 confirmed, final chance."+
                         "\nClick CANCEL to stop SAFEWORD, or RELEASE ME",
                         [mmRELEASE,mmNULL,mmSCANCEL], MENU_CHANNEL);

}

safeword_release() { 

   releaseRestrictions ();
   
   llShout(0,llKey2Name(llGetOwner())+" has SAFEWORDED, please see if they need assistance.");

   if (HARDCORE_ON)
   {
       llOwnerSay ("SAFEWORD! Restrictions Released, Relay is STILL ON, better run... fast.");
       SetMode(MODE_AUTO);
   }
   else
   {
       llOwnerSay ("SAFEWORD! Restrictions Released, Relay is OFF and UNLOCKED");
       SetMode(MODE_OFF);
   }

}


safeword_cancel() { 

   llOwnerSay("SAFEWORD cancelled, we now return you to your confinment.");

}

safewordOFF() { 

   llListenControl(MENU_HANDLE,TRUE);
   
   llDialog(llGetOwner(),"\nYou are about to disable your SAFEWORD OPTION.\n" +
                         "\nThis is NOT reversable with this relay." +
                         "\nMake sure you really want to do this and either" +
                         "\nCONFIRM or CANCEL this option.",
                          [mmSWOCONFIRM,mmNULL,mmSWOCANCEL], MENU_CHANNEL);

}

safewordOFF_CONFIRM() { 

   SAFEWORD_ENABLE = FALSE;
   llOwnerSay("Your SAFEWORD option has been REMOVED. May the gods/goddesss have mercy on you.");

}

safewordOFF_CANCEL() { 

   llOwnerSay("SAFEWORD perserved, you still have a way out.");

}

// ------------------------------------------------------------------------------------------------ // // HARDCORE MODE - the is for the dedicated subbe. Entering HARDCORE mode does the following // // Relay is locked on, may not be detached. ever. // Auto Accept is turned-on. Permanently. (this may be overriden by access lists [future]) // All buttons but SAFEWORD are REMOVED. // SAFEWORD takes on a new meaning, when you safeword, the current restrictions are released BUT // the relay is still locked on, and still in Auto-Accept. Better run quick. //

hardcore_confirm() { 

   llListenControl(MENU_HANDLE,TRUE);
   
   string sSWText = "";
   
   if (!SAFEWORD_ENABLE)
       sSWText =  "\nSAFEWORD has been disabled.";
       
   llDialog(llGetOwner(), "\nHARDCORE MODE: **WARNING**"+
                          "\nEnabling HARDCORE mode is PERMANENT."+
                          sSWText +
                          "\nMake SURE you want to do this. "+
                          "\nThis is your ONLY chance to stop",
                          [mmHARDCORE2,mmNULL,mmHCANCEL], MENU_CHANNEL);

}

hardcore_lockdown() { 

   llOwnerSay("HARDCORE ENABLED: Welcome to permanent slavery.");
   HARDCORE_ON = TRUE;
   SetMode(MODE_AUTO);

}

hardcore_cancel() { 

   llOwnerSay("HARDCORE restrictions cancelled.... but you'll be back... sooner or later.");

}

// check that this command is for us and not someone else integer verifyWeAreTarget(string message) { 

   list tokens = llParseString2List(message, [","], []);
   if (llGetListLength(tokens) != 3) // this is not a normal command
   {
       return FALSE;
   }

   return (llList2String(tokens, 1) == llGetOwner()); // talking to me ?

}

// checks that the type of object (world object, attachment) is allowed integer verifySourceType(key id) { 

   if (ALLOW_CONTROL_BY_ATTACHMENTS)
   {
       return TRUE;
   }

   return !isAttachment(id);

}

processNewRequest(integer corePrim, string message, key id) { 

   if (IsMode(MODE_OFF))
   {
       debug("deactivated - ignoring commands");
       return; // mode is 0 (off) => reject
   }
   
   if (!(verifyWeAreTarget(message) && verifySourceType(id)))
      return;

   if (!verifyPermission(id, corePrim, message))
       return;
   
   debug("Executing: " + (string)corePrim);
   llMessageLinked(corePrim, DOIT_COMMAND, message, id);

}

// // B E G I N S //

default { 

   state_entry()
   {
       init();
   }

   attach(key id)
   {
       if (id == NULL_KEY)
           return;
       integer ap = llGetAttached();
       while (ap < ATTACH_HUD_CENTER_2 || ap > ATTACH_HUD_BOTTOM_RIGHT)
       {
           llOwnerSay("The relay must be attached to the HUD and not elsewhere.");
           llOwnerSay("@detach=y");
           llSleep(30);
           ap = llGetAttached();
       }
   
       vector eul = <0.0,270.0,0.0>;
       eul *= DEG_TO_RAD;
       llSetRot(llEuler2Rot(eul));
       
       if (!IsMode(MODE_OFF))
       {
           lockON();
       }

       // remind the current mode to the user
       //
       
       llOwnerSay(getModeDescription());
   }
   
   link_message(integer sender, integer channel, string message, key id)
   {
       debug("link:" + (string)channel + ": " + message);
       
       if (channel == STATUS_OPEN_CHANNEL)
       {
           llWhisper(0, message);
       }
       else if (channel == STATUS_SAY_CHANNEL)
       {
           llOwnerSay(message);
       }
   }

   listen(integer channel, string name, key id, string message)
   {
       debug("listen:" + (string)channel + ": " + message);
       
       if (channel==RLVRS_CHANNEL)
       {
           list tokens = llParseString2List(message, [","], []);
           if (llGetListLength(tokens) != 3 && llList2Key(tokens, 1) != llGetOwner())
               return;
               
           integer i = findCoreKey(id);
           
           if (i == -1)
           {
               i = findCoreKey(NULL_KEY);
               
               if (i == -1)   return;
               
               processNewRequest(i, message, id);
           }
           else
           {
               debug("Sending '" + message + "' on #" + (string)i);
               llMessageLinked(i, NO_COMMAND, message, id);
           }
       }
       
       else if (channel == DIALOG_CHANNEL)
       {
           processDialogResponse(message);
       }
       
       else if (channel == MENU_CHANNEL)
       {
           llListenControl(MENU_HANDLE,FALSE);          // done with you, go deaf
           
           if ( id != llGetOwner() )           return;

           if      (message == mmOFF)          {   SetMode(MODE_OFF);
                                                   releaseRestrictions ();
                                               }
                                               
           else if (message == mmASK)          {   SetMode(MODE_ASK);
                                               }
           
           else if (message == mmAUTO)         {   SetMode(MODE_AUTO);
                                               }
           
           else if (message == mmHARDCORE1)    hardcore_confirm();
           else if (message == mmHARDCORE2)    hardcore_lockdown();
           else if (message == mmHCANCEL)      hardcore_cancel();
           
           else if (message == mmSAFE)         safeword();
           else if (message == mmSAFE1)        safeword1();
           else if (message == mmSAFE2)        safeword2();
           else if (message == mmSAFE3)        safeword3();
           else if (message == mmRELEASE)      safeword_release();
           else if (message == mmSCANCEL)      safeword_cancel();
           
           else if (message == mmSAFEOFF)      safewordOFF();
           else if (message == mmSWOCONFIRM)   safewordOFF_CONFIRM();
           else if (message == mmSWOCANCEL)    safewordOFF_CANCEL();
       }   
   }

   touch_start(integer num_detected)
   {
       
       if (mDEBUG) llWhisper(0,"Free Memory: " + (string) llGetFreeMemory());
       
       integer cx;
       key     corecheck;
       vector  myPos = llGetPos();
       
       for (cx = 0; cx < cores; ++cx)
       {
           corecheck = getControlObject(llList2Integer(corePrims, cx));
           if (corecheck != NULL_KEY)                                  // just on the off chance the object disappeared
           {                                                           // or we got away without getting released
               list l = llGetObjectDetails(corecheck, [ OBJECT_POS ]);   // check on the object
               float dist = 0.0;
               
               if(llGetListLength(l) > 0)                              // it's still around
               {
                   // we checking to see if we are near the object
                   // compute the distance in 2D (no Z-axis)
                   vector avatarPos = llList2Vector(l, 0);
                   avatarPos.z = 0.0;
                   myPos.z = 0.0;
               
                   dist = llVecDist(avatarPos, myPos);
               }
               
               if(llGetListLength(l) == 0 || dist > 96.0)              // ok, we're too far away, let me go
               {
                   llWhisper(0, "Lucky Day: " + llKey2Name(llGetOwner()) + " is freed because the device is out of range.");
                              
                   llMessageLinked(llList2Integer(corePrims, cx), FREE_COMMAND, "free", NULL_KEY);
               }
           }
       }
       
       list mmBUTTONS;
       string mmMENU;
       
       if (isBusy())         // ahhh.. we are locked down... but maybe can do something
       {
           if ( HARDCORE_ON && !SAFEWORD_ENABLE )  // HARDCORE and turned off SAFEWORD... sneer at them and leave
           {
               llOwnerSay("You're the hardest of the HARDCORE, nothing you can do, no SAFEWORD remember?");
               return;
           } 
           else if (!SAFEWORD_ENABLE)                       // well maybe not, foolish mortal......
           {
               llOwnerSay("You turned off SAFEWORD, that door is closed.");
               return;
           }
           else if (SAFEWORD_ENABLE)
           {                 
               mmBUTTONS = [mmSAFE];               // ok, they can safeword out.. 
               mmMENU = mmMENUTEX2;
           }
       }    
       else                // not locked down, so maybe they can do something
       {
               
           if (HARDCORE_ON)                     // HARDCORE, not locked down... nothing to see here, move along
           { 
               llOwnerSay("HARDCORE: Controls Disabled");
               return;
           } 
                      
           if (SAFEWORD_ENABLE)                // SAFEWORD still enabled, they can go HARDCORE, disable SAFEWORD
           {                                   // or ON/OFF/AUTO
               mmBUTTONS = [mmNULL, mmHARDCORE1, mmSAFEOFF, mmOFF, mmAUTO, mmASK];
               mmMENU = mmMENUTEX1+mmMENUTEX1a+mmMENUTEX2a;
           }
           if (!SAFEWORD_ENABLE)              // SAFEWORD disabled, they can go HARDCORE or ON/OFF/AUTO
           {                                  
               mmBUTTONS = [mmNULL, mmHARDCORE1, mmNULL, mmOFF, mmAUTO, mmASK];
               mmMENU = mmMENUTEX1+mmMENUTEX1a;
           }
       }
       
       llListenControl(MENU_HANDLE,TRUE);                               // turn on the menu listener
       llDialog(llGetOwner(), mmMENU, mmBUTTONS, MENU_CHANNEL );       // and see what they can do
   }

   changed(integer change)
   {
       if (change & (CHANGED_OWNER | CHANGED_INVENTORY | CHANGED_ALLOWED_DROP)) \
            llResetScript();
   }
   
   timer()
   {
       processDialogResponse("Deny");
   }

} </lsl>

The SPU

The SPU (Slave Processing Unit) is assigned to an in-world object as it attempts to control the PBA. Each SPU is located in a seperate prim that, in the tkPBA is a single 'pip' inside the loop of the padlock that is the tkPBA HUD. When a SPU is free, the pip is black, when it is actively being controlled by an object, it turns green. When an object is assigned to the SPU but the tkPBA is in 'ASK' mode, the pip turns yellow until permission is granted (green) or denied (black and freed). The description field of the prim holds the UUID of the object currently controlling the SPU and the UUID of the last Avatar to send it a command (if available).

The SPU maintains all the restrictions of the object on the wearer, and generally the 'dirty work' of the relay function.

version tk.RLV1030 SPU (090305.0) --Ilana Debevec 18:24, 5 March 2009 (UTC)

<lsl> // tk.RLV1030 SPU (090305.0)

// ©left 2009 Think Kink (Think Kink is Ilana Debevec, Lyssa Daehlie & Chloe1982 Constantine)

// the Think Kink Restained Life PBA Relay (tkPBA for short) is released under a modified "CopyLeft" license. // The short form without legalese.

// This code is provided AS-IS, OPEN-SOURCE and holds NO WARRANTY of accuracy, completeness or performance. // It may be distributed in its full source code with this header and disclaimer and is not to be sold without // permission. Optionally it may be distributed in a 'no mod' form within Second Life™ PROVIDED that either a // link to the full source IS provided (ie. this page or a .zip or .rar) within the object the code is contained // AND/OR a off-world contact point (ie. email) that the source code may be requested from. This somewhat unusual // (no-mod) distribution is allowed to maintain the integrity and reliability of the creator reference of in-world // objects (scripts). Changes and improvement to this code must be shared with the community so that we ALL benefit.

// Based on Maike Short's 1030b relay, with thanks to Tahni Taratal, RL Ansome, Nihal Quah and all of the staff of // THINK KINK who helped with the shakedown and development of this device. Recursive thanks to everyone that has // gone before on the devlopment of the Restraint Life Relay, including (but not limited to) Maike Short, Felis Darwin, // Chorazin Allen, Azoth Amat, Gregor Mougin, Nano Siemens, Cerdita Piek, Satomi Ahn, Marissa Mistwallow and she who // started it all ... Marine Kelley.

// An extra special personal thanks to Chloe1982 Constantine who was able to help me put ideas into bits when I // was buried whisker deep in both SL and RL issues.

// In-world (no mod) copies of this relay may be picked up for free at THINK KINK in LaSalle // or email to Ilana.Debevec@gmail.com for full source.

// Ilana Debevec 25 Feb 2009

// I couldn't have written this without both Ilana and Maike. // I wouldn't have written this without Jayne to whom this work is dedicated. // Chloe 14 February 2009

integer DEBUG = FALSE;

// --------------------------------------------------- // Constants // ---------------------------------------------------

integer RLVRS_PROTOCOL_VERSION = 1030; // version of the protocol, stated on the specification page string RLVRS_IMPL_VERSION = "tkPBA based on Maike's 1.030"; // version of the implementation for debugging

string PREFIX_RL_COMMAND = "@"; string PREFIX_METACOMMAND = "!";

integer RLVRS_CHANNEL = -1812221819; // RLVRS in numbers integer STATUS_OPEN_CHANNEL = -1373421300; integer STATUS_SAY_CHANNEL = -1373421301; integer GPU_CHANNEL = -4360493; integer GPU_PRIM;

integer NO_COMMAND = 0; integer FREE_COMMAND = 1; integer HOLD_COMMAND = 2; integer DOIT_COMMAND = 3; integer TEST_COMMAND = 4;

integer MAX_OBJECT_DISTANCE = 100; // 100m is llShout distance

integer LOGIN_DELAY_WAIT_FOR_PONG = 10; integer LOGIN_DELAY_WAIT_FOR_FORCE_SIT = 60;

string RVL_COMMAND_START = "@this-is-a-script-generated-message-beyond-the-control-of-the-agent=n"; string RVL_COMMAND_BLOCK = "@this-is-a-script-generated-message-beyond-the-control-of-the-agent";

string coreName = "0";

// --------------------------------------------------- // Variables // ---------------------------------------------------

list restrictions; // restrictions currently applied (without the "=n" part) key source; // UUID of the object I'm commanded by, always equal to NULL_KEY if restrictions is empty, always set if not

string pendingMessage; // message of pending request integer pendingTime;

// used on login integer timerTickCounter; // count the number of time events on login (forceSit has to be delayed a bit) integer loginWaitingForPong; integer loginPendingForceSit;

integer holding = FALSE; key whoDoing = NULL_KEY; key devOwner = NULL_KEY; key devQuery = NULL_KEY; string devOName = ""; string whoName = "";


// --------------------------------------------------- // Helper functions // ---------------------------------------------------


debug(string x) { 

   if (DEBUG)
   {
       llOwnerSay("DEBUG:Core" + coreName + ": " + x);
   }

}


// --------------------------------------------------- // Low Level Communication // ---------------------------------------------------


// acknowledge or reject ack(string cmd_id, key id, string cmd, string ack) { 

   llShout(RLVRS_CHANNEL, cmd_id + "," + (string)id + "," + cmd + "," + ack);

}

// cmd begins with a '@' sendRLCmd(string cmd) { 

   debug("Send: " + cmd);
   if (cmd != "")
       llOwnerSay(cmd);

}


// --------------------------------------------------- // Permission Handling // ---------------------------------------------------


// check whether the object is in llSay distance. // The specification requires llSay instead of llShout or llRegionSay // to be used to limit the range. But this has to be checked here again // because the objects are not trustworthy. integer isObjectNear(key id) { 

   vector myPosition = llGetRootPosition();
   list temp = llGetObjectDetails(id, ([OBJECT_POS]));
   vector objPostition = llList2Vector(temp,0);
   float distance = llVecDist(objPostition, myPosition);
   debug("Object distance: " + (string)distance);
   return distance <= MAX_OBJECT_DISTANCE;

}

// If we already have commands from this object pending // because of a permission request dialog, just add the // new commands at the end. tryToGluePendingCommands(key id, string message) { 

   if (llStringLength(pendingMessage) > 4000)
   {
       llMessageLinked(LINK_ROOT, STATUS_OPEN_CHANNEL, llKey2Name(id) + " is flooding commands. Releasing restrictions.", NULL_KEY);
       releaseRestrictions();
   }
   else
   {
       pendingMessage = pendingMessage + "|" + llList2String(llParseString2List(message, [","], []), 2);
   }

}


// accept !release even if out of range handleCommandsWhichAreAcceptedOutOfRange(string message) { 

   list list_of_commands = llParseString2List(message, ["|"], []);
   if (llListFindList(list_of_commands, ["!release"]) > -1)
   {
       debug("accepted !release although it was out of range");
       releaseRestrictions();
   }

}


// --------------------------------------------------- // Executing of commands // ---------------------------------------------------

// execute a non-parsed message // this command could be denied here for policy reasons, (if it were implemenetd) // but this time there will be an acknowledgement execute(key id, string message) { 

   list tokens = llParseString2List(message, [","], []);
   string cmd_id = llList2String(tokens, 0); // CheckAttach
   list list_of_commands = llParseString2List(llList2String(tokens, 2), ["|"], []);
   if (llList2Key(tokens, 1) != llGetOwner())
       return;                                 // This shouldn't happen, but can't hurt

   integer len = llGetListLength (list_of_commands);
   integer i;
   string command;
   string prefix;
   for (i=0; i<len; ++i) // execute every command one by one
   {
       // a command is a RL command if it starts with '@' or a metacommand if it starts with '!'
       command = llList2String(list_of_commands, i);
       prefix = llGetSubString(command, 0, 0);

       if (prefix == PREFIX_RL_COMMAND) // this is a RLV command
       {
           executeRLVCommand(cmd_id, id, command);
       }
       else if (prefix == PREFIX_METACOMMAND) // this is a metacommand, aimed at the relay itself
       {
           executeMetaCommand(cmd_id, id, command);
       }
   }

}

// is this a query? integer isQuery(string behav) { 

   return ((llGetSubString(behav, 0, 3) == "@get") ||
           (llGetSubString(behav, 0, 7) == "@version") ||
           (llGetSubString(behav, 0, 10) == "@findfolder"));

}

// executes a command for the restrained life viewer // with some additinal magic like book keeping executeRLVCommand(string cmd_id, string id, string command) { 

   command = llToLower(command);
   // we need to know whether whether is a rule or a simple command
   list tokens = llParseString2List(command, ["="], []);
   string behav = llList2String(tokens, 0); // @getattach:skull
   string param = llList2String(tokens, 1); // 2222
   integer ind = llListFindList(restrictions, [behav]);

   tokens = llParseString2List(behav, [":"], []); // @sit:<uuid>
   string behavName = llList2String (tokens, 0);  // @sit

   debug("executeRLVCommand: behav=!" + behav + "! param=!" + param + "!");

   if ((behavName == RVL_COMMAND_BLOCK && param != "n") ||
       (isQuery(behavName) && (integer)param <= 0))
   {
       ack(cmd_id, id, command, "ko");
       return;
   }
   else if (param=="n" || param=="add") // add to restrictions
   {
       if (ind < 0)
       {
           if (llGetListLength(restrictions) == 0)
           {
               sendRLCmd(RVL_COMMAND_START);
           } 
           restrictions += [behav];
       }
       setSource(id); // we know that source is either NULL_KEY or id already
   }
   else if (param == "y" || param == "rem") // remove from restrictions
   {
       if (ind > -1) 
       {
           restrictions = llDeleteSubList (restrictions, ind, ind);
       }
       if (llGetListLength(restrictions) == 0)
       {
           setSource(NULL_KEY);
       }
       removeFromPendingList(behav);
   }

   else if (param != "force" && ((integer) param == 0) && (behavName != "@clear"))
   {
       // this is either an unknown param (not "n", "add", "y", "rem", "force")
       // or a query which should be answered on the public chat channel 0.
       ack(cmd_id, id, command, "ko");
       return;
   }

   workaroundForAtClear(command);
   sendRLCmd(command); // execute command
   ack(cmd_id, id, command, "ok"); // acknowledge

}

// check for @clear // Note: @clear MUST NOT be used because the restrictions will be reapplied on next login // (but we need this check here because "!release|@clear" is a BROKEN attempt to work around // a bug in the first relay implementation. You should refuse to use relay versions < 1013 // instead.) workaroundForAtClear(string command) { 

   if (command == "@clear")
   {
       releaseRestrictions();
   }

}

setSource(key id) { 

   source = id;
   if (holding)
       llSetObjectDesc((string)id + "^" + (string)whoDoing);
   else
       llSetObjectDesc((string)id);
   if (source == NULL_KEY)
       return;
   devOwner = llGetOwnerKey(source);
   devQuery = llRequestAgentData(devOwner, DATA_NAME);

}

// executes a meta command which is handled by the relay itself executeMetaCommand(string cmd_id, string id, string command) { 

   if (command == PREFIX_METACOMMAND + "version") // checking relay protocol version
   {
       ack(cmd_id, id, command, (string) RLVRS_PROTOCOL_VERSION);
   }
   else if (command == PREFIX_METACOMMAND + "implversion") // checking relay version
   {
       ack(cmd_id, id, command, RLVRS_IMPL_VERSION);
   }
   else if (command == PREFIX_METACOMMAND + "release") // release all the restrictions (end session)
   {
       releaseRestrictions();
       ack(cmd_id, id, command, "ok");
   }
   else if (command == PREFIX_METACOMMAND + "pong")
   {
       loginWaitingForPong = FALSE;
   }
   else if (llGetSubString(command, 0, 3) == PREFIX_METACOMMAND + "who")
   {
       list wCommands = llParseString2List(command, ["/"], []);
       key k = llList2Key(wCommands, 1);
       if (k)
       {
           whoDoing = k;
           whoName = llKey2Name(k);
       }
   }
   else if (llGetSubString(command, 0, 6) == PREFIX_METACOMMAND + "vision")
   {
       llMessageLinked(GPU_PRIM, GPU_CHANNEL, command, NULL_KEY);
       ack(cmd_id, id, command, "ok");
   }

}

// removes a restriction from the list of pending commands removeFromPendingList(string behav) { 

   string search = behav + "=";

   // don't do the expensive parsing (string operations are very slow in pre- 
   // mono LSL) in case we can detect fast that this one is not in the list.
   if (llSubStringIndex(pendingMessage, search) < 0)
   {
       return;
   }

   list tokens = llParseString2List(pendingMessage, [","], []);
   list commands = llParseString2List(llList2String(tokens, 2), ["|"], []);
   integer modified = FALSE;

   integer len = llGetListLength(commands);
   integer i;
   for (i = len - 1; i >= 0; i--)
   {
       string cmd = llList2String(commands, i);
       if (llSubStringIndex(cmd, search) == 0)
       {
           if (llSubStringIndex(cmd, "=n") > -1 || llSubStringIndex(cmd, "=add") > -1)
           {
               commands = llDeleteSubList(commands, i, i);
               modified = TRUE;
           } 
       }
   }

   if (modified)
   {
       if (llGetListLength(commands) > 0)
       {
           pendingMessage = llList2String(tokens, 0) + "," + llList2String(tokens, 1) + "," + llDumpList2String(commands, "|");
       }
       else
       {
           clearPendingMessages();
       }
   }

}


// lift all the restrictions (called by !release and by turning the relay off) releaseRestrictions() { 

   holding = FALSE;
   whoDoing = NULL_KEY;
   whoName = "";
   devOName = "";
   devOwner = NULL_KEY;
   
   llSetColor(<0.0, 0.0, 0.0>,ALL_SIDES); //  Black
   llSetAlpha(1.0,ALL_SIDES);
   llMessageLinked(GPU_PRIM, GPU_CHANNEL, "!visionclear", NULL_KEY);

   setSource(NULL_KEY);
   integer i;
   integer len = llGetListLength (restrictions);
   for (i = 0; i < len; ++i)
   {
       sendRLCmd(llList2String (restrictions, i) + "=y");
   }
   restrictions = [];
   loginPendingForceSit = FALSE;
   clearPendingMessages();

}

// sends an !release,ok to the world object if we are in an active session tellWorldObjectAboutCanceledSession() { 

   if (source != NULL_KEY)
   {
       ack("release", source, "!release", "ok");
   }

}


// deletes the list of pending messsages clearPendingMessages() { 

   // clear pending request
   pendingMessage = "";
   pendingTime = 0;

}


// processes a message send on the relay channel processRelayMessage(key id, string message) { 

   debug("Got message (active world object " + (string) source + "): id=" + (string) id + " message=" + message + "\nholding = "+(string)holding);

   if (!isObjectNear(id)) 
   {
       handleCommandsWhichAreAcceptedOutOfRange(message);
       return;
   }
   if (holding)
       tryToGluePendingCommands(id, message);
   else
       execute(id, message);

}

// --------------------------------------------------- // initialisation and login handling // ---------------------------------------------------

init() { 

   list thisCore = llParseString2List(llGetObjectName(), [":"], []);
   
   if (llGetListLength(thisCore) !=2) return; // less that 2, no colon, more than 2, too many 
   coreName = llList2String(thisCore,1);      // know what you're doing, I'll trust you
   
   llSetColor(<0.0, 0.0, 0.0>,ALL_SIDES); //  Black
   llSetAlpha(1.0,ALL_SIDES);
   
   integer n = llGetNumberOfPrims();
   integer i;
   for(i = 1; i <= n; ++i) 
       if (llGetLinkName(i) == "ddsg.GPU:0")
           GPU_PRIM = i;

   debug("Free Memory: " + (string) llGetFreeMemory());

}


// sends the known restrictions (again) to the RL-viewer // (call this functions on login) reinforceKnownRestrictions() { 

   integer i;
   integer len = llGetListLength(restrictions);
   string restr;
   
   debug("source=" + (string) source);
   if (len > 0)
   {
       sendRLCmd(RVL_COMMAND_START);
   }
   for (i=0; i < len; ++i)
   {
       restr = llList2String(restrictions, i);
       debug("restr=" + restr);
       sendRLCmd(restr + "=n");
       if (restr == "@unsit")
       {
           loginPendingForceSit = TRUE;
       }
   }

}

// send a ping request and start a timer pingWorldObjectIfUnderRestrictions() { 

   loginWaitingForPong = FALSE;
   if (source)
   {
       ack("ping", source, "ping", "ping");
       timerTickCounter = 0;
       llSetTimerEvent(1.0);
       loginWaitingForPong = TRUE;
   }

}

sendForceSitDuringLogin() { 

   debug("Force sit during login on " + (string) source);
   sendRLCmd ("@sit:" + (string) source + "=force");

}


// processes a timer event processTimer() { 

   timerTickCounter++;
   debug("timer (" + (string) timerTickCounter + "): waiting for pong: " + (string) loginWaitingForPong + " pendingForceSit: " + (string) loginPendingForceSit);
   if (loginWaitingForPong && (timerTickCounter >= LOGIN_DELAY_WAIT_FOR_PONG))
   {
       llMessageLinked(LINK_ROOT, STATUS_OPEN_CHANNEL, "Lucky Day: " + llKey2Name(llGetOwner()) + " is freed because " + llKey2Name(source) + " is not available.", NULL_KEY);
       loginWaitingForPong = FALSE;
       loginPendingForceSit = FALSE;
       releaseRestrictions();
   }

   if (loginPendingForceSit)
   {
       integer agentInfo = llGetAgentInfo(llGetOwner());
       if (agentInfo & AGENT_SITTING)
       {
           loginPendingForceSit = FALSE;
           debug("is sitting now");
       }
       else if (timerTickCounter == LOGIN_DELAY_WAIT_FOR_FORCE_SIT)
       {
           llMessageLinked(LINK_ROOT, STATUS_OPEN_CHANNEL, "Lucky Day: " + llKey2Name(llGetOwner()) + " is freed because sitting down again was not possible.", NULL_KEY);
           loginPendingForceSit = FALSE;
           releaseRestrictions();
       }
       else
       {
           sendForceSitDuringLogin();
       }
   }

   if (!loginPendingForceSit && !loginWaitingForPong)
   {
       llSetTimerEvent(0.0);
   }

}

processCmdMessage(integer num, key id, string message) { 

   if (num == DOIT_COMMAND)
   {
       llSetColor(<0.0, 1.0, 0.0>,ALL_SIDES); //  Green
       llSetAlpha(1.0,ALL_SIDES);

       holding = FALSE;
       if (id == NULL_KEY)
       {
           setSource(source);
           execute(source, pendingMessage);
       }
       else
       {
           setSource(id);
           execute(source, message);
       }
   }
   else if (num == TEST_COMMAND)
       execute(id, message);
   else if (num == FREE_COMMAND && message == "free")
       releaseRestrictions();
   else if (num == HOLD_COMMAND)
   {
       llSetColor(<1.0, 1.0, 0.0>,ALL_SIDES); //  Yellow
       llSetAlpha(1.0,ALL_SIDES);
       
       holding = TRUE;
       
       list lCommands = llParseString2List(message, [",", "/", "|"], []);
       debug("First command: " + llList2String(lCommands, 2));
       if (llList2String(lCommands, 2) == "!who")
       {
           key k = llList2Key(lCommands, 3);
           debug("key="+(string)k);
           whoDoing = NULL_KEY;
           if (k)
               whoDoing = k;
       }
       
       setSource(id);
       pendingMessage = message;
       pendingTime = llGetUnixTime();
   }

}

displayState() { 

   string message = "Idle";
   if (source != NULL_KEY)
   {
       key owner = llGetOwner();
       key devOwner = llGetOwnerKey(source);
       
       string who = "";
       if (whoName != "")
           who = whoName + ", using ";
       
       string whose = "an anonymously owned ";
       if (owner == devOwner)
           whose = "your ";
       else if (devOwner == whoDoing)
           whose = "their ";
       else if (devOName != "")
           whose = devOName + "'s ";
       
       vector pos = llList2Vector(llGetObjectDetails(source, [OBJECT_POS]), 0);
       message = who + whose + llKey2Name(source) + " located at " + llGetRegionName()
           +  " <" + (string) ((integer) pos.x)
           + ", " + (string) ((integer) pos.y)
           + ", " + (string) ((integer) pos.z) + ">";
   }
   llMessageLinked(LINK_ROOT, STATUS_SAY_CHANNEL, "Core #" + coreName + ": " +message, NULL_KEY);

}

default { 

   state_entry()
   {
       init();
   }

   on_rez(integer start_param)
   {
       // relogging, we must refresh the viewer and ping the object if any
       // if source is set to something, fire all the stored restrictions
       if (source != NULL_KEY)
       {
           reinforceKnownRestrictions();
           pingWorldObjectIfUnderRestrictions();
       }
   }

   attach(key id)
   {
       if (id == NULL_KEY)
       {
           tellWorldObjectAboutCanceledSession();
           releaseRestrictions();
       }
   }

   timer()
   {
       processTimer();
   }

   link_message(integer sender, integer num, string message, key id)
   {
       debug("Link:" + (string)num + ": " + message);
       
       if (num == NO_COMMAND)
           processRelayMessage(id, message);
       else
           processCmdMessage(num, id, message);
   }
   
   touch_start(integer num)
   {
       // How this could be anything other than 1 I don't know
       displayState();
   }

   changed(integer change)
   {
       if (change & (CHANGED_OWNER | CHANGED_INVENTORY | CHANGED_ALLOWED_DROP)) 
       {
            llResetScript();
       }
   }
   
   dataserver(key query, string data)
   {
       if (query == devQuery)  // I don't see how it could be anything else
           devOName = data;
   }

} </lsl>

The GPU

The GPU is the 'bare metal' interface to the vision restrictions, actually changing the size, shape, texture, transparency, etc of the vision restriction prim. It maintains a stack of restrictions so multiple !vision requests can be additive as they come in and restored as they are lifted.

version tk.GPU (090305.0) --Ilana Debevec 18:25, 5 March 2009 (UTC) <lsl> // tk.GPU (090305.0) // // ©left 2009 Think Kink (Think Kink is Ilana Debevec & Lyssa Daehlie)

// the Think Kink Restained Life PBA Relay (tkPBA for short) is released under a modified "CopyLeft" license. // The short form without legalese.

// This code is provided AS-IS, OPEN-SOURCE and holds NO WARRANTY of accuracy, completeness or performance. // It may be distributed in its full source code with this header and disclaimer and is not to be sold without // permission. Optionally it may be distributed in a 'no mod' form within Second Life™ PROVIDED that either a // link to the full source IS provided (ie. this page or a .zip or .rar) within the object the code is contained // AND/OR a off-world contact point (ie. email) that the source code may be requested from. This somewhat unusual // (no-mod) distribution is allowed to maintain the integrity and reliability of the creator reference of in-world // objects (scripts). Changes and improvement to this code must be shared with the community so that we ALL benefit.

// Based on Maike Short's 1030b relay, with thanks to Tahni Taratal, RL Ansome, Nihal Quah and all of the staff of // THINK KINK who helped with the shakedown and development of this device. Recursive thanks to everyone that has // gone before on the devlopment of the Restraint Life Relay, including (but not limited to) Maike Short, Felis Darwin, // Chorazin Allen, Azoth Amat, Gregor Mougin, Nano Siemens, Cerdita Piek, Satomi Ahn, Marissa Mistwallow and she who // started it all ... Marine Kelley.

// An extra special personal thanks to Chloe1982 Constantine who was able to help me put ideas into bits when I // was buried whisker deep in both SL and RL issues.

// In-world (no mod) copies of this relay may be picked up for free at THINK KINK in LaSalle // or email to Ilana.Debevec@gmail.com for full source.

// Ilana Debevec 25 Feb 2009

// I couldn't have written this without both Ilana and Maike. // I wouldn't have written this without Jayne to whom this work is dedicated. // Chloe 14 February 2009

// if needed to check what is happening here integer DEBUG = FALSE;

integer VISION_COMMAND = -4360493; // identifies commands to the GPU list corePrims; // prims that have sent commands list coreAlphas; // transparency values list coreColors; // colors that have been set list coreTextures; // textures sent to the GPU list coreRepeats; // Repeats values list coreOffsets; // Lists of offsets list coreRotations; // Rotations in radians

debug(string x) { 

   if (DEBUG)
   {
       llOwnerSay("DEBUG:GPU: " + x);
   }

}

string strReplace(string str, string search, string replace) { 

   return llDumpList2String(llParseStringKeepNulls((str = "") + str, [search], []), replace);

}

integer invalidVector(vector v, float lowVal, float highVal) { 

   if (v.x < lowVal || v.y < lowVal || v.z < lowVal)
       return TRUE;
   if (highVal < lowVal)
       return FALSE;
   if (v.x > highVal || v.y > highVal || v.z > highVal)
       return TRUE;
   return FALSE;

}

setBlind(integer corePrim, string color, string alpha, key texture, string repeats, string offsets, string rot) { 

   corePrims += [corePrim];
   
   float na;
   if (alpha == "*")
       na = llList2Float(coreAlphas, -1);
   else
   {
       na = (float)alpha;
       if (na < 0.0)
           na = 0.0;
       else if (na > 1.0 && na <= 100.0)
           na /= 100.0;
       else if (na > 100.0)
           na = 1.0;
   }
   coreAlphas += [na];
   
   vector nc;
   if (color == "*")
       nc = llList2Vector(coreColors, -1);
   else
   {
       nc = (vector)strReplace(color, "'", ",");
       if (nc.x > 1.0)
           nc = nc/255;
       if (invalidVector(nc, 0.0, 1.0))
           nc = llList2Vector(coreColors, 0);
   }
   coreColors += [nc];
   
   if (texture)
   {                   // stupid SL
   }
   else if ((string)texture == "*")
       texture = llList2Key(coreTextures, -1);
   else
       texture = llList2Key(coreTextures, 0);
   coreTextures += [texture];
   
   coreRepeats += [makeVector(repeats, 0.0, -1.0, coreRepeats)];
   
   coreOffsets += [makeVector(offsets, -1.0, 1.0, coreOffsets)];
   
   float nr;
   if (rot == "*")
       na = llList2Float(coreRotations, -1);
   else
   {
       nr = (float)rot;
       if (nr < 0.0)
           nr = 0.0;
   }
   coreRotations += [nr];
   
   integer p;
   p = llListFindList(corePrims, [corePrim]);
   if ((p+1) < llGetListLength(corePrims))
       clearBlind(corePrim);

}

vector makeVector(string str, float lv, float hv, list vecs) { 

   vector nr;
   if (str == "")
       return llList2Vector(vecs, 0);
   if (str == "*")
       return llList2Vector(vecs, -1);
   nr = (vector)("<"+strReplace(str, "'", ",")+",0.0>");
   if (invalidVector(nr, lv, hv))
       return llList2Vector(vecs, 0);
   return nr;

}

clearBlind(integer corePrim) { 

   integer pos = llListFindList(corePrims, [corePrim]);
   if (pos == -1)
       return;
   corePrims = llDeleteSubList(corePrims, pos, pos);
   coreAlphas = llDeleteSubList(coreAlphas, pos, pos);
   coreColors = llDeleteSubList(coreColors, pos, pos);
   coreTextures = llDeleteSubList(coreTextures, pos, pos);
   coreRepeats = llDeleteSubList(coreRepeats, pos, pos);
   coreOffsets = llDeleteSubList(coreOffsets, pos, pos);
   coreRotations = llDeleteSubList(coreRotations, pos, pos);

}

integer allClear() { 

   return llGetListLength(corePrims) == 1;

}

float blindAlpha() { 

   integer i;
   integer n = llGetListLength(coreAlphas);
   float ra = llList2Float(coreAlphas, 0);
   float ta;
   for (i = 1; i < n; i++)
       if ((ta = llList2Float(coreAlphas, i)) < ra)
           ra = ta;
   return ra;

}

default { 

   state_entry ()
   {
       corePrims       = [-1];
       coreAlphas      = [1.0];
       coreColors      = [<1.0,1.0,1.0>];
       coreTextures    = [TEXTURE_BLANK];
       coreRepeats     = [<1.0,1.0,0.0>];
       coreOffsets     = [<0.0,0.0,0.0>];
       coreRotations   = [0.0];
       
       llSetScale(<0.01, 0.01, 0.01>);
       llSetColor(<1,1,1>,ALL_SIDES);
   }  
   
   on_rez (integer foo)
   {
       llResetScript();
   }
   
   link_message(integer sender_num, integer num, string command, key id)
   {
       debug("link:"+(string)num+": " + command);
       if (num != VISION_COMMAND)
           return;
       list lCommand = llParseString2List(command, ["/"], []);
       debug("#"+(string)llGetListLength(lCommand)+": "+(string)lCommand);
       string meta_command = llList2String(lCommand, 0);
       
       if (meta_command == "!vision")
       {
           if (llGetListLength(lCommand) < 4)
               return;
           setBlind(sender_num, llList2String(lCommand, 1), llList2String(lCommand, 2),
               llList2String(lCommand, 3), llList2String(lCommand, 4),
               llList2String(lCommand,5), llList2String(lCommand, 6));
       }
       else if (meta_command == "!visionclear")
       {
           clearBlind(sender_num);
       }
       else
           return;
       
       if (allClear())
       {
           llResetScript();
           return;
       }
       
       llSetPrimitiveParams([PRIM_COLOR, ALL_SIDES, llList2Vector(coreColors, -1),
           blindAlpha()]);
       llSetPrimitiveParams([PRIM_TEXTURE, ALL_SIDES, llList2String(coreTextures, -1),
           llList2Vector(coreRepeats, -1), llList2Vector(coreOffsets, -1),
           llList2Float(coreRotations, -1)]);
       llSetScale(<0.01, 10.0, 10.0>);
   }

} </lsl>

Retrieved from "https://wiki.secondlife.com/w/index.php?title=LSL_Protocol/Restrained_Love_Relay/Other_Implementations/DEM_Relay_HUD&oldid=267093"