//=====================================================================
// ** Multi-Strength Lockable Muffler
//  * Version 1.10
//  * Coded by: Yeyinde
//---------------------------------------------------------------------
// INSTRUCTIONS:
//  1: Change the OBJECT_TYPE constant to reflect on what kind of
//     attachment the script will be in.  Eg. muzzle, gag, mask, ect.
//  2: If muffling of speach heard is desired, change FULL_MUFFLE_MODE
//     to TRUE.
//  3: Save and drag into an attachment's inventory, either from on the
//     ground or while attached.
//  4: Use RLV when attached to see the effects of the script.
//=====================================================================

// The type of object that is housing the script. Eg. muzzle, gag, etc.
string OBJECT_TYPE = "helmet";
// Turns on the hearing muffler when set to TRUE.
integer FULL_MUFFLE_MODE = TRUE;
// Allows for blinders to be toggled when set to TRUE.
integer BLINDABLE_MODE = TRUE;
// RLV channel
integer RLV_CHANNEL = 1812221819;
// Key variables used by the muffler script.
key gObjOwner = NULL_KEY;
key gKeyHolder = NULL_KEY;
string gKeyHolderName;
key gCurrentUser = NULL_KEY;
key gOwner = NULL_KEY;
string gOwnerName;
integer gMufflerListener;
integer gMufflerChannel;
integer gMufflerStrength = 0;
integer gCommandListener;
integer gCommandChannel;
integer gCommandTimeout = 0;
integer gHearingListener;
integer gTimelock = 0;
integer gCurrentTimeLocked = 0;
integer gTotalTimeLocked = 0;
integer gBestTimeLocked = 0;
integer gRlvListener;
integer gRlvState;
integer gBlinderOn = FALSE;
list gSensorKeys;
list gSensorNames;

//---------------------------------------------------------------------
// * Initialize
//   Gets the script ready by selecting channels and reapplying
//   restrictions if valid.
//---------------------------------------------------------------------
initialize()
{
    gObjOwner = llGetOwner();
    llSetTimerEvent(1);
    reset_command_listener();
    gMufflerChannel = (integer)("0x"+llGetSubString((string)llGetKey(),-5,-1));
    gCommandChannel = -1 * gMufflerChannel;
    gRlvListener = llListen(RLV_CHANNEL, "", gObjOwner, "");
    gRlvState = 32;
    llOwnerSay("@version="+(string)RLV_CHANNEL);
}

//---------------------------------------------------------------------
// * Initialize Lock
//   Called after RLV is detected or timed out
//---------------------------------------------------------------------
init_lock()
{
    if (gKeyHolder != NULL_KEY)
        lock();
    else
        unlock();
    set_muffler();
    set_blinder();
    llListenRemove(gRlvListener);
}

//---------------------------------------------------------------------
// * Reset Command Listener
//   Removes the command listener and resets a few variables related to
//   it.  Called when "Cancel" is clicked or when a timeout is reached.
//---------------------------------------------------------------------
reset_command_listener()
{
    gCommandTimeout = 0;
    llListenRemove(gCommandListener);
    gCurrentUser = NULL_KEY;
    gSensorKeys = [];
    gSensorNames = [];
}

//---------------------------------------------------------------------
// * RLV Message
//   Sends an RLV Message if RLV is detected.
//---------------------------------------------------------------------
rlv_message(string message)
{
    if (gRlvState == 1)
        llOwnerSay(message);
}

//---------------------------------------------------------------------
// * Menu Handler
//   Calls the correct menu based on the clicker and what variables are
//   set.  Returns TRUE if a menu is called, FALSE otherwise.
//---------------------------------------------------------------------
integer menu_handler()
{
    integer handled = FALSE;
    if (gCurrentUser == gObjOwner)
    {
        obj_owner_menu();
        handled = TRUE;
    }
    else if (gOwner == gCurrentUser)
    {
        if (gKeyHolder != NULL_KEY && gCurrentUser != gKeyHolder)
        {
            string objName = llGetObjectName();
            llSetObjectName(llKey2Name(gCurrentUser));
            llSay(PUBLIC_CHANNEL, "/me takes back the keys to " + llKey2Name(gObjOwner) + "'s " + OBJECT_TYPE + ".");
            llSetObjectName(objName);
            gKeyHolder = gCurrentUser;
            gKeyHolderName = llKey2Name(gKeyHolder);
        }
        owner_menu();
        handled = TRUE;
    }
    else if (gCurrentUser == gKeyHolder)
    {
        key_holder_menu();
        handled = TRUE;
    }
    else if (gKeyHolder == NULL_KEY)
    {
        default_menu();
        handled = TRUE;
    }
    return handled;
}

