Second Life Wiki - User contributions [en]

LlDialog

2014-04-19T22:33:40Z

Crymysyn Moonbeam: added haiku

{{LSL_Function
|func=llDialog
|sort=Dialog
|func_id=247|func_sleep=1.0|func_energy=10.0
|inject-2=
{{Issues/VWR-17064}}
{{Issues/VWR-14537}}
{{Issues/SVC-1815}}
{{Issues/SCR-43}}
{{LSL_Function/avatar|avatar|sim=*}}
{{LSL_Function/chat|channel|message|dialog=dialog box}}
|p1_type=key|p1_name=avatar|p1_desc
|p2_type=string|p2_name=message|p2_desc
|p3_type=list|p3_name=buttons|p3_desc=button labels
|p4_type=integer|p4_name=channel|p4_desc
|func_desc=Shows a dialog box in the lower right corner of the {{LSLP|avatar}}'s screen (upper right in Viewer 1.x) with a {{LSLP|message}} and choice {{LSLP|buttons}}, as well as an ignore button. This has many uses ranging from simple message delivery to complex menu systems.
|func_footnote=When a button is pressed, the {{LSLP|avatar}} says the text of the button label on {{LSLP|channel}}. The position where the chat is generated is where the root prim of the dialog generating object was when the dialog button was pressed.
|spec
|caveats=
*This function '''only''' opens a dialog box. The script must then also register a listener on the same ''channel'' using [[llListen]] and have a [[listen]] event handler to receive the response.
*There is no way by script to kill a dialog box.
*There is no way for the script to detect if the user clicked the small <code>["Ignore"]</code> button (no chat is generated as a result of pressing this button).
*There is no way to distinguish the input from a dialog box and regular chat made by the same user.
**It is important to expect that the response may not be one of the buttons.
*In most cases, the listener will be in the same script as the llDialog, however if not, the distance between the root prim of the [[listen]]ing object and the dialog generating prim becomes a factor. If this distance is greater than 20 meters when a button is pressed, the response will not be heard. See [[#Limits]].
**This limitation affects attachments too if the wearer moves more than 20 meters from where the listener is located. See [[#Limits]].
**If the [[listen]]er resides in the same script that created the dialog, then the dialog button is heard sim-wide.
----
*The '''dialog response''' (the generated chat) has its in world location at the '''root prim's global position'''.
: It can generate a listen event within 20 meters from that position.
*The listening location for a child prim in the object is either at the child prim's location or at the root prim's location
: see bugtrace JIRA [https://jira.secondlife.com/browse/SCR-43 SCR-43]

===<tt>message</tt> limits===
*{{LSLP|message}} must be fewer than 512 bytes in length and be not empty. If it is empty, [[llDialog]] will shout <code>"[[llDialog]]: must supply a message"</code> on the [[DEBUG_CHANNEL]]. If you want to create an empty message, however, you can do it legally by using a line feed as your message, as in <lsl>llDialog(avatar_key," \n",button_list,dialog_channel);</lsl> If the message length is greater than or equal to 512 bytes, it shouts (again on the [[DEBUG_CHANNEL|debug channel]]): <code>"[[llDialog]]: message too long, must be less than 512 characters"</code>; in both instances, the dialog box will not be created for {{LSLP|avatar}}.
*The client only displays 8 lines of {{LSLP|message}}. If it is longer, the dialog has a scroll bar. See [[#Appearance]].
Note: this should be 7 lines in message; one of the 8 lines is the owner and name of the object.

===<tt>buttons</tt> limits===
*If {{LSLP|buttons}} is an empty list, it will default to as if it were <code>["OK"]</code>
*If a button is named <code>["Ignore"]</code>, it will behave like the small <code>["Ignore"]</code> button of the menu (i.e. pressing it will '''not''' get <code>["Ignore"]</code> sent to the menu channel). If you need an <code>["Ignore"]</code> button in your menu and wish to have its name sent back to the script when you press it, then use spaces in the button name (e.g. <code>[" Ignore "]</code>).
*An error will be shouted on [[DEBUG_CHANNEL]], if...
**there are more than 12 buttons.
**any list item is not a string.
**any list item string length (measured in bytes, using UTF-8 encoding) is zero or greater than 24.
***In other words, a button's text when encoded as UTF-8 cannot be longer than 24 bytes or a empty string.
***This snippet can be used to truncate the string without giving an error: <code>[[llBase64ToString]]([[llGetSubString]]([[llStringToBase64]](theString), 0, 31))</code>
*The client will not display all the characters of a button if the text is wider than the text space of the button. See [[#Appearance]].
*If the script generates button labels from outside sources like inventory or object names, take care to avoid the special string <code>"!!llTextBox!!"</code>. This text, in button 0, will cause [[llDialog]] to behave as [[llTextBox]] instead.
|examples=
<lsl>
// When the prim is touched, give the toucher the option of killing the prim.

integer gListener; // Identity of the listener associated with the dialog, so we can clean up when not needed

default
{
touch_start(integer total_number)
{
// Kill off any outstanding listener, to avoid any chance of multiple listeners being active
llListenRemove(gListener);
// get the UUID of the person touching this prim
key user = llDetectedKey(0);
// Listen to any reply from that user only, and only on the same channel to be used by llDialog
// It's best to set up the listener before issuing the dialog
gListener = llListen(-99, "", user, "");
// Send a dialog to that person. We'll use a fixed negative channel number for simplicity
llDialog(user, "\nDo you wish this prim to die?", ["Yes", "No" ] , -99);
// Start a one-minute timer, after which we will stop listening for responses
llSetTimerEvent(60.0);
}
listen(integer chan, string name, key id, string msg)
{
// If the user clicked the "Yes" button, kill this prim.
if (msg == "Yes")
llDie();
// The user did not click "Yes" ...
// Make the timer fire immediately, to do clean-up actions
llSetTimerEvent(0.1);
}
timer()
{
// Stop listening. It's wise to do this to reduce lag
llListenRemove(gListener);
// Stop the timer now that its job is done
llSetTimerEvent(0.0);// you can use 0 as well to save memory
}
}
</lsl>
{{LSL Tip|Please make sure that you close open listeners where possible. You'll make the Second Life experience so much better when paying attention to details here.}}
{{LSL Tip|There are no built-in submenus nor pagination (like in a list with "previous" and "next") when using [[llDialog]]. You simply get one page with a max of 12 buttons, that's it. If you want a different dialog menu layout (other info and/or other buttons), you'll have to build that functionality into your script as the example below demonstrates. }}
<lsl>
string mainMenuDialog = "\nWhich settings would you like to access?\nClick \"Close\" to close the menu.\n\nYou are here:\nMainmenu";
list mainMenuButtons = ["sub 01", "sub 02", "Close"];

string subMenu_01_Dialog = "\nClick \"Close\" to close the menu.\nClick \"-Main-\" to return to the main menu.\n\nYou are here:\nMainmenu > sub 01";
list subMenu_01_Buttons = ["action 01a", "action 01b", "Close", "-Main-"];

string subMenu_02_Dialog = "\nClick \"Close\" to close the menu.\nClick \"-Main-\" to return to the main menu.\n\nYou are here:\nMainmenu > sub 02";

list subMenu_02_Buttons = ["action 02a", "action 02b", "Close", "-Main-"];

integer dialogChannel;
integer dialogHandle;

open_menu(key inputKey, string inputString, list inputList)
{
dialogChannel = (integer)llFrand(DEBUG_CHANNEL)*-1;
dialogHandle = llListen(dialogChannel, "", inputKey, "");
llDialog(inputKey, inputString, inputList, dialogChannel);
llSetTimerEvent(30.0);
}

close_menu()
{
llSetTimerEvent(0.0);// you can use 0 as well to save memory
llListenRemove(dialogHandle);
}

default
{
on_rez(integer start_param)
{
llResetScript();
}

touch_start(integer total_number)
{
key id = llDetectedKey(0);
// Ensure any outstanding listener is removed before creating a new one
close_menu();
open_menu(id, mainMenuDialog, mainMenuButtons);
}

listen(integer channel, string name, key id, string message)
{
if(channel != dialogChannel)
return;

close_menu();

if(message == "-Main-")
open_menu(id, mainMenuDialog, mainMenuButtons);

else if(message == "sub 01")
open_menu(id, subMenu_01_Dialog, subMenu_01_Buttons);

else if(message == "sub 02")
open_menu(id, subMenu_02_Dialog, subMenu_02_Buttons);

else if (message == "action 01a")
{
//do something
open_menu(id, subMenu_01_Dialog, subMenu_01_Buttons);
}
else if (message == "action 01b")
{
//do something else

//maybe not re-open the menu for this option?
//open_menu(id, subMenu_01_Dialog, subMenu_01_Buttons);
}
else if (message == "action 02a")
{
//do something
open_menu(id, subMenu_02_Dialog, subMenu_02_Buttons);
}
else if (message == "action 02b")
{
//do something else
open_menu(id, subMenu_02_Dialog, subMenu_02_Buttons);
}
}

timer()
{
close_menu();
}
}
</lsl>
|helpers=<lsl>//Compact function to put buttons in "correct" human-readable order
integer channel;

list order_buttons(list buttons)
{
return llList2List(buttons, -3, -1) + llList2List(buttons, -6, -4)
+ llList2List(buttons, -9, -7) + llList2List(buttons, -12, -10);
}

default
{
state_entry()
{ // Create random channel within range [-1000000000,-2000000000]
channel = (integer)(llFrand(-1000000000.0) - 1000000000.0);

llListen(channel,"", "","");
}

touch_start(integer total_number)
{
llDialog(llDetectedKey(0),"\nPlease choose an option:\n",
order_buttons(["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"]),channel);
}

listen(integer _chan, string _name, key _id, string _option)
{
llSay(0, _name + " selected option " + _option);
}
}</lsl>
<lsl>
list make_ordered_buttons(integer input)
{
string output;

if (input == 12) output = "10, 11, 12, 7, 8, 9, 4, 5, 6, 1, 2, 3";
else if (input == 11) output = "10, 11, 7, 8, 9, 4, 5, 6, 1, 2, 3";
else if (input == 10) output = "10, 7, 8, 9, 4, 5, 6, 1, 2, 3";
else if (input == 9) output = "7, 8, 9, 4, 5, 6, 1, 2, 3";
else if (input == 8) output = "7, 8, 4, 5, 6, 1, 2, 3";
else if (input == 7) output = "7, 4, 5, 6, 1, 2, 3";
else if (input == 6) output = "4, 5, 6, 1, 2, 3";
else if (input == 5) output = "4, 5, 1, 2, 3";
else if (input == 4) output = "4, 1, 2, 3";
else if (input == 3) output = "1, 2, 3";
else if (input == 2) output = "1, 2";
else if (input == 1) output = "1";

// when we want to return [] avoid returning [""] here

if (output == "") return [];
/* else convert output */ return llCSV2List(output);
}

// Usage:

llDialog(id, "dialog message", make_ordered_buttons(5), -37812);

// Output:

// - - -
// - - -
// - [ 4 ] [ 5 ]
// [ 1 ] [ 2 ] [ 3 ]
</lsl>
=== Helper Functions ===
{{{!}}
{{LSL DefineRow||[[User:Void_Singer/Functions#uDlgBtnPagList|uDlgBtnPagList]]|Compact Pagination for [[llDialog]] lists, remenu, and multi-user support}}
{{!}}}
|constants={{#vardefine:constants_nb}}
{{{!}}
{{!}}- valign="top"
{{!}}
{{{!}}{{Prettytable|style=margin-top:0;}}
{{!}}-{{Hl2}}
! colspan="4" {{!}} Button Order
{{!}}-
{{!}}9  
{{!}}10
{{!}}11
{{!}}-
{{!}}6
{{!}}7
{{!}}8  
{{!}}-
{{!}}3
{{!}}4
{{!}}5
{{!}}-
{{!}}0
{{!}}1
{{!}}2
{{!}}}
{{!}}
{{!}}}
|related
|notes=
To use dialog boxes to make menu systems, see [[Dialog Menus|Dialog Menus: A step by step guide]] (aimed at learners).

===Tips===
It is a good idea to use a very negative channel (if never more negative than the most negative 32-bit integer that is -2,147,483,648), ''e.g.'',
<lsl>// Create random channel within range [-1000000000,-2000000000]
integer channel = (integer)(llFrand(-1000000000.0) - 1000000000.0);

llDialog(llDetectedKey(0), "Please choose one of the below options:",
["Yes", "No", "0", "1"], channel);</lsl>
Negative channels are popular for script communications because the standard SL client is unable to chat directly on those channels. The only way to do so prior to [[llTextBox]] was to use [[llDialog]] which was limited to 24 bytes. (Several third party viewers can access them from the chat bar.)

You can be reasonably confident that all of your scripted objects have a unique chat channel with this small function:

<lsl>integer dialog_channel; // top of script in variables

integer channel() { // top of script in functions
return (integer)("0x"+llGetSubString((string)llGetKey(),-8,-1));
}

dialog_channel = channel(); // somewhere in actual script execution, such as state_entry()</lsl>

'''Note:''' Since this function uses public information to generate the channel number it should by no means considered secret.

The preceding code can produce both positive and negative channels, depending on the 8th to last character of the key.
The following examples will always produce negative channels:-
<lsl>
gChannel = 0x80000000 | (integer)("0x"+(string)llGetKey());
gChannel = 0x80000000 | (integer)("0x"+(string)llGetOwner());
</lsl>

This next version returns a channel number between -1073741823 (0xBFFFFFFF) and -2147483648 (0x80000000). It is also only one line of code.
<lsl>privchan = ((integer)("0x"+llGetSubString((string)llGetKey(),-8,-1)) & 0x3FFFFFFF) ^ 0xBFFFFFFF;</lsl>

===Appearance===

If {{LSLP|message}} requires more than 8 lines, a vertical scroll bar will appear in the dialog.
: In viewer 3 there is no scroll bar, only the 512 chars message limit is effective, so you may show more than 40 short lines in the message
: Too many lines will hide some of the buttons or all of them outside the window though

The message text can be formatted somewhat using "\n" (for newline) and "\t" (for tab). If URLs are in the text, they will appear as clickable links, and some [[Viewer URI Name Space|viewer application URLs]] will receive special formatting. (Clickable links were not available before Viewer 2.) You can do nothing though to influence the font face, size or weight.

There is no way to change the actual size of the dialog, nor change its color.

The average number of characters that can be displayed on a dialog line is about 35 characters per line in ASCII7 characters. It depends upon the width of the characters, the viewer version, and font settings.

The number of characters that can be displayed in a button depends upon the width of the characters. You should expect around 10 chars, give or take, not the full 24 in the button definition. The full button definition IS said, up to 24 chars, into the chat channel even though fewer characters may be displayed in the button itself.

===Limits===

My testing shows the a Dialog box now works anywhere in the same Region as the object OR any region it hands you off to (e.g. the region you teleport to). It will not work for any subsequent hand offs. I have tested this with teleport only, I haven't tested it walking between regions.

I've tested from the next SIM with an Alt, and from 2 SIMs away myself. Both worked without restriction apart from some lag on the messages. (OQ).

|also_events=
{{LSL DefineRow||[[listen]]|}}
|also_functions=
{{LSL DefineRow||[[llListen]]|}}
{{LSL DefineRow||[[llTextBox]]|}}
{{LSL DefineRow||[[llRegionSay]]|}}
{{LSL DefineRow||[[llWhisper]]|Sends chat limited to 10 meters}}
{{LSL DefineRow||[[llSay]]|Sends chat limited to 20 meters}}
{{LSL DefineRow||[[llShout]]|Sends chat limited to 100 meters}}
{{LSL DefineRow||[[llInstantMessage]]|Sends chat to the specified user}}
{{LSL DefineRow||[[llOwnerSay]]|Sends chat to the owner only}}
|also_tests
|also_articles=
{{LSL DefineRow||[[Dialog Menus|Dialog Menus: A step by step guide]]|A walk through of the entire dialog menu process (aimed at learners).}}
|cat1=Chat
|cat2=Communications
|cat3=Dialog
|cat4
|haiku={{Haiku|click here click there. But,|read the options carefully|you might get a shock.}}
}}

LlGetOwner

2014-04-19T20:28:24Z

Crymysyn Moonbeam: added haiku

{{LSL_Function
|func_id=117|func_sleep=0.0|func_energy=10.0
|func=llGetOwner|sort=GetOwner
|return_type=key
|func_footnote
|func_desc
|return_text=that is the object owner's [[UUID]].
|spec
|caveats=*When the owner of an object changes, code that depends on this function's return value will not automatically update for the new owner or be automatically re-evaluated.
**This requires the reregistration of [[llListen|listens]] and [[llRequestPermissions|requesting of permissions]] from the new owner as needed.
***This is not limited to listens and permissions but anything that caches the return value, it is up to the programmer to work around this limitation.
**Detection of owner change can be achieved with the [[changed]] event in conjunction with the [[CHANGED_OWNER]] flag (see the second example) or by storing the old value and periodically (e.g. in [[on_rez]]) checking if it has changed. Both techniques are valid though the latter will not detect the sale of the object if it is sold with "sell original" in-world and not picked up.
*When the object is deeded to a group, the UUID returned is that of the group.
*When the owner is offline the region can lose the owner uuid and return NULL_KEY or (Loading)... in some rare cases.
|constants
|examples=
<lsl>
llOwnerSay( (string)llGetOwner()); // speaks in chat the "key" (UUID code) of the avatar.
llOwnerSay( llKey2Name(llGetOwner())); // speaks in chat the name of the owner if in the sim.
</lsl>

<lsl>
default
{
changed(integer change)
{
if (change & CHANGED_OWNER)
llResetScript();
}

state_entry()
{
key owner = llGetOwner();
llInstantMessage(owner, "Only you can hear me. Isn't that eerie.");
}
}
</lsl>
|helpers=To determine the owner of an object that might be group-deeded you can use the following code snippet. Setting the <code>groupAdmin</code> parameter to <code>TRUE</code> can be used to specify that group members should ''always'' count as owners, even if the object isn't deeded to that group.
<lsl>
integer isOwner(key id, integer groupAdmin) {
integer result = FALSE;
{
key owner = llGetOwner();
if (id == owner) result = TRUE;
else { // If object is group owned, avatar need only belong to same group
integer sameGroup = llSameGroup(id);
if (groupAdmin) result = sameGroup;
else {
key group = (key)((string)llGetObjectDetails(llGetKey(), [OBJECT_GROUP]));
if (group == owner) result = sameGroup;
}
}
}
return result;
}
</lsl>
|also_functions=
{{LSL DefineRow||[[llGetCreator]]|}}
{{LSL DefineRow||[[llGetOwnerKey]]|}}
{{LSL DefineRow||[[llDetectedOwner]]|}}
|also_tests
|also_events
|also_articles
|notes=
To retrieve the owners name while the owner is in the region use [[llKey2Name]], [[llGetUsername]] or [[llGetDisplayName]]. Respectively [[llRequestAgentData]], [[llRequestUsername]] or [[llRequestDisplayName]] should be used when the owner is not in the region.

The one problem many coders come up against is that previously-activated events referring to the owner don't automatically change when the owner changes. The most often-seen result is a listen registered to owner will continue to listen to the PREVIOUS owner rather than the CURRENT owner. It is often confused as a bug in [[llGetOwner]] or [[llListen]] it is not in fact a bug but part of the design. There are several ways of working around this problem. The easy solution is to reset the script when owner changes or it is rezzed. The easy solution is not always the right solution.

There are two ways to detect if the owner has changed, the most reliable is to use the [[changed]] event.
<lsl>
changed(integer change)
{
if (change & CHANGED_OWNER)//if owner changes, reset the script.
llResetScript();
}
</lsl>

In many applications resetting the script when the object is rezzed is an adequate and easy solution.
<lsl>
on_rez(integer start_param)
{ //when the object is rezzed, reset the script.
llResetScript();
}
</lsl>

Resetting the script is not appropriate if the script needs to keep it's data when it's ownership is transfered or if script startup is slow, in these situations listens will need to be re-keyed to the new owner along with any other owner specific code, like who the script is supposed to be animating.

The [[on_rez]] and [[changed]] events can be harnessed to reinitialize owner specific code every time the object is rezzed or changes owner.

<lsl>
integer listen_handle;

init()
{
key owner = llGetOwner();
llListenRemove(listen_handle);
// PUBLIC_CHANNEL has the integer value 0
listen_handle = llListen(PUBLIC_CHANNEL, "", owner, "");
llRequestPermissions(owner, PERMISSION_TRIGGER_ANIMATION);
}

default
{
state_entry()
{
init();
//insert additional startup code here that doesn't need to run each rez/owner change
//for example, reading settings from a notecard
}

on_rez(integer start)
{
init();
}

changed(integer change)
{
if (change & CHANGED_OWNER)
init();
}

run_time_permissions(integer perm)
{//always use the run_time_permissions event with llRequestPermissions, never assume
if(perm & PERMISSION_TRIGGER_ANIMATION)
{
//setup your animation code here, start your timers, etc.
llOwnerSay("I have animation permissions");
}
}
}
</lsl>
|cat1=Owner
|cat2=Object
|cat3=Key
|cat4
|haiku={{Haiku|Pass me my coat please|it is not always easy|whose coat is it now?}}
}}

LlApplyImpulse

2014-04-19T19:55:10Z

Crymysyn Moonbeam: added haiku

{{LSL_Function
|inject-2={{Issues/SVC-8227}}{{LSL_Function/force|force|local=local}}{{LSL_Function/physical}}
|func=llApplyImpulse
|sort=ApplyImpulse
|func_id=72|func_sleep=0.0|func_energy=10.0
|p1_type=vector|p1_name=force
|p2_type=integer|p2_subtype=boolean|p2_name=local
|func_footnote=Instantaneous impulse. [[llSetForce]] has continuous push. "Instantaneous" seems to mean a one second impulse, as an application of a force (in newtons) equal to the object's mass (in kg) for one second will accelerate it to a velocity of 1 (in meters per second), which appears to be what happens with this function.
|func_desc=Applies impulse to object
|return_text|spec
|caveats=
*The [[llVecMag|magnitude]] of {{LSLP|force}} may be scaled back by the object's available energy.
*The maximum magnitude of {{LSLP|force}} is 20.0 and if it exceeds that it will be scaled back.
*Silently fails when not called from inside the root prim.
|examples=
<lsl>
// Rez an object, and drop this script in it.
// This will launch it at the owner.

default
{
state_entry()
{
key ownerKey = llGetOwner();
vector ownerPosition = llList2Vector(llGetObjectDetails(ownerKey, [OBJECT_POS]), 0);

// if the owner is not in the sim, stop fooling around
if (llGetAgentSize(ownerKey) == ZERO_VECTOR)
return;

// else
llSetStatus(STATUS_PHYSICS, TRUE);

vector objectPosition = llGetPos();
vector direction = llVecNorm(ownerPosition - objectPosition);

llApplyImpulse(direction * 100, 0);
}
}
</lsl>
Make yourself a beer can, drop this script into it, and have some target practice.
<lsl>
vector gHome;
integer gHit;

default
{
collision_start(integer num)
{
if (!gHit)
{
llSetTimerEvent(15.0);
gHome = llGetPos();
gHit = TRUE;
}
llSetStatus(STATUS_PHYSICS, TRUE);
llTriggerSound("b90ed62a-2737-b911-bb53-6b9228bbc933",1.0);
llApplyImpulse(llGetMass()*<0,0,5.0>,TRUE);
llApplyRotationalImpulse(llGetMass()*<llFrand(1.0),llFrand(1.0),llFrand(1.0)>,TRUE);
llResetTime();
}

land_collision(vector where)
{
if (llGetTime() < 0.5)
{
llResetTime();
llApplyImpulse(llGetMass()*<0,0,llFrand(1.0)>,TRUE);
llApplyRotationalImpulse(llGetMass()*<llFrand(1.0),llFrand(1.0),llFrand(1.0)>,TRUE);
}
}

timer()
{
llSetStatus(STATUS_PHYSICS,FALSE);
gHit = FALSE;
llSetRegionPos(gHome); // Send the can home, even if more than 10m away
llSetRot(ZERO_ROTATION);
llSetTimerEvent(0.0);
}
}
</lsl>
|helpers
|also_functions=
{{LSL DefineRow||[[llApplyRotationalImpulse]]|}}
{{LSL DefineRow||[[llSetForce]]|Set continuous force}}
|notes
|deepnotes=
==== Unpredictability ====
Taken from [[Simulator User Group/Transcripts/2012.10.05]]
<blockquote>
[16:24] Andrew Linden<nowiki>: the llApplyImpulse() is even more unpredictable</nowiki> 
[16:24] Andrew Linden<nowiki>: because it uses the legacy script "energy budget"</nowiki> 
[16:25] Andrew Linden<nowiki>: which will attenuate the results if the scripted object doesn't have enough "energy" to execute the impulse that it wants</nowiki> 
[16:25] Andrew Linden<nowiki>: also, that llApplyImpulse() has great griefing potential</nowiki> 
[16:25] Andrew Linden<nowiki>: so we hobbled it a long time ago with a very high energy consumption rate</nowiki> 
</blockquote>
|cat1=Physics
|cat2=Movement
|cat3
|cat4
|haiku={{Haiku|In this crazy world,|Force, momentum, energy|cease to be conserved}}
}}

LlAddToLandBanList

2014-04-19T19:02:10Z

Crymysyn Moonbeam: added haiku

{{LSL_Function
|inject-2={{Issues/SVC-1911}}{{LSL_Function/avatar|avatar}}
|func_id=310|func_sleep=0.1|func_energy=10.0
|func=llAddToLandBanList|sort=AddToLandBanList
|p1_type=key|p1_name=avatar|p2_type=float|p2_name=hours
|func_footnote
|func_desc=Add {{LSLP|avatar}} to the land ban list for {{LSLP|hours}}, or indefinitely if {{LSLP|hours}} is zero.
|return_text
|spec
|caveats=
* Must be owned by the land owner.
|constants
|examples=<lsl>// This is not a complete solution, requires full avatar names to work - even for unbanning someone!
// This is meant only as an example of the land ban and pass management functions.
// free to copy, use, modify, distribute - just don't ask me to debug your modified code. ;-)
//
// Commands are:
// /5 ban:full_avatar_name
// /5 tempban:full_avatar_name
// /5 unban:full_avatar_name
// /5 pass:full_avatar_name
// /5 unpass:full_avatar_name
// /5 clearban
// /5 clearpass

string command;

default
{
state_entry()
{
llListen(5, "", llGetOwner(), "");
}

on_rez(integer param)
{
llResetScript();
}

listen(integer chan, string name, key id, string message)
{
if (command != "")
{
llOwnerSay("Sorry, still processing last command, try again in a second.");
}

list args = llParseString2List(message,[":"],[]);
command = llToLower(llList2String(args,0));

if (command == "clearbans")
{
llResetLandBanList();
}
if (command == "clearpass")
{
llResetLandPassList();
}
else
{
llSensor(llList2String(args,1),NULL_KEY,AGENT,96,PI);
}
}

no_sensor()
{
command = "";
}

sensor(integer num)
{
integer i = 0;
for (; i < num; ++i)
{
if (command == "ban")
{
// Ban indefinetely
llAddToLandBanList(llDetectedKey(i),0.0);
}
if (command == "tempban")
{
// Ban for 1 hour.
llAddToLandBanList(llDetectedKey(i),1.0);
}
if (command == "unban")
{
llRemoveFromLandBanList(llDetectedKey(i));
}
if (command == "pass")
{
// Add to land pass list for 1 hour
llAddToLandPassList(llDetectedKey(i),1.0);
}
if (command == "unpass")
{
llRemoveFromLandPassList(llDetectedKey(i));
}
}
command = "";
}
}</lsl>
|helpers
|also_functions=
{{LSL DefineRow||[[llAddToLandPassList]]|}}
{{LSL DefineRow||[[llRemoveFromLandBanList]]|}}
{{LSL DefineRow||[[llRemoveFromLandPassList]]|}}
{{LSL DefineRow||[[llResetLandBanList]]|}}
{{LSL DefineRow||[[llResetLandPassList]]|}}
|also_tests
|also_events
|also_articles
|issues
|haiku=
{{Haiku|All are welcome here|except for the following|who have annoyed me}}
|cat1=Security
|cat2=Parcel
|cat3
|cat4
}}