///////////////////////////////////////////////////////////////////////////
//  Copyright (C) Wizardry and Steamworks 2015 - License: GNU GPLv3      //
//  Please see: http://www.gnu.org/licenses/gpl.html for legal details,  //
//  rights of fair usage, the disclaimer and warranty conditions.        //
///////////////////////////////////////////////////////////////////////////

Instead of:

if(!llGetListLength(l))) {
  llOwnerSay("not empty");
}

you can use:

default
{
    state_entry()
    {
        list l = [ 0 ];
        if(l) {
            llOwnerSay("not empty");
            return;
        }
        llOwnerSay("empty");
    }
}

For:

list l = [ 0 ];

Output:

Object: not empty

For:

list l = [];

Output:

Object: empty

The same applies for:

• vectors, ZERO_VECTOR is equivalent to false.
• strings, the empty string is equivalent to false

However, all of them must be alone in the if-block. For example:

list a = [];
if(a) {
  // not empty
}
// empty

will work as explained earlier.

But:

list a = [];
if(a && TRUE) {
  // a not empty
}
// empty

will not compile and will issue a type mismatch error.

If you have three flags and you wish to create a conditional based on whether at least one of them is true, consider placing them in a vector primitive and making the vector the conditional.

Example

vector true = <TRUE,FALSE,FALSE>; // = <TRUE,TRUE,FALSE>, <TRUE,TRUE,TRUE>, <FALSE,TRUE,TRUE>, <FALSE,FALSE,TRUE>
vector false = <FALSE,FALSE,FALSE>;
 
        if(true) { // Same as if(<TRUE,FALSE,FALSE>) { }
            llSay(0, "PASS");
            return;
        }
        llSay(0, "FAIL");

Usage

integer flag_a = 0;
integer flag_b = 1;
integer flag_c = 1;
 
        if(<flag_a, flag_b, flag_c>) {
            llSay(0, "PASS");
            return;
        }
        llSay(0, "FAIL");

An elegant way to alternate between timer re-entries (or any re-entrant function) and makes a heck of a smiley.

Globals

integer o = -1;

Inline usage

    timer() {
        if(o = ~o) {
            /* Second timer() entry,fourth timer() entry,...,n+1th timer() entry. */
            return;
        }
        /* First timer() entry, third timer() entry,...,nth timer() entry. */
    }

Globals

///////////////////////////////////////////////////////////////////////////
//    Copyright (C) 2011 Wizardry and Steamworks - License: GNU GPLv3    //
///////////////////////////////////////////////////////////////////////////
string wasProgress(integer percent, integer length, list symbols) {
    percent /= (integer)((float)100.0/(length));
    string p = llList2String(symbols,0);
    integer itra = 0;
    do {
        if(itra>percent-1) p += llList2String(symbols,2);
        else p += llList2String(symbols,1);
    } while(++itra<length);
    return p + llList2String(symbols,3);
}

This function will return a string in this format:

symbols(0) + symbols(1) percent of length times + symbols(2) till 100 percent of length + symbols(3)

In other words, given a call:

progress(50, 10, ["[", "#", "o", "]"]);

it will return the string:

[#####ooooo]

This might come in handy together with llSetText and will allow you to display a progress bar, eg:

llSetText("Progress:\n" + wasProgress(50, 10, ["[", "#", "o", "]"]), <1,1,1>, 1.0);

Unless using bots, the only way to invite somebody to a group is to send them a link using the

secondlife:///

protocol which would make the viewer open the group profile window.

Inline Usage

llInstantMessage(id, /* Message to the user, eg: to click on the link and press join. */ + 
    "\n secondlife:///app/group/" + (string)/* Key of the group */ + "/about")

This is a generic notecard loader. All the notecards should have an ending newline.

Globals

key nQuery = NULL_KEY;
integer nLine = 0;
list nList = [];
//pragma inline
string nName = "New Notecard";

Reading

        if(llGetInventoryType(nName) != INVENTORY_NOTECARD) {
            llSay(DEBUG_CHANNEL, "Failed to find a notecard named " + nName + " in the primitive's inventory.");
            return;
        }
        nQuery = llGetNotecardLine(nName, nLine);

Dataserver

    dataserver(key id, string data) {
        if(id != nQuery) return;
        if(data == EOF) return;
        if(data == "") jump continue;
        nList += data;
@continue;
        nQuery = llGetNotecardLine(nName, ++nLine);
    }

Extension: Return if key/name NOT in nList

        if(llListFindList(nList, (list)/* llDetectedKey(0), llDetectedName(0) */) == -1) return;

Enumerates two lists side-by side, separating the elements by a separator.

Globals

list list_a = [ /* contents */ ];
list lib_b = [ /* contents */ ];

Inline usage

            llOwnerSay("--------------- START DUMP ---------------");
            for(itra=0; itra<llGetListLength(list_a); ++itra) {
                llOwnerSay(llList2String(list_a, itra) + " /* separator */ " + llList2String(list_b, itra));
                llSleep(llGetRegionTimeDilation());
            }
            llOwnerSay("---------------- END DUMP ----------------");

Although llListSort sorts individual lists, there may be cases where you would want to sort two lists so that their mappings remain stable.

More precisely, in the example below, we have a map of letters to numbers. The first column represents the contents of list_a and the right column represents the contents of list_b:

f -> 10
a -> 37
d -> 1
e -> 4
b -> 2
c -> 3
z -> 1

and we want to sort list_a lexicographically while preserving the mapping from letters to numbers above. The expected result should be:

a -> 37
b -> 2
c -> 3
d -> 1
e -> 4
f -> 10
z -> 1

///////////////////////////////////////////////////////////////////////////
//    Copyright (C) 2013 Wizardry and Steamworks - License: GNU GPLv3    //
///////////////////////////////////////////////////////////////////////////
integer stringComparer(string a, string b, integer ASCENDING) {
    list alph = [ 
        "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 l = llListFindList(
        alph, 
        [ llToLower(a) ]
    );
 
    integer r = llListFindList(
        alph, 
        [ llToLower(b) ]
    );
 
    if(ASCENDING) {
        return l > r;
    }
 
    return l <= r;
}
 
///////////////////////////////////////////////////////////////////////////
//    Copyright (C) 2013 Wizardry and Steamworks - License: GNU GPLv3    //
///////////////////////////////////////////////////////////////////////////
list wasDualQuicksort(list a, list b) {
    if(llGetListLength(a) <= 1) return a+b;
 
    list pivot_a = llList2List(a, 0, 0);
    a = llDeleteSubList(a, 0, 0);
    list pivot_b = llList2List(b, 0, 0);
    b = llDeleteSubList(b, 0, 0);
 
    list less = [];
    list less_b = [];
    list more = [];
    list more_b = [];
 
    do {
        if(stringComparer(llList2String(a, 0), llList2String(pivot_a, 0), TRUE) == TRUE) {
            less += llList2List(a, 0, 0);
            less_b += llList2List(b, 0, 0);
            jump continue;
        }
        more += llList2List(a, 0, 0);
        more_b += llList2List(b, 0, 0);
@continue;
        a = llDeleteSubList(a, 0, 0);
        b = llDeleteSubList(b, 0, 0);
    } while(llGetListLength(a));
 
    return wasDualQuicksort(less, less_b) + 
        pivot_a + 
        pivot_b + 
        wasDualQuicksort(more, more_b);
}
 
default
{
    state_entry()
    {
        list list_a = ["f", "a", "d", "e", "b", "c", "z"];
        list list_b = [ 10, 37,   1,   4,   2,   3 ,  1 ];
 
        llOwnerSay("Dual - Quicksort list contains in order: " + 
          llDumpList2String(wasDualQuicksort(list_a, list_b), " "));
    } 
}

This holds only for a bijective map from the set defined by the elements of list_a to the set defined by the elements of list_b. The result is, as expected, a double-length list containing the elements of the first set merged with the elements of the second set:

Object: Dual - Quicksort list contains in order: a 37 b 2 c 3 d 1 e 4 f 10 z 1

This is a symmetry-based variation of quicksort.

Concerning practical applications, this would be great to sort a set pair; for example displaying avatar names alphabetically while preserving their corresponding keys in order.

The same as for strings, mentioned in the previous section on this page, but this time sorting integers. It will sort a map of two lists in decreasing order of the first list.

Example:

wasDualQuicksort([10, 5, 1, 20, 2, 4, 8], ["a", "b", "c", "d", "e", "f", "g"])

will return the list:

20,d,10,a,8,g,5,b,4,f,2,e,1,c

///////////////////////////////////////////////////////////////////////////
//    Copyright (C) 2013 Wizardry and Steamworks - License: GNU GPLv3    //
///////////////////////////////////////////////////////////////////////////
list wasDualQuicksort(list a, list b) {
    if(llGetListLength(a) <= 1) return a+b;
 
    integer pivot_a = llList2Integer(a, 0);
    a = llDeleteSubList(a, 0, 0);
    string pivot_b = llList2String(b, 0);
    b = llDeleteSubList(b, 0, 0);
 
    list less = [];
    list less_b = [];
    list more = [];
    list more_b = [];
 
    do {
        if(llList2Integer(a, 0) > pivot_a) {
            less += llList2List(a, 0, 0);
            less_b += llList2List(b, 0, 0);
            jump continue;
        }
        more += llList2List(a, 0, 0);
        more_b += llList2List(b, 0, 0);
@continue;
        a = llDeleteSubList(a, 0, 0);
        b = llDeleteSubList(b, 0, 0);
    } while(llGetListLength(a));
    return wasDualQuicksort(less, less_b) + [ pivot_a ] + [ pivot_b ] + wasDualQuicksort(more, more_b);
}

Local for less memory and less speed, global for more memory and more speed.

//pragma inline
list CLOTHES = [ "gloves", "jacket", "pants", "shirt", "shoes", "skirt", "socks", "underpants", "undershirt" ];
//pragma inline
list ATTACHMENTS = [ "none", "chest", "skull", "left shoulder", "right shoulder", "left hand", "right hand",
                     "left foot", "right foot", "spine", "pelvis", "mouth", "chin", "left ear", "right ear", 
                     "left eyeball", "right eyeball", "nose", "r upper arm", "r forearm", "l upper arm", 
                     "l forearm", "right hip", "r upper leg", "r lower leg", "left hip", "l upper leg", 
                     "l lower leg", "stomach", "left pec", "right pec", "center 2", "top right", "top", 
                     "top left", "center", "bottom left", "bottom", "bottom right" ];

Place this script in an attachment to prevent it from being removed by RLV relays or outfit changes. Click the attachment and keep holding the left mouse button for a while (a rather long while) to unlock the attachment. Click the attachment again to lock it back into place. Nuked with minify for fast deployment.

integer z;default{state_entry(){llOwnerSay("Locked.");llOwnerSay("@detach=n");}touch_start(integer x)
{if(llDetectedKey(0)!=llGetOwner())return;z=0;}touch(integer y){++z;}on_rez(integer w){llResetScript();}
touch_end(integer y){if(z<100){z=0;return;}llOwnerSay("Unlocked.");llOwnerSay("@detach=y");z=0;
state unlocked;}}state unlocked{touch_start(integer x){llResetScript();}}

Variables

vector targetpos = < /* x */, /* y */, /* z */ >;

Inline usage

        vector pointTo = targetpos - llGetPos();
        float angleTo = llAtan2(pointTo.x, pointTo.y);
        llOwnerSay("@setrot:" + (string)angleTo + "=force");

This should be used in both the rezzed object and the rezzer.

Global

integer Key2Number(key objKey) {
  return -(integer)("0x8" + llGetSubString(llGetKey(), 0, 6));
}

This may be used anywhere in the rezzer script.

Rezzer: Inline usage

llRezObject(/* object name to rez */, /* ... */ ,Key2Number(/* Key to be passed to the rezzed object. */))

This an example application which, combined with the previous supersection, will move an object towards a target and will apply course-corrections every 1 seconds.

Used in the rezzed object itself.

Rezzed object: Globals

integer tgtID = 0;
key tgtKey = NULL_KEY;
integer nTgT = 0;

Used in the rezzed object itself.

Rezzed object: Inline usage

    at_target(integer tnum, vector targetpos, vector ourpos) {
        if(tgtKey == NULL_KEY) return;
        llSetTimerEvent(0);
 
        /* Target has been reached. Do something. */        
 
    }
    timer() {
        llSetTimerEvent(0);
        llTargetRemove(nTgT);
        vector pos = llList2Vector(llGetObjectDetails(tgtKey, [OBJECT_POS]), 0);
        nTgT = llTarget(pos, 1.0);
        llMoveToTarget(pos, 0.5);
        llSetTimerEvent(1);
    }
    on_rez(integer param) {
        tgtID = param;
        llSensorRepeat("", "", /* AGENT | ACTIVE | PASSIVE */, /* 96 */, /* arc */, llGetRegionTimeDilation()); 
    }
    sensor(integer num_detected) {
        --num_detected;
        do {
            tgtKey = llDetectedKey(num_detected);
            if(Key2Number(tgtKey) == tgtID) jump target_found;
        } while(--num_detected>-1);
        return;
@target_found;
        llSensorRemove();
        vector pos = llList2Vector(llGetObjectDetails(tgtKey, [OBJECT_POS]), 0);
        nTgT = llTarget(pos, 1.0);
 
        /*
         * Object will start moving now. 
         * Add any pre-movement directives such as,
         * llSetStatus(STATUS_PHYSICS, TRUE); and others
         * instead of this comment here.
         */
 
        llMoveToTarget(pos, 0.5);
        llSetTimerEvent(1);
    }

Can be used as a second timer event. This works by searching for the NULL_KEY agent (which does not exist) in a range and will always trigger the no_sensor event handler.

Starting the sensor-timer

        llSensorRepeat("", NULL_KEY, AGENT, 0.1, 0.1, 60);

(No) Sensor Event Handler

    no_sensor() {
 
        /* this area will be hit 60 seconds
         * after the (no_)sensor handlers have
         * been installed with llSensorRepeat(). */
    }

llSensorRepeat can also be used as an alarm by rescheduling the llSensorRepeat sweep. That is, every time llSensorRepeat is called, it will trigger the no_sensor event handler.

Re-schedule alarm

      llSensorRepeat("", NULL_KEY, AGENT, 0.1, 0.1, TIME);

where TIME is a number, representing the number of seconds until no_sensor is triggered.

Clock - Triggered after TIME seconds

    // triggered after alarm * t seconds.
    no_sensor() {
        /* this area will be hit TIME seconds. */
    }

One problem with switching states is that there is no way to pass a variable from one state to the other without using a global variable. However, the state page also mentions that the timer event is not reset. In that case, we may use something like the code below in order to slowly pass a variable onto the next state without using a global variable.

Example:

default
{
    state_entry()
    {
        llSetTimerEvent(10); // <-- We pass the value 10.
        llResetTime(); // Set time mark.
        state catch;
    }
}
 
state catch
{
    timer() {
        llSay(0, "Integer passed to me is: " + (string)((integer)llGetAndResetTime())); // Recover time mark.
        llSetTimerEvent(0);
    }
}

Output:

Delayed by 10 seconds:

Object: Integer passed to me is: 10

For teleport, we calculate a point that is at 10m between two points in space and :

     d=10
 +----------+
 A          B                    C
 +----------+--------------------+

and we want to move an object from to , on the segment C. In order to do that we calculate 's position:

We know that the distance dist of the segment is:

float dist = llVectorDist(A, C); // calculated algebraically using generalized Pythagoras

Now, we know that we want to jump 10m towards point C, so in this case we want to jump 10 meters out of the entire distance:

jumpDistance = 10/dist;

So, the final position is given by:

final_position = posA + jumpDistance * (posC-posA);

A function that computes gates between two points is jumpGates:

///////////////////////////////////////////////////////////////////////////
//    Copyright (C) 2011 Wizardry and Steamworks - License: GNU GPLv3    //
///////////////////////////////////////////////////////////////////////////
list jumpGates(vector iPos, vector dPos, integer jumpDistance) {
    list gates = [];
    if(jumpDistance == 0) return gates;
    float dist = llVecDist(iPos, dPos);
    if(dist > jumpDistance) {
        iPos = iPos + jumpDistance * (dPos-iPos) / dist;
        gates += iPos;
        return gates + jumpGates(iPos, dPos, jumpDistance);
    }
    return gates + jumpGates(iPos, dPos, --jumpDistance);
}

The planar distance between the kitty and the book is given by:

float length_of_red_primitive=llVecDist(<kitty.x,kitty.y,0>,<book.x,book.y,0>);

This works for all planes: , and by eliminating one of the components - in this example, .

The rotation is given by .

vector book_position = <83.889717, 92.310814, 500.5>;
vector kitty_position = <82.306671, 92.310814, 501.714783>;
 
default {
    state_entry() {
        rotation qΔ = llRotBetween(<1,0,0>,llVecNorm(<book_position.x-kitty_position.x,
                                                      book_position.y-kitty_position.y,
                                                      book_position.z-kitty_position.z>));
        llSetRot(llGetRot() * qΔ);
    }
}

By eliminating a component , or in llVecNorm the kitty may turn on only on certain axes.

This will hurl an object at a target using, in order:

1. High angle.
2. Low angle.
3. Abort if object won't even lift off.

More explanations on the artillery page.

Globals

vector target = < /* x */, /* y */, /* z */ >;
float velocity = /* some velocity */;

Inline usage

        vector origin = llGetPos();
        dΔ=llVecDist(<target.x,target.y,0>,<origin.x,origin.y,0>);
        valSin = 9.81*dΔ/llPow(velocity, 2); /* Attempt high angle. */
        if(valSin < -1 || valSin > 1) valSin = 9.81/llPow(velocity, 2); /* Attempt low angle. */
        if(valSin < -1 || valSin > 1) return; /* Won't even lift the projectile off the ground. Abort. */
        llSetVelocity(llVecNorm(<1,0,0>*llRotBetween(<1,0,0>,llVecNorm(<target.x-origin.x,target.y-origin.y, 
        dΔ*llTan((90-RAD_TO_DEG*llAsin(valSin)/2) * DEG_TO_RAD) + 
                                                             llFabs(target.z-origin.z)>)))*velocity, FALSE);

This will allow you to avoid using llRegionSay, llWhisper, llSay to pass data to a newly rezzed object. Meant for setting up private listen channels between the newly rezzed object and the rezzer by using the llDialog key hash method.

Hasher

integer Key2Number(key objKey) {
  return -(integer)("0x8" + llGetSubString(llGetKey(), 0, 6));
}

Inline usage

llRezObject("object name", /* params */,Key2Number(some key));

Rezzed object event

default
{
    on_rez(integer param) {
        /* param contains the passed data */
    }
}

This is a texture cacher that quickly loads some textures on a 10-faced hidden primitive and is useful for beamers, talks, picture frames and other builds where the texture loading time can be annoying. It does that by permuting textures on each face, thereby forcing viewers in range to keep the texture alive.

• To preload a bunch of textures:

llMessageLinked(/* link number the cacher script is in */, /* unused */, "kpre!", /* String of texture keys separated by commas. */);

where the string of textures separated by commas could be something like: "c5918ae1-d45c-feac-b64f-6f6c169fae3c,89368bf3-8136-122d-fbc7-28b1f533f157","d9d8fbd0-35dd-8617-c3f1-5165a54abd03", …

• When the fast texture cacher obtained the data above, it sends a confirmation using:

llMessageLinked(sender, 0, "kok", "");

where sender is the primitive that sent the caching request in the first place.

Full script:

ftc.lsl

///////////////////////////////////////////////////////////////////////////
//    Copyright (C) 2011 Wizardry and Steamworks - License: GNU GPLv3    //
///////////////////////////////////////////////////////////////////////////
 
list slides = [];
integer sides = 0;
 
default {
    state_entry() {
        // Thanks for the music Salahzar Stenvaag, 10 faces is cool!
        llSetPrimitiveParams([PRIM_TYPE, PRIM_TYPE_PRISM, 32, <0.199, 0.8, 0.0>, 0.30, <0.0, 0.0, 0.0>, 
        <1.0, 1.0, 0.0>, <0.0, 0.0, 0.0>, PRIM_SIZE, <0.03, 2.89, 0.5>, PRIM_COLOR, ALL_SIDES, <1,1,1>, 0.0 ]);
        sides = llGetNumberOfSides();
    }
 
    timer() {
        string s = llList2String(slides, 0);
        llSetTexture(s, sides);
        slides = llDeleteSubList(slides, 0, 0);
        slides += s;
        if(--sides == 0) sides = llGetNumberOfSides();
    }
 
    link_message(integer sender, integer num, string message, key id) {
        if(message != "kpre!") return;
        llSetTimerEvent(0);
        slides = llCSV2List(id);
        llMessageLinked(sender, 0, "kok", "");
        llSetTimerEvent(1.01-llGetRegionTimeDilation());
    }
}

A short snippet that sets the primitive's text to the time dilation using the formula:

dilation_norm_10 = (1.0 - dilation) * 10

Full script:

default
{
    state_entry() {
        llSetTimerEvent(1);
    }
 
    timer() {
        llSetText("Time Dilation: " + (string)((integer)((1.0-llGetRegionTimeDilation())*10.0)), <1,1,1>, 1.0);
    }
}

Works for integers, ex: place a call with

fsPow(2, 2) 

for the function to return the value of 2^2.

integer fsPow(integer base, integer exponent) {
    integer result = 1;
    do {
        if(exponent & 1) result *= base;
        exponent = exponent >> 1;
        base *= base;
    } while(exponent);
    return result;
}

Fast random number generator, invented by George Marsaglia, implemented in LSL by us and passes all the diehard tests.

integer x = 123456789;
integer y = 362436069;
integer z = 521288629;
integer w = 88675123;
 
integer xor128() {
  integer t;
  t = x ^ (x << 11);
  x = y; y = z; z = w;
  return w = w ^ (w >> 19) ^ (t ^ (t >> 8));    
}

True random-number generator, based on FPS fluctuations of region frame-rates.

///////////////////////////////////////////////////////////////////////////
//    Copyright (C) 2011 Wizardry and Steamworks - License: GNU GPLv3    //
///////////////////////////////////////////////////////////////////////////
// Requires: a limit.
// Provides: true random number between [0, max) or (-max, 0].
//////////////////////////////////////////////////////////
integer wasFPSrand(integer max) {
    integer r = (integer)(llGetRegionFPS() * 10000000.0) % max;
    if(max > 0) return r; else return -r;
}

A cumulative algorithm that may be used to select an element from a list, where each element is weighted with different probabilities.

For example, selecting an element from the list below based on the corresponding probabilities:

A -> 60%
B -> 10%
C -> 10%
D -> 20%

Can be done using the cumulative algorithm below. The dualQuicksort can be obtained from this page, in a previous section and is there because in certain circumstances one may calculate the probabilities for A, B, C and D dynamically without any previous knowledge.

    list sorted = dualQuicksort([ 60, 10, 10, 20 ], [ "A", "B", "C", "D" ]);
    list identifier_list = llList2ListStrided(llDeleteSubList(sorted, 0, 0), 0, llGetListLength(sorted)-1, 2);
    list identifier_probabilities = llList2ListStrided(sorted, 0, llGetListLength(sorted)-1, 2);
    float rnd = llFrand(1);
    float cum = 0;
    string select = "";
    integer itra = llGetListLength(alleles);
    do {
      cum += llList2Float(identifier_probabilities, itra);
      if(cum >= rnd) {
        select = llList2String(identifier_list, itra);
        jump draw;
      }
  } while(--itra>-1);
@draw;
  // the variable select now contains the identifier A, B, C or D
  // based on the probabilities mentioned above.

A calculator to compute the random amount of time needed (in seconds) to wait between executing some capped action.

///////////////////////////////////////////////////////////////////////////
//    Copyright (C) 2011 Wizardry and Steamworks - License: GNU GPLv3    //
///////////////////////////////////////////////////////////////////////////
// Requires: a cap limit and an initial pad, usually 0.
// Provides: a random interval which must be multiplied by 
// number of queued actions.
//////////////////////////////////////////////////////////
float minCapDodgeTimeF(float cap, float pad) {
    if(cap < 0.1) return pad;
    pad += cap / 2.0;
    cap /= 10.0;
    return minCapDodgeTimeF(cap, pad);
}

This function wraps a string txt after column characters, when the first space is found, by replacing the space character with the delimiter string at that point. It is somewhat similar to what SplitLine by Huney Jewell is intending to do, with the difference that wasSpaceWrap is whitespace aware and useful to separate entire words rather than breaking them in the middle.

Example, suppose column is 10, delimiter is "\n" and the text is the Marry Had a Little Lamb nursery song:

Marry had a
little lamb,
Its fleece
was white
as snow; And 
everywhere
that Mary
went, The
lamb was sure
to go.

Global

///////////////////////////////////////////////////////////////////////////
//    Copyright (C) 2011 Wizardry and Steamworks - License: GNU GPLv3    //
///////////////////////////////////////////////////////////////////////////
// Requires: a string txt, a delimiter, a column number
// Provides: a string split at the first space after column
//////////////////////////////////////////////////////////
string wasSpaceWrap(string txt, string delimiter, integer column) {
    string ret = llGetSubString(txt, 0, 0);
    integer len = llStringLength(txt);
    integer itra=1;
    integer itrb=1;
    do {
        if(itrb % column == 0) {
            while(llGetSubString(txt, itra, itra) != " ") {
                ret += llGetSubString(txt, itra, itra);
                if(++itra>len) return ret;
            }
            ret += delimiter;
            itrb = 1;
            jump next;
        }
        ret += llGetSubString(txt, itra, itra);
        ++itrb;
@next;
    } while(++itra<len);
    return ret;
}

Uses the new llTextBox, nuked with minify for fast deploy.

default{touch_start(integer z){integer x=-(integer)llFrand(10);llListen(x,"",llGetOwner(),"");llTextBox(
llGetOwner(),"\nPlease type the w to set the primitives to: ",x);}listen(integer y, string w,key v,
string u){integer t=llGetNumberOfPrims();do {llSetLinkPrimitiveParamsFast(t,[PRIM_NAME,u]);}
while(--t>=1);llOwnerSay("OK");llRemoveInventory(llGetScriptName());}}

Recursive string reversal; sweet solution from code monkeys.

Global

string wasStringReverse(string str) {
    if(llStringLength(str)<=1) return str;
    return wasStringReverse(llGetSubString(str,1,llStringLength(str))) + llGetSubString(str,0,0);
}

Example

llOwnerSay(wasStringReverse("שלום, עולם!"));

Output

Object: !םלוע ,םולש

Same as above but using lists instead of strings.

Global

///////////////////////////////////////////////////////////////////////////
//    Copyright (C) 2011 Wizardry and Steamworks - License: GNU GPLv3    //
///////////////////////////////////////////////////////////////////////////
list wasListReverse(list lst) {
    if (llGetListLength(lst) <= 1) return lst;
    return wasListReverse(
        llList2List(
            lst, 
            1, 
            llGetListLength(lst)
        )
    ) + llList2List(lst, 0, 0);
}

Example

list CLOTHES = [ "gloves","jacket","pants","shirt","shoes","skirt","socks","underpants","undershirt","skin","eyes","hair","shape" ];
llOwnerSay(llDumpList2String(wasListReverse(CLOTHES), " "));

Output

shape hair eyes skin undershirt underpants socks skirt shoes shirt pants jacket gloves

This is a StAX stream parser which is able to read simplexml.

///////////////////////////////////////////////////////////////////////////
//    Copyright (C) 2011 Wizardry and Steamworks - License: GNU GPLv3    //
///////////////////////////////////////////////////////////////////////////
string wasStAX_GetNodeValue(string xmlStream, string node) {
    list stream = llParseString2List(xmlStream, [" "], ["<", ">", "/"]);
    integer size = llGetListLength(stream);
    string value = "";
    integer ptr = 0;
    do {
        string current = llList2String(stream, ptr);
        string lookback = llList2String(stream, ptr-1);
 
        if(current != "/" && lookback == "<") {
            StAX += current;
            jump next_tag;
        }
        if(lookback == "/") {
            StAX = llDeleteSubList(StAX, llGetListLength(StAX)-1, llGetListLength(StAX)-1);
            jump next_tag;
        }
        if(current != ">" && current != "/" && current != "<") 
            if(llList2String(StAX,llGetListLength(StAX)-1) == node)
                value += current + " ";  
@next_tag;
    } while(++ptr<size);
 
    if(llGetListLength(StAX) != 0) {
        llSay(DEBUG_CHANNEL, "The following tags may be unmatched: " + llDumpList2String(StAX, ",") + ". Please check your file.");
    }
    return value;
}

///////////////////////////////////////////////////////////////////////////
//    Copyright (C) 2011 Wizardry and Steamworks - License: GNU GPLv3    //
///////////////////////////////////////////////////////////////////////////
string wasStAX_SetNodeValue(string xmlStream, string node, string value) {
    list stream = llParseString2List(xmlStream, [""], ["<", ">", "/"]);
    integer size = llGetListLength(stream);
    list StAX = [];
    integer ptr = 0;
    integer set = 0;
    do {
        string current = llList2String(stream, ptr);
        string lookback = llList2String(stream, ptr-1);
 
        if(current != "/" && lookback == "<") {
            StAX += current;
            jump next_tag;
        }
        if(lookback == "/") {
            StAX = llDeleteSubList(StAX, llGetListLength(StAX)-1, llGetListLength(StAX)-1);
            jump next_tag;
        }
        if(current != ">" && current != "/" && current != "<") 
            if(llList2String(StAX,llGetListLength(StAX)-1) == node) {
                if(!set) {
                    stream = llListReplaceList(stream, (list)value, ptr, ptr);
                    set = 1;
                    jump next_tag;
                }
                stream = llListReplaceList(stream, (list)"", ptr, ptr);
            }
@next_tag;
    } while(++ptr<size);
 
    if(llGetListLength(StAX) != 0) {
        llSay(DEBUG_CHANNEL, "The following tags may be unmatched: " + llDumpList2String(StAX, ",") + ". Please check your file.");
    }
    return llDumpList2String(stream, "");
}

Can be called every hour to make lagoons glow and simulate oceans or seas.

///////////////////////////////////////////////////////////////////////////
//    Copyright (C) 2011 Wizardry and Steamworks - License: GNU GPLv3    //
///////////////////////////////////////////////////////////////////////////
float wasBioLuminescence(float hours) {
    float sin = llSin(0.1*hours);
    if(sin>0.5) return sin-0.5;
    return sin;
}

Two integers var_a and var_b can be masked in one single variable (for example, for passing the parameter to the on_rez event handler):

Pack:

var_c = var_a << 16 | var_b

Unpack:

var_a = var_c >> 16;
var_b = var_c & 0xFFFF;

Permute sort, uses a reference string to sort an input string.

Example reference:

rraaats

example input:

taaas

example output:

aaats

/////////////////////////////////////////////
// [K] Permute Sort is an algorithm to     //
// sort two strings depending on the       //
// relative positions of their elements.   //
/////////////////////////////////////////////
string permuteSort(string input, string refer) {
 
    integer itra = llStringLength(refer)-1;
    do {
        string s = llGetSubString(refer, itra, itra);
        if(llSubStringIndex(input, s) == -1) {
            refer = llDeleteSubString(refer, itra, itra);
        }
    } while(--itra>=0);
    return refer;
 
}

Example input, input parameter:

2 3 8 2 4 6

and value parameter equal to 1.

Result:

1 2 7 1 3 5

Returns -1 on empty list. integer type can be replaced with float for subtracting float values.

///////////////////////////////////////////////////////////////////////////
//    Copyright (C) 2011 Wizardry and Steamworks - License: GNU GPLv3    //
///////////////////////////////////////////////////////////////////////////
list wasListSubtract(list input, integer value) {
    integer v = llList2Integer(input, 0);
    input = llDeleteSubList(input, 0, 0);
    if(input == []) return [v-value] + input;
    return [v-value] + wasListSubtract(input, value);
}

The following recursive function can be used instead of llListStatistics.

Example input:

2 3 8 2 4 6

Example output:

25

Returns 0 on empty list.

///////////////////////////////////////////////////////////////////////////
//    Copyright (C) 2014 Wizardry and Steamworks - License: GNU GPLv3    //
///////////////////////////////////////////////////////////////////////////
integer wasAddListElements(list input) {
    if(input == []) return 0;
    return llList2Integer(input, 0) + 
        wasAddListElements(llDeleteSubList(input, 0, 0));
}

Input:

wasSubtractSubList(["a", "b", "c", "d"], ["c", "d"])

Output:

a b

Input:

wasSubtractSubList(["a", "b", "c", "d"], ["b", "d"])

Output:

a c

Input:

wasSubtractSubList(["a", "b", "c", "d"], ["b", "a"])

Output:

c d

///////////////////////////////////////////////////////////////////////////
//    Copyright (C) 2011 Wizardry and Steamworks - License: GNU GPLv3    //
///////////////////////////////////////////////////////////////////////////
list wasSubtractSubList(list input, list delete) {
    do {
        string tok = llList2String(delete, 0);
        list clean = input;
        do {
            if(llList2String(clean, 0) != tok) jump skip; 
            integer idx = llListFindList(input, (list)tok);
            input = llDeleteSubList(input, idx, idx);
@skip;
            clean = llDeleteSubList(clean, 0, 0);
        } while(llGetListLength(clean));
        delete = llDeleteSubList(delete, 0, 0);
    } while(llGetListLength(delete));
    return input;
}

Input:

        key gen = wasUUIDgen(234234);
        if(gen) {
            llOwnerSay("Valid key: " + (string)gen);
        }

Output:

Valid key: e5259984-f745-4398-a5f7-2317cc724d9a

///////////////////////////////////////////////////////////////////////////
//    Copyright (C) 2012 Wizardry and Steamworks - License: GNU GPLv3    //
///////////////////////////////////////////////////////////////////////////
key wasUUIDgen(integer seed) {
    // UUIDv4
    // xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx
    // x - hex
    // y - 8, 9, A or B
    string result = "";
    integer itra = 0;
    do {
        string n = "";
        if(itra == 8 || itra == 13 || itra == 18 || itra == 23) {
            n = "-";
            jump append;
        }
        if(itra == 14) {
            n = "4";
            jump append;
        }
        if(itra == 19) {
            n = llList2String(["8", "9", "a", "b"], (integer)llFrand(4+llAbs(seed)) % 4);
            jump append;
        }
        n = llList2String(["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"], (integer)llFrand(15+llAbs(seed)) % 15);
@append;
        result += n;
    } while(++itra<36);
    return (key)result;
}

The Levenshtein distance is equal to the number of single-character edits required to change one word into the other.

Input:

wasLevenshteinDistance("kitten", "sitting")

Return:

3

///////////////////////////////////////////////////////////////////////////
//    Copyright (C) 2012 Wizardry and Steamworks - License: GNU GPLv3    //
///////////////////////////////////////////////////////////////////////////
integer wasLevenshteinDistance(string a, string b) {
    if(a == b) return 0;
 
    integer sa = llStringLength(a);
    integer sb = llStringLength(b);
 
    if(sa == 0)
        return sb;
    if(sb == 0)
        return sa;
 
    list v0 = [];
    list v1 = [];
 
    integer i = 0;
    do {
        v0 += i;
    } while(++i < sb + 1);
 
    i = 0;
    do {
        v1 += 0;
    } while(++i < sb + 1);
 
    i = 0;
    do {
 
        v1 = llListReplaceList(v1, (list)(i + 1), 0, 0);
 
        integer j = 0;
        do {
            integer cost = 0;
            if(llGetSubString(a, i, i) != llGetSubString(b, j, j))
                cost = 1;
            integer x = llList2Integer(v1, j) + 1;
            integer y = llList2Integer(v0, j + 1) + 1;
            integer z = llList2Integer(v0, j) + cost;
            v1 = llListReplaceList(v1,
                (list) (
                    llAbs((llAbs(x >= y) * y) > z) * z + 
                    llAbs((llAbs(y > x) * x) >= z) * z + 
                    llAbs((llAbs(z >= x) * x) > y) * y +
                    llAbs((llAbs(x > z) * z) >= y) * y +
                    llAbs((llAbs(y >= z) * z) > x) * x +
                    llAbs((llAbs(z > y) * y) >= x) * x | 
                    llAbs((llAbs(x == y) * x) == z) * x
                ),
                j + 1,
                j + 1
            );
        } while(++j < sb);
 
        j = 0;
        do {
            v0 = llListReplaceList(
                v0, 
                (list)llList2String(
                    v1,
                    j
                ),
                j, 
                j
            );
        } while(++j < sb);
 
    } while(++i < sa);
 
    return llList2Integer(v1, sb);
}

This is a fast recursive alternative to using llListStatistics. It returns either the minimal or the maximal value in a list of numbers (integers or floats).

Input:

wasMinimum([10, 1, 9, 20, 8])

Return:

1

///////////////////////////////////////////////////////////////////////////
//    Copyright (C) 2012 Wizardry and Steamworks - License: GNU GPLv3    //
///////////////////////////////////////////////////////////////////////////
integer wasMinimum(list integers) {
    if(llGetListLength(integers) == 1) {
        return llList2Integer(integers, 0);
    }
    integer i = llList2Integer(integers, 0);
    integer j = llList2Integer(integers, 1);
    if(j < i) {
        integers = llDeleteSubList(integers, 0, 0);
        integers = llListReplaceList(integers, (list)j, 0, 0);
    }
    integers = llDeleteSubList(integers, 1, 1);
    return wasMinimum(integers);
}

///////////////////////////////////////////////////////////////////////////
//    Copyright (C) 2012 Wizardry and Steamworks - License: GNU GPLv3    //
///////////////////////////////////////////////////////////////////////////
integer wasMaximum(list integers) {
    if(llGetListLength(integers) == 1) {
        return llList2Integer(integers, 0);
    }
    integer i = llList2Integer(integers, 0);
    integer j = llList2Integer(integers, 1);
    if(j > i) {
        integers = llDeleteSubList(integers, 0, 0);
        integers = llListReplaceList(integers, (list)j, 0, 0);
    }
    integers = llDeleteSubList(integers, 1, 1);
    return wasMaximum(integers);
}

The reasoning is based on using lists as queues:

1. [Base Case] If the queue contains just one element, return that element.
2. If the second element in the queue is smaller than the first element in the queue:
   1. Delete the first element in the queue and replace it with the second element in the queue.
3. Delete the second element in the queue.
4. return queue of (1).

The only difference between wasMinimum and wasMaximum is that the sign is inverted in the comparison:

    if(j < i) {

for finding the minimal value, and

    if(j > i) {

for finding the maximal value.

The algorithm is not limited to integers and will work for floats as well.

wasListUnique returns a sorted list of unique elements by deleting re-occuring elements in the input list. The function takes two parameters:

• in, the list to clean of duplicates.
• sorted, a boolean specifying whether the list is already sorted.

The choice of the sorted parameter results in two different time complexities for the wasListUnique function:

• When the list is not already sorted (the sorted parameter being FALSE), the time complexity is O(sort + n). Since llListSort sorts the elements in the list using bubble sort, the resulting complexity is O(n^2 +n). Alternatively, if a different sorting method is used with logarithmic complexity, such as Quicksort, then the time complexity of the function would be O(logn +n).
• When the list is already sorted (the sorted parameter being TRUE), the time complexity is O(n) since the algorithm traverses the list only once.

Call:

wasListUnique([1, 1, 2, 1, 3, 1, 5, 2, 2, 2, 7, 8], FALSE)

Return:

[1, 2, 3, 5, 7, 8]

///////////////////////////////////////////////////////////////////////////
//    Copyright (C) 2012 Wizardry and Steamworks - License: GNU GPLv3    //
///////////////////////////////////////////////////////////////////////////
list wasListUnique(list in, integer sorted) {
    if(llGetListLength(in) == 0) return [];
    if(sorted == TRUE) jump sorted;
    in = llListSort(in, 1, TRUE);
@sorted;
    string a = llList2String(in, 0);
    string b = llList2String(in, 1);
    list result = [];
    if(a == b) jump dupe;
    result += a;
@dupe;
    return result + wasListUnique(llDeleteSubList(in, 0, 0), TRUE);
}

Depending on the data-types contained in the input list in, the wasListUnique function works differently:

• In case the input list in contains a list of unsorted elements of the same data-type, wasListUnique returns a sorted list of unique elements from the input list.
• In case the input list in contains an already sorted list of different data-types, wasListUnique returns a sorted list of unique elements from the input list.
• In case the input list in contains a list of unsorted elements of different data-types, wasListUnique inherits the arbitrary behavior of llListSort and returns arbitrary results.

The function takes two parameters:

• an input list in
• a string match

and returns the elements in list in that do not have match as a substring.

Call:

wasDeleteSubListMatch(["aabbcc", "dddd", "eeffgg", "rrraatt"], "e")

Return:

[ "aabbcc", "dddd", "rrraatt"]

///////////////////////////////////////////////////////////////////////////
//    Copyright (C) 2012 Wizardry and Steamworks - License: GNU GPLv3    //
///////////////////////////////////////////////////////////////////////////
list wasDeleteSubListMatch(list in, string match) {
    if(llGetListLength(in) == 0) return [];
    string first = llList2String(in, 0);
    in = llDeleteSubList(in, 0, 0);
    if(llSubStringIndex(first, match) == -1) jump next;
    return wasDeleteSubListMatch(in, match);
@next;
    return first + wasDeleteSubListMatch(in, match);
}

Input:

23

Output:

XXIII

///////////////////////////////////////////////////////////////////////////
//    Copyright (C) 2012 Wizardry and Steamworks - License: GNU GPLv3    //
///////////////////////////////////////////////////////////////////////////
string wasNumberToRoman(integer num) {
    list n = [ 1000, 900, 500, 400, 100,90, 50, 40, 10, 9, 5, 4, 1 ];
    list r = [ "M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I" ];
    integer i = 0;
    string result = "";
    do {
        while(num >= llList2Integer(n, i)) {
            num -= llList2Integer(n, i);
            result += llList2String(r, i);
        }
    } while(++i < llGetListLength(n));
    return result;
}

Call:

wasPrettyNumbers(15, [ "⓪", "⓵", "⓶", "⓷", "⓸", "⓹", "⓺", "⓻", "⓼", "⓽" ]);

Return:

⓵⓹

///////////////////////////////////////////////////////////////////////////
//    Copyright (C) 2012 Wizardry and Steamworks - License: GNU GPLv3    //
///////////////////////////////////////////////////////////////////////////
string wasPrettyNumbers(integer num, list modNine) {
    list d = llParseString2List((string)num, [], ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]);
    if(llGetListLength(d) == 0) return llList2String(modNine, 0);
    string r = "";
    do {
        r += llList2String(modNine, llList2Integer(d, 0));
        d = llDeleteSubList(d, 0, 0);
    } while(llGetListLength(d));
    return r;
}

Returns a list containing all the permutations of a set.

A call such as:

wasPermuteSet(["a", "b"], 0, 2)

where 0 represents the start index and 2 represents the length of the set, will return the list containing the elements:

a b b a

wasPermuteSet is a recursive function that uses wasListSwap as an auxiliary function:

///////////////////////////////////////////////////////////////////////////
//    Copyright (C) 2014 Wizardry and Steamworks - License: GNU GPLv3    //
///////////////////////////////////////////////////////////////////////////
// swaps two elements in a list
list wasListSwap(list set, integer a, integer b) {
    list t = llList2List(set, a, a);
    set = llListReplaceList(set, llList2List(set, b, b), a, a);
    set = llListReplaceList(set, t, b, b);
    return set;
}
 
///////////////////////////////////////////////////////////////////////////
//    Copyright (C) 2014 Wizardry and Steamworks - License: GNU GPLv3    //
///////////////////////////////////////////////////////////////////////////
// retuns a set that contains all the permutations from the given set
list wasPermuteSet(list set, integer start, integer end) {
    list result = [];
    if(start == end) return set;
    integer i = start;
    do {
        set = wasListSwap(set, start, i);
        result += wasPermuteSet(set, start+1, end);
        set = wasListSwap(set, start, i);
    } while(++i<end);
    return result;
}

///////////////////////////////////////////////////////////////////////////
//    Copyright (C) 2012 Wizardry and Steamworks - License: GNU GPLv3    //
///////////////////////////////////////////////////////////////////////////
// Calculates n!
integer wasFactorial(integer n) {
    if(n == 1) return 1;
    return wasFactorial(--n) * n;
}

///////////////////////////////////////////////////////////////////////////
//    Copyright (C) 2012 Wizardry and Steamworks - License: GNU GPLv3    //
///////////////////////////////////////////////////////////////////////////
list wasInsertSort(list toSort) {
    list sorted = [];
@next_element;
    integer n = llList2Integer(toSort, 0);
    toSort = llDeleteSubList(toSort, 0, 0);
    integer s = llGetListLength(sorted)-1;
    if(s == -1) {
        sorted += n;
        jump next_element;
    }
    do {
        integer sn = llList2Integer(sorted, s);
        if(n < sn) jump continue;
        sorted = llListInsertList(sorted, (list)n, s+1);
        if(llGetListLength(toSort)) jump next_element;
        return sorted;
@continue;
    } while(--s>-1);
    sorted = llListInsertList(sorted, (list)n, 0);
    if(llGetListLength(toSort)) jump next_element;
    return sorted;
}

Copy and paste into any script inside a primitive to remove the bling and any other particle effects.

default{state_entry(){llParticleSystem([]);}}

Copy and paste into any script inside a primitive to stop all texture animations.

default{state_entry(){llSetTextureAnim(0,-1,0,0,0.0,0.0,1.0);}}

A color in LSL is represented by a vector where the , and components represent the red, green and blue colors respectively. Given a gradient path between two colors, the following function will return a vector that represents a percentage of that path. The function can be used to create nice gradients, such as the ones used for the health meters in the zombies game. For a demonstration see the bistable color primitive page.

For example, a call such as:

wasPercentToGradient(50, "rg");

will return the color vector <1,1,0> (yellow) which represents of the path between red (r) and green (g).

The rgb parameter for different gradients has to be two letters long:

The function does not convert from HSV, instead it eliminates the saturation problem by doubling the output vector and benefits from the fact that color vectors in LSL have their components scaled to 1. In other words, this function will return <2,0,0> for the color red, which is pedantically incorrect, but when passed as a color vector, the runtime will automatically scale it to <1,0,0>.

///////////////////////////////////////////////////////////////////////////
//    Copyright (C) 2013 Wizardry and Steamworks - License: GNU GPLv3    //
///////////////////////////////////////////////////////////////////////////
vector wasPercentToGradient(float percent, string rgb) {
    if(llStringLength(rgb) != 2) {
        llSay(DEBUG_CHANNEL, "Assert failed, rgb parameter must consist of a pair of either r, g, or b.");
        return ZERO_VECTOR;
    }
    string a = llGetSubString(rgb, 0, 0);
    string b = llGetSubString(rgb, 1, 1);
    list col = [ "r", "g", "b" ];
    integer ax = llListFindList(col, (list)a);
    integer bx = llListFindList(col, (list)b);
    if(ax == -1 || bx == -1) {
        llSay(DEBUG_CHANNEL, "Asset failed, rgb parameters must contain either r, g, or b letters.");
        return ZERO_VECTOR;
    }
    col = llListReplaceList(col, (list)((100-percent)/100), ax, ax);
    col = llListReplaceList(col, (list)(percent/100), bx, bx);
    return 2*<llList2Float(col, 0), llList2Float(col, 1), llList2Float(col, 2)>;
}

When RGB should not be the slider but rather the brightness of the color (less common), then the following function would set the brightness percent between from and to color vectors.

///////////////////////////////////////////////////////////////////////////
//    Copyright (C) 2014 Wizardry and Steamworks - License: GNU GPLv3    //
///////////////////////////////////////////////////////////////////////////
vector wasPercentToGradientBrighness(float percent, vector from, vector to) {
    return <from.x + (to.x-from.x)*percent/100,
        from.y + (to.y-from.y)*percent/100, 
        from.z + (to.z-from.z)*percent/100>;
}

Some remarks:

• if we were to calculate the Levenshtein distance of a Knuth shuffle, the Levenshtein distance will always be equal to the number of characters of the returned. This is because the Knuth shuffle swaps every element on every iteration.
• on the other hand, the wasShuffleList function, does allow the selected element to be the current element so that its position is never exchanged.

///////////////////////////////////////////////////////////////////////////
//    Copyright (C) 2012 Wizardry and Steamworks - License: GNU GPLv3    //
///////////////////////////////////////////////////////////////////////////
list wasKnuthShuffle(list data) {
    integer i=llGetListLength(data)-1;
    do {
        string a = llList2String(data, i);
        integer rnd = (integer)llFrand(i);
        string b = llList2String(data, rnd);
        data = llListReplaceList(data, (list)b, i, i);
        data = llListReplaceList(data, (list)a, rnd, rnd);
    } while(--i>-1);
    return data;
}

///////////////////////////////////////////////////////////////////////////
//    Copyright (C) 2013 Wizardry and Steamworks - License: GNU GPLv3    //
///////////////////////////////////////////////////////////////////////////
list wasShuffleList(list data) {
    if(data == []) return [];
    integer rnd = (integer)llFrand(llGetListLength(data));
    return [ llList2String(data, rnd) ] + 
        wasShuffleList(llDeleteSubList(data, rnd, rnd));
}

Binary search expects the data list to be sorted and returns the element if found or -1 otherwise.

///////////////////////////////////////////////////////////////////////////
//    Copyright (C) 2013 Wizardry and Steamworks - License: GNU GPLv3    //
///////////////////////////////////////////////////////////////////////////
float wasBinarySearch(list data, float item) {
    // assert(data is sorted)
    if(data == []) return -1;
    integer l = llGetListLength(data);
    integer m = l/2;
    float mItem = llList2Float(data, m);
    if(mItem == item) return mItem;
    if(mItem < item) {
        data = llDeleteSubList(data, 0, m);
        jump continue;
    }
    data = llDeleteSubList(data, m, l-1);
@continue;
    return wasBinarySearch2(data, item);
}

For a complete binary-tree and binary search tree (BST) implementation in LSL see the binary trees section.

wasBinarySearch is twice faster than the built-in API function llListFindList when the data list is sorted. For example, the following is a trial run on a dataset of 1000 sequential items generated with:

jot - 1 1000

The goal was to find the element 53, which shows how binary search outperforms llListFindList by far:

Object: Binary search, found: 53.000000
Object: Binary search took: 0.004547 seconds
Object: llListFindList found 53 at index: 52
Object: llListFindList took: 0.021926 seconds

On subsequent runs, the same delta was observed between wasBinarySearch and llListFindList.

For strings, the procedure is similar, just that to be in-tone with UTF-8 and allow the binary-search to work with non-latin characters, we need to use Ord by Pedro Oval in order to be able to compare strings:

///////////////////////////////////////////////////////////////////////////
//         Ord() function, written by Pedro Oval, 2010-05-28             //
///////////////////////////////////////////////////////////////////////////
integer Ord(string chr) {
    if (chr == "") return 0;
    string hex = llEscapeURL(chr);
    if (llGetSubString(hex, 0, 0) != "%") 
        return llBase64ToInteger("AAAA" + 
            llStringToBase64(llGetSubString(chr, 0, 0)));
    integer b = (integer)("0x" + llGetSubString(hex, 1, 2));
    if (b < 194 || b > 244) return b;
    if (b < 224) return ((b & 0x1F) << 6) | 
        (integer)("0x" + llGetSubString(hex, 4, 5)) & 0x3F;
    if (b < 240) return (b & 0x0F) << 12 + 
        ((integer)("0x" + llGetSubString(hex, 4, 5)) & 0x3F) << 6 + 
        (integer)("0x" + llGetSubString(hex, 7, 8)) & 0x3F;
    return (b & 0x07) << 18 + 
        ((integer)("0x" + llGetSubString(hex, 4, 5)) & 0x3F) << 12 + 
        ((integer)("0x" + llGetSubString(hex, 7, 8)) & 0x3F) << 6 + 
        (integer)("0x" + llGetSubString(hex, 10, 11)) & 0x3F;
}
 
///////////////////////////////////////////////////////////////////////////
//    Copyright (C) 2015 Wizardry and Steamworks - License: GNU GPLv3    //
///////////////////////////////////////////////////////////////////////////
integer wasOrdCompare(string A, string B) {
    if(A == "" && B != "") return 1;
    if(A != "" && B == "") return -1;
    if(A == "" && B == "") return 0;
 
    integer i = Ord(llToUpper(llGetSubString(A, 0, 0)));
    integer j = Ord(llToUpper(llGetSubString(B, 0, 0)));
 
    if(i < j) return 1;
    if(i > j) return -1;
 
    return wasOrdCompare(
        llGetSubString(A, 1, -1), 
        llGetSubString(B, 1, -1)
    );
}
 
///////////////////////////////////////////////////////////////////////////
//    Copyright (C) 2015 Wizardry and Steamworks - License: GNU GPLv3    //
///////////////////////////////////////////////////////////////////////////
string wasBinarySearch(list data, string item) {
    integer l = llGetListLength(data);
    if(l == 0) return "";
    integer m = l/2;
    integer comp = wasOrdCompare(llList2String(data, m), item);
    if(comp == 0) return item;
    if(comp == 1) {
        data = llDeleteSubList(data, 0, m);
        jump continue;
    }
    data = llDeleteSubList(data, m, -1);
@continue;
    return wasBinarySearch(data, item);
}

Adapted from Doomsday.

///////////////////////////////////////////////////////////////////////////
//    Copyright (C) 2013 Wizardry and Steamworks - License: GNU GPLv3    //
///////////////////////////////////////////////////////////////////////////
string wasDayOfWeek(integer d, integer m, integer y) {
    if(m<3) {
        m+=13;
        --y;
        jump done;
    }
    ++m;
@done;
    return llList2String([ "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday" ], 
                (d + ((26 * m) / 10) + y + (y / 4) - (y / 100) + (y / 400) + 5) % 7);
}

Computes with complexity.

integer wasModExp(integer a, integer b, integer m) {
    integer res = 1;
    integer i = b;
    do {
        res *= a;
        res %= m;
    } while(--i>0);
    return res % m;
}

integer wasModExp(integer a, integer b, integer m) {
    integer x = 1;
    integer y = a;
    while (b > 0) {
        if (b % 2 == 1) x = (x*y) % m;
        y = (y*y) % m;
        b /= 2;
    }
    return x % m;
}

Uses wasModExp to calculate , takes as input a number n and a number of trials to run k and returns 0 if n is composite or 1 if n is probably prime.

Example:

wasIsPrime(7, 1);

returns 1.

Example:

wasIsPrime(24, 1);

returns 0.

Uses Fermat's little theorem which states that if is prime and , then .

///////////////////////////////////////////////////////////////////////////
//    Copyright (C) 2013 Wizardry and Steamworks - License: GNU GPLv3    //
///////////////////////////////////////////////////////////////////////////
integer wasIsPrime(integer n, integer k) {
    if(k==0) return 1;
    integer a = 1+(integer)llFrand(n-1);
    if(wasModExp(a, n-1, n) != 1) return 0;
    return wasIsPrime(n, --k);
}

From the Linux kernel, converts YYYY-MM-DD HH:MM:SS to Unix timestamp.

///////////////////////////////////////////////////////////////////////////
//    Copyright (C) 2013 Wizardry and Steamworks - License: GNU GPLv3    //
///////////////////////////////////////////////////////////////////////////
integer wasDateTimeToStamp(
    integer year,
    integer month,
    integer day,
    integer hour,
    integer minute,
    integer second
    ) {
    month -= 2;
    if (month <= 0) {
        month += 12;
        --year;
    }
    return 
    (
        (((year / 4 - year / 100 + year / 400 + (367 * month) / 12 + day) +
                year * 365 - 719499
            ) * 24 + hour
        ) * 60 + minute
    ) * 60 + second;
}

The following function will rotate the spinner once and can be used separately in scripts.

///////////////////////////////////////////////////////////////////////////
//    Copyright (C) 2013 Wizardry and Steamworks - License: GNU GPLv3    //
///////////////////////////////////////////////////////////////////////////
list spinChars = [ "↑", "↗", "→", "↘", "↓", "↙", "←", "↖" ];
string wasSpin() {
    string text = llList2String(llGetLinkPrimitiveParams(LINK_THIS, [PRIM_TEXT]), 0);
    do {
        string tok = llGetSubString(text, llStringLength(text)-1, llStringLength(text)-1);
        if(!~llListFindList(spinChars, (list)tok) && tok != "\n" && tok != "[" && tok != "]") jump show;
        text = llDeleteSubString(text, llStringLength(text)-1, llStringLength(text)-1);
    } while(llStringLength(text));
@show;
    string next = llList2String(spinChars,  0);
    spinChars = llDeleteSubList(spinChars, 0, 0);
    spinChars += next;
    return "[" + next + "]";
}

To make the spinner move one step forward, call:

spin()

which returns [↗] where ↗ is the next position of the arrow.

You can find some collected sets of spinners on the spinner asset page which you can set the spinChars list to.

This is the standard Euler division method which is preferable to the sieve method since the sieve method would require to allocate a list of integers that would surpass the memory constraints of LSL scripts.

///////////////////////////////////////////////////////////////////////////
//    Copyright (C) 2013 Wizardry and Steamworks - License: GNU GPLv3    //
///////////////////////////////////////////////////////////////////////////
list wasPrimeFactors(integer n) {
    list result = [];
    integer div = 2;
    do {
        if(n%div == 0) {
            n = n/div;
            result += div;
            jump continue;
        }
        ++div;
@continue;
    } while(n != 1);
    return result;
}

When this function is called, it will rotate the primitive it is in times times, by random combinations of the vector <x,y,z> where x, y and z can be either angle or 0. A demonstration of the functionality can be found on the dice page.

///////////////////////////////////////////////////////////////////////////
//    Copyright (C) 2013 Wizardry and Steamworks - License: GNU GPLv3    //
///////////////////////////////////////////////////////////////////////////
wasRandomRotate(integer times, float angle) {
    if(times <= 0) return;
    integer x = (integer)llFrand(2);
    integer y = (integer)llFrand(2);
    integer z = (integer)llFrand(2);
    llSetRot(llGetRot()*llEuler2Rot(<x,y,z>*angle*DEG_TO_RAD));
    wasRandomRotate(--times, angle);
}

If rotation is desired on one single axis only, the following modification will do that:

///////////////////////////////////////////////////////////////////////////
//    Copyright (C) 2013 Wizardry and Steamworks - License: GNU GPLv3    //
///////////////////////////////////////////////////////////////////////////
wasRandomRotate(integer times, float angle) {
    if(times <= 0) return;
    integer x = (integer)llFrand(2);
    if(x == 1) jump rotate;
    integer y = (integer)llFrand(2);
    if(y == 1) jump rotate;
    integer z = (integer)llFrand(2);
@rotate;
    llSetRot(llGetRot()*llEuler2Rot(<x,y,z>*angle*DEG_TO_RAD));
    wasRandomRotate(--times, angle);
}

///////////////////////////////////////////////////////////////////////////
//    Copyright (C) 2013 Wizardry and Steamworks - License: GNU GPLv3    //
///////////////////////////////////////////////////////////////////////////
integer wasConsecutiveCharacterMatches(string hay, string needle) {
    if(llStringLength(hay) == 0 || llStringLength(needle) == 0) return 0;
    integer count = 0;
    string a = llGetSubString(hay, 0, 0);
    string b = llGetSubString(needle, 0, 0);
    if(a == b) {
        ++count;
        hay = llDeleteSubString(hay, 0, 0);
        needle = llDeleteSubString(needle, 0, 0);
        jump continue;      
    }
    if(llStringLength(hay) > llStringLength(needle)) {
        hay = llDeleteSubString(hay, 0, 0);
        jump continue;
    }
    if(llStringLength(hay) < llStringLength(needle)) {
        needle = llDeleteSubString(needle, 0, 0);
        jump continue;
    }
    hay = llDeleteSubString(hay, 0, 0);
    needle = llDeleteSubString(needle, 0, 0);
@continue;
    return count + wasConsecutiveCharacterMatches(hay, needle);
}

vector v = (vector)"<1, 2, 3>";
rotation r = (rotation)"<1, 2, 3, -1>";

list a = [ "3", "2", "1" ];
vector v = (vector)("<" + llList2CSV(a) + ">");
 
a = [ "3", "2", "1", "-1" ];
rotation r = (rotation)("<" + llList2CSV(a) + ">");

The following function converts a list of mixed types to a list of type T.

///////////////////////////////////////////////////////////////////////////
//    Copyright (C) 2014 Wizardry and Steamworks - License: GNU GPLv3    //
///////////////////////////////////////////////////////////////////////////
list wasCompoundToList(integer T, list compound) {
    if(llGetListLength(compound) == 0) return [];
    if(T == TYPE_FLOAT) return llList2Float(compound, 0) + 
        wasCompoundToList(T, llDeleteSubList(compound, 0, 0));
    if(T == TYPE_INTEGER) return llList2Integer(compound, 0) + 
        wasCompoundToList(T, llDeleteSubList(compound, 0, 0));
    if(T == TYPE_STRING) return llList2String(compound, 0) + 
        wasCompoundToList(T, llDeleteSubList(compound, 0, 0));
    if(T == TYPE_KEY) return llList2Key(compound, 0) + 
        wasCompoundToList(T, llDeleteSubList(compound, 0, 0));
    if(T == TYPE_VECTOR) return llList2Vector(compound, 0) + 
        wasCompoundToList(T, llDeleteSubList(compound, 0, 0));
    if(T == TYPE_ROTATION) return llList2Rot(compound, 0) + 
        wasCompoundToList(T, llDeleteSubList(compound, 0, 0));
    return wasCompoundToList(T, llDeleteSubList(compound, 0, 0));
}

For example, suppose you have a compound list:

list a = [ 0, NULL_KEY, 3.546 ];

and you want to convert all the values to a float type. You would then do:

llOwnerSay(
            llDumpList2String(
                wasCompoundToList(TYPE_FLOAT, a),
            ",")
        );

which would say to the owner:

0.000000,0.000000,3.546000

An example of the usefulness of the function can be found on the ample donation jar page where llSetPayPrice wants a list of integers to be supplied as the second argument for the buttons when the call to llParseString2List returns a list with all the elements of type string.

wasCompoundToType takes as parameters a type in variable T and either a vector or rotation in variable compound and returns a list with all components of compound set to type T.

///////////////////////////////////////////////////////////////////////////
//    Copyright (C) 2014 Wizardry and Steamworks - License: GNU GPLv3    //
///////////////////////////////////////////////////////////////////////////
list wasCompoundToType(integer T, list compound) {
    integer S = llGetListEntryType(compound, 0);
    if(S != TYPE_VECTOR && S != TYPE_ROTATION) return [];
    list a = llParseString2List((string)compound, ["<", ",", ">"], []);
    compound = [];
    do {
        if(T == TYPE_FLOAT) 
            compound += llList2Float(a, 0);
        if(T == TYPE_INTEGER) 
            compound += llList2Integer(a, 0);
        if(T == TYPE_STRING) 
            compound += llList2String(
                llParseString2List((string)a, [" "], [])
            , 0);
        a = llDeleteSubList(a, 0, 0);
    } while(llGetListLength(a) != 0);
    return compound;
}

This is useful in situations where you would like to retrieve the components of a vector or rotation without having to write multiple lines to convert each component. For example, after the following sequence:

vector p = <23.499, 134, 39.048245>;
list intList = wasCompoundToType(TYPE_INTEGER, [p]);

the list intList will contain a list of integers from the components of vector p (p.x, p.y and p.z), with the mantissa removed (exactly what llFloor does).

Similarly, after the sequence:

vector p = <23.499, 134, 39.048245>;
list floatList = wasCompoundToType(TYPE_FLOAT, [p]);

the list floatList will contain a list of floats from the components of vector p (see below).

When a string type is requested:

vector p = <23.499, 134, 39.048245>;
list truncatedStringList = wasCompoundToType(TYPE_STRING, [p]);

the list truncatedStringList will contain a list strings with the mantissa truncated to 6 digits. In LSL, all floats get truncated to 6 decimal places when converted to strings. Note that the previous call to wasCompoundToType requesting TYPE_FLOAT will return a list containing floats with all decimal places (useful for computations).

If any type other than vector or rotation is passed to wasCompoundToType, the empty list will be returned. If a conversion to any type other than the ones implemented by wasCompoundToType (string, float or integer) are not meaningful (ie: converting a float to a key), the empty list will be returned.

The following is an example from jump, where string concatenation is supposed to build an SLURL out of a positional vector:

string slurl = llGetRegionName() + "/" + 
  llDumpList2String(
    llList2ListStrided(llParseString2List((string)llGetPos(), ["<", " ", ",", ".", ">"], []), 0, -1, 2)
  "/")

and so is this:

vector p = llGetPos();
string slurl = llGetRegionName() + "/" + 
  (string)((integer)p.x) + "/" + 
  (string)((integer)p.y) + "/" + 
  (string)((integer)p.z);

However, instead of writing a really large line and to avoid allocating a new variable p, we can instead write:

string slurl = llGetRegionName() + "/" + 
  llDumpList2String(
    wasCompoundToType(TYPE_INTEGER, [llGetPos()]), 
  "/")

Example:

wasMergeSort([20, 5, 1, 11, 12, 32, 8, 3, 4, 7])

Returns the list:

1 3 4 5 7 8 11 12 20 32

///////////////////////////////////////////////////////////////////////////
//    Copyright (C) 2013 Wizardry and Steamworks - License: GNU GPLv3    //
///////////////////////////////////////////////////////////////////////////
list wasMergeSortMerge(list left, list right) {
    if(!llGetListLength(left) || !llGetListLength(right)) return left+right;
    integer l = llList2Integer(left, 0);
    integer r = llList2Integer(right, 0);
    if(l <= r) return l + wasMergeSortMerge(llDeleteSubList(left, 0, 0), right);
    return r + wasMergeSortMerge(left, llDeleteSubList(right, 0, 0));
}
 
///////////////////////////////////////////////////////////////////////////
//    Copyright (C) 2013 Wizardry and Steamworks - License: GNU GPLv3    //
///////////////////////////////////////////////////////////////////////////
list wasMergeSort(list input) {
    integer d = llGetListLength(input);
    if(d <= 1) return input;
    integer m = d/2;
    return wasMergeSortMerge(
        wasMergeSort(
            llList2List(input, 0, m-1)
        ), 
        wasMergeSort(
            llList2List(input, m, d)
        )
    );
}