//---------------------------------------------------------------------
// * Object Owner Menu
//   The menu for when the owner of the attachment clicks it.
//---------------------------------------------------------------------
obj_owner_menu()
{
    string message = "";
    list commands = ["Cancel", "Lock", "Unlock", "Safeword", "Timelock", "Muffler", "Blinder", "Set Owner"];
    integer i;
    if (!BLINDABLE_MODE)
    {
        i = llListFindList(commands, ["Blinder"]);
        commands = llDeleteSubList(commands, i, i);
    }
    if (gKeyHolder != NULL_KEY)
    {
        i = llListFindList(commands, ["Lock"]);
        commands = llDeleteSubList(commands, i, i);
        
        if ((gKeyHolder == gObjOwner && gTimelock == 0) || (gOwner == gKeyHolder))
        {
            i = llListFindList(commands, ["Safeword"]);
            commands = llDeleteSubList(commands, i, i);
        }
        if (gKeyHolder != gObjOwner || (gKeyHolder == gObjOwner && gTimelock > 0))
        {
            i = llListFindList(commands, ["Unlock"]);
            commands = llDeleteSubList(commands, i, i);
            i = llListFindList(commands, ["Timelock"]);
            commands = llDeleteSubList(commands, i, i);
            i = llListFindList(commands, ["Muffler"]);
            commands = llDeleteSubList(commands, i, i);
            if (~i = llListFindList(commands, ["Blinder"]))
                commands = llDeleteSubList(commands, i, i);
            
        }
        message += "Currently locked by " + gKeyHolderName +".\n";
        message += "Time locked: " + Time2String(gCurrentTimeLocked, 1) + "\n";
    }
    else
    {
        i = llListFindList(commands, ["Unlock"]);
        commands = llDeleteSubList(commands, i, i);
        i = llListFindList(commands, ["Safeword"]);
        commands = llDeleteSubList(commands, i, i);
        i = llListFindList(commands, ["Timelock"]);
        commands = llDeleteSubList(commands, i, i);
        message += "Currently unlocked.\n";
    }
    message += "Total time locked: " + Time2String(gTotalTimeLocked, 1) + "\n";
    message += "Best time locked: " + Time2String(gBestTimeLocked, 1) + "\n";
    if (gOwner == NULL_KEY)
        message += "No owner set.\n";
    else
    {
        message += "Current owner: " + gOwnerName + "\n";
        i = llListFindList(commands, ["Set Owner"]);
        commands = llDeleteSubList(commands, i, i);
    }
    if (gTimelock > 0)
    {
        message += "Timelock active.\n";
    }
    llDialog(gCurrentUser, message, commands, gCommandChannel);
    gCommandListener = llListen(gCommandChannel, "", gCurrentUser, "");
    gCommandTimeout = 30;
}

//---------------------------------------------------------------------
// * Owner Menu
//   The menu for when the set owner clicks on the attachment.
//---------------------------------------------------------------------
owner_menu()
{
    string message = "";
    list commands = ["Cancel", "Lock", "Unlock", "Timelock", "Muffler", "Blinder", "Resign Ownership"];
    integer i;
    if (!BLINDABLE_MODE)
    {
        i = llListFindList(commands, ["Blinder"]);
        commands = llDeleteSubList(commands, i, i);
    }
    if (gKeyHolder != NULL_KEY)
    {
        i = llListFindList(commands, ["Lock"]);
        commands = llDeleteSubList(commands, i, i);
        message += "Currently locked.\n";
        message += "Time locked: " + Time2String(gCurrentTimeLocked, 1) + "\n";
    }
    else
    {
        i = llListFindList(commands, ["Unlock"]);
        commands = llDeleteSubList(commands, i, i);
        i = llListFindList(commands, ["Timelock"]);
        commands = llDeleteSubList(commands, i, i);
        message += "Currently unlocked.\n";
    }
    message += "Total time locked: " + Time2String(gTotalTimeLocked, 1) + "\n";
    message += "Best time locked: " + Time2String(gBestTimeLocked, 1) + "\n";
    if (gTimelock > 0)
    {
        message += "Timelock active.\nTime remaining: " + Time2String(gTimelock, 1) + "\n";
    }
    llDialog(gCurrentUser, message, commands, gCommandChannel);
    gCommandListener = llListen(gCommandChannel, "", gCurrentUser, "");
    gCommandTimeout = 30;
}

