Second Life Wiki - User contributions [en]

Talk:LlList2Json

2016-11-13T10:50:46Z

Haravikk Mistral: /* String Handling Caveat */ new section

== Safe strings ==

Passing strings verbatim to [[llJsonSetValue]] or [[llList2Json]] is not safe. One way to escape strings properly to make them safe for use with both is to use this function:
<source lang="lsl2">
string String2Json(string s)
{
return llGetSubString(llList2Json(JSON_OBJECT, [s,""]), 1, -5);
}
</source>
Examples:
<source lang="lsl2">
llOwnerSay(String2Json(llUnescapeURL("%09"))); // outputs: Object: "\t"
llOwnerSay(String2Json("\n")); // outputs: Object: "\n"
llOwnerSay(String2Json("this \"string\" is not safe")); // outputs: Object: "this \"string\" is not safe"
llOwnerSay(String2Json("\"ab\"")); // outputs: Object: "\"ab\""

// Examples of use with the corresponding functions:
llOwnerSay(llJsonSetValue("[]", [0], String2Json("this \"string\" is not safe")));
llOwnerSay(llList2Json(JSON_ARRAY, [String2Json("this \"string\" is not safe")]));
// both output: Object: ["this \"string\" is not safe"]
</source>

--[[User:Sei Lisa|Sei Lisa]] 17:22, 6 June 2014 (PDT)

:Due to {{jira|BUG-6495}} this won't work. Nothing will. JSON is just broken.--[[User:Sei Lisa|Sei Lisa]] ([[User talk:Sei Lisa|talk]]) 07:27, 27 January 2015 (PST)

== String Handling Caveat ==

Currently the caveats section lists string handling as not enclosing strings automatically in inverted commas, however I just tried this myself and it does not appear to be true, as strings were enclosed as I would expect; was this historic behaviour during testing? Can the caveat be removed? -- --'''[[User:Haravikk_Mistral|Haravikk]]''' 02:50, 13 November 2016 (PST)

Feature Requests

2016-10-30T14:25:11Z

Haravikk Mistral: /* Why wasn't my Feature Request Accepted? */

Do you have suggestions for a new or enhanced feature? We're always looking for new ideas. Please let us know what you would like to see done.