//---------------------------------------------------------------------
// * Key Holder Menu
//   Menu for the key holder who is not an owner of the object.
//---------------------------------------------------------------------
key_holder_menu()
{
    string message = "";
    list commands = ["Cancel", "Unlock", "Timelock", "Muffler", "Blinder"];
    if (!BLINDABLE_MODE)
    {
        integer i = llListFindList(commands, ["Blinder"]);
        commands = llDeleteSubList(commands, i, i);
    }
    message += "You have the keys to " + llKey2Name(gObjOwner) + "'s " + OBJECT_TYPE + ".\n";
    message += "You are not the owner of " + llKey2Name(gObjOwner) + "'s " + OBJECT_TYPE + ".\n";
    message += "Time locked: " + Time2String(gCurrentTimeLocked, 1) + "\n";
    message += "Total time locked: " + Time2String(gTotalTimeLocked, 1) + "\n";
    message += "Best time locked: " + Time2String(gBestTimeLocked, 1) + "\n";
    if (gTimelock > 0)
    {
        message += "Timelock active.\nTime remaining: " + Time2String(gTimelock, 1) + "\n";
    }
    llDialog(gCurrentUser, message, commands, gCommandChannel);
    gCommandListener = llListen(gCommandChannel, "", gCurrentUser, "");
    gCommandTimeout = 25;
}

//---------------------------------------------------------------------
// * Default Menu
//   Menu for when a non owner clicks on the attachment while unlocked.
//---------------------------------------------------------------------
default_menu()
{
    string message = "";
    list commands = ["Cancel", "Lock"];
    message += llKey2Name(gObjOwner) + "'s " + OBJECT_TYPE + " is unlocked.\n";
    llDialog(gCurrentUser, message, commands, gCommandChannel);
    gCommandListener = llListen(gCommandChannel, "", gCurrentUser, "");
    gCommandTimeout = 20;
}

//---------------------------------------------------------------------
// * Timelock Menu
//   Menu for setting the timelock counter.
//---------------------------------------------------------------------
timelock_menu()
{
    string message = "";
    list commands = ["Cancel", "Back", "Reset", "+5 Min", "+15 Min", "+30 Min", "+1 Hour", "+2 Hour", "+3 Hour", "+6 Hour", "+12 Hour", "+24 Hour"];
    if (gTimelock > 0)
        message += "Timelock active.\nTime remaining: " + Time2String(gTimelock, 1) + "\n";
    else
        message += "Timelock inactive.\n";
    llDialog(gCurrentUser, message, commands, gCommandChannel);
    gCommandListener = llListen(gCommandChannel, "", gCurrentUser, "");
    gCommandTimeout = 30;
}

//---------------------------------------------------------------------
// * Muffler Menu
//   Menu for setting the muffle strength
//---------------------------------------------------------------------
muffler_menu()
{
    string message = "";
    list commands = ["Cancel", "Back", "None", "Light", "Medium", "Heavy", "Extreme", "Mute"];
    message += "Current muffle strength: " + llList2String(commands, gMufflerStrength + 2) + "\n";
    commands = llDeleteSubList(commands, gMufflerStrength + 2,  gMufflerStrength + 2);
    llDialog(gCurrentUser, message, commands, gCommandChannel);
    gCommandTimeout = 30;
}
//---------------------------------------------------------------------
// * Blinder Menu
//   Menu for setting blinder
//---------------------------------------------------------------------
blinder_menu()
{
    string message = "";
    list commands = ["Cancel", "Back", "Clear", "Blind"];
    message += "Current blinder state: " + llList2String(commands, gBlinderOn + 2) + "\n";
    commands = llDeleteSubList(commands, gBlinderOn + 2,  gBlinderOn + 2);
    llDialog(gCurrentUser, message, commands, gCommandChannel);
    gCommandTimeout = 30;
}

//---------------------------------------------------------------------
// * Lock
//---------------------------------------------------------------------
lock()
{
    rlv_message("@detach=n");
    llMessageLinked(LINK_SET, 0, "show", NULL_KEY);
}

//---------------------------------------------------------------------
// * Unlock
//---------------------------------------------------------------------
unlock()
{
    gKeyHolder = NULL_KEY;
    gKeyHolderName = "";
    rlv_message("@detach=y");
    llMessageLinked(LINK_SET, 0, "hide", NULL_KEY);
    gTimelock = 0;
    gTotalTimeLocked += gCurrentTimeLocked;
    if (gCurrentTimeLocked > gBestTimeLocked)
        gBestTimeLocked = gCurrentTimeLocked;
    gCurrentTimeLocked = 0;
}

//---------------------------------------------------------------------
// * Set Muffler
//   Resets the muffler listeners and applies RLV restrictions.
//---------------------------------------------------------------------
set_muffler()
{
    llListenRemove(gMufflerListener);
    if (FULL_MUFFLE_MODE)
        llListenRemove(gHearingListener);
    if (gMufflerStrength > 0)
    {
        rlv_message("@redirchat:"+(string)gMufflerChannel+"=add");
        rlv_message("@rediremote:"+(string)gMufflerChannel+"=add");
        gMufflerListener = llListen(gMufflerChannel, "", gObjOwner, "");           
        if (FULL_MUFFLE_MODE && gRlvState == 1)
        {
            rlv_message("@recvchat_sec=n");
            rlv_message("@recvemote_sec=n");
            gHearingListener = llListen(PUBLIC_CHANNEL, "", NULL_KEY, "");
        }
    }
    else
    {
        rlv_message("@sendchat=y");
        rlv_message("@redirchat:"+(string)gMufflerChannel+"=rem");
        rlv_message("@rediremote:"+(string)gMufflerChannel+"=rem");
        if (FULL_MUFFLE_MODE)
        {
            rlv_message("@recvchat_sec=y");
            rlv_message("@recvemote_sec=y");
        }
    }
}

//---------------------------------------------------------------------
// * Set Blinder
//   Sets blinding restrictions.
//---------------------------------------------------------------------
set_blinder()
{
    if (!BLINDABLE_MODE)
        return;
    if (gBlinderOn)
    {
        llMessageLinked(LINK_SET, 0, "blind", NULL_KEY);
        rlv_message("@shownames=n");
        rlv_message("@showworldmap=n");
        rlv_message("@showminimap=n");
        rlv_message("@showloc=n");
    }
    else
    {
        llMessageLinked(LINK_SET, 0, "see", NULL_KEY);
        rlv_message("@shownames=y");
        rlv_message("@showworldmap=y");
        rlv_message("@showminimap=y");
        rlv_message("@showloc=y");
    }
}

//---------------------------------------------------------------------
// * Time To String Conversion
//   Takes 'seconds' and turns it into a formatted string.
//---------------------------------------------------------------------
string Time2String(integer seconds, integer short)
{
    list times = [];
    integer i;
    string s = "";
    if (seconds % 60 > 0 || seconds == 0)
    {
        i = seconds % 60;
        s = "s";
        if (!short)
            s = " " + s + "econd";
        if (i != 1 && !short)
            s += "s";
        times = [(string)i+s] + times;
    }
    if (seconds % 3600 / 60 > 0)
    {
        i = seconds % 3600 / 60;
        s = "m";
        if (!short)
            s = " " + s + "inute";
        if (i != 1 && !short)
            s += "s";
        times = [(string)i+s] + times;
    }
    if (seconds % 86400 / 3600 > 0)
    {
        i = seconds % 86400 / 3600;
        s = "h";
        if (!short)
            s = " " + s + "our";
        if (i != 1 && !short)
            s += "s";
        times = [(string)i+s] + times;
    }
    if (seconds / 86400 > 0)
    {
        i = seconds / 86400;
        s = "d";
        if (!short)
            s = " " + s + "ay";
        if (i != 1 && !short)
            s += "s";
        times = [(string)i+s] + times;
    }
    return llList2CSV(times);
}