The best place for your feature requests to get noticed is in [http://jira.secondlife.com JIRA Bug Tracker].

{{TOCright}}

== How to Write a great Feature Request ==

* Tell us about the specific functionality you're hoping to see. Describe both the current behavior and desired behavior in as much detail as possible.

* Provide Supporting Materials. This can be done with snapshots, videos, example code, etc. Again, the more information you provide, the better!

* What are the benefits of your Feature?

== What Happens Next ==

Once your Feature Request has been submitted, it will join the queue for a team of Lindens to review. Please be patient... Depending on the nature of your request, it may require members of multiple teams to review.

== Why wasn't my Feature Request Accepted? ==

Please be reassured this isn't personal! We understand, and appreciate, that you put a lot of thought into these proposals, and we consider them seriously. Some feature requests we simply cannot do. Here are some of the reasons why:

* Our internal architecture doesn't allow it.
* It will break existing content.
* It is not scalable.
* The request will introduce security issues.
* Scope of work is too great.
* A Linden didn't even read it, or couldn't be bothered talking to you about it.
[[Category:Bug Tracker]]

Template:Issues/BUG-40739

2016-10-22T10:51:42Z

Haravikk Mistral:

{{Issues|BUG-40739|Redesign [[llSitOnLink]]() to use the permissions system|type=nf}}

LlSitOnLink

2016-10-22T10:50:53Z

Haravikk Mistral:

{{LSL_Function
|func=llSitOnLink
|func_desc=The avatar specified by agent_id is forced to sit on the sit target of the prim indicated by the link parameter. If the specified link is already occupied, the simulator searches down the chain of prims in the link set looking for an available sit target.

|func_footnote=If successful, this method returns 1.

If the function fails, it returns a negative number constant.

Link constants that indicate a single prim may be used for the link parameter. These are LINK_ROOT and LINK_THIS. Other constants such as LINK_SET, LINK_CHILDREN, LINK_ALL_OTHERS will return an INVALID_LINK error.

'''''This method must be called from an experience enabled script running on land that has enabled the experience key.''''' If these conditions are not met this method returns a NOT_EXPERIENCE error.

The targeted avatar must also have accepted the experience. If the user is not participating in the experience this method returns NO_EXPERIENCE_PERMISSION. If the avatar id can not be found or is not over land that has enabled the experience this method returns INVALID_AGENT.

If there are no valid sit targets remaining in the linkset this method returns NO_SIT_TARGET and no action is taken with the avatar.

If the avatar does not have access to the parcel containing the prim running this script, this call fails.
|return_type=Integer
|p1_type=key|p1_name=agent_id|p1_desc=UUID of the avatar being forced to sit
|p2_type=integer|p2_name=link|p2_desc=Link number for the prim containing the desired sit target
|constants={{llSitOnLinkConstants}}
|notes=This function was introduced in conjunction with new [[llSetPrimitiveParams|primitive parameter]] constants: [[PRIM_ALLOW_UNSIT]], [[PRIM_SCRIPTED_SITS_ONLY]], and [[PRIM_SIT_TARGET]].
|also_functions=
* [[llLinkSitTarget]]
* [[llSitTarget]]
* [[llSetSitText]]
* [[llAvatarOnLinkSitTarget]]
* [[llAvatarOnSitTarget]]
* [[llUnSit]]
===Constants===
* [[PRIM_ALLOW_UNSIT]]
* [[PRIM_SCRIPTED_SIT_ONLY]]
* [[PRIM_SIT_TARGET]]
|inject-2={{Issues/BUG-40739}}
}}

Template:Issues/BUG-40739

2016-10-22T10:50:40Z

Haravikk Mistral: Created page with "{{Issues|BUG-40739|Redesign llSitOnLink() to the permissions system|type=nf}}"

{{Issues|BUG-40739|Redesign [[llSitOnLink]]() to the permissions system|type=nf}}

LlGetAgentList

2016-10-12T13:26:48Z

Haravikk Mistral:

{{LSL_Function
|inject-2={{Issues/SCR-311}}{{Issues/SVC-5488}}{{Issues/MISC-243}}{{Issues/BUG-40680}}{{Issues/BUG-40681}}
|func=llGetAgentList
|sort=GetAgentList
|func_id
|func_sleep=0
|func_energy=0
|func_desc=Requests a list of agents currently in the region, limited by the scope parameter.
|func_footnote=
|return_type=list
|return_text=<code><nowiki>[</nowiki>[[key]] {{HoverText|id0|First agent key}}, [[key]] {{HoverText|id1|Second agent key}}, ..., [[key]] {{HoverText|idn|nᵗʰ agent key}}]</code> or <code><nowiki>[</nowiki>[[string]] {{HoverText|error_msg|An error message}}]</code> - returns avatar keys for all agents in the region limited to the area(s) specified by scope
|spec=
|p1_type=integer|p1_name=scope|p1_hover=AGENT_LIST_* flag specifies the selection scope|p1_desc=<span></span>
{{Collapsible_Table/Simple|title=AGENT_LIST_* flag specifies the selection scope
|content={{!}}
* [[AGENT_LIST_PARCEL]] - returns only agents on the same parcel where the script is running.
* [[AGENT_LIST_PARCEL_OWNER]] - returns only agents on any parcel in the region where the parcel owner is the same as the owner of the parcel under the scripted object.
* [[AGENT_LIST_REGION]] - returns any/all agents in the region.
}}
|p2_type=list|p2_subtype=instructions|p2_name=options|p2_desc=Unused.
|constants=
|caveats=
* There is no guaranteed understandable order or randomness to the list returned.
* Will only return up to 100 agents.
|examples=
{{LSL Tip|To check if an avatar is in the same sim, please check whether [[llGetAgentSize]] does NOT return [[ZERO_VECTOR]]. It's much faster and easier than calling [[llGetAgentList]] and running through the list to compare a given key with each list item.}}
{{LSL Tip|As of now, this function does not have a delimiter for its option list. This means, the function MIGHT return up to a hundred avatar keys. You'll need a lot of free memory to be able to store those keys, be warned of possible STACK_HEAP_COLLISION_ERRORs.}}
<source lang="lsl2">
//Displays up to 100 avatar key: name pairs detected in the entire region

default
{
touch_start(integer total_number)
{
list avatarsInRegion = llGetAgentList(AGENT_LIST_REGION, []);
integer numOfAvatars = llGetListLength(avatarsInRegion);

// if no avatars, abort avatar listing process and give a short notice
if (!numOfAvatars)
{
llOwnerSay("No avatars found within the region!");
return;
}

integer index;
while (index < numOfAvatars)
{
key id = llList2Key(avatarsInRegion, index);
string name = llKey2Name(id);

llOwnerSay(name + " [ " + (string)id + " ]");
++index;
}
}
}
</source>
<source lang="lsl2">
// Orders new list based on distance
// and returns names and distances on touch

default
{
touch_start(integer num_detected)
{
list keys = llGetAgentList(AGENT_LIST_REGION, []);
integer numberOfKeys = llGetListLength(keys);

vector currentPos = llGetPos();
list newkeys;
key thisAvKey;

integer i;
for (i = 0; i < numberOfKeys; ++i) {
thisAvKey = llList2Key(keys,i);
newkeys += [llRound(llVecDist(currentPos,
llList2Vector(llGetObjectDetails(thisAvKey, [OBJECT_POS]), 0))),
thisAvKey];
}

newkeys = llListSort(newkeys, 2, FALSE); // sort strided list by descending distance

for (i = 0; i < (numberOfKeys * 2); i += 2) {
llOwnerSay(llGetDisplayName(llList2Key(newkeys, i+1))
+" ["+ (string) llList2Integer(newkeys, i) + "m]");
}
}
}
</source>
|helpers
|also_header
|also_functions=*[[llGetRegionAgentCount]]
|also_tests
|also_events
|also_articles
|also_footer
|notes
|deprecated
|location
|history=
* New function proposed by LL, reconciling the feature suggestions {{Jira|SVC-805}}, {{Jira|SVC-6427}}, {{Jira|MISC-243}} and {{Jira|SVC-5488}}.
* Pre-Released [[Release_Notes/Second_Life_RC_Magnum/12]] - Original JIRA requested "llGetRegionAgents()", the name changed since the released function does more.
* Date of Release [[ Release_Notes/Second_Life_Server/12#12.04.30.255166 | 30/04/2012 ]]
|cat1=Functions
|cat2=Avatar
|cat3=Owner
|cat4=Parcel
|cat5=Region
|cat6
}}

Template:Issues/BUG-40680

2016-10-12T13:26:06Z

Haravikk Mistral: Created page with "{{Issues|BUG-40680|'''AGENT_LIST_LIMIT''' option for llGetAgentList()|type=nf}}"

{{Issues|BUG-40680|'''AGENT_LIST_LIMIT''' option for [[llGetAgentList]]()|type=nf}}

Template:Issues/SCR-311

2016-10-12T13:25:10Z

Haravikk Mistral: Marking as fixed, even though the JIRA issue itself has been left as pending (function works properly in all simulator versions).

{{Issues|SCR-311|type=bug|status=fixp|[[llGetAgentList]]() with scope [[AGENT_LIST_PARCEL]] or [[AGENT_LIST_PARCEL_OWNER]] returns {{HoverText|empty list|[]}} when [[attach]]ed to avatar|status=vfix|resolution=fixed}}

Template:Issues/BUG-40681

2016-10-12T13:21:50Z

Haravikk Mistral: Created page with "{{Issues|BUG-40681|'''llGetNumberOfAgents'''() - companion to llGetAgentList() for retrieving count only.|type=nf}}"

{{Issues|BUG-40681|'''llGetNumberOfAgents'''() - companion to [[llGetAgentList]]() for retrieving count only.|type=nf}}

LlSitOnLink

2016-10-12T10:15:40Z

Haravikk Mistral:

Template:Issues/BUG-40679

2016-10-12T10:15:17Z

Haravikk Mistral:

{{Issues|BUG-40679|Enable [[llSitOnLink]]() for non-experience use cases|type=nf}}

Template:Issues/BUG-40679

2016-10-12T10:14:45Z

Haravikk Mistral: Created page with "{{Issues|BUG-40679|Enable '''llSitOnLink'''() for non-experience use cases|type=nf}}"

{{Issues|BUG-40679|Enable '''llSitOnLink'''() for non-experience use cases|type=nf}}

User:Haravikk Mistral/JIRA/Issues/All

2016-10-07T10:47:14Z

Haravikk Mistral:

{{#if:

{{#vardefine:issues|}}

{{Issues/BUG-40656}}
{{Issues/BUG-40654}}
{{Issues/BUG-40653}}
{{Issues/BUG-40645}}
{{Issues/BUG-40588}}
{{Issues/BUG-10964}}
{{Issues/BUG-10965}}
{{Issues/BUG-7729}}
{{Issues/BUG-7853}}
{{Issues/BUG-7854}}
{{Issues/BUG-7743}}
{{Issues/BUG-7767}}
{{Issues/BUG-7882}}

}}{{{!}}
{{#var:issues}}
{{!}}}{{#vardefine:issues|}}
[https://jira.secondlife.com/issues/?jql=reporter%20%3D'Haravikk%20Mistral'%20ORDER%20BY%20createdDate%20DESC More]

Template:Issues/BUG-40656

2016-10-07T10:41:56Z

Haravikk Mistral: Created page with "{{Issues|BUG-40656|Cookie support for HTTP requests and responses|type=nf}}"

{{Issues|BUG-40656|Cookie support for HTTP requests and responses|type=nf}}

Template:Issues/BUG-40654

2016-10-07T10:41:20Z

Haravikk Mistral: Created page with "{{Issues|BUG-40654|'''llSetHTTPHeader'''() - Enable setting of headers in '''http_response'''()|type=nf}}"

{{Issues|BUG-40654|'''llSetHTTPHeader'''() - Enable setting of headers in '''http_response'''()|type=nf}}

Template:Issues/BUG-40653

2016-10-07T10:40:15Z

Haravikk Mistral: Created page with "{{Issues|BUG-40653|Allow '''llGetHTTPHeader'''() in the '''http_response'''() event|type=nf}}"

{{Issues|BUG-40653|Allow '''llGetHTTPHeader'''() in the '''http_response'''() event|type=nf}}

Simulator User Group

2016-10-07T10:34:24Z

Haravikk Mistral:

{{User Group Page
|purpose=
The Server User Group exists to provide an opportunity for discussion about server technology, annoying bugs, and feature ideas.
|date-time=
* Tuesdays 12:00-13:00 (general) http://slurl.com/secondlife/Denby/220/41/33,
Meetings are
|location= '''Denby/225/25/25'''
|agenda=
* LL developer news
* Open discussion

== News ==

|team=
* [[User:Andrew Linden|Andrew Linden]] (honorary member for all time)
* [[User:Simon Linden|Simon Linden]]
* [[User:Kelly Linden|Kelly Linden]]
* [[User:Baker Linden|Baker Linden]]
* [[User:Oz Linden|Oz Linden]]
}}

'''Meeting cancelled for August 12, 2014'''

2014.12 '''December'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
| 01
| [[Simulator_User_Group/Transcripts/2014.12.02|02]]
| 03
| 04
| 05
| 06
|-
| 07
| 06
| [[Simulator_User_Group/Transcripts/2014.12.09|09]]
| 10
| 11
| 12
| 13
|-
| 14
| 15
| [[Simulator_User_Group/Transcripts/2014.12.16|16]]
| 17
| 18
| 19
| 20
|-
| 21
| 22
| [[Simulator_User_Group/Transcripts/2014.12.23|23]]
| 24
| 25
| 26
| 27
|-
| 28
| 29
| [[Simulator_User_Group/Transcripts/2014.12.30|30]]
| 31
|
|
|
|}

2014.11 '''Nov'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
|
|
|
|
|
| 01
|-
| 02
| 03
| [[Simulator_User_Group/Transcripts/2014.03.04|04]]
| 05
| 06
| 07
| 08
|-
| 09
| 10
| [[Simulator_User_Group/Transcripts/2014.03.11|11]]
| 12
| 13
| 14
| 15
|-
| 16
| 17
| [[Simulator_User_Group/Transcripts/2014.03.18|18]]
| 19
| 20
| 21
| 22
|-
| 23
| 24
| [[Simulator_User_Group/Transcripts/2014.03.25|25]]
| 26
| 27
| 28
| 29
|-
| 30
|
|
|
|
|
|
|}

2014.01 '''October'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
|
|
| 01
| 02
| 03
| 04
|-
| 05
| 06
| [[Simulator_User_Group/Transcripts/2014.10.07|07]]
| 08
| 09
| 10
| 11
|-
| 12
| 13
| [[Simulator_User_Group/Transcripts/2014.10.14|14]]
| 15
| 16
| 17
| 18
|-
| 19
| 20
| [[Simulator_User_Group/Transcripts/2014.10.21|21]]
| 22
| 23
| 24
| 25
|-
| 26
| 27
| [[Simulator_User_Group/Transcripts/2014.10.28|28]]
| 29
| 30
| 31
|
|}

2014.09 '''September'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
| 01
| [[Simulator_User_Group/Transcripts/2014.09.02|02]]
| 03
| 04
| 05
| 06
|-
| 07
| 06
| [[Simulator_User_Group/Transcripts/2014.09.09|09]]
| 10
| 11
| 12
| 13
|-
| 14
| 15
| [[Simulator_User_Group/Transcripts/2014.09.16|16]]
| 17
| 18
| 19
| 20
|-
| 21
| 22
| [[Simulator_User_Group/Transcripts/2014.09.23|23]]
| 24
| 25
| 26
| 27
|-
| 28
| 29
| [[Simulator_User_Group/Transcripts/2014.09.30|30]]
|
|
|
|
|}

2014.08 '''August'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
|
|
|
|
| 01
| 02
|-
| 03
| 04
| [[Simulator_User_Group/Transcripts/2014.08.05|05]]
| 06
| 07
| 08
| 09
|-
| 10
| 11
| [[Simulator_User_Group/Transcripts/2014.08.12|12]]
| 13
| 14
| 15
| 16
|-
| 17
| 18
| [[Simulator_User_Group/Transcripts/2014.08.19|19]]
| 20
| 21
| 22
| 23
|-
| 24
| 25
| [[Simulator_User_Group/Transcripts/2014.08.26|26]]
| 27
| 28
| 29
| 30
|-
| 31
|
|
|
|
|
|
|}

2014.07 '''July'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
|
| [[Simulator_User_Group/Transcripts/2014.07.01|01]]
| 02
| 03
| 04
| 05
|-
| 06
| 07
| [[Simulator_User_Group/Transcripts/2014.07.08|08]]
| 09
| 10
| 11
| 12
|-
| 13
| 14
| [[Simulator_User_Group/Transcripts/2014.07.15|15]]
| 16
| 17
| 18
| 19
|-
| 20
| 21
| [[Simulator_User_Group/Transcripts/2014.07.22|22]]
| 23
| 24
| 25
| 26
|-
| 27
| 28
| [[Simulator_User_Group/Transcripts/2014.07.29|29]]
| 30
| 31
|
|
|}

2014.06 '''June'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
| 01
| 02
| [[Simulator_User_Group/Transcripts/2014.06.03|03]]
| 04
| 05
| 06
| 07
|-
| 08
| 09
| [[Simulator_User_Group/Transcripts/2014.06.10|10]]
| 11
| 12
| 13
| 14
|-
| 15
| 16
| [[Simulator_User_Group/Transcripts/2014.06.17|17]]
| 18
| 19
| 20
| 21
|-
| 22
| 23
| [[Simulator_User_Group/Transcripts/2014.06.24|24]]
| 25
| 26
| 27
| 28
|-
| 29
| 30
|
|
|
|
|
|}

2014.05 '''May'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
|
|
|
| 01
| 02
| 03
|-
| 04
| 05
| [[Simulator_User_Group/Transcripts/2014.05.06|06]]
| 07
| 08
| 09
| 10
|-
| 11
| 12
| [[Simulator_User_Group/Transcripts/2014.05.13|13]]
| 14
| 15
| 16
| 17
|-
| 18
| 19
| [[Simulator_User_Group/Transcripts/2014.05.20|20]]
| 21
| 22
| 23
| 24
|-
| 25
| 26
| [[Simulator_User_Group/Transcripts/2014.05.27|27]]
| 28
| 29
| 30
| 31
|}

2014.04 '''April'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
|
| [[Simulator_User_Group/Transcripts/2014.04.01|01]]
| 02
| 03
| 04
| 05
|-
| 06
| 07
| [[Simulator_User_Group/Transcripts/2014.04.08|08]]
| 09
| 10
| 11
| 12
|-
| 13
| 14
| [[Simulator_User_Group/Transcripts/2014.04.15|15]]
| 16
| 17
| 18
| 19
|-
| 20
| 21
| [[Simulator_User_Group/Transcripts/2014.04.22|22]]
| 23
| 24
| 25
| 26
|-
| 27
| 28
| [[Simulator_User_Group/Transcripts/2014.04.29|29]]
| 30
|
|
|
|}

2014.03 '''March'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
|
|
|
|
|
| 01
|-
| 02
| 03
| [[Simulator_User_Group/Transcripts/2014.03.04|04]]
| 05
| 06
| 07
| 08
|-
| 09
| 10
| [[Simulator_User_Group/Transcripts/2014.03.11|11]]
| 12
| 13
| 14
| 15
|-
| 16
| 17
| [[Simulator_User_Group/Transcripts/2014.03.18|18]]
| 19
| 20
| 21
| 22
|-
| 23
| 24
| [[Simulator_User_Group/Transcripts/2014.03.25|25]]
| 26
| 27
| 28
| 29
|-
| 30
| 31
|
|
|
|
|
|}

2014.02 '''February'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
|
|
|
|
|
| 01
|-
| 02
| 03
| [[Simulator_User_Group/Transcripts/2014.02.04|04]]
| 05
| 06
| 07
| 08
|-
| 09
| 10
| [[Simulator_User_Group/Transcripts/2014.03.11|11]]
| 12
| 13
| 14
| 15
|-
| 16
| 17
| [[Simulator_User_Group/Transcripts/2014.02.18|18]]
| 19
| 20
| 21
| 22
|-
| 23
| 24
| [[Simulator_User_Group/Transcripts/2014.02.25|25]]
| 26
| 27
| 28
|
|}

2014.01 '''January'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
|
|
| 01
| 02
| 03
| 04
|-
| 05
| 06
| [[Simulator_User_Group/Transcripts/2014.01.07|07]]
| 08
| 09
| 10
| 11
|-
| 12
| 13
| [[Simulator_User_Group/Transcripts/2014.01.14|14]]
| 15
| 16
| 17
| 18
|-
| 19
| 20
| [[Simulator_User_Group/Transcripts/2014.01.21|21]]
| 22
| 23
| 24
| 25
|-
| 26
| 27
| [[Simulator_User_Group/Transcripts/2014.01.28|28]]
| 29
| 30
| 31
|
|}

[[Simulator_User_Group/Transcripts/2012]]

[[Simulator_User_Group/Transcripts/2011]]

User:Haravikk Mistral/JIRA/Issues/All

2016-10-06T14:18:02Z

Haravikk Mistral:

{{#if:

{{#vardefine:issues|}}

{{Issues/BUG-40645}}
{{Issues/BUG-40588}}
{{Issues/BUG-10964}}
{{Issues/BUG-10965}}
{{Issues/BUG-7729}}
{{Issues/BUG-10924}}
{{Issues/BUG-7853}}
{{Issues/BUG-7854}}
{{Issues/BUG-7743}}
{{Issues/BUG-7767}}
{{Issues/BUG-7882}}
{{Issues/BUG-10971}}

}}{{{!}}
{{#var:issues}}
{{!}}}{{#vardefine:issues|}}
[https://jira.secondlife.com/issues/?jql=reporter%20%3D'Haravikk%20Mistral'%20ORDER%20BY%20createdDate%20DESC More]

Template:Issues/BUG-40645

2016-10-06T14:17:20Z

Haravikk Mistral: Created page with "{{Issues|BUG-40645|'''llCreateBakedTexture'''() - Texture Baking for Scripted Objects|type=nf}}"

{{Issues|BUG-40645|'''llCreateBakedTexture'''() - Texture Baking for Scripted Objects|type=nf}}

User:Haravikk Mistral/JIRA/Issues/All

2016-09-28T10:03:43Z

Haravikk Mistral:

{{#if:

{{#vardefine:issues|}}

{{Issues/BUG-40588}}
{{Issues/BUG-10964}}
{{Issues/BUG-10965}}
{{Issues/BUG-7729}}
{{Issues/BUG-10924}}
{{Issues/BUG-7853}}
{{Issues/BUG-7854}}
{{Issues/BUG-7743}}
{{Issues/BUG-7767}}
{{Issues/BUG-7882}}
{{Issues/BUG-10971}}

}}{{{!}}
{{#var:issues}}
{{!}}}{{#vardefine:issues|}}
[https://jira.secondlife.com/issues/?jql=reporter%20%3D'Haravikk%20Mistral'%20ORDER%20BY%20createdDate%20DESC More]

Template:Issues/BUG-40588

2016-09-28T10:03:08Z

Haravikk Mistral: Created page with "{{issues|BUG-40588|'''llGetInventoryTime'''() - Added/Modified Time for Inventory Assets|type=nf}}"

{{issues|BUG-40588|'''llGetInventoryTime'''() - Added/Modified Time for Inventory Assets|type=nf}}

Talk:PRIM POINT LIGHT

2016-02-17T11:10:19Z

Haravikk Mistral: /* Multiplying Colour? */ new section

== Multiplying Colour? ==

In the compact version example is there a reason for multiplying the colour in this line:

<source lang="lsl2">PRIM_POINT_LIGHT, switch, <1, 0.5, 0.1> * switch, 1, 10, 0.6 </source>

If the light is being switched off then the colour will be multiplied down to <0,0,0> (black), but it seems that this is set when a light is disabled anyway (if you turn a light off then back on via script, it will be coloured black, with 0 for all values). -- --'''[[User:Haravikk_Mistral|Haravikk]]''' 03:10, 17 February 2016 (PST)

Talk:LlSetText

2016-01-12T09:58:59Z

Haravikk Mistral: /* llSetText for storage */ new section

== JIRA New Feature llGetText ==

Here's a first draft. Good to go? Ready to add near http://jira.secondlife.com/secure/QuickSearch.jspa after logging in with the usual Second Life name & password? Yes/ no/ almost? -- [[User:Ppaatt Lynagh|Ppaatt Lynagh]] 20:55, 1 November 2007 (PDT)

PROJECT = MISC (chosen from VWR SVX WEB MISC Eventlet Mulib CertifiedHTTP)

ISSUE TYPE = New Feature (chosen from Bug, New Feature)

SUMMARY = A function named llGetText should exist to tell the script calling llSetText if the script is or is not changing the floating text of the prim.

PRIORITY = Normal (chosen from Showstopper, Critical, Major, Normal, Small)

COMPONENT/S = Unknown (chosen from Unknown, Miscellaneous)

AFFECTS VERSION/S = Unknown (not editable)

LINDEN LAB ISSUE ID = (intentionally left blank)

ENVIRONMENT = N/A

DESCRIPTION =

A function named llGetText should exist to tell the script calling llSetText if the script is or is not changing the floating text of the prim. For example, llGetText could return a list of four results: [text, color, alpha, font].

This specific need to add llGetText to LSL illustrates a general design principle. LSL should define a way to get back everything it sets. Otherwise one script cannot discover if another script has set a property. For example, a script cannot see if an object has been labeled for sale, given a custom label, or given no label at all as its floating text. As another example, an instance of an editor script cannot show the operator if the operator has set the property thru another script instance.

ATTACHMENT = None

PATCH ATTACHED = (intentionally left blank)

SOURCE VERSION = (intentionally left blank)

== llGetText ==

I think it should point to a JIRA feature suggestion but I'm not feeling inspired enough to write one up. -- [[User:Strife Onizuka|Strife Onizuka]] 12:55, 29 October 2007 (PDT)

:Thanks for making time to say so. I didn't know that. Now that I do, I'll volunteer me to research and then publish an article here that invites our audience to contribute to JIRA also. Writing up the JIRA entry for llGetText will be my first example, unless another among us beats me to it. -- [[User:Ppaatt Lynagh|Ppaatt Lynagh]] 13:07, 29 October 2007 (PDT)

:[[User:Strife_Onizuka]] > http://wiki.secondlife.com/wiki/Category:Jira_Reporters > [[Bug Reporting 101]] may be relevant. -- [[User:Ppaatt Lynagh|Ppaatt Lynagh]] 13:16, 29 October 2007 (PDT)

:Wow that mess of a web of pages near [[Bug Reporting 101]] is nearly indecipherable.

:http://jira.secondlife.com/secure/QuickSearch.jspa might be the first step that those too many words recommend. As of this moment, llSetText finds hits, llGetText finds no hits, confirming Strife's idea that we should add llGetText. -- [[User:Ppaatt Lynagh|Ppaatt Lynagh]] 20:26, 1 November 2007 (PDT)

== General ==

I regret that there were so many edits, it's the first time I've contributed content to this Wiki, and am still learning the formatting. Thanks for understanding. It would help if there were a generic page with the formatting already in place that users could edit -- there may be one somewhere, but I haven't found it yet. -- [[User:Rich Nykvist|Rich]]
:Don't worry about the number of edits. Just look around at the syntax used on other pages, it's the easiest way. [[User:Strife Onizuka|Strife Onizuka]] 04:54, 8 February 2007 (PST)

: With the exception of editing actual template code (as opposed to code that uses templates), the "Show Preview" button will allow you to keep an eye on your changes without committing them to the article :-)
: [[User:SignpostMarv Martin|SignpostMarv Martin]] 05:36, 8 February 2007 (PST)

== Different colors in the displayed text? ==

I recently saw some RPG engine that lets people have colored health bars in the hovertext above their head.

Is there a way to specify colors for individual text characters, or are they doing this by stacking up several llSetText prims, each showing only one color? [[User:Scalar Tardis|Scalar Tardis]] 20:25, 25 March 2008 (PDT)

:Stacking. -- [[User:Strife Onizuka|Strife Onizuka]] 15:19, 26 March 2008 (PDT)

== llSetText for storage ==

Regarding the caveat "Do not rely on Floating Text as a storage medium; it is neither secure nor finalized." I'm wondering how necessary some of this is as a caveat anymore?

I'm not aware of the text limit for hover-text having changed in a long time, and even if it were to change that's an argument for checking that any stored data is the length you expect it to be (e.g- store expected length first). The main argument against storage is the lack of security, but the same is true of using prim descriptions, which are also commonly used for storage that can survive resets.

I often use invisible set-text to store short pieces of persistent data that I need to survive resets (but which I'm not concerned about being inspected), while leaving descriptions free for users to change manually (as I like to use descriptions for specifying prim-properties that a script can load, such as allowing a script to change all prims with the "primary" keyword). Obviously pushing the limits of either isn't a great idea, but short text should be fine in both so long as it's nothing sensitive, so I'm wondering if the caveats should be updated to reflect that? The caveats for this page could probably use a cleanup in general actually, as things like clearing text could do with being in examples I think. --'''[[User:Haravikk_Mistral|Haravikk]]''' 01:58, 12 January 2016 (PST)

User:Haravikk Mistral/Signature

2016-01-12T09:55:31Z

Haravikk Mistral:

--'''[[User:Haravikk_Mistral|Haravikk]]'''

Simulator User Group

2016-01-06T20:47:18Z

Haravikk Mistral:

{{User Group Page
|purpose=
The Server User Group exists to provide an opportunity for discussion about server technology, annoying bugs, and feature ideas.
|date-time=
* Tuesdays 12:00-13:00 (general) http://slurl.com/secondlife/Denby/220/41/33,
Meetings are
|location= '''Denby/225/25/25'''
|agenda=
* LL developer news
* Please review the premature closure of the following issues by Kyle Linden. I know he's not listed as a server/sim/scripting group member, but I have no idea who we're supposed to contact about closed issues as Lindens never seem to reply to IMs. I want to stress also that I am utterly sick of the pathetic canned responses that JIRA issues get when closed, because not only do they give no specific information, all they really do is link to a wiki page that is worse than useless at indicating valid reasons why an issue was closed, it's a deeply hostile process that makes me wonder why anyone bothers trying to improve SL. Anyway, sorry that these aren't all server/sim/scripting, but who the heck are we supposed to talk to about closed issues anymore? Reporters don't have any control over their own issues once closed. Anyway, these are the ones that I posted, I'm sure Kyle's closing-with-worthless-canned-text rampage has affected others as well. -- [[User:Haravikk Mistral|Haravikk]]
** {{jira|BUG-10924|BUG-10924 llSubListFindList}}- this clearly comes under the remit of server/sim/scripting, so I don't know who Kyle is representing while closing the issue. However, the proposed function is very simple, actually it's just a case of adding a loop to skip items till start index is reached, then a counter to exit the function if the end index is reached, both changes that can actually be added to the existing code, with llListFindList becoming an equivalent of llSubListFindList(haystack, needle, 0, -1).
** {{jira|BUG-10965|BUG-10965|BUG-10965}}- this is a viewer-side only issue intended for open development which I'm still hoping to find someone to implement or, if I can ever find the time, will implement myself. I don't know why it should be closed, at all, and I actually added as a result of discussion at one of these meetings.
** {{jira|BUG-10931|BUG-10931 Add support Ctrl-A and Ctrl-E Mac keyboard shortcuts for start/end of line}}- another viewer-only issue intended for open development, but I don't know who Kyle Linden is representing (no mention anywhere that I can see). It's a fairly important one as duplicating all Ctrl-key combinations onto Command-key was never a good idea in the first place, as it limits the keyspace for Mac shortcuts, and actually results in shortcuts that behave very differently to other programs; as mentioned in the JIRA issue, Ctrl-E and Ctrl-A are commonly available in most Mac programs with text-fields, but behave very differently in SL.
* Open discussion

== News ==

|team=
* [[User:Andrew Linden|Andrew Linden]] (honorary member for all time)
* [[User:Simon Linden|Simon Linden]]
* [[User:Kelly Linden|Kelly Linden]]
* [[User:Baker Linden|Baker Linden]]
* [[User:Oz Linden|Oz Linden]]
}}

'''Meeting cancelled for August 12, 2014'''

2014.12 '''December'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
| 01
| [[Simulator_User_Group/Transcripts/2014.12.02|02]]
| 03
| 04
| 05
| 06
|-
| 07
| 06
| [[Simulator_User_Group/Transcripts/2014.12.09|09]]
| 10
| 11
| 12
| 13
|-
| 14
| 15
| [[Simulator_User_Group/Transcripts/2014.12.16|16]]
| 17
| 18
| 19
| 20
|-
| 21
| 22
| [[Simulator_User_Group/Transcripts/2014.12.23|23]]
| 24
| 25
| 26
| 27
|-
| 28
| 29
| [[Simulator_User_Group/Transcripts/2014.12.30|30]]
| 31
|
|
|
|}

2014.11 '''Nov'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
|
|
|
|
|
| 01
|-
| 02
| 03
| [[Simulator_User_Group/Transcripts/2014.03.04|04]]
| 05
| 06
| 07
| 08
|-
| 09
| 10
| [[Simulator_User_Group/Transcripts/2014.03.11|11]]
| 12
| 13
| 14
| 15
|-
| 16
| 17
| [[Simulator_User_Group/Transcripts/2014.03.18|18]]
| 19
| 20
| 21
| 22
|-
| 23
| 24
| [[Simulator_User_Group/Transcripts/2014.03.25|25]]
| 26
| 27
| 28
| 29
|-
| 30
|
|
|
|
|
|
|}

2014.01 '''October'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
|
|
| 01
| 02
| 03
| 04
|-
| 05
| 06
| [[Simulator_User_Group/Transcripts/2014.10.07|07]]
| 08
| 09
| 10
| 11
|-
| 12
| 13
| [[Simulator_User_Group/Transcripts/2014.10.14|14]]
| 15
| 16
| 17
| 18
|-
| 19
| 20
| [[Simulator_User_Group/Transcripts/2014.10.21|21]]
| 22
| 23
| 24
| 25
|-
| 26
| 27
| [[Simulator_User_Group/Transcripts/2014.10.28|28]]
| 29
| 30
| 31
|
|}

2014.09 '''September'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
| 01
| [[Simulator_User_Group/Transcripts/2014.09.02|02]]
| 03
| 04
| 05
| 06
|-
| 07
| 06
| [[Simulator_User_Group/Transcripts/2014.09.09|09]]
| 10
| 11
| 12
| 13
|-
| 14
| 15
| [[Simulator_User_Group/Transcripts/2014.09.16|16]]
| 17
| 18
| 19
| 20
|-
| 21
| 22
| [[Simulator_User_Group/Transcripts/2014.09.23|23]]
| 24
| 25
| 26
| 27
|-
| 28
| 29
| [[Simulator_User_Group/Transcripts/2014.09.30|30]]
|
|
|
|
|}

2014.08 '''August'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
|
|
|
|
| 01
| 02
|-
| 03
| 04
| [[Simulator_User_Group/Transcripts/2014.08.05|05]]
| 06
| 07
| 08
| 09
|-
| 10
| 11
| [[Simulator_User_Group/Transcripts/2014.08.12|12]]
| 13
| 14
| 15
| 16
|-
| 17
| 18
| [[Simulator_User_Group/Transcripts/2014.08.19|19]]
| 20
| 21
| 22
| 23
|-
| 24
| 25
| [[Simulator_User_Group/Transcripts/2014.08.26|26]]
| 27
| 28
| 29
| 30
|-
| 31
|
|
|
|
|
|
|}

2014.07 '''July'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
|
| [[Simulator_User_Group/Transcripts/2014.07.01|01]]
| 02
| 03
| 04
| 05
|-
| 06
| 07
| [[Simulator_User_Group/Transcripts/2014.07.08|08]]
| 09
| 10
| 11
| 12
|-
| 13
| 14
| [[Simulator_User_Group/Transcripts/2014.07.15|15]]
| 16
| 17
| 18
| 19
|-
| 20
| 21
| [[Simulator_User_Group/Transcripts/2014.07.22|22]]
| 23
| 24
| 25
| 26
|-
| 27
| 28
| [[Simulator_User_Group/Transcripts/2014.07.29|29]]
| 30
| 31
|
|
|}

2014.06 '''June'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
| 01
| 02
| [[Simulator_User_Group/Transcripts/2014.06.03|03]]
| 04
| 05
| 06
| 07
|-
| 08
| 09
| [[Simulator_User_Group/Transcripts/2014.06.10|10]]
| 11
| 12
| 13
| 14
|-
| 15
| 16
| [[Simulator_User_Group/Transcripts/2014.06.17|17]]
| 18
| 19
| 20
| 21
|-
| 22
| 23
| [[Simulator_User_Group/Transcripts/2014.06.24|24]]
| 25
| 26
| 27
| 28
|-
| 29
| 30
|
|
|
|
|
|}

2014.05 '''May'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
|
|
|
| 01
| 02
| 03
|-
| 04
| 05
| [[Simulator_User_Group/Transcripts/2014.05.06|06]]
| 07
| 08
| 09
| 10
|-
| 11
| 12
| [[Simulator_User_Group/Transcripts/2014.05.13|13]]
| 14
| 15
| 16
| 17
|-
| 18
| 19
| [[Simulator_User_Group/Transcripts/2014.05.20|20]]
| 21
| 22
| 23
| 24
|-
| 25
| 26
| [[Simulator_User_Group/Transcripts/2014.05.27|27]]
| 28
| 29
| 30
| 31
|}

2014.04 '''April'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
|
| [[Simulator_User_Group/Transcripts/2014.04.01|01]]
| 02
| 03
| 04
| 05
|-
| 06
| 07
| [[Simulator_User_Group/Transcripts/2014.04.08|08]]
| 09
| 10
| 11
| 12
|-
| 13
| 14
| [[Simulator_User_Group/Transcripts/2014.04.15|15]]
| 16
| 17
| 18
| 19
|-
| 20
| 21
| [[Simulator_User_Group/Transcripts/2014.04.22|22]]
| 23
| 24
| 25
| 26
|-
| 27
| 28
| [[Simulator_User_Group/Transcripts/2014.04.29|29]]
| 30
|
|
|
|}

2014.03 '''March'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
|
|
|
|
|
| 01
|-
| 02
| 03
| [[Simulator_User_Group/Transcripts/2014.03.04|04]]
| 05
| 06
| 07
| 08
|-
| 09
| 10
| [[Simulator_User_Group/Transcripts/2014.03.11|11]]
| 12
| 13
| 14
| 15
|-
| 16
| 17
| [[Simulator_User_Group/Transcripts/2014.03.18|18]]
| 19
| 20
| 21
| 22
|-
| 23
| 24
| [[Simulator_User_Group/Transcripts/2014.03.25|25]]
| 26
| 27
| 28
| 29
|-
| 30
| 31
|
|
|
|
|
|}

2014.02 '''February'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
|
|
|
|
|
| 01
|-
| 02
| 03
| [[Simulator_User_Group/Transcripts/2014.02.04|04]]
| 05
| 06
| 07
| 08
|-
| 09
| 10
| [[Simulator_User_Group/Transcripts/2014.03.11|11]]
| 12
| 13
| 14
| 15
|-
| 16
| 17
| [[Simulator_User_Group/Transcripts/2014.02.18|18]]
| 19
| 20
| 21
| 22
|-
| 23
| 24
| [[Simulator_User_Group/Transcripts/2014.02.25|25]]
| 26
| 27
| 28
|
|}

2014.01 '''January'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
|
|
| 01
| 02
| 03
| 04
|-
| 05
| 06
| [[Simulator_User_Group/Transcripts/2014.01.07|07]]
| 08
| 09
| 10
| 11
|-
| 12
| 13
| [[Simulator_User_Group/Transcripts/2014.01.14|14]]
| 15
| 16
| 17
| 18
|-
| 19
| 20
| [[Simulator_User_Group/Transcripts/2014.01.21|21]]
| 22
| 23
| 24
| 25
|-
| 26
| 27
| [[Simulator_User_Group/Transcripts/2014.01.28|28]]
| 29
| 30
| 31
|
|}

[[Simulator_User_Group/Transcripts/2012]]

[[Simulator_User_Group/Transcripts/2011]]

Simulator User Group

2016-01-06T20:23:07Z

Haravikk Mistral:

{{User Group Page
|purpose=
The Server User Group exists to provide an opportunity for discussion about server technology, annoying bugs, and feature ideas.
|date-time=
* Tuesdays 12:00-13:00 (general) http://slurl.com/secondlife/Denby/220/41/33,
Meetings are
|location= '''Denby/225/25/25'''
|agenda=
* LL developer news
* Review premature closure of {{jira|BUG-10924|BUG-10924 llSubListFindList}}- it is a very simple function as llListFindList is already implemented, all that is required is to skip to the start index, and stop after the end index is reached. In essence only a single function implementation is required, as llListFindList would be equivalent to llSubListFindList(haystack, needle, 0, -1). With the woeful inefficiency of lists it's also a very important capability to have, if it can be strided at the same time (thus restricting which indices potential matches can start from) that would be even better. -- [[User:Haravikk Mistral|Haravikk]]
* Review premature closure of {{jira|BUG-10965|BUG-10965|BUG-10965}}- mainly because it isn't a server, simulator or scripting issue at all, since the drift occurs on the client-side. This particular issue is also specifically a viewer-side open-development issue that I'm hoping to either find someone willing to implement or, if I can ever find the time, implement myself; also, if {{jira|BUG-10964}} is accepted then this should be too, as they're essentially two aspects of the same thing (ensuring animations display with correct timing per-viewer, so future cross-viewer features can be implemented for synchronised timing). -- [[User:Haravikk Mistral|Haravikk]]
* Review premature closure of {{jira|BUG-10931|BUG-10931 Add support Ctrl-A and Ctrl-E Mac keyboard shortcuts for start/end of line}}- in what way is this "unactionable"? I have to say I'm really sick of the pathetic canned responses that closed issues get, it provides no information whatsoever as to why this issue might be "unactionable" (the wiki page is worse than useless). This is a simple keyboard shortcut, it's clearly possible to have separate Mac and Windows shortcuts, and it's a very useful shortcut to have, it's also an issue with SL's generally poor native platform support, as these shortcuts are available in most Mac programs with text-fields, yet behave completely differently in SL. In fact, having every Ctrl-shortcut from the Windows client in the Mac client was just a bad idea to begin with, as that's just now how keyboard shortcuts are done on Macs. -- [[User:Haravikk Mistral|Haravikk]]
* Open discussion

== News ==

|team=
* [[User:Andrew Linden|Andrew Linden]] (honorary member for all time)
* [[User:Simon Linden|Simon Linden]]
* [[User:Kelly Linden|Kelly Linden]]
* [[User:Baker Linden|Baker Linden]]
* [[User:Oz Linden|Oz Linden]]
}}

'''Meeting cancelled for August 12, 2014'''

2014.12 '''December'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
| 01
| [[Simulator_User_Group/Transcripts/2014.12.02|02]]
| 03
| 04
| 05
| 06
|-
| 07
| 06
| [[Simulator_User_Group/Transcripts/2014.12.09|09]]
| 10
| 11
| 12
| 13
|-
| 14
| 15
| [[Simulator_User_Group/Transcripts/2014.12.16|16]]
| 17
| 18
| 19
| 20
|-
| 21
| 22
| [[Simulator_User_Group/Transcripts/2014.12.23|23]]
| 24
| 25
| 26
| 27
|-
| 28
| 29
| [[Simulator_User_Group/Transcripts/2014.12.30|30]]
| 31
|
|
|
|}

2014.11 '''Nov'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
|
|
|
|
|
| 01
|-
| 02
| 03
| [[Simulator_User_Group/Transcripts/2014.03.04|04]]
| 05
| 06
| 07
| 08
|-
| 09
| 10
| [[Simulator_User_Group/Transcripts/2014.03.11|11]]
| 12
| 13
| 14
| 15
|-
| 16
| 17
| [[Simulator_User_Group/Transcripts/2014.03.18|18]]
| 19
| 20
| 21
| 22
|-
| 23
| 24
| [[Simulator_User_Group/Transcripts/2014.03.25|25]]
| 26
| 27
| 28
| 29
|-
| 30
|
|
|
|
|
|
|}

2014.01 '''October'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
|
|
| 01
| 02
| 03
| 04
|-
| 05
| 06
| [[Simulator_User_Group/Transcripts/2014.10.07|07]]
| 08
| 09
| 10
| 11
|-
| 12
| 13
| [[Simulator_User_Group/Transcripts/2014.10.14|14]]
| 15
| 16
| 17
| 18
|-
| 19
| 20
| [[Simulator_User_Group/Transcripts/2014.10.21|21]]
| 22
| 23
| 24
| 25
|-
| 26
| 27
| [[Simulator_User_Group/Transcripts/2014.10.28|28]]
| 29
| 30
| 31
|
|}

2014.09 '''September'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
| 01
| [[Simulator_User_Group/Transcripts/2014.09.02|02]]
| 03
| 04
| 05
| 06
|-
| 07
| 06
| [[Simulator_User_Group/Transcripts/2014.09.09|09]]
| 10
| 11
| 12
| 13
|-
| 14
| 15
| [[Simulator_User_Group/Transcripts/2014.09.16|16]]
| 17
| 18
| 19
| 20
|-
| 21
| 22
| [[Simulator_User_Group/Transcripts/2014.09.23|23]]
| 24
| 25
| 26
| 27
|-
| 28
| 29
| [[Simulator_User_Group/Transcripts/2014.09.30|30]]
|
|
|
|
|}

2014.08 '''August'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
|
|
|
|
| 01
| 02
|-
| 03
| 04
| [[Simulator_User_Group/Transcripts/2014.08.05|05]]
| 06
| 07
| 08
| 09
|-
| 10
| 11
| [[Simulator_User_Group/Transcripts/2014.08.12|12]]
| 13
| 14
| 15
| 16
|-
| 17
| 18
| [[Simulator_User_Group/Transcripts/2014.08.19|19]]
| 20
| 21
| 22
| 23
|-
| 24
| 25
| [[Simulator_User_Group/Transcripts/2014.08.26|26]]
| 27
| 28
| 29
| 30
|-
| 31
|
|
|
|
|
|
|}

2014.07 '''July'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
|
| [[Simulator_User_Group/Transcripts/2014.07.01|01]]
| 02
| 03
| 04
| 05
|-
| 06
| 07
| [[Simulator_User_Group/Transcripts/2014.07.08|08]]
| 09
| 10
| 11
| 12
|-
| 13
| 14
| [[Simulator_User_Group/Transcripts/2014.07.15|15]]
| 16
| 17
| 18
| 19
|-
| 20
| 21
| [[Simulator_User_Group/Transcripts/2014.07.22|22]]
| 23
| 24
| 25
| 26
|-
| 27
| 28
| [[Simulator_User_Group/Transcripts/2014.07.29|29]]
| 30
| 31
|
|
|}

2014.06 '''June'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
| 01
| 02
| [[Simulator_User_Group/Transcripts/2014.06.03|03]]
| 04
| 05
| 06
| 07
|-
| 08
| 09
| [[Simulator_User_Group/Transcripts/2014.06.10|10]]
| 11
| 12
| 13
| 14
|-
| 15
| 16
| [[Simulator_User_Group/Transcripts/2014.06.17|17]]
| 18
| 19
| 20
| 21
|-
| 22
| 23
| [[Simulator_User_Group/Transcripts/2014.06.24|24]]
| 25
| 26
| 27
| 28
|-
| 29
| 30
|
|
|
|
|
|}

2014.05 '''May'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
|
|
|
| 01
| 02
| 03
|-
| 04
| 05
| [[Simulator_User_Group/Transcripts/2014.05.06|06]]
| 07
| 08
| 09
| 10
|-
| 11
| 12
| [[Simulator_User_Group/Transcripts/2014.05.13|13]]
| 14
| 15
| 16
| 17
|-
| 18
| 19
| [[Simulator_User_Group/Transcripts/2014.05.20|20]]
| 21
| 22
| 23
| 24
|-
| 25
| 26
| [[Simulator_User_Group/Transcripts/2014.05.27|27]]
| 28
| 29
| 30
| 31
|}

2014.04 '''April'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
|
| [[Simulator_User_Group/Transcripts/2014.04.01|01]]
| 02
| 03
| 04
| 05
|-
| 06
| 07
| [[Simulator_User_Group/Transcripts/2014.04.08|08]]
| 09
| 10
| 11
| 12
|-
| 13
| 14
| [[Simulator_User_Group/Transcripts/2014.04.15|15]]
| 16
| 17
| 18
| 19
|-
| 20
| 21
| [[Simulator_User_Group/Transcripts/2014.04.22|22]]
| 23
| 24
| 25
| 26
|-
| 27
| 28
| [[Simulator_User_Group/Transcripts/2014.04.29|29]]
| 30
|
|
|
|}

2014.03 '''March'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
|
|
|
|
|
| 01
|-
| 02
| 03
| [[Simulator_User_Group/Transcripts/2014.03.04|04]]
| 05
| 06
| 07
| 08
|-
| 09
| 10
| [[Simulator_User_Group/Transcripts/2014.03.11|11]]
| 12
| 13
| 14
| 15
|-
| 16
| 17
| [[Simulator_User_Group/Transcripts/2014.03.18|18]]
| 19
| 20
| 21
| 22
|-
| 23
| 24
| [[Simulator_User_Group/Transcripts/2014.03.25|25]]
| 26
| 27
| 28
| 29
|-
| 30
| 31
|
|
|
|
|
|}

2014.02 '''February'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
|
|
|
|
|
| 01
|-
| 02
| 03
| [[Simulator_User_Group/Transcripts/2014.02.04|04]]
| 05
| 06
| 07
| 08
|-
| 09
| 10
| [[Simulator_User_Group/Transcripts/2014.03.11|11]]
| 12
| 13
| 14
| 15
|-
| 16
| 17
| [[Simulator_User_Group/Transcripts/2014.02.18|18]]
| 19
| 20
| 21
| 22
|-
| 23
| 24
| [[Simulator_User_Group/Transcripts/2014.02.25|25]]
| 26
| 27
| 28
|
|}

2014.01 '''January'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
|
|
| 01
| 02
| 03
| 04
|-
| 05
| 06
| [[Simulator_User_Group/Transcripts/2014.01.07|07]]
| 08
| 09
| 10
| 11
|-
| 12
| 13
| [[Simulator_User_Group/Transcripts/2014.01.14|14]]
| 15
| 16
| 17
| 18
|-
| 19
| 20
| [[Simulator_User_Group/Transcripts/2014.01.21|21]]
| 22
| 23
| 24
| 25
|-
| 26
| 27
| [[Simulator_User_Group/Transcripts/2014.01.28|28]]
| 29
| 30
| 31
|
|}

[[Simulator_User_Group/Transcripts/2012]]

[[Simulator_User_Group/Transcripts/2011]]

Simulator User Group

2016-01-06T19:55:16Z

Haravikk Mistral:

{{User Group Page
|purpose=
The Server User Group exists to provide an opportunity for discussion about server technology, annoying bugs, and feature ideas.
|date-time=
* Tuesdays 12:00-13:00 (general) http://slurl.com/secondlife/Denby/220/41/33,
Meetings are
|location= '''Denby/225/25/25'''
|agenda=
* LL developer news
* Review premature closure of {{jira|BUG-10924}}- it is a very simple function as llListFindList is already implemented, all that is required is to skip to the start index, and stop after the end index is reached. In essence only a single function implementation is required, as llListFindList would be equivalent to llSubListFindList(haystack, needle, 0, -1). With the woeful inefficiency of lists it's also a very important capability to have, if it can be strided at the same time (thus restricting which indices potential matches can start from) that would be even better.
* Open discussion

== News ==

|team=
* [[User:Andrew Linden|Andrew Linden]] (honorary member for all time)
* [[User:Simon Linden|Simon Linden]]
* [[User:Kelly Linden|Kelly Linden]]
* [[User:Baker Linden|Baker Linden]]
* [[User:Oz Linden|Oz Linden]]
}}

'''Meeting cancelled for August 12, 2014'''

2014.12 '''December'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
| 01
| [[Simulator_User_Group/Transcripts/2014.12.02|02]]
| 03
| 04
| 05
| 06
|-
| 07
| 06
| [[Simulator_User_Group/Transcripts/2014.12.09|09]]
| 10
| 11
| 12
| 13
|-
| 14
| 15
| [[Simulator_User_Group/Transcripts/2014.12.16|16]]
| 17
| 18
| 19
| 20
|-
| 21
| 22
| [[Simulator_User_Group/Transcripts/2014.12.23|23]]
| 24
| 25
| 26
| 27
|-
| 28
| 29
| [[Simulator_User_Group/Transcripts/2014.12.30|30]]
| 31
|
|
|
|}

2014.11 '''Nov'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
|
|
|
|
|
| 01
|-
| 02
| 03
| [[Simulator_User_Group/Transcripts/2014.03.04|04]]
| 05
| 06
| 07
| 08
|-
| 09
| 10
| [[Simulator_User_Group/Transcripts/2014.03.11|11]]
| 12
| 13
| 14
| 15
|-
| 16
| 17
| [[Simulator_User_Group/Transcripts/2014.03.18|18]]
| 19
| 20
| 21
| 22
|-
| 23
| 24
| [[Simulator_User_Group/Transcripts/2014.03.25|25]]
| 26
| 27
| 28
| 29
|-
| 30
|
|
|
|
|
|
|}

2014.01 '''October'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
|
|
| 01
| 02
| 03
| 04
|-
| 05
| 06
| [[Simulator_User_Group/Transcripts/2014.10.07|07]]
| 08
| 09
| 10
| 11
|-
| 12
| 13
| [[Simulator_User_Group/Transcripts/2014.10.14|14]]
| 15
| 16
| 17
| 18
|-
| 19
| 20
| [[Simulator_User_Group/Transcripts/2014.10.21|21]]
| 22
| 23
| 24
| 25
|-
| 26
| 27
| [[Simulator_User_Group/Transcripts/2014.10.28|28]]
| 29
| 30
| 31
|
|}

2014.09 '''September'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
| 01
| [[Simulator_User_Group/Transcripts/2014.09.02|02]]
| 03
| 04
| 05
| 06
|-
| 07
| 06
| [[Simulator_User_Group/Transcripts/2014.09.09|09]]
| 10
| 11
| 12
| 13
|-
| 14
| 15
| [[Simulator_User_Group/Transcripts/2014.09.16|16]]
| 17
| 18
| 19
| 20
|-
| 21
| 22
| [[Simulator_User_Group/Transcripts/2014.09.23|23]]
| 24
| 25
| 26
| 27
|-
| 28
| 29
| [[Simulator_User_Group/Transcripts/2014.09.30|30]]
|
|
|
|
|}

2014.08 '''August'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
|
|
|
|
| 01
| 02
|-
| 03
| 04
| [[Simulator_User_Group/Transcripts/2014.08.05|05]]
| 06
| 07
| 08
| 09
|-
| 10
| 11
| [[Simulator_User_Group/Transcripts/2014.08.12|12]]
| 13
| 14
| 15
| 16
|-
| 17
| 18
| [[Simulator_User_Group/Transcripts/2014.08.19|19]]
| 20
| 21
| 22
| 23
|-
| 24
| 25
| [[Simulator_User_Group/Transcripts/2014.08.26|26]]
| 27
| 28
| 29
| 30
|-
| 31
|
|
|
|
|
|
|}

2014.07 '''July'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
|
| [[Simulator_User_Group/Transcripts/2014.07.01|01]]
| 02
| 03
| 04
| 05
|-
| 06
| 07
| [[Simulator_User_Group/Transcripts/2014.07.08|08]]
| 09
| 10
| 11
| 12
|-
| 13
| 14
| [[Simulator_User_Group/Transcripts/2014.07.15|15]]
| 16
| 17
| 18
| 19
|-
| 20
| 21
| [[Simulator_User_Group/Transcripts/2014.07.22|22]]
| 23
| 24
| 25
| 26
|-
| 27
| 28
| [[Simulator_User_Group/Transcripts/2014.07.29|29]]
| 30
| 31
|
|
|}

2014.06 '''June'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
| 01
| 02
| [[Simulator_User_Group/Transcripts/2014.06.03|03]]
| 04
| 05
| 06
| 07
|-
| 08
| 09
| [[Simulator_User_Group/Transcripts/2014.06.10|10]]
| 11
| 12
| 13
| 14
|-
| 15
| 16
| [[Simulator_User_Group/Transcripts/2014.06.17|17]]
| 18
| 19
| 20
| 21
|-
| 22
| 23
| [[Simulator_User_Group/Transcripts/2014.06.24|24]]
| 25
| 26
| 27
| 28
|-
| 29
| 30
|
|
|
|
|
|}

2014.05 '''May'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
|
|
|
| 01
| 02
| 03
|-
| 04
| 05
| [[Simulator_User_Group/Transcripts/2014.05.06|06]]
| 07
| 08
| 09
| 10
|-
| 11
| 12
| [[Simulator_User_Group/Transcripts/2014.05.13|13]]
| 14
| 15
| 16
| 17
|-
| 18
| 19
| [[Simulator_User_Group/Transcripts/2014.05.20|20]]
| 21
| 22
| 23
| 24
|-
| 25
| 26
| [[Simulator_User_Group/Transcripts/2014.05.27|27]]
| 28
| 29
| 30
| 31
|}

2014.04 '''April'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
|
| [[Simulator_User_Group/Transcripts/2014.04.01|01]]
| 02
| 03
| 04
| 05
|-
| 06
| 07
| [[Simulator_User_Group/Transcripts/2014.04.08|08]]
| 09
| 10
| 11
| 12
|-
| 13
| 14
| [[Simulator_User_Group/Transcripts/2014.04.15|15]]
| 16
| 17
| 18
| 19
|-
| 20
| 21
| [[Simulator_User_Group/Transcripts/2014.04.22|22]]
| 23
| 24
| 25
| 26
|-
| 27
| 28
| [[Simulator_User_Group/Transcripts/2014.04.29|29]]
| 30
|
|
|
|}

2014.03 '''March'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
|
|
|
|
|
| 01
|-
| 02
| 03
| [[Simulator_User_Group/Transcripts/2014.03.04|04]]
| 05
| 06
| 07
| 08
|-
| 09
| 10
| [[Simulator_User_Group/Transcripts/2014.03.11|11]]
| 12
| 13
| 14
| 15
|-
| 16
| 17
| [[Simulator_User_Group/Transcripts/2014.03.18|18]]
| 19
| 20
| 21
| 22
|-
| 23
| 24
| [[Simulator_User_Group/Transcripts/2014.03.25|25]]
| 26
| 27
| 28
| 29
|-
| 30
| 31
|
|
|
|
|
|}

2014.02 '''February'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
|
|
|
|
|
| 01
|-
| 02
| 03
| [[Simulator_User_Group/Transcripts/2014.02.04|04]]
| 05
| 06
| 07
| 08
|-
| 09
| 10
| [[Simulator_User_Group/Transcripts/2014.03.11|11]]
| 12
| 13
| 14
| 15
|-
| 16
| 17
| [[Simulator_User_Group/Transcripts/2014.02.18|18]]
| 19
| 20
| 21
| 22
|-
| 23
| 24
| [[Simulator_User_Group/Transcripts/2014.02.25|25]]
| 26
| 27
| 28
|
|}

2014.01 '''January'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
|
|
| 01
| 02
| 03
| 04
|-
| 05
| 06
| [[Simulator_User_Group/Transcripts/2014.01.07|07]]
| 08
| 09
| 10
| 11
|-
| 12
| 13
| [[Simulator_User_Group/Transcripts/2014.01.14|14]]
| 15
| 16
| 17
| 18
|-
| 19
| 20
| [[Simulator_User_Group/Transcripts/2014.01.21|21]]
| 22
| 23
| 24
| 25
|-
| 26
| 27
| [[Simulator_User_Group/Transcripts/2014.01.28|28]]
| 29
| 30
| 31
|
|}

[[Simulator_User_Group/Transcripts/2012]]

[[Simulator_User_Group/Transcripts/2011]]

Simulator User Group

2016-01-06T19:54:21Z

Haravikk Mistral:

{{User Group Page
|purpose=
The Server User Group exists to provide an opportunity for discussion about server technology, annoying bugs, and feature ideas.
|date-time=
* Tuesdays 12:00-13:00 (general) http://slurl.com/secondlife/Denby/220/41/33,
Meetings are
|location= '''Denby/225/25/25'''
|agenda=
* LL developer news
* Review premature closure of {{jira|BUG-10924}}- it is a very simple function as llListFindList is already implemented, all that is required is to skip to the start index, and stop after the end index is reached. In essence only a single function implementation is required, as llListFindList would be equivalent to llSubListFindList(haystack, needle, 0, -1). With the woeful inefficiency of lists it's also a very important capability to have, it can be strided at the same time (thus restricting which indices potential matches can start from) that would be even better.
* Open discussion

== News ==

|team=
* [[User:Andrew Linden|Andrew Linden]] (honorary member for all time)
* [[User:Simon Linden|Simon Linden]]
* [[User:Kelly Linden|Kelly Linden]]
* [[User:Baker Linden|Baker Linden]]
* [[User:Oz Linden|Oz Linden]]
}}

'''Meeting cancelled for August 12, 2014'''

2014.12 '''December'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
| 01
| [[Simulator_User_Group/Transcripts/2014.12.02|02]]
| 03
| 04
| 05
| 06
|-
| 07
| 06
| [[Simulator_User_Group/Transcripts/2014.12.09|09]]
| 10
| 11
| 12
| 13
|-
| 14
| 15
| [[Simulator_User_Group/Transcripts/2014.12.16|16]]
| 17
| 18
| 19
| 20
|-
| 21
| 22
| [[Simulator_User_Group/Transcripts/2014.12.23|23]]
| 24
| 25
| 26
| 27
|-
| 28
| 29
| [[Simulator_User_Group/Transcripts/2014.12.30|30]]
| 31
|
|
|
|}

2014.11 '''Nov'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
|
|
|
|
|
| 01
|-
| 02
| 03
| [[Simulator_User_Group/Transcripts/2014.03.04|04]]
| 05
| 06
| 07
| 08
|-
| 09
| 10
| [[Simulator_User_Group/Transcripts/2014.03.11|11]]
| 12
| 13
| 14
| 15
|-
| 16
| 17
| [[Simulator_User_Group/Transcripts/2014.03.18|18]]
| 19
| 20
| 21
| 22
|-
| 23
| 24
| [[Simulator_User_Group/Transcripts/2014.03.25|25]]
| 26
| 27
| 28
| 29
|-
| 30
|
|
|
|
|
|
|}

2014.01 '''October'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
|
|
| 01
| 02
| 03
| 04
|-
| 05
| 06
| [[Simulator_User_Group/Transcripts/2014.10.07|07]]
| 08
| 09
| 10
| 11
|-
| 12
| 13
| [[Simulator_User_Group/Transcripts/2014.10.14|14]]
| 15
| 16
| 17
| 18
|-
| 19
| 20
| [[Simulator_User_Group/Transcripts/2014.10.21|21]]
| 22
| 23
| 24
| 25
|-
| 26
| 27
| [[Simulator_User_Group/Transcripts/2014.10.28|28]]
| 29
| 30
| 31
|
|}

2014.09 '''September'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
| 01
| [[Simulator_User_Group/Transcripts/2014.09.02|02]]
| 03
| 04
| 05
| 06
|-
| 07
| 06
| [[Simulator_User_Group/Transcripts/2014.09.09|09]]
| 10
| 11
| 12
| 13
|-
| 14
| 15
| [[Simulator_User_Group/Transcripts/2014.09.16|16]]
| 17
| 18
| 19
| 20
|-
| 21
| 22
| [[Simulator_User_Group/Transcripts/2014.09.23|23]]
| 24
| 25
| 26
| 27
|-
| 28
| 29
| [[Simulator_User_Group/Transcripts/2014.09.30|30]]
|
|
|
|
|}

2014.08 '''August'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
|
|
|
|
| 01
| 02
|-
| 03
| 04
| [[Simulator_User_Group/Transcripts/2014.08.05|05]]
| 06
| 07
| 08
| 09
|-
| 10
| 11
| [[Simulator_User_Group/Transcripts/2014.08.12|12]]
| 13
| 14
| 15
| 16
|-
| 17
| 18
| [[Simulator_User_Group/Transcripts/2014.08.19|19]]
| 20
| 21
| 22
| 23
|-
| 24
| 25
| [[Simulator_User_Group/Transcripts/2014.08.26|26]]
| 27
| 28
| 29
| 30
|-
| 31
|
|
|
|
|
|
|}

2014.07 '''July'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
|
| [[Simulator_User_Group/Transcripts/2014.07.01|01]]
| 02
| 03
| 04
| 05
|-
| 06
| 07
| [[Simulator_User_Group/Transcripts/2014.07.08|08]]
| 09
| 10
| 11
| 12
|-
| 13
| 14
| [[Simulator_User_Group/Transcripts/2014.07.15|15]]
| 16
| 17
| 18
| 19
|-
| 20
| 21
| [[Simulator_User_Group/Transcripts/2014.07.22|22]]
| 23
| 24
| 25
| 26
|-
| 27
| 28
| [[Simulator_User_Group/Transcripts/2014.07.29|29]]
| 30
| 31
|
|
|}

2014.06 '''June'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
| 01
| 02
| [[Simulator_User_Group/Transcripts/2014.06.03|03]]
| 04
| 05
| 06
| 07
|-
| 08
| 09
| [[Simulator_User_Group/Transcripts/2014.06.10|10]]
| 11
| 12
| 13
| 14
|-
| 15
| 16
| [[Simulator_User_Group/Transcripts/2014.06.17|17]]
| 18
| 19
| 20
| 21
|-
| 22
| 23
| [[Simulator_User_Group/Transcripts/2014.06.24|24]]
| 25
| 26
| 27
| 28
|-
| 29
| 30
|
|
|
|
|
|}

2014.05 '''May'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
|
|
|
| 01
| 02
| 03
|-
| 04
| 05
| [[Simulator_User_Group/Transcripts/2014.05.06|06]]
| 07
| 08
| 09
| 10
|-
| 11
| 12
| [[Simulator_User_Group/Transcripts/2014.05.13|13]]
| 14
| 15
| 16
| 17
|-
| 18
| 19
| [[Simulator_User_Group/Transcripts/2014.05.20|20]]
| 21
| 22
| 23
| 24
|-
| 25
| 26
| [[Simulator_User_Group/Transcripts/2014.05.27|27]]
| 28
| 29
| 30
| 31
|}

2014.04 '''April'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
|
| [[Simulator_User_Group/Transcripts/2014.04.01|01]]
| 02
| 03
| 04
| 05
|-
| 06
| 07
| [[Simulator_User_Group/Transcripts/2014.04.08|08]]
| 09
| 10
| 11
| 12
|-
| 13
| 14
| [[Simulator_User_Group/Transcripts/2014.04.15|15]]
| 16
| 17
| 18
| 19
|-
| 20
| 21
| [[Simulator_User_Group/Transcripts/2014.04.22|22]]
| 23
| 24
| 25
| 26
|-
| 27
| 28
| [[Simulator_User_Group/Transcripts/2014.04.29|29]]
| 30
|
|
|
|}

2014.03 '''March'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
|
|
|
|
|
| 01
|-
| 02
| 03
| [[Simulator_User_Group/Transcripts/2014.03.04|04]]
| 05
| 06
| 07
| 08
|-
| 09
| 10
| [[Simulator_User_Group/Transcripts/2014.03.11|11]]
| 12
| 13
| 14
| 15
|-
| 16
| 17
| [[Simulator_User_Group/Transcripts/2014.03.18|18]]
| 19
| 20
| 21
| 22
|-
| 23
| 24
| [[Simulator_User_Group/Transcripts/2014.03.25|25]]
| 26
| 27
| 28
| 29
|-
| 30
| 31
|
|
|
|
|
|}