string MuffleString(string message, integer emoting)
{
    string out;
    integer i;
    integer skip = emoting;
    integer muted = FALSE;
    for (i=0; i < llStringLength(message); i++)
    {
        string c = llGetSubString(message, i, i);
        if (emoting && (c == "\""))
        {
            skip = !skip;
            if (skip)
                muted = FALSE;
        }
        if (!emoting && c == "*")
        {
            skip = !skip;
            if (skip)
                muted = FALSE;
                
        }
        if (skip)
            out += c;
        else if (gMufflerStrength < 5)
            out += MuffleChar(c);
        else
            if (!muted)
            {
                if (c == "*" || (c == "\""))
                    out += c;
                else
                {
                    out += "...";
                    muted = TRUE;
                }
            }
    }
    return out;
}

//---------------------------------------------------------------------
// * Muffle Character
//   Returns a character that may have been muffled.
//---------------------------------------------------------------------
string MuffleChar(string c)
{
    if (llFloor(llFrand(100.0)) < (gMufflerStrength*25))
        return MuffleTable(c);
    return c;
}

//---------------------------------------------------------------------
// * Muffle Table
//   Returns a changed character, depending on the one given.
//---------------------------------------------------------------------
string MuffleTable(string c)
{
    if (c == "B" || c == "D" || c == "H" || c == "K" || c == "T" || c == "V") return "G";
    if (c == "b" || c == "d" || c == "h" || c == "k" || c == "t" || c == "v") return "g";
    if (c == "D" || c == "J" || c == "L" || c == "Q" || c == "R") return "W";
    if (c == "d" || c == "j" || c == "l" || c == "q" || c == "r") return "w";
    if (c == "S") return "F";
    if (c == "s") return "f";
    return c;
}

//---------------------------------------------------------------------
// * Increase Timelock
//   Increases the timelock if 'min' is greater than 0.  Resets the
//   timelock if 'min' is 0 or less.
//---------------------------------------------------------------------
increase_timelock(integer min)
{
    string objName = llGetObjectName();
    llSetObjectName(llKey2Name(gCurrentUser));
    if (min <= 0)
    {
        gTimelock = 0;
        llSay(PUBLIC_CHANNEL, "/me resets " + llKey2Name(gObjOwner) + "'s timelock.");
    }
    else
    {
        gTimelock += min * 60;
        llSay(PUBLIC_CHANNEL, "/me increases " + llKey2Name(gObjOwner) + "'s timelock by " + Time2String(min*60, 0) + ".  Time remaining: " + Time2String(gTimelock, 0));
    }
    llSetObjectName(objName);
}

//---------------------------------------------------------------------
// * Change Muffler Strength
//   Changes the muffler strength and displays a message saying that
//   it was changed.  Out of domain values are assumed to be maximum.
//---------------------------------------------------------------------
change_muffler_strength(integer new_muffle)
{
    string objName = llGetObjectName();
    string extra = "";
    if (FULL_MUFFLE_MODE)
        extra = "and hearing ";
    llSetObjectName(llKey2Name(gObjOwner));
    if (new_muffle == 0)
        llSay(PUBLIC_CHANNEL, "/me's speech " + extra + "is now clearly understood."); 
    else if (new_muffle == 1)
        llSay(PUBLIC_CHANNEL, "/me's speech " + extra + "is now lightly muffled.");
    else if (new_muffle == 2)
        llSay(PUBLIC_CHANNEL, "/me's speech " + extra + "is now fairly muffled.");
    else if (new_muffle == 3)
        llSay(PUBLIC_CHANNEL, "/me's speech " + extra + "is now heavily muffled.");
    else if (new_muffle == 4)
        llSay(PUBLIC_CHANNEL, "/me's speech " + extra + "is now extremely muffled.");
    else
        llSay(PUBLIC_CHANNEL, "/me's speach " + extra + "is now completely mute.");
    gMufflerStrength = new_muffle;
    llSetObjectName(objName);
    set_muffler();
}

//---------------------------------------------------------------------
// * Change Blinder
//   Changes the blinder state
//---------------------------------------------------------------------
change_blinder(integer new_blind)
{
    string objName = llGetObjectName();
    llSetObjectName(llKey2Name(gObjOwner));
    if (new_blind == FALSE)
        llSay(PUBLIC_CHANNEL, "/me's sight is now clear."); 
    else
        llSay(PUBLIC_CHANNEL, "/me's sight is blocked.");
    gBlinderOn = (new_blind != 0);
    llSetObjectName(objName);
    set_blinder();
}