2014.02 '''February'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
|
|
|
|
|
| 01
|-
| 02
| 03
| [[Simulator_User_Group/Transcripts/2014.02.04|04]]
| 05
| 06
| 07
| 08
|-
| 09
| 10
| [[Simulator_User_Group/Transcripts/2014.03.11|11]]
| 12
| 13
| 14
| 15
|-
| 16
| 17
| [[Simulator_User_Group/Transcripts/2014.02.18|18]]
| 19
| 20
| 21
| 22
|-
| 23
| 24
| [[Simulator_User_Group/Transcripts/2014.02.25|25]]
| 26
| 27
| 28
|
|}

2014.01 '''January'''
{|
| Sun
| Mon
| Tue
| Wed
| Thu
| Fri
| Sat
|-
|
|
|
| 01
| 02
| 03
| 04
|-
| 05
| 06
| [[Simulator_User_Group/Transcripts/2014.01.07|07]]
| 08
| 09
| 10
| 11
|-
| 12
| 13
| [[Simulator_User_Group/Transcripts/2014.01.14|14]]
| 15
| 16
| 17
| 18
|-
| 19
| 20
| [[Simulator_User_Group/Transcripts/2014.01.21|21]]
| 22
| 23
| 24
| 25
|-
| 26
| 27
| [[Simulator_User_Group/Transcripts/2014.01.28|28]]
| 29
| 30
| 31
|
|}

[[Simulator_User_Group/Transcripts/2012]]

[[Simulator_User_Group/Transcripts/2011]]

LlSetText

2015-12-29T10:27:24Z

Haravikk Mistral:

{{LSL_Function
|inject-2={{:PRIM_TEXT|set}}{{Issues/SVC-4539}}{{Issues/BUG-11077}}
|func_id=152
|func_sleep=0.0
|func_energy=10.0
|func=llSetText
|sort=SetText
|p1_type=string|p1_name=text
|p2_type=vector|p2_name=color
|p3_type=float|p3_name=alpha
|func_desc=Displays {{LSLP|text}} that hovers over the prim with specific {{LSLP|color}} and translucency (specified with {{LSLP|alpha}}).
|return_text
|spec=
|caveats=
*If more than one [[llSetText]] is called (By reset,interaction or script state) within a prim the latest call will take priority over the previous.
*{{LSLP|text}} is limited to 254 [[bytes]] (compare [[Limits#Building]]), if the [[string]] is longer it will be truncated to 254 [[bytes]], even if that means the truncation will chop a character in half.
*An unbroken line of text of a great length may be broken automatically into two lines (one above the other).
*{{LSLP|text}} can be seen through walls and other object. Be considerate of neighbors in malls and apartment buildings.
**Visibility distance increases with prim size.
*Removing the script or deactivating it '''will not remove''' a prim's {{LSLP|text}} property. Floating {{LSLP|text}} is not dependent on a script for its continued existence but only when wanting to change it.
*To remove a prim's {{LSLP|text}}, use the following:
{{{!}} class="sortable" width="100%" {{Prettytable}}
{{!}}- {{Hl2}}
! '''Preferred method to remove a prim's floating {{LSLP|text}}'''
! '''Second method does the same effect-wise.'''
{{!}}-
{{!!}}
<syntaxhighlight lang="lsl2">
// empty string & black & transparent
llSetText("", ZERO_VECTOR, 0);
</syntaxhighlight>
{{!!}}
<syntaxhighlight lang="lsl2">
// empty string & black & transparent
llSetText("", <0.0, 0.0, 0.0>, 0.0);
</syntaxhighlight>
{{!}}}
*Vertical whitespace is removed from the end of the {{LSLP|text}} string, so if you want vertical whitespace put any character (like a space) on the last line.
*Multiple linebreaks with empty lines are converted to a single linebreak, so add a whitespace character on every line you want to skip:
{{{!}} class="sortable" width="100%" {{Prettytable}}
{{!}}- {{Hl2}}
! '''Good'''
! '''Bad'''
{{!}}-
{{!!}}
<syntaxhighlight lang="lsl2">
vector COLOR_WHITE = <1.0, 1.0, 1.0>;
float OPAQUE = 1.0;

llSetText("Monkeys\n \n \n \n \n ", COLOR_WHITE, OPAQUE);
</syntaxhighlight>
{{!!}}
<syntaxhighlight lang="lsl2">
vector COLOR_WHITE = <1.0, 1.0, 1.0>;
float OPAQUE = 1.0;

llSetText("Monkeys\n\n\n\n\n", COLOR_WHITE, OPAQUE);
</syntaxhighlight>
{{!}}}
*'''Measurements showed a high impact of process time when doing numerous iterations in a while loop'''. For approx. 65 thousand iterations the process times are ca. 5 seconds without floating text, 24 seconds with [[llSetText]] and 96 seconds when using [[llSetPrimitiveParams#llSetLinkPrimitiveParamsFast]] in combination with [[PRIM_TEXT]]. Thats why you are '''not advised''' to make excessive use of changing a prim's {{LSLP|text}} within such iterations.
|examples=
Example of how [[llSetText]] could be used to show prim's name in green {{LSLP|text}}:
<syntaxhighlight lang="lsl2">
default
{
state_entry()
{
vector COLOR_GREEN = <0.0, 1.0, 0.0>;
float OPAQUE = 1.0;

// prim's name (not necessarily object's)
llSetText(llGetObjectName(), COLOR_GREEN, OPAQUE );

// delete the script as we only needed it to change the floating text property
llRemoveInventory(llGetScriptName());
}
}
</syntaxhighlight>
By default the floating {{LSLP|text}} will appear on a single line. However, it can be spread over multiple lines by using a line break <code>"\n"</code> (read [[SplitLine]] in section 'See Also').

===String escape codes:===

LSL has four [[String#Escape Codes|string escape codes]]:
* <code>\n</code> for a new line
* <code>\\</code> for a backslash
* <code>\t</code> for a tab
* <code>\"</code> for a double-quote

===Color & Alpha===

{{{!}} class="sortable" {{Prettytable}}
{{!}}- {{Hl2}}
! Color
! Code
{{!}}-
{{!}} style="color: white; background: #001f3f" {{!}}NAVY
{{!}}<code><0.000, 0.122, 0.247></code>
{{!}}-
{{!}} style="background: #0074d9" {{!}}BLUE
{{!}}<code><0.000, 0.455, 0.851></code>
{{!}}-
{{!}} style="background: #7fdbff" {{!}}AQUA
{{!}}<code><0.498, 0.859, 1.000></code>
{{!}}-
{{!}} style="background: #39cccc" {{!}}TEAL
{{!}}<code><0.224, 0.800, 0.800></code>
{{!}}-
{{!}} style="background: #3d9970" {{!}}OLIVE
{{!}}<code><0.239, 0.600, 0.439></code>
{{!}}-
{{!}} style="background: #2ecc40" {{!}}GREEN
{{!}}<code><0.180, 0.800, 0.251></code>
{{!}}-
{{!}} style="background: #01ff70" {{!}}LIME
{{!}}<code><0.004, 1.000, 0.439></code>
{{!}}-
{{!}} style="background: #ffdc00" {{!}}YELLOW
{{!}}<code><1.000, 0.863, 0.000></code>
{{!}}-
{{!}} style="background: #ff851b" {{!}}ORANGE
{{!}}<code><1.000, 0.522, 0.106></code>
{{!}}-
{{!}} style="background: #ff4136" {{!}}RED
{{!}}<code><1.000, 0.255, 0.212></code>
{{!}}-
{{!}} style="color: white; background: #85144b" {{!}}MAROON
{{!}}<code><0.522, 0.078, 0.294></code>
{{!}}-
{{!}} style="background: #f012be" {{!}}FUCHSIA
{{!}}<code><0.941, 0.071, 0.745></code>
{{!}}-
{{!}} style="color: white; background: #b10dc9" {{!}}PURPLE
{{!}}<code><0.694, 0.051, 0.788></code>
{{!}}-
{{!}} style="background: #ffffff" {{!}}WHITE
{{!}}<code><1.000, 1.000, 1.000></code>
{{!}}-
{{!}} style="background: #dddddd" {{!}}SILVER
{{!}}<code><0.867, 0.867, 0.867></code>
{{!}}-
{{!}} style="background: #aaaaaa" {{!}}GRAY
{{!}}<code><0.667, 0.667, 0.667></code>
{{!}}-
{{!}} style="color: white; background: #111111" {{!}}BLACK
{{!}}<code><0.000, 0.000, 0.000></code>
{{!}}}

The x, y & z [[Vector#Components|components of the vector]] are used to represent red, green, and blue respectively. The range is <span style="background-color: yellow">different from traditional RGB</span>, instead of being 0 -> 255, LSL uses 0 -> 1. <code><1.0, 1.0, 1.0></code> represents "white" and <code><0.0, 0.0, 0.0></code> represents "black":
<syntaxhighlight lang="lsl2">
// white & opaque
llSetText("I am white", <1.0, 1.0, 1.0>, 1.0);
</syntaxhighlight>
<syntaxhighlight lang="lsl2">
vector myColor;// defaults to ZERO_VECTOR or <0.0, 0.0, 0.0> which is black

llSetText("I am black and 30% transparent.", myColor, 0.7);

llSleep(7.5); // before: <0.0, 0.0, 0.0> black
myColor.x = 1.0;// now: <1.0, 0.0, 0.0> red

llSetText("I am now red and 10% transparent.", myColor, 0.9);
</syntaxhighlight>
If {{LSLP|alpha}} is 1.0 it means the {{LSLP|text}} is fully opaque (alpha), 0.0 would make it completely transparent (invisible):
<syntaxhighlight lang="lsl2">
llSetText("green text with alpha 0.7", <0.0, 1.0, 0.0>, 0.7);

llSetText("white text with alpha 0.4\n60% transparent", <1.0, 1.0, 1.0>, 0.4);
llSetText("white text with alpha 1.0\nfully opaque", <1.0, 1.0, 1.0>, 1.0);

// next to lines have the same effect
llSetText("invisible black text with alpha 0.0\nfully transparent", ZERO_VECTOR, 0);
llSetText("invisible black text with alpha 0.0\nfully transparent", <0.0, 0.0, 0.0>, 0.0);
</syntaxhighlight>
===Multiple lines===
<syntaxhighlight lang="lsl2">
// two lines of orange text

llSetText("I am\non two lines!", <1.0, 0.4, 0.0>, 1.0);
</syntaxhighlight>
|helpers=
Drag this script out of inventory onto an object to erase its set text:
<syntaxhighlight lang="lsl2">
// http://wiki.secondlife.com/wiki/llSetText

default
{
state_entry()
{
// remove floating text (empty string & black & 100% transparent)
llSetText("", ZERO_VECTOR, 0.0);

// delete the script as we only needed it to change the floating text property
llRemoveInventory(llGetScriptName());
}
}
</syntaxhighlight>
Code to easily specify appearance of hovertext:
<syntaxhighlight lang="lsl2">
vector NAVY = <0, 0.122, 0.247>;
vector BLUE = <0, 0.455, 0.851>;
vector AQUA = <0.498, 0.859, 1 >;
vector TEAL = <0.224, 0.8, 0.8 >;
vector OLIVE = <0.239, 0.6, 0.439>;
vector GREEN = <0.18, 0.8, 0.251>;
vector LIME = <0.004, 1 , 0.439>;
vector YELLOW = <1 , 0.863, 0 >;
vector ORANGE = <1 , 0.522, 0.106>;
vector RED = <1 , 0.255, 0.212>;
vector MAROON = <0.522, 0.078, 0.294>;
vector FUCHSIA = <0.941, 0.071, 0.745>;
vector PURPLE = <0.694, 0.051, 0.788>;
vector WHITE = <1 , 1 , 1 >;
vector SILVER = <0.867, 0.867, 0.867>;
vector GRAY = <0.667, 0.667, 0.667>;
vector BLACK = <0.000, 0.000, 0.000>;

string hoverText = "TEXT GOES HERE";
vector hoverColor = LIME;// set predefined color or any RGB color vector in float form
float hoverAlpha = 1.0; // Sets the text's transparency, 1.0 being opaque, while 0.0 would be transparent

default
{
state_entry()
{
llSetText(hoverText, hoverColor, hoverAlpha);
}
}
</syntaxhighlight>
To make hovertext when using linked prims you can use this simple function:
<syntaxhighlight lang="lsl2">
mySetLinkText(integer linknum, string text, vector color, float alpha) {
llSetLinkPrimitiveParamsFast(linknum, [PRIM_TEXT, text, color, alpha]);
}

// For example:

default
{
touch_start(integer total_number)
{
mySetLinkText(LINK_SET, "TEST", <0, 1, 0>, 0.5);
}
}
</syntaxhighlight>
|also
|also_functions
|also_constants=
{{LSL DefineRow||[[PRIM_TEXT]]}}
|also_articles=
{{LSL DefineRow||[[:Category:LSL Examples|Examples]]: [[SplitLine]]|Insert 'new line' escape codes at certain positions of a string}}
{{LSL DefineRow||Useful snippet: [[llGetObjectPermMask]]|Label an object with text and newlines to give away or sell}}
|notes=To actually display text on a prim, see [[XyzzyText]], or consider using parcel prim [[:Category:LSL_Media|Media]] options (useful only if you have control over the land's media settings.)
----
The function displays {{LSLP|text}} that hover over the prim's center, the prim position. The height over the center is proportional to the prim's Z-dimension exclusively
* It doesn't matter how the prim is rotated, so if Z is smaller than X and Y the {{LSLP|text}} may be seen {{LSLP|on}} the prim
|cat1=Effects
|cat2=Prim
|cat3=Stop
|cat4=Floating Text
}}

Template:Issues/BUG-11077

2015-12-29T10:27:10Z

Haravikk Mistral: Created page with "{{Issues|BUG-11077|Set Floating Text Colour and Alpha Only|type=nf}}"

{{Issues|BUG-11077|Set Floating Text Colour and Alpha Only|type=nf}}

Pseudo-randomly Generate Unique Indices

2015-12-21T15:45:55Z

Haravikk Mistral: /* Example */

{{LSL Header}}
= Pseudo-randomly Generate Unique Indices =
Ordinarily when a collection of data needs to be retrieved in a random order, it can simply be reshuffled by randomly swapping elements and then iterating through the resulting, shuffled, collection. However there are cases where this is infeasible, especially in LSL, and as such the following functions can be used to generate indices in a pseudo-random way that should be "good enough" for many purposes.

<source lang="lsl2">integer _prui_counter = 1;
integer _prui_limit = 0;

integer _prui_start = 0;
integer _prui_stride = 0;
integer _prui_next = 0;

// Configures the random number generator to generate values between 0 (inclusive) and limit (exclusive) and initialises
prui_init(integer limit) {
_prui_limit = limit;
_prui_start = (integer)llFrand((float)limit);
_prui_stride = (integer)llFrand((float)limit - 1.0) + 1;
_prui_next = _prui_start;
}

// Call this each time the next random value is required.
// When configured with a limit of N, every discreet batch of N calls to this function will return each possible index only once.
integer prui_next() {
if (!_prui_counter) prui_init(_prui_limit);

integer result = _prui_next;
_prui_next = (_prui_next + _prui_stride) % _prui_limit;
if (_prui_next == _prui_start) {
_prui_start = (_prui_start + 1) % _prui_limit;
_prui_next = _prui_start;
}

_prui_counter = (_prui_counter + 1) % _prui_limit;
return result;
}</source>

== Examples ==
=== List ===
The following script will spit out a random entry from a list when touched. In this example the list contains letters of the alphabet and as such the first 26 touches will produce a unique letter, the following 26 touches will likewise produce no duplicates and so-on.

<source lang="lsl2">// Add the above prui variables and functions here

list myList = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"];
integer myListLength;

default {
state_entry() {
prui_init(myListLength = llGetListLength(myList));
llSetText("Touch me for a complimentary letter of the alphabet!", <1.0, 1.0, 1.0>, 1.0);
}

touch_start(integer x) { llRegionSayTo(llDetectedKey(0), PUBLIC_CHANNEL, llList2String(myList, prui_next())); }
}</source>

=== String ===
This is the same example rewritten to more efficiently use a string for storing the letters of the alphabet:

<source lang="lsl2">// Add the above prui variables and functions here

string myString = "abcdefghijklmnopqrstuvwxyz";
integer myStringLength;

default {
state_entry() {
prui_init(myStringLength = llStringLength(myString));
llSetText("Touch me for a complimentary letter of the alphabet!", <1.0, 1.0, 1.0>, 1.0);
}

touch_start(integer x) { llRegionSayTo(llDetectedKey(0), PUBLIC_CHANNEL, llGetSubString(myString, x = prui_next(), x)); }
}</source>

=== Notecard ===
Finally, this example performs the same incredible feat using lines in a notecard (one for each letter of the alphabet):

<source lang="lsl2">// Add the above prui variables and functions here

key myNotecard = "a62213ba-381d-2347-7f7b-818f15f12d83";
integer myNotecardLength = -1;
key talkTo = NULL_KEY;

default {
state_entry() { llGetNumberOfNotecardLines(myNotecard); }
dataserver(key id, string data) {
if (myNotecardLength > 0) llRegionSayTo(talkTo, PUBLIC_CHANNEL, data);
else prui_init(myNotecardLength = (integer)data);
}

touch_start(integer x) {
talkTo = llDetectedKey(0);
llGetNotecardLine(myNotecard, prui_next());
}
}</source>

= Multiple Number Generators =
The above code is fine for uses where only a single number generator is required, for example when communicating with a single avatar. However, when working with multiple random tasks it is not possible for a single number generator to produce values for different limits without completing the tasks sequentially (or aborting one), and in cases where the limit is the same, sharing a single number generator between multiple tasks will cause it to produce duplicates faster. For example, if a script is sending one of 100 possible messages randomly to four different avatars, then it will only have an effective entropy of around 25 messages (though for random messages this doesn't necessarily mean noticeably more duplicates).

For such cases, the following alternative functions enable the use of multiple number generators by producing and updating a state, by giving each task/avatar their own state value, it is possible to generate the full range of indices for each task/avatar.

== Single Integer State ==
The fastest and most memory efficient implementation uses four 8-bit values packed into a single 32-bit integer for its state, however this produces the following caveats:
* This implementation can only handle limits of up to 256.
* This implementation does not call mprui_init() after exactly N iterations, which means that it cannot guarantee a full N iterations without duplicates, however for most purposes this should still be adequate.

<source lang="lsl2">// Configures the random number generator to generate values between 0 (inclusive) and limit (exclusive, max 256) and initialises
// Returns an mprui state that can then be passed into mprui_next()
integer mprui_init(integer limit) {
integer start = (integer)llFrand((float)limit);
integer stride = (integer)llFrand((float)limit - 1.0) + 1;

return ((limit - 1) << 24) | (start << 16) | (stride << 8) | start;
}

// Call this each time the next random value is required.
// When configured with a limit of N, every discreet batch of *around* N calls to this function will return each possible index only once.
// This function should be passed an mprui_state generated using mprui_init, and will return an updated state in response. Mask with 0xFF to get the index like so:
// mprui_state = prui_next(mprui_state);
// integer next_index = mprui_state & 0xFF;
integer mprui_next(integer mprui_state) {
integer limit = ((mprui_state >> 24) & 0xFF) + 1;
integer start = (mprui_state >> 16) & 0xFF;
integer stride = (mprui_state >> 8) & 0xFF;
integer next = mprui_state & 0xFF;

next = (next + stride) % limit;
if (next == start) { // We're about to repeat
// This is a hack that can result in fewer or greater than limit
// repetitions, but is fine in the spirit of "good enough"
if (next >= (limit - 1)) return mprui_init(limit);

// Move the start and insert into new state
next = (start + 1) % limit;
mprui_state = (mprui_state & 0xFF00FFFF) | (next << 16);
}

// Insert next value into state
return (mprui_state & 0xFFFFFF00) | next;
}</source>

=== Example ===
The following example takes the same string-based alphabet spewing device and adapts it to support multiple avatars, which will each get their own unique range of random letters no matter how many are also using the device.

<source lang="lsl2">// Insert the single-integer mprui functions here

string myString = "abcdefghijklmnopqrstuvwxyz";
integer myStringLength;

list avatars = []; integer avatar_limit = 8; // Maximum number of avatars to keep track of (list is pruned from longest ago touch)
integer avatar_stride = 2; // Key + mprui state

default {
state_entry() { llSetText("Touch me for a complimentary letter of the alphabet!", <1.0, 1.0, 1.0>, 1.0); }

touch_start(integer x) {
key id = llDetectedKey(0); integer mprui_state;

integer index = llListFindList(avatars, [id]);
if (~index) {
mprui_state = mprui_next(llList2Integer(avatars, index + 1));

// Remove our old state
avatars = llDeleteSubList(avatars, index, index + 1);
} else {
mprui_state = mprui_init(llStringLength(myString));

// Make room if the list is full
integer prune = ((llGetListLength(avatars) / avatar_stride) + 1) - avatar_limit;
if (prune > 0) avatars = llDeleteSubList(avatars, 0, (prune * avatar_stride) - 1);
}

integer next = mprui_state & 0xFF;
llRegionSayTo(id, PUBLIC_CHANNEL, llGetSubString(myString, next, next));

// Add the new state to the end of the list
avatars += [id, mprui_state];
}
}</source>

== List State ==
For greater precision a list-based state must be used, which naturally carries with it the overhead of list manipulation. This comes in two varieties, a 16-bit precision which uses a list that is three elements long, and a full (32-bit) precision variation that uses a five element list. In both cases the next value is stored in the first element of the list, as such the implementations can actually be used interchangeably.

=== Full Precision ===
<source lang="lsl2">// Configures the random number generator to generate values between 0 (inclusive) and limit (exclusive) and initialises
// Returns an mprui state that can then be passed into mprui_next()
list mprui_init(integer limit) {
integer start = (integer)llFrand((float)limit);
integer stride = (integer)llFrand((float)limit - 1.0) + 1;

return [start, 1, start, stride, limit];
}

// Call this each time the next random value is required.
// When configured with a limit of N, every discreet batch of N calls to this function will return each possible index only once.
// This function should be passed an mprui_state generated using mprui_init, and will return an updated state in response. Retrieve the first element to get the next index like so:
// mprui_state = prui_next(mprui_state);
// integer next_index = llList2Integer(mprui_state, 0);
list mprui_next(list mprui_state) {
integer next = llList2Integer(mprui_state, 0);
integer counter = llList2Integer(mprui_state, 1);
integer start = llList2Integer(mprui_state, 2);
integer stride = llList2Integer(mprui_state, 3);
integer limit = llList2Integer(mprui_state, 4);

if (!counter) return mprui_init(limit);

next = (next + stride) % limit;
if (next == start) {
start = (start + 1) % limit;
next = start;

return llListReplaceList(mprui_state, [next, (counter + 1) % limit, start], 0, 2);
}

return llListReplaceList(mprui_state, [next, (counter + 1) % limit], 0, 1);
}</source>

=== 16-bit Precision ===
The following list-state implementation restricts precision to 16-bits (max limit of 65536) but uses a smaller list for its state (3 elements vs 5):

<source lang="lsl2">// Configures the random number generator to generate values between 0 (inclusive) and limit (exclusive) and initialises
// Returns an mprui state that can then be passed into mprui_next()
list mprui_init(integer limit) {
integer start = (integer)llFrand((float)limit);
integer stride = (integer)llFrand((float)limit - 1.0) + 1;

return [start, 0x10000 | start, (stride << 16) | limit];
}

// Call this each time the next random value is required.
// When configured with a limit of N, every discreet batch of N calls to this function will return each possible index only once.
// This function should be passed an mprui_state generated using mprui_init, and will return an updated state in response. Retrieve the first element to get the next index like so:
// mprui_state = prui_next(mprui_state);
// integer next_index = llList2Integer(mprui_state, 0);
list mprui_next(list mprui_state) {
integer next = llList2Integer(mprui_state, 0);
integer counter = llList2Integer(mprui_state, 1);
integer start = counter & 0xFFFF; counter = (counter >> 16) & 0xFFFF;
integer stride = llList2Integer(mprui_state, 2);
integer limit = stride & 0xFFFF; stride = (stride >> 16) & 0xFFFF;

if (!counter) return mprui_init(limit);

next = (next + stride) % limit;
if (next == start) {
start = (start + 1) % limit;
next = start;
}

return llListReplaceList(mprui_state, [next, ((counter + 1) % limit) << 16 | start], 0, 1);
}</source>

=== Example ===
Once again we grant the gift of the alphabet upon avatars, this time using either of the above list-state implementations:

<source lang="lsl2">// Insert the mprui functions from either of the list-state options here

string myString = "abcdefghijklmnopqrstuvwxyz";
integer myStringLength;

list avatars = []; integer avatar_limit = 8; // Maximum number of avatars to keep track of (list is pruned from longest ago touch)
integer avatar_stride;

default {
state_entry() {
// Get the stride width for avatar entries
avatar_stride = llGetListLength(mprui_init(llStringLength(myString))) + 1;
llSetText("Touch me for a complimentary letter of the alphabet!", <1.0, 1.0, 1.0>, 1.0);
}

touch_start(integer x) {
key id = llDetectedKey(0); list mprui_state;

integer index = llListFindList(avatars, [id]);
if (~index) {
mprui_state = mprui_next(llList2List(avatars, index + 1, index + (avatar_stride - 1)));

// Remove our old state
avatars = llDeleteSubList(avatars, index, index + 5);
} else {
mprui_state = mprui_init(llStringLength(myString));

// Make room if the list is full
integer prune = ((llGetListLength(avatars) / avatar_stride) + 1) - avatar_limit;
if (prune > 0) avatars = llDeleteSubList(avatars, 0, (prune * avatar_stride) - 1);
}

integer next = llList2Integer(mprui_state, 0);
llRegionSayTo(id, PUBLIC_CHANNEL, llGetSubString(myString, next, next));

// Add the new state to the end of the list
avatars += [id] + mprui_state;
}
}</source>

{{LSLC|Library}}

Pseudo-randomly Generate Unique Indices

2015-12-21T15:45:33Z

Haravikk Mistral: /* Example */

{{LSL Header}}
= Pseudo-randomly Generate Unique Indices =
Ordinarily when a collection of data needs to be retrieved in a random order, it can simply be reshuffled by randomly swapping elements and then iterating through the resulting, shuffled, collection. However there are cases where this is infeasible, especially in LSL, and as such the following functions can be used to generate indices in a pseudo-random way that should be "good enough" for many purposes.

<source lang="lsl2">integer _prui_counter = 1;
integer _prui_limit = 0;

integer _prui_start = 0;
integer _prui_stride = 0;
integer _prui_next = 0;

// Configures the random number generator to generate values between 0 (inclusive) and limit (exclusive) and initialises
prui_init(integer limit) {
_prui_limit = limit;
_prui_start = (integer)llFrand((float)limit);
_prui_stride = (integer)llFrand((float)limit - 1.0) + 1;
_prui_next = _prui_start;
}

// Call this each time the next random value is required.
// When configured with a limit of N, every discreet batch of N calls to this function will return each possible index only once.
integer prui_next() {
if (!_prui_counter) prui_init(_prui_limit);

integer result = _prui_next;
_prui_next = (_prui_next + _prui_stride) % _prui_limit;
if (_prui_next == _prui_start) {
_prui_start = (_prui_start + 1) % _prui_limit;
_prui_next = _prui_start;
}

_prui_counter = (_prui_counter + 1) % _prui_limit;
return result;
}</source>

== Examples ==
=== List ===
The following script will spit out a random entry from a list when touched. In this example the list contains letters of the alphabet and as such the first 26 touches will produce a unique letter, the following 26 touches will likewise produce no duplicates and so-on.

<source lang="lsl2">// Add the above prui variables and functions here

list myList = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"];
integer myListLength;

default {
state_entry() {
prui_init(myListLength = llGetListLength(myList));
llSetText("Touch me for a complimentary letter of the alphabet!", <1.0, 1.0, 1.0>, 1.0);
}

touch_start(integer x) { llRegionSayTo(llDetectedKey(0), PUBLIC_CHANNEL, llList2String(myList, prui_next())); }
}</source>

=== String ===
This is the same example rewritten to more efficiently use a string for storing the letters of the alphabet:

<source lang="lsl2">// Add the above prui variables and functions here

string myString = "abcdefghijklmnopqrstuvwxyz";
integer myStringLength;

default {
state_entry() {
prui_init(myStringLength = llStringLength(myString));
llSetText("Touch me for a complimentary letter of the alphabet!", <1.0, 1.0, 1.0>, 1.0);
}

touch_start(integer x) { llRegionSayTo(llDetectedKey(0), PUBLIC_CHANNEL, llGetSubString(myString, x = prui_next(), x)); }
}</source>

=== Notecard ===
Finally, this example performs the same incredible feat using lines in a notecard (one for each letter of the alphabet):

<source lang="lsl2">// Add the above prui variables and functions here

key myNotecard = "a62213ba-381d-2347-7f7b-818f15f12d83";
integer myNotecardLength = -1;
key talkTo = NULL_KEY;

default {
state_entry() { llGetNumberOfNotecardLines(myNotecard); }
dataserver(key id, string data) {
if (myNotecardLength > 0) llRegionSayTo(talkTo, PUBLIC_CHANNEL, data);
else prui_init(myNotecardLength = (integer)data);
}

touch_start(integer x) {
talkTo = llDetectedKey(0);
llGetNotecardLine(myNotecard, prui_next());
}
}</source>

= Multiple Number Generators =
The above code is fine for uses where only a single number generator is required, for example when communicating with a single avatar. However, when working with multiple random tasks it is not possible for a single number generator to produce values for different limits without completing the tasks sequentially (or aborting one), and in cases where the limit is the same, sharing a single number generator between multiple tasks will cause it to produce duplicates faster. For example, if a script is sending one of 100 possible messages randomly to four different avatars, then it will only have an effective entropy of around 25 messages (though for random messages this doesn't necessarily mean noticeably more duplicates).

For such cases, the following alternative functions enable the use of multiple number generators by producing and updating a state, by giving each task/avatar their own state value, it is possible to generate the full range of indices for each task/avatar.

== Single Integer State ==
The fastest and most memory efficient implementation uses four 8-bit values packed into a single 32-bit integer for its state, however this produces the following caveats:
* This implementation can only handle limits of up to 256.
* This implementation does not call mprui_init() after exactly N iterations, which means that it cannot guarantee a full N iterations without duplicates, however for most purposes this should still be adequate.

<source lang="lsl2">// Configures the random number generator to generate values between 0 (inclusive) and limit (exclusive, max 256) and initialises
// Returns an mprui state that can then be passed into mprui_next()
integer mprui_init(integer limit) {
integer start = (integer)llFrand((float)limit);
integer stride = (integer)llFrand((float)limit - 1.0) + 1;

return ((limit - 1) << 24) | (start << 16) | (stride << 8) | start;
}

// Call this each time the next random value is required.
// When configured with a limit of N, every discreet batch of *around* N calls to this function will return each possible index only once.
// This function should be passed an mprui_state generated using mprui_init, and will return an updated state in response. Mask with 0xFF to get the index like so:
// mprui_state = prui_next(mprui_state);
// integer next_index = mprui_state & 0xFF;
integer mprui_next(integer mprui_state) {
integer limit = ((mprui_state >> 24) & 0xFF) + 1;
integer start = (mprui_state >> 16) & 0xFF;
integer stride = (mprui_state >> 8) & 0xFF;
integer next = mprui_state & 0xFF;

next = (next + stride) % limit;
if (next == start) { // We're about to repeat
// This is a hack that can result in fewer or greater than limit
// repetitions, but is fine in the spirit of "good enough"
if (next >= (limit - 1)) return mprui_init(limit);

// Move the start and insert into new state
next = (start + 1) % limit;
mprui_state = (mprui_state & 0xFF00FFFF) | (next << 16);
}

// Insert next value into state
return (mprui_state & 0xFFFFFF00) | next;
}</source>

=== Example ===
The following example takes the same string-based alphabet spewing device and adapts it to support multiple avatars, which will each get their own unique range of random letters no matter how many are also using the device.

<source lang="lsl2">// Insert the single-integer mprui functions here

string myString = "abcdefghijklmnopqrstuvwxyz";
integer myStringLength;

list avatars = []; integer avatar_limit = 8; // Maximum number of avatars to keep track of (list is pruned from longest ago touch)
integer avatar_stride = 2; // Key + mprui state

default {
state_entry() { llSetText("Touch me for a complimentary letter of the alphabet!", <1.0, 1.0, 1.0>, 1.0); }

touch_start(integer x) {
key id = llDetectedKey(0); integer mprui_state;

integer index = llListFindList(avatars, [id]);
if (~index) {
mprui_state = mprui_next(llList2Integer(avatars, index + 1));

// Remove our old state
avatars = llDeleteSubList(avatars, index, index + 1);
} else {
mprui_state = mprui_init(llStringLength(myString));

// Make room if the list is full
integer prune = ((llGetListLength(avatars) / avatar_stride) + 1) - avatar_limit;
if (prune > 0) avatars = llDeleteSubList(avatars, 0, (prune * avatar_stride) - 1);
}

integer next = mprui_state & 0xFF;
llRegionSayTo(id, PUBLIC_CHANNEL, llGetSubString(myString, next, next));

// Add the new state to the end of the list
avatars += [id, mprui_state];
}
}</source>

== List State ==
For greater precision a list-based state must be used, which naturally carries with it the overhead of list manipulation. This comes in two varieties, a 16-bit precision which uses a list that is three elements long, and a full (32-bit) precision variation that uses a five element list. In both cases the next value is stored in the first element of the list, as such the implementations can actually be used interchangeably.

=== Full Precision ===
<source lang="lsl2">// Configures the random number generator to generate values between 0 (inclusive) and limit (exclusive) and initialises
// Returns an mprui state that can then be passed into mprui_next()
list mprui_init(integer limit) {
integer start = (integer)llFrand((float)limit);
integer stride = (integer)llFrand((float)limit - 1.0) + 1;

return [start, 1, start, stride, limit];
}

// Call this each time the next random value is required.
// When configured with a limit of N, every discreet batch of N calls to this function will return each possible index only once.
// This function should be passed an mprui_state generated using mprui_init, and will return an updated state in response. Retrieve the first element to get the next index like so:
// mprui_state = prui_next(mprui_state);
// integer next_index = llList2Integer(mprui_state, 0);
list mprui_next(list mprui_state) {
integer next = llList2Integer(mprui_state, 0);
integer counter = llList2Integer(mprui_state, 1);
integer start = llList2Integer(mprui_state, 2);
integer stride = llList2Integer(mprui_state, 3);
integer limit = llList2Integer(mprui_state, 4);

if (!counter) return mprui_init(limit);

next = (next + stride) % limit;
if (next == start) {
start = (start + 1) % limit;
next = start;

return llListReplaceList(mprui_state, [next, (counter + 1) % limit, start], 0, 2);
}

return llListReplaceList(mprui_state, [next, (counter + 1) % limit], 0, 1);
}</source>

=== 16-bit Precision ===
The following list-state implementation restricts precision to 16-bits (max limit of 65536) but uses a smaller list for its state (3 elements vs 5):

<source lang="lsl2">// Configures the random number generator to generate values between 0 (inclusive) and limit (exclusive) and initialises
// Returns an mprui state that can then be passed into mprui_next()
list mprui_init(integer limit) {
integer start = (integer)llFrand((float)limit);
integer stride = (integer)llFrand((float)limit - 1.0) + 1;

return [start, 0x10000 | start, (stride << 16) | limit];
}

// Call this each time the next random value is required.
// When configured with a limit of N, every discreet batch of N calls to this function will return each possible index only once.
// This function should be passed an mprui_state generated using mprui_init, and will return an updated state in response. Retrieve the first element to get the next index like so:
// mprui_state = prui_next(mprui_state);
// integer next_index = llList2Integer(mprui_state, 0);
list mprui_next(list mprui_state) {
integer next = llList2Integer(mprui_state, 0);
integer counter = llList2Integer(mprui_state, 1);
integer start = counter & 0xFFFF; counter = (counter >> 16) & 0xFFFF;
integer stride = llList2Integer(mprui_state, 2);
integer limit = stride & 0xFFFF; stride = (stride >> 16) & 0xFFFF;

if (!counter) return mprui_init(limit);

next = (next + stride) % limit;
if (next == start) {
start = (start + 1) % limit;
next = start;
}

return llListReplaceList(mprui_state, [next, ((counter + 1) % limit) << 16 | start], 0, 1);
}</source>

=== Example ===
Once again we grant the gift of the alphabet upon avatars, this time using either of the above list-state implementations:

<source lang="lsl2">// Insert the mprui functions from either of the list-state options here

string myString = "abcdefghijklmnopqrstuvwxyz";
integer myStringLength;

list avatars = []; integer avatar_limit = 8; // Maximum number of avatars to keep track of (list is pruned from longest ago touch)
integer avatar_stride;

default {
state_entry() {
// Get the stride width for avatar entries
avatar_stride = llGetListLength(mprui_init(llStringLength(myString))) + 1;
llSetText("Touch me for a complimentary letter of the alphabet!", <1.0, 1.0, 1.0>, 1.0);
}

touch_start(integer x) {
key id = llDetectedKey(0); list mprui_state;

integer index = llListFindList(avatars, [id]);
if (~index) {
mprui_state = mprui_next(llList2List(avatars, index + 1, index + (avatar_stride - 1)));

// Remove our old state
avatars = llDeleteSubList(avatars, index, index + 5);
} else {
mprui_state = mprui_init(llStringLength(myString));

// Make room if the list is full
integer prune = (llGetListLength(avatars) + 1) - avatar_limit;
if (prune > 0) avatars = llDeleteSubList(avatars, 0, (prune * avatar_stride) - 1);
}

integer next = llList2Integer(mprui_state, 0);
llRegionSayTo(id, PUBLIC_CHANNEL, llGetSubString(myString, next, next));

// Add the new state to the end of the list
avatars += [id] + mprui_state;
}
}</source>

{{LSLC|Library}}

Pseudo-randomly Generate Unique Indices

2015-12-21T15:44:30Z

Haravikk Mistral: /* Example */

{{LSL Header}}
= Pseudo-randomly Generate Unique Indices =
Ordinarily when a collection of data needs to be retrieved in a random order, it can simply be reshuffled by randomly swapping elements and then iterating through the resulting, shuffled, collection. However there are cases where this is infeasible, especially in LSL, and as such the following functions can be used to generate indices in a pseudo-random way that should be "good enough" for many purposes.

<source lang="lsl2">integer _prui_counter = 1;
integer _prui_limit = 0;

integer _prui_start = 0;
integer _prui_stride = 0;
integer _prui_next = 0;

// Configures the random number generator to generate values between 0 (inclusive) and limit (exclusive) and initialises
prui_init(integer limit) {
_prui_limit = limit;
_prui_start = (integer)llFrand((float)limit);
_prui_stride = (integer)llFrand((float)limit - 1.0) + 1;
_prui_next = _prui_start;
}

// Call this each time the next random value is required.
// When configured with a limit of N, every discreet batch of N calls to this function will return each possible index only once.
integer prui_next() {
if (!_prui_counter) prui_init(_prui_limit);

integer result = _prui_next;
_prui_next = (_prui_next + _prui_stride) % _prui_limit;
if (_prui_next == _prui_start) {
_prui_start = (_prui_start + 1) % _prui_limit;
_prui_next = _prui_start;
}

_prui_counter = (_prui_counter + 1) % _prui_limit;
return result;
}</source>

== Examples ==
=== List ===
The following script will spit out a random entry from a list when touched. In this example the list contains letters of the alphabet and as such the first 26 touches will produce a unique letter, the following 26 touches will likewise produce no duplicates and so-on.

<source lang="lsl2">// Add the above prui variables and functions here

list myList = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"];
integer myListLength;

default {
state_entry() {
prui_init(myListLength = llGetListLength(myList));
llSetText("Touch me for a complimentary letter of the alphabet!", <1.0, 1.0, 1.0>, 1.0);
}

touch_start(integer x) { llRegionSayTo(llDetectedKey(0), PUBLIC_CHANNEL, llList2String(myList, prui_next())); }
}</source>

=== String ===
This is the same example rewritten to more efficiently use a string for storing the letters of the alphabet:

<source lang="lsl2">// Add the above prui variables and functions here

string myString = "abcdefghijklmnopqrstuvwxyz";
integer myStringLength;

default {
state_entry() {
prui_init(myStringLength = llStringLength(myString));
llSetText("Touch me for a complimentary letter of the alphabet!", <1.0, 1.0, 1.0>, 1.0);
}

touch_start(integer x) { llRegionSayTo(llDetectedKey(0), PUBLIC_CHANNEL, llGetSubString(myString, x = prui_next(), x)); }
}</source>

=== Notecard ===
Finally, this example performs the same incredible feat using lines in a notecard (one for each letter of the alphabet):

<source lang="lsl2">// Add the above prui variables and functions here

key myNotecard = "a62213ba-381d-2347-7f7b-818f15f12d83";
integer myNotecardLength = -1;
key talkTo = NULL_KEY;

default {
state_entry() { llGetNumberOfNotecardLines(myNotecard); }
dataserver(key id, string data) {
if (myNotecardLength > 0) llRegionSayTo(talkTo, PUBLIC_CHANNEL, data);
else prui_init(myNotecardLength = (integer)data);
}

touch_start(integer x) {
talkTo = llDetectedKey(0);
llGetNotecardLine(myNotecard, prui_next());
}
}</source>

= Multiple Number Generators =
The above code is fine for uses where only a single number generator is required, for example when communicating with a single avatar. However, when working with multiple random tasks it is not possible for a single number generator to produce values for different limits without completing the tasks sequentially (or aborting one), and in cases where the limit is the same, sharing a single number generator between multiple tasks will cause it to produce duplicates faster. For example, if a script is sending one of 100 possible messages randomly to four different avatars, then it will only have an effective entropy of around 25 messages (though for random messages this doesn't necessarily mean noticeably more duplicates).

For such cases, the following alternative functions enable the use of multiple number generators by producing and updating a state, by giving each task/avatar their own state value, it is possible to generate the full range of indices for each task/avatar.

== Single Integer State ==
The fastest and most memory efficient implementation uses four 8-bit values packed into a single 32-bit integer for its state, however this produces the following caveats:
* This implementation can only handle limits of up to 256.
* This implementation does not call mprui_init() after exactly N iterations, which means that it cannot guarantee a full N iterations without duplicates, however for most purposes this should still be adequate.

<source lang="lsl2">// Configures the random number generator to generate values between 0 (inclusive) and limit (exclusive, max 256) and initialises
// Returns an mprui state that can then be passed into mprui_next()
integer mprui_init(integer limit) {
integer start = (integer)llFrand((float)limit);
integer stride = (integer)llFrand((float)limit - 1.0) + 1;

return ((limit - 1) << 24) | (start << 16) | (stride << 8) | start;
}

// Call this each time the next random value is required.
// When configured with a limit of N, every discreet batch of *around* N calls to this function will return each possible index only once.
// This function should be passed an mprui_state generated using mprui_init, and will return an updated state in response. Mask with 0xFF to get the index like so:
// mprui_state = prui_next(mprui_state);
// integer next_index = mprui_state & 0xFF;
integer mprui_next(integer mprui_state) {
integer limit = ((mprui_state >> 24) & 0xFF) + 1;
integer start = (mprui_state >> 16) & 0xFF;
integer stride = (mprui_state >> 8) & 0xFF;
integer next = mprui_state & 0xFF;

next = (next + stride) % limit;
if (next == start) { // We're about to repeat
// This is a hack that can result in fewer or greater than limit
// repetitions, but is fine in the spirit of "good enough"
if (next >= (limit - 1)) return mprui_init(limit);

// Move the start and insert into new state
next = (start + 1) % limit;
mprui_state = (mprui_state & 0xFF00FFFF) | (next << 16);
}

// Insert next value into state
return (mprui_state & 0xFFFFFF00) | next;
}</source>

=== Example ===
The following example takes the same string-based alphabet spewing device and adapts it to support multiple avatars, which will each get their own unique range of random letters no matter how many are also using the device.

<source lang="lsl2">// Insert the single-integer mprui functions here

string myString = "abcdefghijklmnopqrstuvwxyz";
integer myStringLength;

list avatars = []; integer avatar_limit = 8; // Maximum number of avatars to keep track of (list is pruned from longest ago touch)

default {
state_entry() { llSetText("Touch me for a complimentary letter of the alphabet!", <1.0, 1.0, 1.0>, 1.0); }

touch_start(integer x) {
key id = llDetectedKey(0); integer mprui_state;

integer index = llListFindList(avatars, [id]);
if (~index) {
mprui_state = mprui_next(llList2Integer(avatars, index + 1));

// Remove our old state
avatars = llDeleteSubList(avatars, index, index + 1);
} else {
mprui_state = mprui_init(llStringLength(myString));

// Make room if the list is full
integer prune = (llGetListLength(avatars) + 1) - avatar_limit;
if (prune > 0) avatars = llDeleteSubList(avatars, 0, (prune * 2) - 1);
}

integer next = mprui_state & 0xFF;
llRegionSayTo(id, PUBLIC_CHANNEL, llGetSubString(myString, next, next));

// Add the new state to the end of the list
avatars += [id, mprui_state];
}
}</source>

== List State ==
For greater precision a list-based state must be used, which naturally carries with it the overhead of list manipulation. This comes in two varieties, a 16-bit precision which uses a list that is three elements long, and a full (32-bit) precision variation that uses a five element list. In both cases the next value is stored in the first element of the list, as such the implementations can actually be used interchangeably.

=== Full Precision ===
<source lang="lsl2">// Configures the random number generator to generate values between 0 (inclusive) and limit (exclusive) and initialises
// Returns an mprui state that can then be passed into mprui_next()
list mprui_init(integer limit) {
integer start = (integer)llFrand((float)limit);
integer stride = (integer)llFrand((float)limit - 1.0) + 1;

return [start, 1, start, stride, limit];
}

// Call this each time the next random value is required.
// When configured with a limit of N, every discreet batch of N calls to this function will return each possible index only once.
// This function should be passed an mprui_state generated using mprui_init, and will return an updated state in response. Retrieve the first element to get the next index like so:
// mprui_state = prui_next(mprui_state);
// integer next_index = llList2Integer(mprui_state, 0);
list mprui_next(list mprui_state) {
integer next = llList2Integer(mprui_state, 0);
integer counter = llList2Integer(mprui_state, 1);
integer start = llList2Integer(mprui_state, 2);
integer stride = llList2Integer(mprui_state, 3);
integer limit = llList2Integer(mprui_state, 4);

if (!counter) return mprui_init(limit);

next = (next + stride) % limit;
if (next == start) {
start = (start + 1) % limit;
next = start;

return llListReplaceList(mprui_state, [next, (counter + 1) % limit, start], 0, 2);
}

return llListReplaceList(mprui_state, [next, (counter + 1) % limit], 0, 1);
}</source>

=== 16-bit Precision ===
The following list-state implementation restricts precision to 16-bits (max limit of 65536) but uses a smaller list for its state (3 elements vs 5):

<source lang="lsl2">// Configures the random number generator to generate values between 0 (inclusive) and limit (exclusive) and initialises
// Returns an mprui state that can then be passed into mprui_next()
list mprui_init(integer limit) {
integer start = (integer)llFrand((float)limit);
integer stride = (integer)llFrand((float)limit - 1.0) + 1;

return [start, 0x10000 | start, (stride << 16) | limit];
}

// Call this each time the next random value is required.
// When configured with a limit of N, every discreet batch of N calls to this function will return each possible index only once.
// This function should be passed an mprui_state generated using mprui_init, and will return an updated state in response. Retrieve the first element to get the next index like so:
// mprui_state = prui_next(mprui_state);
// integer next_index = llList2Integer(mprui_state, 0);
list mprui_next(list mprui_state) {
integer next = llList2Integer(mprui_state, 0);
integer counter = llList2Integer(mprui_state, 1);
integer start = counter & 0xFFFF; counter = (counter >> 16) & 0xFFFF;
integer stride = llList2Integer(mprui_state, 2);
integer limit = stride & 0xFFFF; stride = (stride >> 16) & 0xFFFF;

if (!counter) return mprui_init(limit);

next = (next + stride) % limit;
if (next == start) {
start = (start + 1) % limit;
next = start;
}

return llListReplaceList(mprui_state, [next, ((counter + 1) % limit) << 16 | start], 0, 1);
}</source>

=== Example ===
Once again we grant the gift of the alphabet upon avatars, this time using either of the above list-state implementations:

<source lang="lsl2">// Insert the mprui functions from either of the list-state options here

string myString = "abcdefghijklmnopqrstuvwxyz";
integer myStringLength;

list avatars = []; integer avatar_limit = 8; // Maximum number of avatars to keep track of (list is pruned from longest ago touch)
integer avatar_stride;

default {
state_entry() {
// Get the stride width for avatar entries
avatar_stride = llGetListLength(mprui_init(llStringLength(myString))) + 1;
llSetText("Touch me for a complimentary letter of the alphabet!", <1.0, 1.0, 1.0>, 1.0);
}

touch_start(integer x) {
key id = llDetectedKey(0); list mprui_state;

integer index = llListFindList(avatars, [id]);
if (~index) {
mprui_state = mprui_next(llList2List(avatars, index + 1, index + (avatar_stride - 1)));

// Remove our old state
avatars = llDeleteSubList(avatars, index, index + 5);
} else {
mprui_state = mprui_init(llStringLength(myString));

// Make room if the list is full
integer prune = (llGetListLength(avatars) + 1) - avatar_limit;
if (prune > 0) avatars = llDeleteSubList(avatars, 0, (prune * avatar_stride) - 1);
}

integer next = llList2Integer(mprui_state, 0);
llRegionSayTo(id, PUBLIC_CHANNEL, llGetSubString(myString, next, next));

// Add the new state to the end of the list
avatars += [id] + mprui_state;
}
}</source>

{{LSLC|Library}}

Pseudo-randomly Generate Unique Indices

2015-12-17T12:57:04Z

Haravikk Mistral: /* Example */

{{LSL Header}}
= Pseudo-randomly Generate Unique Indices =
Ordinarily when a collection of data needs to be retrieved in a random order, it can simply be reshuffled by randomly swapping elements and then iterating through the resulting, shuffled, collection. However there are cases where this is infeasible, especially in LSL, and as such the following functions can be used to generate indices in a pseudo-random way that should be "good enough" for many purposes.

<source lang="lsl2">integer _prui_counter = 1;
integer _prui_limit = 0;

integer _prui_start = 0;
integer _prui_stride = 0;
integer _prui_next = 0;

// Configures the random number generator to generate values between 0 (inclusive) and limit (exclusive) and initialises
prui_init(integer limit) {
_prui_limit = limit;
_prui_start = (integer)llFrand((float)limit);
_prui_stride = (integer)llFrand((float)limit - 1.0) + 1;
_prui_next = _prui_start;
}

// Call this each time the next random value is required.
// When configured with a limit of N, every discreet batch of N calls to this function will return each possible index only once.
integer prui_next() {
if (!_prui_counter) prui_init(_prui_limit);

integer result = _prui_next;
_prui_next = (_prui_next + _prui_stride) % _prui_limit;
if (_prui_next == _prui_start) {
_prui_start = (_prui_start + 1) % _prui_limit;
_prui_next = _prui_start;
}

_prui_counter = (_prui_counter + 1) % _prui_limit;
return result;
}</source>

== Examples ==
=== List ===
The following script will spit out a random entry from a list when touched. In this example the list contains letters of the alphabet and as such the first 26 touches will produce a unique letter, the following 26 touches will likewise produce no duplicates and so-on.

<source lang="lsl2">// Add the above prui variables and functions here

list myList = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"];
integer myListLength;

default {
state_entry() {
prui_init(myListLength = llGetListLength(myList));
llSetText("Touch me for a complimentary letter of the alphabet!", <1.0, 1.0, 1.0>, 1.0);
}

touch_start(integer x) { llRegionSayTo(llDetectedKey(0), PUBLIC_CHANNEL, llList2String(myList, prui_next())); }
}</source>

=== String ===
This is the same example rewritten to more efficiently use a string for storing the letters of the alphabet:

<source lang="lsl2">// Add the above prui variables and functions here

string myString = "abcdefghijklmnopqrstuvwxyz";
integer myStringLength;

default {
state_entry() {
prui_init(myStringLength = llStringLength(myString));
llSetText("Touch me for a complimentary letter of the alphabet!", <1.0, 1.0, 1.0>, 1.0);
}

touch_start(integer x) { llRegionSayTo(llDetectedKey(0), PUBLIC_CHANNEL, llGetSubString(myString, x = prui_next(), x)); }
}</source>

=== Notecard ===
Finally, this example performs the same incredible feat using lines in a notecard (one for each letter of the alphabet):

<source lang="lsl2">// Add the above prui variables and functions here

key myNotecard = "a62213ba-381d-2347-7f7b-818f15f12d83";
integer myNotecardLength = -1;
key talkTo = NULL_KEY;

default {
state_entry() { llGetNumberOfNotecardLines(myNotecard); }
dataserver(key id, string data) {
if (myNotecardLength > 0) llRegionSayTo(talkTo, PUBLIC_CHANNEL, data);
else prui_init(myNotecardLength = (integer)data);
}

touch_start(integer x) {
talkTo = llDetectedKey(0);
llGetNotecardLine(myNotecard, prui_next());
}
}</source>

= Multiple Number Generators =
The above code is fine for uses where only a single number generator is required, for example when communicating with a single avatar. However, when working with multiple random tasks it is not possible for a single number generator to produce values for different limits without completing the tasks sequentially (or aborting one), and in cases where the limit is the same, sharing a single number generator between multiple tasks will cause it to produce duplicates faster. For example, if a script is sending one of 100 possible messages randomly to four different avatars, then it will only have an effective entropy of around 25 messages (though for random messages this doesn't necessarily mean noticeably more duplicates).

For such cases, the following alternative functions enable the use of multiple number generators by producing and updating a state, by giving each task/avatar their own state value, it is possible to generate the full range of indices for each task/avatar.

== Single Integer State ==
The fastest and most memory efficient implementation uses four 8-bit values packed into a single 32-bit integer for its state, however this produces the following caveats:
* This implementation can only handle limits of up to 256.
* This implementation does not call mprui_init() after exactly N iterations, which means that it cannot guarantee a full N iterations without duplicates, however for most purposes this should still be adequate.

<source lang="lsl2">// Configures the random number generator to generate values between 0 (inclusive) and limit (exclusive, max 256) and initialises
// Returns an mprui state that can then be passed into mprui_next()
integer mprui_init(integer limit) {
integer start = (integer)llFrand((float)limit);
integer stride = (integer)llFrand((float)limit - 1.0) + 1;

return ((limit - 1) << 24) | (start << 16) | (stride << 8) | start;
}

// Call this each time the next random value is required.
// When configured with a limit of N, every discreet batch of *around* N calls to this function will return each possible index only once.
// This function should be passed an mprui_state generated using mprui_init, and will return an updated state in response. Mask with 0xFF to get the index like so:
// mprui_state = prui_next(mprui_state);
// integer next_index = mprui_state & 0xFF;
integer mprui_next(integer mprui_state) {
integer limit = ((mprui_state >> 24) & 0xFF) + 1;
integer start = (mprui_state >> 16) & 0xFF;
integer stride = (mprui_state >> 8) & 0xFF;
integer next = mprui_state & 0xFF;

next = (next + stride) % limit;
if (next == start) { // We're about to repeat
// This is a hack that can result in fewer or greater than limit
// repetitions, but is fine in the spirit of "good enough"
if (next >= (limit - 1)) return mprui_init(limit);

// Move the start and insert into new state
next = (start + 1) % limit;
mprui_state = (mprui_state & 0xFF00FFFF) | (next << 16);
}

// Insert next value into state
return (mprui_state & 0xFFFFFF00) | next;
}</source>

=== Example ===
The following example takes the same string-based alphabet spewing device and adapts it to support multiple avatars, which will each get their own unique range of random letters no matter how many are also using the device.

<source lang="lsl2">// Insert the single-integer mprui functions here

string myString = "abcdefghijklmnopqrstuvwxyz";
integer myStringLength;

list avatars = []; integer avatar_limit = 8; // Maximum number of avatars to keep track of (list is pruned from longest ago touch)

default {
state_entry() { llSetText("Touch me for a complimentary letter of the alphabet!", <1.0, 1.0, 1.0>, 1.0); }

touch_start(integer x) {
key id = llDetectedKey(0); integer mprui_state;

integer index = llListFindList(avatars, [id]);
if (~index) {
mprui_state = mprui_next(llList2Integer(avatars, index + 1));

// Remove our old state
avatars = llDeleteSubList(avatars, index, index + 1);
} else {
mprui_state = mprui_init(llStringLength(myString));

// Make room if the list is full
integer prune = (llGetListLength(avatars) + 1) - avatar_limit;
if (prune > 0) avatars = llDeleteSubList(avatars, 0, (prune * 2) - 1);
}

integer next = mprui_state & 0xFF;
llRegionSayTo(id, PUBLIC_CHANNEL, llGetSubString(myString, next, next));

// Add the new state to the end of the list
avatars += [id, mprui_state];
}
}</source>

== List State ==
For greater precision a list-based state must be used, which naturally carries with it the overhead of list manipulation. This comes in two varieties, a 16-bit precision which uses a list that is three elements long, and a full (32-bit) precision variation that uses a five element list. In both cases the next value is stored in the first element of the list, as such the implementations can actually be used interchangeably.

=== Full Precision ===
<source lang="lsl2">// Configures the random number generator to generate values between 0 (inclusive) and limit (exclusive) and initialises
// Returns an mprui state that can then be passed into mprui_next()
list mprui_init(integer limit) {
integer start = (integer)llFrand((float)limit);
integer stride = (integer)llFrand((float)limit - 1.0) + 1;

return [start, 1, start, stride, limit];
}

// Call this each time the next random value is required.
// When configured with a limit of N, every discreet batch of N calls to this function will return each possible index only once.
// This function should be passed an mprui_state generated using mprui_init, and will return an updated state in response. Retrieve the first element to get the next index like so:
// mprui_state = prui_next(mprui_state);
// integer next_index = llList2Integer(mprui_state, 0);
list mprui_next(list mprui_state) {
integer next = llList2Integer(mprui_state, 0);
integer counter = llList2Integer(mprui_state, 1);
integer start = llList2Integer(mprui_state, 2);
integer stride = llList2Integer(mprui_state, 3);
integer limit = llList2Integer(mprui_state, 4);

if (!counter) return mprui_init(limit);

next = (next + stride) % limit;
if (next == start) {
start = (start + 1) % limit;
next = start;

return llListReplaceList(mprui_state, [next, (counter + 1) % limit, start], 0, 2);
}

return llListReplaceList(mprui_state, [next, (counter + 1) % limit], 0, 1);
}</source>

=== 16-bit Precision ===
The following list-state implementation restricts precision to 16-bits (max limit of 65536) but uses a smaller list for its state (3 elements vs 5):

<source lang="lsl2">// Configures the random number generator to generate values between 0 (inclusive) and limit (exclusive) and initialises
// Returns an mprui state that can then be passed into mprui_next()
list mprui_init(integer limit) {
integer start = (integer)llFrand((float)limit);
integer stride = (integer)llFrand((float)limit - 1.0) + 1;

return [start, 0x10000 | start, (stride << 16) | limit];
}

// Call this each time the next random value is required.
// When configured with a limit of N, every discreet batch of N calls to this function will return each possible index only once.
// This function should be passed an mprui_state generated using mprui_init, and will return an updated state in response. Retrieve the first element to get the next index like so:
// mprui_state = prui_next(mprui_state);
// integer next_index = llList2Integer(mprui_state, 0);
list mprui_next(list mprui_state) {
integer next = llList2Integer(mprui_state, 0);
integer counter = llList2Integer(mprui_state, 1);
integer start = counter & 0xFFFF; counter = (counter >> 16) & 0xFFFF;
integer stride = llList2Integer(mprui_state, 2);
integer limit = stride & 0xFFFF; stride = (stride >> 16) & 0xFFFF;

if (!counter) return mprui_init(limit);

next = (next + stride) % limit;
if (next == start) {
start = (start + 1) % limit;
next = start;
}

return llListReplaceList(mprui_state, [next, ((counter + 1) % limit) << 16 | start], 0, 1);
}</source>

=== Example ===
Once again we grant the gift of the alphabet upon avatars, this time using either of the above list-state implementations:

<source lang="lsl2">// Insert the mprui functions from either of the list-state options here

string myString = "abcdefghijklmnopqrstuvwxyz";
integer myStringLength;

list avatars = []; integer avatar_limit = 8; // Maximum number of avatars to keep track of (list is pruned from longest ago touch)

default {
state_entry() { llSetText("Touch me for a complimentary letter of the alphabet!", <1.0, 1.0, 1.0>, 1.0); }

touch_start(integer x) {
key id = llDetectedKey(0); list mprui_state;

integer index = llListFindList(avatars, [id]);
if (~index) {
mprui_state = mprui_next(llList2List(avatars, index + 1, index + 5));

// Remove our old state
avatars = llDeleteSubList(avatars, index, index + 5);
} else {
mprui_state = mprui_init(llStringLength(myString));

// Make room if the list is full
integer prune = (llGetListLength(avatars) + 1) - avatar_limit;
if (prune > 0) avatars = llDeleteSubList(avatars, 0, (prune * 6) - 1);
}

integer next = llList2Integer(mprui_state, 0);
llRegionSayTo(id, PUBLIC_CHANNEL, llGetSubString(myString, next, next));

// Add the new state to the end of the list
avatars += [id] + mprui_state;
}
}</source>

{{LSLC|Library}}

Pseudo-randomly Generate Unique Indices

2015-12-17T12:56:07Z

Haravikk Mistral: /* Single Integer State */

{{LSL Header}}
= Pseudo-randomly Generate Unique Indices =
Ordinarily when a collection of data needs to be retrieved in a random order, it can simply be reshuffled by randomly swapping elements and then iterating through the resulting, shuffled, collection. However there are cases where this is infeasible, especially in LSL, and as such the following functions can be used to generate indices in a pseudo-random way that should be "good enough" for many purposes.

<source lang="lsl2">integer _prui_counter = 1;
integer _prui_limit = 0;

integer _prui_start = 0;
integer _prui_stride = 0;
integer _prui_next = 0;

// Configures the random number generator to generate values between 0 (inclusive) and limit (exclusive) and initialises
prui_init(integer limit) {
_prui_limit = limit;
_prui_start = (integer)llFrand((float)limit);
_prui_stride = (integer)llFrand((float)limit - 1.0) + 1;
_prui_next = _prui_start;
}

// Call this each time the next random value is required.
// When configured with a limit of N, every discreet batch of N calls to this function will return each possible index only once.
integer prui_next() {
if (!_prui_counter) prui_init(_prui_limit);

integer result = _prui_next;
_prui_next = (_prui_next + _prui_stride) % _prui_limit;
if (_prui_next == _prui_start) {
_prui_start = (_prui_start + 1) % _prui_limit;
_prui_next = _prui_start;
}

_prui_counter = (_prui_counter + 1) % _prui_limit;
return result;
}</source>

== Examples ==
=== List ===
The following script will spit out a random entry from a list when touched. In this example the list contains letters of the alphabet and as such the first 26 touches will produce a unique letter, the following 26 touches will likewise produce no duplicates and so-on.

<source lang="lsl2">// Add the above prui variables and functions here

list myList = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"];
integer myListLength;

default {
state_entry() {
prui_init(myListLength = llGetListLength(myList));
llSetText("Touch me for a complimentary letter of the alphabet!", <1.0, 1.0, 1.0>, 1.0);
}

touch_start(integer x) { llRegionSayTo(llDetectedKey(0), PUBLIC_CHANNEL, llList2String(myList, prui_next())); }
}</source>

=== String ===
This is the same example rewritten to more efficiently use a string for storing the letters of the alphabet:

<source lang="lsl2">// Add the above prui variables and functions here

string myString = "abcdefghijklmnopqrstuvwxyz";
integer myStringLength;

default {
state_entry() {
prui_init(myStringLength = llStringLength(myString));
llSetText("Touch me for a complimentary letter of the alphabet!", <1.0, 1.0, 1.0>, 1.0);
}

touch_start(integer x) { llRegionSayTo(llDetectedKey(0), PUBLIC_CHANNEL, llGetSubString(myString, x = prui_next(), x)); }
}</source>

=== Notecard ===
Finally, this example performs the same incredible feat using lines in a notecard (one for each letter of the alphabet):

<source lang="lsl2">// Add the above prui variables and functions here

key myNotecard = "a62213ba-381d-2347-7f7b-818f15f12d83";
integer myNotecardLength = -1;
key talkTo = NULL_KEY;

default {
state_entry() { llGetNumberOfNotecardLines(myNotecard); }
dataserver(key id, string data) {
if (myNotecardLength > 0) llRegionSayTo(talkTo, PUBLIC_CHANNEL, data);
else prui_init(myNotecardLength = (integer)data);
}

touch_start(integer x) {
talkTo = llDetectedKey(0);
llGetNotecardLine(myNotecard, prui_next());
}
}</source>

= Multiple Number Generators =
The above code is fine for uses where only a single number generator is required, for example when communicating with a single avatar. However, when working with multiple random tasks it is not possible for a single number generator to produce values for different limits without completing the tasks sequentially (or aborting one), and in cases where the limit is the same, sharing a single number generator between multiple tasks will cause it to produce duplicates faster. For example, if a script is sending one of 100 possible messages randomly to four different avatars, then it will only have an effective entropy of around 25 messages (though for random messages this doesn't necessarily mean noticeably more duplicates).

For such cases, the following alternative functions enable the use of multiple number generators by producing and updating a state, by giving each task/avatar their own state value, it is possible to generate the full range of indices for each task/avatar.

== Single Integer State ==
The fastest and most memory efficient implementation uses four 8-bit values packed into a single 32-bit integer for its state, however this produces the following caveats:
* This implementation can only handle limits of up to 256.
* This implementation does not call mprui_init() after exactly N iterations, which means that it cannot guarantee a full N iterations without duplicates, however for most purposes this should still be adequate.

<source lang="lsl2">// Configures the random number generator to generate values between 0 (inclusive) and limit (exclusive, max 256) and initialises
// Returns an mprui state that can then be passed into mprui_next()
integer mprui_init(integer limit) {
integer start = (integer)llFrand((float)limit);
integer stride = (integer)llFrand((float)limit - 1.0) + 1;

return ((limit - 1) << 24) | (start << 16) | (stride << 8) | start;
}

// Call this each time the next random value is required.
// When configured with a limit of N, every discreet batch of *around* N calls to this function will return each possible index only once.
// This function should be passed an mprui_state generated using mprui_init, and will return an updated state in response. Mask with 0xFF to get the index like so:
// mprui_state = prui_next(mprui_state);
// integer next_index = mprui_state & 0xFF;
integer mprui_next(integer mprui_state) {
integer limit = ((mprui_state >> 24) & 0xFF) + 1;
integer start = (mprui_state >> 16) & 0xFF;
integer stride = (mprui_state >> 8) & 0xFF;
integer next = mprui_state & 0xFF;

next = (next + stride) % limit;
if (next == start) { // We're about to repeat
// This is a hack that can result in fewer or greater than limit
// repetitions, but is fine in the spirit of "good enough"
if (next >= (limit - 1)) return mprui_init(limit);

// Move the start and insert into new state
next = (start + 1) % limit;
mprui_state = (mprui_state & 0xFF00FFFF) | (next << 16);
}

// Insert next value into state
return (mprui_state & 0xFFFFFF00) | next;
}</source>

=== Example ===
The following example takes the same string-based alphabet spewing device and adapts it to support multiple avatars, which will each get their own unique range of random letters no matter how many are also using the device.

<source lang="lsl2">// Insert the single-integer mprui functions here

string myString = "abcdefghijklmnopqrstuvwxyz";
integer myStringLength;

list avatars = []; integer avatar_limit = 8;

default {
state_entry() { llSetText("Touch me for a complimentary letter of the alphabet!", <1.0, 1.0, 1.0>, 1.0); }

touch_start(integer x) {
key id = llDetectedKey(0); integer mprui_state;

integer index = llListFindList(avatars, [id]);
if (~index) {
mprui_state = mprui_next(llList2Integer(avatars, index + 1));

// Remove our old state
avatars = llDeleteSubList(avatars, index, index + 1);
} else {
mprui_state = mprui_init(llStringLength(myString));

// Make room if the list is full
integer prune = (llGetListLength(avatars) + 1) - avatar_limit;
if (prune > 0) avatars = llDeleteSubList(avatars, 0, (prune * 2) - 1);
}

integer next = mprui_state & 0xFF;
llRegionSayTo(id, PUBLIC_CHANNEL, llGetSubString(myString, next, next));

// Add the new state to the end of the list
avatars += [id, mprui_state];
}
}</source>

== List State ==
For greater precision a list-based state must be used, which naturally carries with it the overhead of list manipulation. This comes in two varieties, a 16-bit precision which uses a list that is three elements long, and a full (32-bit) precision variation that uses a five element list. In both cases the next value is stored in the first element of the list, as such the implementations can actually be used interchangeably.

=== Full Precision ===
<source lang="lsl2">// Configures the random number generator to generate values between 0 (inclusive) and limit (exclusive) and initialises
// Returns an mprui state that can then be passed into mprui_next()
list mprui_init(integer limit) {
integer start = (integer)llFrand((float)limit);
integer stride = (integer)llFrand((float)limit - 1.0) + 1;

return [start, 1, start, stride, limit];
}

// Call this each time the next random value is required.
// When configured with a limit of N, every discreet batch of N calls to this function will return each possible index only once.
// This function should be passed an mprui_state generated using mprui_init, and will return an updated state in response. Retrieve the first element to get the next index like so:
// mprui_state = prui_next(mprui_state);
// integer next_index = llList2Integer(mprui_state, 0);
list mprui_next(list mprui_state) {
integer next = llList2Integer(mprui_state, 0);
integer counter = llList2Integer(mprui_state, 1);
integer start = llList2Integer(mprui_state, 2);
integer stride = llList2Integer(mprui_state, 3);
integer limit = llList2Integer(mprui_state, 4);

if (!counter) return mprui_init(limit);

next = (next + stride) % limit;
if (next == start) {
start = (start + 1) % limit;
next = start;

return llListReplaceList(mprui_state, [next, (counter + 1) % limit, start], 0, 2);
}

return llListReplaceList(mprui_state, [next, (counter + 1) % limit], 0, 1);
}</source>

=== 16-bit Precision ===
The following list-state implementation restricts precision to 16-bits (max limit of 65536) but uses a smaller list for its state (3 elements vs 5):

<source lang="lsl2">// Configures the random number generator to generate values between 0 (inclusive) and limit (exclusive) and initialises
// Returns an mprui state that can then be passed into mprui_next()
list mprui_init(integer limit) {
integer start = (integer)llFrand((float)limit);
integer stride = (integer)llFrand((float)limit - 1.0) + 1;

return [start, 0x10000 | start, (stride << 16) | limit];
}

// Call this each time the next random value is required.
// When configured with a limit of N, every discreet batch of N calls to this function will return each possible index only once.
// This function should be passed an mprui_state generated using mprui_init, and will return an updated state in response. Retrieve the first element to get the next index like so:
// mprui_state = prui_next(mprui_state);
// integer next_index = llList2Integer(mprui_state, 0);
list mprui_next(list mprui_state) {
integer next = llList2Integer(mprui_state, 0);
integer counter = llList2Integer(mprui_state, 1);
integer start = counter & 0xFFFF; counter = (counter >> 16) & 0xFFFF;
integer stride = llList2Integer(mprui_state, 2);
integer limit = stride & 0xFFFF; stride = (stride >> 16) & 0xFFFF;

if (!counter) return mprui_init(limit);

next = (next + stride) % limit;
if (next == start) {
start = (start + 1) % limit;
next = start;
}

return llListReplaceList(mprui_state, [next, ((counter + 1) % limit) << 16 | start], 0, 1);
}</source>

=== Example ===
Once again we grant the gift of the alphabet upon avatars, this time using either of the above list-state implementations:

<source lang="lsl2">// Insert the mprui functions from either of the list-state options here

string myString = "abcdefghijklmnopqrstuvwxyz";
integer myStringLength;

list avatars = []; integer avatar_limit = 8; // Maximum number of avatars to keep track of (list is pruned from longest ago touch)

default {
state_entry() { llSetText("Touch me for a complimentary letter of the alphabet!", <1.0, 1.0, 1.0>, 1.0); }

touch_start(integer x) {
key id = llDetectedKey(0); list mprui_state;

integer index = llListFindList(avatars, [id]);
if (~index) {
mprui_state = mprui_next(llList2List(avatars, index + 1, index + 5));

// Remove our old state
avatars = llDeleteSubList(avatars, index, index + 5);
} else {
mprui_state = mprui_init(llStringLength(myString));

// Make room if the list is full
integer prune = (llGetListLength(avatars) + 1) - avatar_limit;
if (prune > 0) avatars = llDeleteSubList(avatars, 0, (prune * 6) - 1);
}

integer next = llList2Integer(mprui_state, 0);
llRegionSayTo(id, PUBLIC_CHANNEL, llGetSubString(myString, next, next));

// Add the new state to the end of the list
avatars += [id] + mprui_state;
}
}</source>

{{LSLC|Library}}

Pseudo-randomly Generate Unique Indices

2015-12-17T12:55:46Z

Haravikk Mistral: /* Single Integer State */

{{LSL Header}}
= Pseudo-randomly Generate Unique Indices =
Ordinarily when a collection of data needs to be retrieved in a random order, it can simply be reshuffled by randomly swapping elements and then iterating through the resulting, shuffled, collection. However there are cases where this is infeasible, especially in LSL, and as such the following functions can be used to generate indices in a pseudo-random way that should be "good enough" for many purposes.

<source lang="lsl2">integer _prui_counter = 1;
integer _prui_limit = 0;

integer _prui_start = 0;
integer _prui_stride = 0;
integer _prui_next = 0;

// Configures the random number generator to generate values between 0 (inclusive) and limit (exclusive) and initialises
prui_init(integer limit) {
_prui_limit = limit;
_prui_start = (integer)llFrand((float)limit);
_prui_stride = (integer)llFrand((float)limit - 1.0) + 1;
_prui_next = _prui_start;
}

// Call this each time the next random value is required.
// When configured with a limit of N, every discreet batch of N calls to this function will return each possible index only once.
integer prui_next() {
if (!_prui_counter) prui_init(_prui_limit);

integer result = _prui_next;
_prui_next = (_prui_next + _prui_stride) % _prui_limit;
if (_prui_next == _prui_start) {
_prui_start = (_prui_start + 1) % _prui_limit;
_prui_next = _prui_start;
}

_prui_counter = (_prui_counter + 1) % _prui_limit;
return result;
}</source>

== Examples ==
=== List ===
The following script will spit out a random entry from a list when touched. In this example the list contains letters of the alphabet and as such the first 26 touches will produce a unique letter, the following 26 touches will likewise produce no duplicates and so-on.

<source lang="lsl2">// Add the above prui variables and functions here

list myList = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"];
integer myListLength;

default {
state_entry() {
prui_init(myListLength = llGetListLength(myList));
llSetText("Touch me for a complimentary letter of the alphabet!", <1.0, 1.0, 1.0>, 1.0);
}

touch_start(integer x) { llRegionSayTo(llDetectedKey(0), PUBLIC_CHANNEL, llList2String(myList, prui_next())); }
}</source>

=== String ===
This is the same example rewritten to more efficiently use a string for storing the letters of the alphabet:

<source lang="lsl2">// Add the above prui variables and functions here

string myString = "abcdefghijklmnopqrstuvwxyz";
integer myStringLength;

default {
state_entry() {
prui_init(myStringLength = llStringLength(myString));
llSetText("Touch me for a complimentary letter of the alphabet!", <1.0, 1.0, 1.0>, 1.0);
}

touch_start(integer x) { llRegionSayTo(llDetectedKey(0), PUBLIC_CHANNEL, llGetSubString(myString, x = prui_next(), x)); }
}</source>

=== Notecard ===
Finally, this example performs the same incredible feat using lines in a notecard (one for each letter of the alphabet):

<source lang="lsl2">// Add the above prui variables and functions here

key myNotecard = "a62213ba-381d-2347-7f7b-818f15f12d83";
integer myNotecardLength = -1;
key talkTo = NULL_KEY;

default {
state_entry() { llGetNumberOfNotecardLines(myNotecard); }
dataserver(key id, string data) {
if (myNotecardLength > 0) llRegionSayTo(talkTo, PUBLIC_CHANNEL, data);
else prui_init(myNotecardLength = (integer)data);
}

touch_start(integer x) {
talkTo = llDetectedKey(0);
llGetNotecardLine(myNotecard, prui_next());
}
}</source>

= Multiple Number Generators =
The above code is fine for uses where only a single number generator is required, for example when communicating with a single avatar. However, when working with multiple random tasks it is not possible for a single number generator to produce values for different limits without completing the tasks sequentially (or aborting one), and in cases where the limit is the same, sharing a single number generator between multiple tasks will cause it to produce duplicates faster. For example, if a script is sending one of 100 possible messages randomly to four different avatars, then it will only have an effective entropy of around 25 messages (though for random messages this doesn't necessarily mean noticeably more duplicates).

For such cases, the following alternative functions enable the use of multiple number generators by producing and updating a state, by giving each task/avatar their own state value, it is possible to generate the full range of indices for each task/avatar.

== Single Integer State ==
The fastest and most memory efficient implementation uses four 8-bit values packed into a single 32-bit integer for its state, however this produces the following caveats:
* This implementation can only handle limits of up to 256.
* This implementation does not call mprui_init() after exactly N iterations, which means that it cannot guarantee a full N iterations without duplicates, however for the purposes of randomised behaviour this should still be adequate.

<source lang="lsl2">// Configures the random number generator to generate values between 0 (inclusive) and limit (exclusive, max 256) and initialises
// Returns an mprui state that can then be passed into mprui_next()
integer mprui_init(integer limit) {
integer start = (integer)llFrand((float)limit);
integer stride = (integer)llFrand((float)limit - 1.0) + 1;

return ((limit - 1) << 24) | (start << 16) | (stride << 8) | start;
}

// Call this each time the next random value is required.
// When configured with a limit of N, every discreet batch of *around* N calls to this function will return each possible index only once.
// This function should be passed an mprui_state generated using mprui_init, and will return an updated state in response. Mask with 0xFF to get the index like so:
// mprui_state = prui_next(mprui_state);
// integer next_index = mprui_state & 0xFF;
integer mprui_next(integer mprui_state) {
integer limit = ((mprui_state >> 24) & 0xFF) + 1;
integer start = (mprui_state >> 16) & 0xFF;
integer stride = (mprui_state >> 8) & 0xFF;
integer next = mprui_state & 0xFF;

next = (next + stride) % limit;
if (next == start) { // We're about to repeat
// This is a hack that can result in fewer or greater than limit
// repetitions, but is fine in the spirit of "good enough"
if (next >= (limit - 1)) return mprui_init(limit);

// Move the start and insert into new state
next = (start + 1) % limit;
mprui_state = (mprui_state & 0xFF00FFFF) | (next << 16);
}

// Insert next value into state
return (mprui_state & 0xFFFFFF00) | next;
}</source>

=== Example ===
The following example takes the same string-based alphabet spewing device and adapts it to support multiple avatars, which will each get their own unique range of random letters no matter how many are also using the device.

<source lang="lsl2">// Insert the single-integer mprui functions here

string myString = "abcdefghijklmnopqrstuvwxyz";
integer myStringLength;

list avatars = []; integer avatar_limit = 8;

default {
state_entry() { llSetText("Touch me for a complimentary letter of the alphabet!", <1.0, 1.0, 1.0>, 1.0); }

touch_start(integer x) {
key id = llDetectedKey(0); integer mprui_state;

integer index = llListFindList(avatars, [id]);
if (~index) {
mprui_state = mprui_next(llList2Integer(avatars, index + 1));

// Remove our old state
avatars = llDeleteSubList(avatars, index, index + 1);
} else {
mprui_state = mprui_init(llStringLength(myString));

// Make room if the list is full
integer prune = (llGetListLength(avatars) + 1) - avatar_limit;
if (prune > 0) avatars = llDeleteSubList(avatars, 0, (prune * 2) - 1);
}

integer next = mprui_state & 0xFF;
llRegionSayTo(id, PUBLIC_CHANNEL, llGetSubString(myString, next, next));

// Add the new state to the end of the list
avatars += [id, mprui_state];
}
}</source>

== List State ==
For greater precision a list-based state must be used, which naturally carries with it the overhead of list manipulation. This comes in two varieties, a 16-bit precision which uses a list that is three elements long, and a full (32-bit) precision variation that uses a five element list. In both cases the next value is stored in the first element of the list, as such the implementations can actually be used interchangeably.

=== Full Precision ===
<source lang="lsl2">// Configures the random number generator to generate values between 0 (inclusive) and limit (exclusive) and initialises
// Returns an mprui state that can then be passed into mprui_next()
list mprui_init(integer limit) {
integer start = (integer)llFrand((float)limit);
integer stride = (integer)llFrand((float)limit - 1.0) + 1;

return [start, 1, start, stride, limit];
}

// Call this each time the next random value is required.
// When configured with a limit of N, every discreet batch of N calls to this function will return each possible index only once.
// This function should be passed an mprui_state generated using mprui_init, and will return an updated state in response. Retrieve the first element to get the next index like so:
// mprui_state = prui_next(mprui_state);
// integer next_index = llList2Integer(mprui_state, 0);
list mprui_next(list mprui_state) {
integer next = llList2Integer(mprui_state, 0);
integer counter = llList2Integer(mprui_state, 1);
integer start = llList2Integer(mprui_state, 2);
integer stride = llList2Integer(mprui_state, 3);
integer limit = llList2Integer(mprui_state, 4);

if (!counter) return mprui_init(limit);

next = (next + stride) % limit;
if (next == start) {
start = (start + 1) % limit;
next = start;

return llListReplaceList(mprui_state, [next, (counter + 1) % limit, start], 0, 2);
}

return llListReplaceList(mprui_state, [next, (counter + 1) % limit], 0, 1);
}</source>

=== 16-bit Precision ===
The following list-state implementation restricts precision to 16-bits (max limit of 65536) but uses a smaller list for its state (3 elements vs 5):

<source lang="lsl2">// Configures the random number generator to generate values between 0 (inclusive) and limit (exclusive) and initialises
// Returns an mprui state that can then be passed into mprui_next()
list mprui_init(integer limit) {
integer start = (integer)llFrand((float)limit);
integer stride = (integer)llFrand((float)limit - 1.0) + 1;

return [start, 0x10000 | start, (stride << 16) | limit];
}

// Call this each time the next random value is required.
// When configured with a limit of N, every discreet batch of N calls to this function will return each possible index only once.
// This function should be passed an mprui_state generated using mprui_init, and will return an updated state in response. Retrieve the first element to get the next index like so:
// mprui_state = prui_next(mprui_state);
// integer next_index = llList2Integer(mprui_state, 0);
list mprui_next(list mprui_state) {
integer next = llList2Integer(mprui_state, 0);
integer counter = llList2Integer(mprui_state, 1);
integer start = counter & 0xFFFF; counter = (counter >> 16) & 0xFFFF;
integer stride = llList2Integer(mprui_state, 2);
integer limit = stride & 0xFFFF; stride = (stride >> 16) & 0xFFFF;

if (!counter) return mprui_init(limit);

next = (next + stride) % limit;
if (next == start) {
start = (start + 1) % limit;
next = start;
}

return llListReplaceList(mprui_state, [next, ((counter + 1) % limit) << 16 | start], 0, 1);
}</source>

=== Example ===
Once again we grant the gift of the alphabet upon avatars, this time using either of the above list-state implementations:

<source lang="lsl2">// Insert the mprui functions from either of the list-state options here

string myString = "abcdefghijklmnopqrstuvwxyz";
integer myStringLength;

list avatars = []; integer avatar_limit = 8; // Maximum number of avatars to keep track of (list is pruned from longest ago touch)

default {
state_entry() { llSetText("Touch me for a complimentary letter of the alphabet!", <1.0, 1.0, 1.0>, 1.0); }

touch_start(integer x) {
key id = llDetectedKey(0); list mprui_state;

integer index = llListFindList(avatars, [id]);
if (~index) {
mprui_state = mprui_next(llList2List(avatars, index + 1, index + 5));

// Remove our old state
avatars = llDeleteSubList(avatars, index, index + 5);
} else {
mprui_state = mprui_init(llStringLength(myString));

// Make room if the list is full
integer prune = (llGetListLength(avatars) + 1) - avatar_limit;
if (prune > 0) avatars = llDeleteSubList(avatars, 0, (prune * 6) - 1);
}

integer next = llList2Integer(mprui_state, 0);
llRegionSayTo(id, PUBLIC_CHANNEL, llGetSubString(myString, next, next));

// Add the new state to the end of the list
avatars += [id] + mprui_state;
}
}</source>

{{LSLC|Library}}

Pseudo-randomly Generate Unique Indices

2015-12-17T12:54:48Z

Haravikk Mistral: /* Multiple Number Generators */

{{LSL Header}}
= Pseudo-randomly Generate Unique Indices =
Ordinarily when a collection of data needs to be retrieved in a random order, it can simply be reshuffled by randomly swapping elements and then iterating through the resulting, shuffled, collection. However there are cases where this is infeasible, especially in LSL, and as such the following functions can be used to generate indices in a pseudo-random way that should be "good enough" for many purposes.

<source lang="lsl2">integer _prui_counter = 1;
integer _prui_limit = 0;

integer _prui_start = 0;
integer _prui_stride = 0;
integer _prui_next = 0;

// Configures the random number generator to generate values between 0 (inclusive) and limit (exclusive) and initialises
prui_init(integer limit) {
_prui_limit = limit;
_prui_start = (integer)llFrand((float)limit);
_prui_stride = (integer)llFrand((float)limit - 1.0) + 1;
_prui_next = _prui_start;
}

// Call this each time the next random value is required.
// When configured with a limit of N, every discreet batch of N calls to this function will return each possible index only once.
integer prui_next() {
if (!_prui_counter) prui_init(_prui_limit);

integer result = _prui_next;
_prui_next = (_prui_next + _prui_stride) % _prui_limit;
if (_prui_next == _prui_start) {
_prui_start = (_prui_start + 1) % _prui_limit;
_prui_next = _prui_start;
}

_prui_counter = (_prui_counter + 1) % _prui_limit;
return result;
}</source>

== Examples ==
=== List ===
The following script will spit out a random entry from a list when touched. In this example the list contains letters of the alphabet and as such the first 26 touches will produce a unique letter, the following 26 touches will likewise produce no duplicates and so-on.

<source lang="lsl2">// Add the above prui variables and functions here

list myList = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"];
integer myListLength;

default {
state_entry() {
prui_init(myListLength = llGetListLength(myList));
llSetText("Touch me for a complimentary letter of the alphabet!", <1.0, 1.0, 1.0>, 1.0);
}

touch_start(integer x) { llRegionSayTo(llDetectedKey(0), PUBLIC_CHANNEL, llList2String(myList, prui_next())); }
}</source>

=== String ===
This is the same example rewritten to more efficiently use a string for storing the letters of the alphabet:

<source lang="lsl2">// Add the above prui variables and functions here

string myString = "abcdefghijklmnopqrstuvwxyz";
integer myStringLength;

default {
state_entry() {
prui_init(myStringLength = llStringLength(myString));
llSetText("Touch me for a complimentary letter of the alphabet!", <1.0, 1.0, 1.0>, 1.0);
}

touch_start(integer x) { llRegionSayTo(llDetectedKey(0), PUBLIC_CHANNEL, llGetSubString(myString, x = prui_next(), x)); }
}</source>

=== Notecard ===
Finally, this example performs the same incredible feat using lines in a notecard (one for each letter of the alphabet):

<source lang="lsl2">// Add the above prui variables and functions here

key myNotecard = "a62213ba-381d-2347-7f7b-818f15f12d83";
integer myNotecardLength = -1;
key talkTo = NULL_KEY;

default {
state_entry() { llGetNumberOfNotecardLines(myNotecard); }
dataserver(key id, string data) {
if (myNotecardLength > 0) llRegionSayTo(talkTo, PUBLIC_CHANNEL, data);
else prui_init(myNotecardLength = (integer)data);
}

touch_start(integer x) {
talkTo = llDetectedKey(0);
llGetNotecardLine(myNotecard, prui_next());
}
}</source>

= Multiple Number Generators =
The above code is fine for uses where only a single number generator is required, for example when communicating with a single avatar. However, when working with multiple random tasks it is not possible for a single number generator to produce values for different limits without completing the tasks sequentially (or aborting one), and in cases where the limit is the same, sharing a single number generator between multiple tasks will cause it to produce duplicates faster. For example, if a script is sending one of 100 possible messages randomly to four different avatars, then it will only have an effective entropy of around 25 messages (though for random messages this doesn't necessarily mean noticeably more duplicates).

For such cases, the following alternative functions enable the use of multiple number generators by producing and updating a state, by giving each task/avatar their own state value, it is possible to generate the full range of indices for each task/avatar.

== Single Integer State ==
The fastest and most memory efficient implementation uses four 8-bit values packed into a single 32-bit integer for its state, however this produces the following caveats:
* This implementation can only handle limits of up to 256.
* This implementation does not use a separate counter to call mprui_init() every N iterations, which means that it cannot guarantee a full N iterations without duplicates, however for the purposes of randomised behaviour this should still be adequate.

<source lang="lsl2">// Configures the random number generator to generate values between 0 (inclusive) and limit (exclusive, max 256) and initialises
// Returns an mprui state that can then be passed into mprui_next()
integer mprui_init(integer limit) {
integer start = (integer)llFrand((float)limit);
integer stride = (integer)llFrand((float)limit - 1.0) + 1;

return ((limit - 1) << 24) | (start << 16) | (stride << 8) | start;
}

// Call this each time the next random value is required.
// When configured with a limit of N, every discreet batch of *around* N calls to this function will return each possible index only once.
// This function should be passed an mprui_state generated using mprui_init, and will return an updated state in response. Mask with 0xFF to get the index like so:
// mprui_state = prui_next(mprui_state);
// integer next_index = mprui_state & 0xFF;
integer mprui_next(integer mprui_state) {
integer limit = ((mprui_state >> 24) & 0xFF) + 1;
integer start = (mprui_state >> 16) & 0xFF;
integer stride = (mprui_state >> 8) & 0xFF;
integer next = mprui_state & 0xFF;

next = (next + stride) % limit;
if (next == start) { // We're about to repeat
// This is a hack that can result in fewer or greater than limit
// repetitions, but is fine in the spirit of "good enough"
if (next >= (limit - 1)) return mprui_init(limit);

// Move the start and insert into new state
next = (start + 1) % limit;
mprui_state = (mprui_state & 0xFF00FFFF) | (next << 16);
}

// Insert next value into state
return (mprui_state & 0xFFFFFF00) | next;
}</source>

=== Example ===
The following example takes the same string-based alphabet spewing device and adapts it to support multiple avatars, which will each get their own unique range of random letters no matter how many are also using the device.

<source lang="lsl2">// Insert the single-integer mprui functions here

string myString = "abcdefghijklmnopqrstuvwxyz";
integer myStringLength;

list avatars = []; integer avatar_limit = 8;

default {
state_entry() { llSetText("Touch me for a complimentary letter of the alphabet!", <1.0, 1.0, 1.0>, 1.0); }

touch_start(integer x) {
key id = llDetectedKey(0); integer mprui_state;

integer index = llListFindList(avatars, [id]);
if (~index) {
mprui_state = mprui_next(llList2Integer(avatars, index + 1));

// Remove our old state
avatars = llDeleteSubList(avatars, index, index + 1);
} else {
mprui_state = mprui_init(llStringLength(myString));

// Make room if the list is full
integer prune = (llGetListLength(avatars) + 1) - avatar_limit;
if (prune > 0) avatars = llDeleteSubList(avatars, 0, (prune * 2) - 1);
}

integer next = mprui_state & 0xFF;
llRegionSayTo(id, PUBLIC_CHANNEL, llGetSubString(myString, next, next));

// Add the new state to the end of the list
avatars += [id, mprui_state];
}
}</source>

== List State ==
For greater precision a list-based state must be used, which naturally carries with it the overhead of list manipulation. This comes in two varieties, a 16-bit precision which uses a list that is three elements long, and a full (32-bit) precision variation that uses a five element list. In both cases the next value is stored in the first element of the list, as such the implementations can actually be used interchangeably.

=== Full Precision ===
<source lang="lsl2">// Configures the random number generator to generate values between 0 (inclusive) and limit (exclusive) and initialises
// Returns an mprui state that can then be passed into mprui_next()
list mprui_init(integer limit) {
integer start = (integer)llFrand((float)limit);
integer stride = (integer)llFrand((float)limit - 1.0) + 1;

return [start, 1, start, stride, limit];
}

// Call this each time the next random value is required.
// When configured with a limit of N, every discreet batch of N calls to this function will return each possible index only once.
// This function should be passed an mprui_state generated using mprui_init, and will return an updated state in response. Retrieve the first element to get the next index like so:
// mprui_state = prui_next(mprui_state);
// integer next_index = llList2Integer(mprui_state, 0);
list mprui_next(list mprui_state) {
integer next = llList2Integer(mprui_state, 0);
integer counter = llList2Integer(mprui_state, 1);
integer start = llList2Integer(mprui_state, 2);
integer stride = llList2Integer(mprui_state, 3);
integer limit = llList2Integer(mprui_state, 4);

if (!counter) return mprui_init(limit);

next = (next + stride) % limit;
if (next == start) {
start = (start + 1) % limit;
next = start;

return llListReplaceList(mprui_state, [next, (counter + 1) % limit, start], 0, 2);
}

return llListReplaceList(mprui_state, [next, (counter + 1) % limit], 0, 1);
}</source>

=== 16-bit Precision ===
The following list-state implementation restricts precision to 16-bits (max limit of 65536) but uses a smaller list for its state (3 elements vs 5):

<source lang="lsl2">// Configures the random number generator to generate values between 0 (inclusive) and limit (exclusive) and initialises
// Returns an mprui state that can then be passed into mprui_next()
list mprui_init(integer limit) {
integer start = (integer)llFrand((float)limit);
integer stride = (integer)llFrand((float)limit - 1.0) + 1;

return [start, 0x10000 | start, (stride << 16) | limit];
}

// Call this each time the next random value is required.
// When configured with a limit of N, every discreet batch of N calls to this function will return each possible index only once.
// This function should be passed an mprui_state generated using mprui_init, and will return an updated state in response. Retrieve the first element to get the next index like so:
// mprui_state = prui_next(mprui_state);
// integer next_index = llList2Integer(mprui_state, 0);
list mprui_next(list mprui_state) {
integer next = llList2Integer(mprui_state, 0);
integer counter = llList2Integer(mprui_state, 1);
integer start = counter & 0xFFFF; counter = (counter >> 16) & 0xFFFF;
integer stride = llList2Integer(mprui_state, 2);
integer limit = stride & 0xFFFF; stride = (stride >> 16) & 0xFFFF;

if (!counter) return mprui_init(limit);

next = (next + stride) % limit;
if (next == start) {
start = (start + 1) % limit;
next = start;
}

return llListReplaceList(mprui_state, [next, ((counter + 1) % limit) << 16 | start], 0, 1);
}</source>

=== Example ===
Once again we grant the gift of the alphabet upon avatars, this time using either of the above list-state implementations:

<source lang="lsl2">// Insert the mprui functions from either of the list-state options here

string myString = "abcdefghijklmnopqrstuvwxyz";
integer myStringLength;

list avatars = []; integer avatar_limit = 8; // Maximum number of avatars to keep track of (list is pruned from longest ago touch)

default {
state_entry() { llSetText("Touch me for a complimentary letter of the alphabet!", <1.0, 1.0, 1.0>, 1.0); }

touch_start(integer x) {
key id = llDetectedKey(0); list mprui_state;

integer index = llListFindList(avatars, [id]);
if (~index) {
mprui_state = mprui_next(llList2List(avatars, index + 1, index + 5));

// Remove our old state
avatars = llDeleteSubList(avatars, index, index + 5);
} else {
mprui_state = mprui_init(llStringLength(myString));

// Make room if the list is full
integer prune = (llGetListLength(avatars) + 1) - avatar_limit;
if (prune > 0) avatars = llDeleteSubList(avatars, 0, (prune * 6) - 1);
}

integer next = llList2Integer(mprui_state, 0);
llRegionSayTo(id, PUBLIC_CHANNEL, llGetSubString(myString, next, next));

// Add the new state to the end of the list
avatars += [id] + mprui_state;
}
}</source>

{{LSLC|Library}}

Pseudo-randomly Generate Unique Indices

2015-12-17T12:53:15Z

Haravikk Mistral: /* Single Integer */

{{LSL Header}}
= Pseudo-randomly Generate Unique Indices =
Ordinarily when a collection of data needs to be retrieved in a random order, it can simply be reshuffled by randomly swapping elements and then iterating through the resulting, shuffled, collection. However there are cases where this is infeasible, especially in LSL, and as such the following functions can be used to generate indices in a pseudo-random way that should be "good enough" for many purposes.

<source lang="lsl2">integer _prui_counter = 1;
integer _prui_limit = 0;

integer _prui_start = 0;
integer _prui_stride = 0;
integer _prui_next = 0;

// Configures the random number generator to generate values between 0 (inclusive) and limit (exclusive) and initialises
prui_init(integer limit) {
_prui_limit = limit;
_prui_start = (integer)llFrand((float)limit);
_prui_stride = (integer)llFrand((float)limit - 1.0) + 1;
_prui_next = _prui_start;
}

// Call this each time the next random value is required.
// When configured with a limit of N, every discreet batch of N calls to this function will return each possible index only once.
integer prui_next() {
if (!_prui_counter) prui_init(_prui_limit);

integer result = _prui_next;
_prui_next = (_prui_next + _prui_stride) % _prui_limit;
if (_prui_next == _prui_start) {
_prui_start = (_prui_start + 1) % _prui_limit;
_prui_next = _prui_start;
}

_prui_counter = (_prui_counter + 1) % _prui_limit;
return result;
}</source>

== Examples ==
=== List ===
The following script will spit out a random entry from a list when touched. In this example the list contains letters of the alphabet and as such the first 26 touches will produce a unique letter, the following 26 touches will likewise produce no duplicates and so-on.

<source lang="lsl2">// Add the above prui variables and functions here

list myList = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"];
integer myListLength;

default {
state_entry() {
prui_init(myListLength = llGetListLength(myList));
llSetText("Touch me for a complimentary letter of the alphabet!", <1.0, 1.0, 1.0>, 1.0);
}

touch_start(integer x) { llRegionSayTo(llDetectedKey(0), PUBLIC_CHANNEL, llList2String(myList, prui_next())); }
}</source>

=== String ===
This is the same example rewritten to more efficiently use a string for storing the letters of the alphabet:

<source lang="lsl2">// Add the above prui variables and functions here

string myString = "abcdefghijklmnopqrstuvwxyz";
integer myStringLength;

default {
state_entry() {
prui_init(myStringLength = llStringLength(myString));
llSetText("Touch me for a complimentary letter of the alphabet!", <1.0, 1.0, 1.0>, 1.0);
}

touch_start(integer x) { llRegionSayTo(llDetectedKey(0), PUBLIC_CHANNEL, llGetSubString(myString, x = prui_next(), x)); }
}</source>

=== Notecard ===
Finally, this example performs the same incredible feat using lines in a notecard (one for each letter of the alphabet):

<source lang="lsl2">// Add the above prui variables and functions here

key myNotecard = "a62213ba-381d-2347-7f7b-818f15f12d83";
integer myNotecardLength = -1;
key talkTo = NULL_KEY;

default {
state_entry() { llGetNumberOfNotecardLines(myNotecard); }
dataserver(key id, string data) {
if (myNotecardLength > 0) llRegionSayTo(talkTo, PUBLIC_CHANNEL, data);
else prui_init(myNotecardLength = (integer)data);
}

touch_start(integer x) {
talkTo = llDetectedKey(0);
llGetNotecardLine(myNotecard, prui_next());
}
}</source>

= Multiple Number Generators =
The above code is fine for uses where only a single number generator is required, for example when communicating with a single avatar. However, when working with multiple random tasks it is not possible for a single number generator to produce values for different limits without completing the tasks sequentially (or aborting one), and in cases where the limit is the same, sharing a single number generator between multiple tasks will cause it to produce duplicates faster. For example, if a script is sending one of 100 possible messages randomly to four different avatars, then it will only have an effective entropy of around 25 messages.

For such cases, the following alternative functions enable the use of multiple number generators by producing and updating a state, by giving each task/avatar their own state value, it is possible to generate the full range of indices for each task/avatar.

== Single Integer State ==
The fastest and most memory efficient implementation uses four 8-bit values packed into a single 32-bit integer for its state, however this produces the following caveats:
* This implementation can only handle limits of up to 256.
* This implementation does not use a separate counter to call mprui_init() every N iterations, which means that it cannot guarantee a full N iterations without duplicates, however for the purposes of randomised behaviour this should still be adequate.

<source lang="lsl2">// Configures the random number generator to generate values between 0 (inclusive) and limit (exclusive, max 256) and initialises
// Returns an mprui state that can then be passed into mprui_next()
integer mprui_init(integer limit) {
integer start = (integer)llFrand((float)limit);
integer stride = (integer)llFrand((float)limit - 1.0) + 1;

return ((limit - 1) << 24) | (start << 16) | (stride << 8) | start;
}

// Call this each time the next random value is required.
// When configured with a limit of N, every discreet batch of *around* N calls to this function will return each possible index only once.
// This function should be passed an mprui_state generated using mprui_init, and will return an updated state in response. Mask with 0xFF to get the index like so:
// mprui_state = prui_next(mprui_state);
// integer next_index = mprui_state & 0xFF;
integer mprui_next(integer mprui_state) {
integer limit = ((mprui_state >> 24) & 0xFF) + 1;
integer start = (mprui_state >> 16) & 0xFF;
integer stride = (mprui_state >> 8) & 0xFF;
integer next = mprui_state & 0xFF;

next = (next + stride) % limit;
if (next == start) { // We're about to repeat
// This is a hack that can result in fewer or greater than limit
// repetitions, but is fine in the spirit of "good enough"
if (next >= (limit - 1)) return mprui_init(limit);

// Move the start and insert into new state
next = (start + 1) % limit;
mprui_state = (mprui_state & 0xFF00FFFF) | (next << 16);
}

// Insert next value into state
return (mprui_state & 0xFFFFFF00) | next;
}</source>

=== Example ===
The following example takes the same string-based alphabet spewing device and adapts it to support multiple avatars, which will each get their own unique range of random letters no matter how many are also using the device.

<source lang="lsl2">// Insert the single-integer mprui functions here

string myString = "abcdefghijklmnopqrstuvwxyz";
integer myStringLength;

list avatars = []; integer avatar_limit = 8;

default {
state_entry() { llSetText("Touch me for a complimentary letter of the alphabet!", <1.0, 1.0, 1.0>, 1.0); }

touch_start(integer x) {
key id = llDetectedKey(0); integer mprui_state;

integer index = llListFindList(avatars, [id]);
if (~index) {
mprui_state = mprui_next(llList2Integer(avatars, index + 1));

// Remove our old state
avatars = llDeleteSubList(avatars, index, index + 1);
} else {
mprui_state = mprui_init(llStringLength(myString));

// Make room if the list is full
integer prune = (llGetListLength(avatars) + 1) - avatar_limit;
if (prune > 0) avatars = llDeleteSubList(avatars, 0, (prune * 2) - 1);
}

integer next = mprui_state & 0xFF;
llRegionSayTo(id, PUBLIC_CHANNEL, llGetSubString(myString, next, next));

// Add the new state to the end of the list
avatars += [id, mprui_state];
}
}</source>

== List State ==
For greater precision a list-based state must be used, which naturally carries with it the overhead of list manipulation. This comes in two varieties, a 16-bit precision which uses a list that is three elements long, and a full (32-bit) precision variation that uses a five element list. In both cases the next value is stored in the first element of the list, as such the implementations can actually be used interchangeably.

=== Full Precision ===
<source lang="lsl2">// Configures the random number generator to generate values between 0 (inclusive) and limit (exclusive) and initialises
// Returns an mprui state that can then be passed into mprui_next()
list mprui_init(integer limit) {
integer start = (integer)llFrand((float)limit);
integer stride = (integer)llFrand((float)limit - 1.0) + 1;

return [start, 1, start, stride, limit];
}

// Call this each time the next random value is required.
// When configured with a limit of N, every discreet batch of N calls to this function will return each possible index only once.
// This function should be passed an mprui_state generated using mprui_init, and will return an updated state in response. Retrieve the first element to get the next index like so:
// mprui_state = prui_next(mprui_state);
// integer next_index = llList2Integer(mprui_state, 0);
list mprui_next(list mprui_state) {
integer next = llList2Integer(mprui_state, 0);
integer counter = llList2Integer(mprui_state, 1);
integer start = llList2Integer(mprui_state, 2);
integer stride = llList2Integer(mprui_state, 3);
integer limit = llList2Integer(mprui_state, 4);

if (!counter) return mprui_init(limit);

next = (next + stride) % limit;
if (next == start) {
start = (start + 1) % limit;
next = start;

return llListReplaceList(mprui_state, [next, (counter + 1) % limit, start], 0, 2);
}

return llListReplaceList(mprui_state, [next, (counter + 1) % limit], 0, 1);
}</source>

=== 16-bit Precision ===
The following list-state implementation restricts precision to 16-bits (max limit of 65536) but uses a smaller list for its state (3 elements vs 5):

<source lang="lsl2">// Configures the random number generator to generate values between 0 (inclusive) and limit (exclusive) and initialises
// Returns an mprui state that can then be passed into mprui_next()
list mprui_init(integer limit) {
integer start = (integer)llFrand((float)limit);
integer stride = (integer)llFrand((float)limit - 1.0) + 1;

return [start, 0x10000 | start, (stride << 16) | limit];
}

// Call this each time the next random value is required.
// When configured with a limit of N, every discreet batch of N calls to this function will return each possible index only once.
// This function should be passed an mprui_state generated using mprui_init, and will return an updated state in response. Retrieve the first element to get the next index like so:
// mprui_state = prui_next(mprui_state);
// integer next_index = llList2Integer(mprui_state, 0);
list mprui_next(list mprui_state) {
integer next = llList2Integer(mprui_state, 0);
integer counter = llList2Integer(mprui_state, 1);
integer start = counter & 0xFFFF; counter = (counter >> 16) & 0xFFFF;
integer stride = llList2Integer(mprui_state, 2);
integer limit = stride & 0xFFFF; stride = (stride >> 16) & 0xFFFF;

if (!counter) return mprui_init(limit);

next = (next + stride) % limit;
if (next == start) {
start = (start + 1) % limit;
next = start;
}

return llListReplaceList(mprui_state, [next, ((counter + 1) % limit) << 16 | start], 0, 1);
}</source>

=== Example ===
Once again we grant the gift of the alphabet upon avatars, this time using either of the above list-state implementations:

<source lang="lsl2">// Insert the mprui functions from either of the list-state options here

string myString = "abcdefghijklmnopqrstuvwxyz";
integer myStringLength;

list avatars = []; integer avatar_limit = 8; // Maximum number of avatars to keep track of (list is pruned from longest ago touch)

default {
state_entry() { llSetText("Touch me for a complimentary letter of the alphabet!", <1.0, 1.0, 1.0>, 1.0); }

touch_start(integer x) {
key id = llDetectedKey(0); list mprui_state;

integer index = llListFindList(avatars, [id]);
if (~index) {
mprui_state = mprui_next(llList2List(avatars, index + 1, index + 5));

// Remove our old state
avatars = llDeleteSubList(avatars, index, index + 5);
} else {
mprui_state = mprui_init(llStringLength(myString));

// Make room if the list is full
integer prune = (llGetListLength(avatars) + 1) - avatar_limit;
if (prune > 0) avatars = llDeleteSubList(avatars, 0, (prune * 6) - 1);
}

integer next = llList2Integer(mprui_state, 0);
llRegionSayTo(id, PUBLIC_CHANNEL, llGetSubString(myString, next, next));

// Add the new state to the end of the list
avatars += [id] + mprui_state;
}
}</source>

{{LSLC|Library}}

Pseudo-randomly Generate Unique Indices

2015-12-17T12:29:54Z

Haravikk Mistral: /* Example */

Pseudo-randomly Generate Unique Indices

2015-12-17T12:29:41Z

Haravikk Mistral: /* Single Integer */

Pseudo-randomly Generate Unique Indices

2015-12-17T12:05:17Z

Haravikk Mistral:

Pseudo-randomly Generate Unique Indices

2015-12-17T11:32:23Z

Haravikk Mistral: /* Pseudo-randomly Generate Unique Indices */

Offset Compression

2015-12-17T00:09:35Z

Haravikk Mistral:

{{LSL Header}}
= Offset Compression =
In scripts that involve object manipulation and/or offsets for animations it is common to end up storing a vector and rotation for every such interaction, which can be memory intensive if the object has a lot of values to store. However, such offsets typically don't need to be very precise as linked objects won't move far from their root prim, and small errors in the rotation shouldn't result in any major issues, so long as those rotations aren't used as a reference for future actions.

With this in mind, I've produced some functions that allow both a positional and rotational offset to be stored as a single vector value, effectively cutting memory requirements by more than half (especially when considering list overhead), though this comes at the cost of declaring the functions instead, so if only require these in a few places you may wish to consider inlining them instead.

== Functions ==
For simplicity, these functions handle rotations as Euler vectors, which can be converted using [[llRot2Euler]]() and [[llEuler2Rot]](), this is also a convenient format for devices where rotation offsets may be specified in the user-friendly format in degrees (to match the build tools), such as in parsed notecards. These should still be converted to rotations for transformations in order to avoid [http://en.wikipedia.org/wiki/Gimbal_Lock Gimbal Lock]. '''NOTE:''' the combinedOffset() function below expects euler rotations to contain no component that exceeds positive or negative PI (just as the build tools do not allow this); for convenience the clampEulerRot() function is provided below to ensure that an Euler rotation is safe to use, but if your script is not vulnerable to this (for example, if your Euler rotations are created with llRot2Euler) then this function may be omitted.

<source lang="lsl2">// Ensures that an euler rot is within the required range (no values exceed plus or minus PI)
vector clampEulerRot(vector eulerRot) {
@loopX1; @loopX2;
if (eulerRot.x > PI) { eulerRot.x -= TWO_PI; jump loopX1; }
else if (eulerRot.x < -PI) { eulerRot.x += TWO_PI; jump loopX2; }
@loopY1; @loopY2;
if (eulerRot.y > PI) { eulerRot.y -= TWO_PI; jump loopY1; }
else if (eulerRot.y < -PI) { eulerRot.y += TWO_PI; jump loopY2; }
@loopZ1; @loopZ2;
if (eulerRot.z > PI) { eulerRot.z -= TWO_PI; jump loopZ1; }
else if (eulerRot.z < -PI) { eulerRot.z += TWO_PI; jump loopZ2; }
return eulerRot;
}

// Creates a combined vector from a position and Euler rotation. The rotation *must* be within the required range (no values exceed plus or minus PI) or it will not be possible to restore the values correctly
vector combinedOffset(vector offsetPos, vector offsetEulerRot) {
return <
(float)((integer)(offsetPos.x * 1000.0) * 10) + ((float)(((offsetPos.x < 0) * -2) + 1) * (offsetEulerRot.x + 5.0)),
(float)((integer)(offsetPos.y * 1000.0) * 10) + ((float)(((offsetPos.y < 0) * -2) + 1) * (offsetEulerRot.y + 5.0)),
(float)((integer)(offsetPos.z * 1000.0) * 10) + ((float)(((offsetPos.z < 0) * -2) + 1) * (offsetEulerRot.z + 5.0))
>;
}

// Retrieve the positional part from the combined offset
vector offsetToPos(vector offset) {
return <
(float)((integer)(offset.x / 10.0)) / 1000.0,
(float)((integer)(offset.y / 10.0)) / 1000.0,
(float)((integer)(offset.z / 10.0)) / 1000.0
>;
}

// Retrieve the rotation part from the combined offset
vector offsetToEulerRot(vector offset) {
return <
(offset.x - ((integer)(offset.x / 10.0) * 10)) * (float)(((offset.x < 0) * -2) + 1) - 5.0,
(offset.y - ((integer)(offset.y / 10.0) * 10)) * (float)(((offset.y < 0) * -2) + 1) - 5.0,
(offset.z - ((integer)(offset.z / 10.0) * 10)) * (float)(((offset.z < 0) * -2) + 1) - 5.0
>;
}</source>

== Examples ==
=== Functions ===
The silly example below can be placed inside the root prim of a linked-set that you don't care much about (as it may be ruined). It will store the offsets of all prims and allow you to "crush" the object and then restore it by touching.

<source lang="lsl2">// Paste the above functions in here

list prim_offsets = []; integer crushed = FALSE;
default {
state_entry() {
integer prims = llGetNumberOfPrims();
if (prims < 2) { llOwnerSay("This object is not a linked set"); return; }

integer link;
for (link = LINK_ROOT + 1; link <= prims; ++link) {
list params = llGetLinkPrimitiveParams(link, [PRIM_POS_LOCAL, PRIM_ROT_LOCAL]);
prim_offsets += [combinedOffset(llList2Vector(params, 0), llRot2Euler(llList2Rot(params, 1)))];
}
llSetText("Touch to crush!", <1.0, 1.0, 1.0>, 1.0);
}

changed(integer changes) { if (changes & CHANGED_LINK) llOwnerSay("Object has changed, script should be reset"); }

touch_start(integer x) {
// If the object was crushed, restore it
if (crushed) {
integer x = prim_offsets != [];
while ((--x) >= 0) {
vector offset = llList2Vector(prim_offsets, x);
llSetLinkPrimitiveParamsFast(x + 2,
[PRIM_POS_LOCAL, offsetToPos(offset), PRIM_ROT_LOCAL, llEuler2Rot(offsetToEulerRot(offset))]
);
}
llSetText("Touch to crush!", <1.0, 1.0, 1.0>, 1.0);
crushed = FALSE;
} else {
integer x = prim_offsets != [];
while ((--x) >= 0) llSetLinkPrimitiveParamsFast(x + 2, [PRIM_POS_LOCAL, ZERO_VECTOR, PRIM_ROT_LOCAL, ZERO_ROTATION]);
llSetText("Ouch!", <1.0, 0.0, 0.0>, 1.0);
crushed = TRUE;
}
}
}</source>

=== Inline ===
This second example is an identical script, but instead of using the functions as-is it shows how they can be inlined. You may wish to do this in a script that only uses offset conversion in a few places, e.g- on load and on use, as this will eliminate the memory and performance costs of declaring and executing functions.

<source lang="lsl2">list prim_offsets = []; integer crushed = FALSE;
default {
state_entry() {
integer prims = llGetNumberOfPrims();
if (prims < 2) { llOwnerSay("This object is not a linked set"); return; }

integer link;
for (link = LINK_ROOT + 1; link <= prims; ++link) {
list params = llGetLinkPrimitiveParams(link, [PRIM_POS_LOCAL, PRIM_ROT_LOCAL]);
vector offsetPos = llList2Vector(params, 0);
vector offsetEulerRot = llList2Vector(params, 1);
prim_offsets += [< // Inline conversion to offset
(float)((integer)(offsetPos.x * 1000.0) * 10) + ((float)(((offsetPos.x < 0) * -2) + 1) * (offsetEulerRot.x + 5.0)),
(float)((integer)(offsetPos.y * 1000.0) * 10) + ((float)(((offsetPos.y < 0) * -2) + 1) * (offsetEulerRot.y + 5.0)),
(float)((integer)(offsetPos.z * 1000.0) * 10) + ((float)(((offsetPos.z < 0) * -2) + 1) * (offsetEulerRot.z + 5.0))
>];
}
llSetText("Touch to crush!", <1.0, 1.0, 1.0>, 1.0);
}

changed(integer changes) { if (changes & CHANGED_LINK) llOwnerSay("Object has changed, script should be reset"); }

touch_start(integer x) {
// If the object was crushed, restore it
if (crushed) {
integer x = prim_offsets != [];
while ((--x) >= 0) {
vector offset = llList2Vector(prim_offsets, x);
llSetLinkPrimitiveParamsFast(x + 2,
[
PRIM_POS_LOCAL, < // Inline conversion from offset
(float)((integer)(offset.x / 10.0)) / 1000.0,
(float)((integer)(offset.y / 10.0)) / 1000.0,
(float)((integer)(offset.z / 10.0)) / 1000.0
>,
PRIM_ROT_LOCAL, llEuler2Rot(< // Inline conversion from offset
(offset.x - ((integer)(offset.x / 10.0) * 10)) * (float)(((offset.x < 0) * -2) + 1) - 5.0,
(offset.y - ((integer)(offset.y / 10.0) * 10)) * (float)(((offset.y < 0) * -2) + 1) - 5.0,
(offset.z - ((integer)(offset.z / 10.0) * 10)) * (float)(((offset.z < 0) * -2) + 1) - 5.0
>)]
);
}
llSetText("Touch to crush!", <1.0, 1.0, 1.0>, 1.0);
crushed = FALSE;
} else {
integer x = prim_offsets != [];
while ((--x) >= 0) llSetLinkPrimitiveParamsFast(x + 2, [PRIM_POS_LOCAL, ZERO_VECTOR, PRIM_ROT_LOCAL, ZERO_ROTATION]);
llSetText("Ouch!", <1.0, 0.0, 0.0>, 1.0);
crushed = TRUE;
}
}
}</source>

{{LSLC|Compression}}
{{LSLC|Library}}

Pseudo-randomly Generate Unique Indices

2015-12-17T00:09:16Z

Haravikk Mistral:

User:Haravikk Mistral

2015-12-17T00:05:50Z

Haravikk Mistral: /* Useful Functions */

{{User:Haravikk_Mistral/Profile}}
= About =
== Real Life ==
Haravikk Mistral, or just Haravikk outside of [[Second Life]], is a Master of Engineering with Merit in Computer Science, and currently lives in central Scotland.
Interests are mostly computer-related, including a strong love for programming, as well as some experience in [[business]].
Programming knowledge includes:
* [http://en.wikipedia.org/wiki/C_(programming_language) C]/[http://en.wikipedia.org/wiki/C%2B%2B C++]
* [http://en.wikipedia.org/wiki/Objective-C Objective-C]/[http://en.wikipedia.org/wiki/Objective-C#Objective-C.2B.2B C++]
* [http://en.wikipedia.org/wiki/Java_(programming_language) Java]
* [[LSL]]
* [http://en.wikipedia.org/wiki/PHP PHP]

== Resident ==
Haravikk Mistral has been a Second Life [[Resident]] since 5th September 2005. Since joining Second Life Haravikk has been active in the [[Furry]] community, including popular places such as [http://furnation.com Furnation]. After quickly learning to build and script Haravikk began producing a number of popular scripted items, as well as open-source scripting projects.

Haravikk frequently is seen wearing a self-styled [http://wikipedia.org/Renamon Renamon]-based avatar, a character referred to as [http://renara.com Renara] due to the different markings and other customisations. As a result of adopting Renara as an avatar, Haravikk typically wears the female form of the avatar, but is in actuality male.

= Contributions =
Haravikk Mistral is an active [[community]] participant, and can be seen regularly posting in the [http://forums.secondlife.com Second Life.com Forums].

== JIRA Reporter ==
Haravikk Mistral is an active participant of the [[JIRA|Second Life JIRA]], posting feature requests/bugs and spending some time helping with misfiled/duplicated issues.
{{Jira Reporter}}

=== Key Issues ===
{{User:Haravikk_Mistral/JIRA/Issues/All}}

== Scripting ==
Haravikk Mistral specialises in scripting within the Second Life community, and is usually working on a number of scripting projects at any one time. Below are some useful code snippets or scripts that others may find useful in their own projects. Check back regularly as these are constantly being added to!

=== Useful Functions ===
* [[Key]]
** [[generateKey|Generate a Key]]
* [[List]]
** [[ListCompare|Compare two lists]]
** [[ListCast|Cast the contents of a list to one-type]]
** [[Pseudo-randomly Generate Unique Indices]]
* Miscellaneous
** [[isPointInPolygon2D|Point in Polygon]]

=== Useful Scripts ===
* [[:Category:LSL Compression|Compression]]
** [[Key Compression]]
** [[LZW Compression]]
** [[User:Haravikk_Mistral/Library/Offset_Compression|Offset Compression]]
* [[:Category:LSL Encryption|Cryptography]]
** [[AES Strong Encryption]]
** [[Vignére Weak Encryption]]
* [[:Category:LSL Parcel|Parcel]]
** [[Parcel Scanning]]
* Tools
** [[Pseudo Random Number Generator]]
** [[Scheduler]]
* Miscellaneous
** [[Lever Library]] (**IN DEVELOPMENT**)

{{skills
|Architect=*
|Builder=*
|Machinima=
|Roleplayer=*
|Scenographer=
|Scripter=*
|SLogistician=
|Terraformer=
|}}

User:Haravikk Mistral

2015-12-17T00:05:28Z

Haravikk Mistral: /* Useful Functions */

PseudoRandomUniqueIndices

2015-12-17T00:04:40Z

Haravikk Mistral: Haravikk Mistral moved page PseudoRandomUniqueIndices to Pseudo-randomly Generate Unique Indices

#REDIRECT [[Pseudo-randomly Generate Unique Indices]]

Pseudo-randomly Generate Unique Indices

2015-12-17T00:04:39Z

Haravikk Mistral: Haravikk Mistral moved page PseudoRandomUniqueIndices to Pseudo-randomly Generate Unique Indices

= Pseudo-randomly Generate Unique Indices =
Ordinarily when a collection of data needs to be retrieved in a random order, it can simply be reshuffled by randomly swapping elements and then iterating through the resulting, shuffled, collection. However there are cases where this is infeasible, especially in LSL, and as such the following functions can be used to generate indices in a pseudo-random way that should be "good enough" for many purposes.

<source lang="lsl2">integer _prui_counter = 1;
integer _prui_limit = 0;

integer _prui_start = 0;
integer _prui_stride = 0;
integer _prui_next = 0;

prui_init(integer limit) {
_prui_limit = limit;
_prui_start = (integer)llFrand((float)limit);
_prui_stride = (integer)llFrand((float)limit - 1.0) + 1;
_prui_next = _prui_start;
}

integer prui_next() {
if (!_prui_counter) prui_init(_prui_limit);

integer result = _prui_next;
_prui_next = (_prui_next + _prui_stride) % _prui_limit;
if (_prui_next == _prui_start) {
_prui_start = (_prui_start + 1) % _prui_limit;
_prui_next = _prui_start;
}
return result;
}</source>

== Examples ==
=== List ===
The following script will spit out a random entry from a list when touched. In this example the list contains letters of the alphabet and as such the first 26 touches will produce a unique letter, the following 26 touches will likewise produce no duplicates and so-on.

<source lang="lsl2">// Add the above prui variables and functions here

list myList = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"];
integer myListLength;

default {
state_entry() {
prui_init(myListLength = llGetListLength(myList));
llSetText("Touch me for a complimentary letter of the alphabet!", <1.0, 1.0, 1.0>, 1.0);
}

touch_start(integer x) { llRegionSayTo(llDetectedKey(0), PUBLIC_CHANNEL, llList2String(myList, prui_next())); }
}</source>

=== String ===
This is the same example rewritten to more efficiently use a string for storing the letters of the alphabet:

<source lang="lsl2">// Add the above prui variables and functions here

string myString = "abcdefghijklmnopqrstuvwxyz";
integer myStringLength;

default {
state_entry() {
prui_init(myStringLength = llStringLength(myString));
llSetText("Touch me for a complimentary letter of the alphabet!", <1.0, 1.0, 1.0>, 1.0);
}

touch_start(integer x) { llRegionSayTo(llDetectedKey(0), PUBLIC_CHANNEL, llGetSubString(myString, x = prui_next(), x)); }
}</source>

=== Notecard ===
Finally, this example performs the same incredible feat using lines in a notecard (one for each letter of the alphabet):

<source lang="lsl2">// Add the above prui variables and functions here

key myNotecard = "a62213ba-381d-2347-7f7b-818f15f12d83";
integer myNotecardLength = -1;
key talkTo = NULL_KEY;

default {
state_entry() { llGetNumberOfNotecardLines(myNotecard); }
dataserver(key id, string data) {
if (myNotecardLength > 0) llRegionSayTo(talkTo, PUBLIC_CHANNEL, data);
else prui_init(myNotecardLength = (integer)data);
}

touch_start(integer x) {
talkTo = llDetectedKey(0);
llGetNotecardLine(myNotecard, prui_next());
}
}</source>

Pseudo-randomly Generate Unique Indices

2015-12-17T00:04:05Z

Haravikk Mistral: Created page with "= Pseudo-randomly Generate Unique Indices = Ordinarily when a collection of data needs to be retrieved in a random order, it can simply be reshuffled by randomly swapping elem..."

Offset Compression

2015-12-16T18:09:20Z

Haravikk Mistral: /* Functions */