default
{
    state_entry()
    {
        initialize();
    }
    
    attach(key id)
    {
        if (id != NULL_KEY)
            initialize();
    }
    
    touch(integer total_number)
    {
        if(gCommandTimeout > 0 && gCurrentUser != llDetectedKey(0))
        {
            llInstantMessage(llDetectedKey(0), llKey2Name(gObjOwner) + "'s " + OBJECT_TYPE + " is currently in use and you cannot play with it.");
            return;
        }
        gCurrentUser = llDetectedKey(0);
        if(!menu_handler())
        {
            llInstantMessage(gCurrentUser, llKey2Name(gObjOwner) + "'s " + OBJECT_TYPE + " is currently locked and you cannot play with it.");
            return;
        }
    }
    
    timer()
    {
        if (gRlvState > 1)
        {
            gRlvState--;
            if (gRlvState == 2)
            {
                gRlvState = 0;
                gMufflerChannel = llCeil(llFrand(10))+10;
                llOwnerSay("No RLV detected.  Use channel " + (string)gMufflerChannel + " to send muffled messages.");
                init_lock();
                if (gKeyHolder != NULL_KEY && gOwner == gKeyHolder)
                {
                    llOwnerSay("Your owner has been notified that you are not in RLV.");
                    llInstantMessage(gOwner, llKey2Name(gObjOwner) + " has logged in without RLV.");
                }
            }
        }
        if (gCommandTimeout > 0)
        {
            gCommandTimeout--;
            if (gCommandTimeout == 0)
                reset_command_listener();
        }
        if (gTimelock > 0)
        {
            gTimelock--;
            if (gTimelock == 0)
            {
                string objName = llGetObjectName();
                llSetObjectName(llKey2Name(gObjOwner));
                llSay(PUBLIC_CHANNEL, "/me's " + OBJECT_TYPE + " was unlocked by their timelock.");
                llSetObjectName(objName);
                unlock();
                reset_command_listener();
            }
        }
        if (gKeyHolder != NULL_KEY)
            gCurrentTimeLocked++;
    }
    
    sensor(integer detected)
    {
        string message = "Select who will be your future owner:";
        list commands = ["Cancel", "Back"];
        integer i = detected;
        if (i > 10)
            i = 10;
        do
        {
            i--;
            gSensorKeys += [llDetectedKey(i)];
            gSensorNames += [llGetSubString(llDetectedName(i), 0, 23)];
        }
        while (i > 0);
        commands += gSensorNames;
        llDialog(gCurrentUser, message, commands, gCommandChannel);
        gCommandTimeout = 20;
    }
    
    no_sensor()
    {
        llInstantMessage(gCurrentUser, "No potential owners in range. (10m)");
        reset_command_listener();
    }
    
    listen(integer channel, string name, key id, string message)
    {
        if (channel == gCommandChannel)
        {
            if (message == "Lock")
            {
                gKeyHolder = gCurrentUser;
                gKeyHolderName = llKey2Name(gKeyHolder);
                string objName = llGetObjectName();
                llSetObjectName(name);
                llSay(PUBLIC_CHANNEL, "/me locks " + llKey2Name(gObjOwner) + "'s " + OBJECT_TYPE + ".");
                llSetObjectName(objName);
                lock();
                menu_handler();
            }
            else if (message == "Unlock")
            {
                string objName = llGetObjectName();
                llSetObjectName(name);
                llSay(PUBLIC_CHANNEL, "/me unlocks " + llKey2Name(gObjOwner) + "'s " + OBJECT_TYPE + ".");
                llSetObjectName(objName);
                unlock();
                menu_handler();
            }
            else if (message == "Safeword")
            {
                string objName = llGetObjectName();
                llSetObjectName(name);
                llSay(PUBLIC_CHANNEL, "/me safewords from their " + OBJECT_TYPE + ".");
                llSetObjectName(objName);
                unlock();
            }
            else if (message == "Timelock")
            {
                timelock_menu();
            }
            else if (message == "Muffler")
            {
                muffler_menu();
            }
            else if (message == "Blinder")
            {
                blinder_menu();
            }
            else if (message == "Back")
            {
                reset_command_listener();
                gCurrentUser = id;
                menu_handler();
            }
            else if (message == "Cancel")
            {
                reset_command_listener();
            }
            else if (message == "Set Owner")
            {
                llSensor("", NULL_KEY, AGENT, 10, PI);
            }
            else if (message == "Resign Ownership")
            {
                gOwner = NULL_KEY;
                gOwnerName = "";
                string objName = llGetObjectName();
                llSetObjectName(name);
                llSay(PUBLIC_CHANNEL, "/me resigns their ownership of " + llKey2Name(gObjOwner) + "'s " + OBJECT_TYPE + ".");
                llSetObjectName(objName);
                unlock();
                reset_command_listener();
            }
            else if (message == "None")
            {
                change_muffler_strength(0);
                reset_command_listener();
            }
            else if (message == "Light")
            {
                change_muffler_strength(1);
                reset_command_listener();
            }
            else if (message == "Medium")
            {
                change_muffler_strength(2);
                reset_command_listener();
            }
            else if (message == "Heavy")
            {
                change_muffler_strength(3);
                reset_command_listener();
            }
            else if (message == "Extreme")
            {
                change_muffler_strength(4);
                reset_command_listener();
            }
            else if (message == "Mute")
            {
                change_muffler_strength(5);
                reset_command_listener();
            }
            else if (message == "Clear")
            {
                change_blinder(FALSE);
                reset_command_listener();
            }
            else if (message == "Blind")
            {
                change_blinder(TRUE);
                reset_command_listener();
            }
            else if (message == "Reset")
            {
                increase_timelock(0);
                timelock_menu();
            }
            else if (message == "+5 Min")
            {
                increase_timelock(5);
                timelock_menu();
            }
            else if (message == "+15 Min")
            {
                increase_timelock(15);
                timelock_menu();
            }
            else if (message == "+30 Min")
            {
                increase_timelock(30);
                timelock_menu();
            }
            else if (message == "+1 Hour")
            {
                increase_timelock(60);
                timelock_menu();
            }
            else if (message == "+2 Hour")
            {
                increase_timelock(120);
                timelock_menu();
            }
            else if (message == "+3 Hour")
            {
                increase_timelock(180);
                timelock_menu();
            }
            else if (message == "+6 Hour")
            {
                increase_timelock(360);
                timelock_menu();
            }
            else if (message == "+12 Hour")
            {
                increase_timelock(720);
                timelock_menu();
            }
            else if (message == "+24 Hour")
            {
                increase_timelock(1440);
                timelock_menu();
            }
            else if (message == "Yes")
            {
                gOwner = id;
                gOwnerName = name;
                string objName = llGetObjectName();
                llSetObjectName(llKey2Name(gObjOwner));
                llSay(PUBLIC_CHANNEL, "/me declares " + name + " to be the owner of their " + OBJECT_TYPE + ".");
                llSetObjectName(objName);
                reset_command_listener();
            }
            else if (message == "No")
            {
                string objName = llGetObjectName();
                llSetObjectName(name);
                llSay(PUBLIC_CHANNEL, "/me declines ownership of " + llKey2Name(gObjOwner) + "'s " + OBJECT_TYPE + ".");
                llSetObjectName(objName);
                reset_command_listener();
            }
            else
            {
                integer i = llListFindList(gSensorNames, [message]);
                if (i >= 0)
                {
                    key user = llList2Key(gSensorKeys, i);
                    string own_msg = name + " would like to to be the owner of their " + OBJECT_TYPE + ".";
                    list commands = ["Yes", "No"];
                    reset_command_listener();
                    gCommandTimeout = 20;
                    gCommandListener = llListen(gCommandChannel, "", user, "");
                    llDialog(user, own_msg, commands, gCommandChannel);
                }
            }
        }
        else if (channel == gMufflerChannel)
        {
            string objName = llGetObjectName();
            integer emote = FALSE;
            llSetObjectName(llKey2Name(gObjOwner)); 
            if (llGetSubString(message,0,2) == "/me")
                emote = TRUE;           
            llSay(PUBLIC_CHANNEL, MuffleString(message, emote));
            llSetObjectName(objName);
        }
        else if (channel == PUBLIC_CHANNEL)
        {
            string objName = llGetObjectName();
            integer emote = FALSE;
            llSetObjectName(name);
            if (llGetSubString(message,0,2) == "/me")
                emote = TRUE;
            llOwnerSay(MuffleString(message, emote));
            llSetObjectName(objName);
        }
        else if (channel == RLV_CHANNEL)
        {
            llOwnerSay(message);
            gRlvState = 1;
            init_lock();
        }
    }
}