User:Xaviar Czervik/Code

From Second Life Wiki
Jump to: navigation, search

Xaviar Czervik's Code

Here is the code that Xaviar Czervik has submitted to the wiki - he likes to keep it all together so he can find it when he loses it in his inventory. ;D


Object to Data v1.1

(http://www.gnu.org/copyleft/fdl.html) in the spirit of which this script is GPL'd. Copyright (C) 2007 Xaviar Czervik

(This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

I took the list serialize list code from someone, and it was posted on a wiki somewhere... (If this was you, please add your name so I can credit you).


I'm not one for writing documentation, so I apologize in advance for the confusion of the following.



Here is a map of the objects:

Object To Data
|
|---Object_Main (Script)
|---Listen (Object)
|---|
|---|---Listen_Main(Script)
|---HoloBox (Object)
|---|
|---|---Holo_Main (Script)
|---|Data_Default (Note)


Now that everything is set up, drag the last script into every PRIM. No objects can be linked. Then, click Save Program. The objects WILL DELETE THEM SELF, so be careful. Copy and paste the text into a note, exactly as it appers in the chat log. No need to remove any dates, or the object name. Simply paste it.



Main_Main (Script) <lsl> list data; key gSetupQueryId; integer gSetupNotecardLine = 0; string gSetupNotecardName = "Data_Default"; string lastData;

readSettingsNotecard() {

  gSetupNotecardLine = 0;
  gSetupQueryId = llGetNotecardLine(gSetupNotecardName,gSetupNotecardLine); 

}

default {

   state_entry() {
       llListen(-5, "", "", "");
       llListen(-10, "", "", "");
       llListen(1, "", "", "");
       llListen(-1, "", llGetOwner(), "");
       llPassTouches(0);
   }
   touch_start(integer total_number) {
       if (llDetectedKey(0) != llGetOwner())
           return;
       llDialog(llGetOwner(), "What do you want to do?", ["Save Program", "Run Program"], -1);
   }
   listen(integer i, string s, key id, string m) {
       if (i == -5)
           llRezObject("Listen", llGetPos() + <0,0,2>, <0,0,0>, <0,0,0,0>, (integer)m);
       if (i == -10) {
           data += m;
           llSetTimerEvent(3);
       }
       if (i == -1) {
           if (m == "Save Program") {
               llShout(-15, "Save Program");
           }
           if (m == "Run Program") {
               readSettingsNotecard();
           }
       }
   }
   timer() {
       llOwnerSay("Copy and paste the following into a note and call it 'Data_' and some descriptor.");
       llSetTimerEvent(0);
       integer i = 0;
       while (i < llGetListLength(data)) {
           llOwnerSay("\n" + llGetSubString(llList2String(data, i), 0, 250));
           llOwnerSay("\n" + llGetSubString(llList2String(data, i), 251, -1));
           i++;
       }
   }
   dataserver(key queryId, string data) {
       if(queryId == gSetupQueryId)  {
           if(data != EOF) {
               gSetupNotecardLine += 1;
               gSetupQueryId = llGetNotecardLine(gSetupNotecardName,gSetupNotecardLine); 
               if (llGetSubString(data, 0, 0) == "[")
                   return;
               if (lastData == "") {
                   lastData += data;
               } else {
                   lastData += data;
                   integer f = (integer)llFrand(10000) - 10000;
                   llRezObject("HoloBox", llGetPos() + <0,0,2>, <0,0,0>, <0,0,0,0>, f);
                   list lis = llParseString2List(lastData, ["-=!!=-"], []);
                   integer i = 0;
                   while (i < llGetListLength(lis)) {
                       llSay(f, llList2String(lis, i));
                       i++;
                   }
                   lastData = "";
               }
           }
       }
   }

} </lsl>


Listen_Main (Script) <lsl> integer num = 0; list total = [];

default {

   on_rez(integer i) {
       llListen(i, "", "", "");
   }
   listen(integer i, string n, key id, string m) {
       if (llGetOwnerKey(id) == llGetOwner()) {
           num++;
           total += m;
           if (num == 10) {
               llShout(-10, llDumpList2String(total, "-=!!=-"));
               llDie();
           }
           
           
       }
   }

} </lsl>


Holo_Main (Script)

<lsl> string SERIALIZER_DELIMITER = "$!#"; integer num = 0;

list unserializeList(string serialized_data) {

   // TODO: add some checking in-case we encounter a poorly formed serialization
   //       consider using the same mem-packing list pushing technique used above
   //       (want to run performace tests first)
   list result = [];
   list t;
   list l = llParseStringKeepNulls(serialized_data, [SERIALIZER_DELIMITER], []);
   string item;
   integer i = (l != []);//This is a hack, it gets list lenght.
   integer type = 0;
   do
   {
       if((type = (integer)(item = llList2String(l, (i=~-i)))))
       {//Little error checking (also takes care of null strings).
           integer p = llSubStringIndex(item, ",");
           item = llDeleteSubString(item, 0, p);
           // How about those switch statements, Lindens???
           if (TYPE_INTEGER == type)
               t = [(integer)item];
           else if (TYPE_FLOAT == type)
               t = [(float)item];
           else if (TYPE_STRING == type)
               t = [item];
           else if (TYPE_KEY == type)
               t = [(key)item];
           else
           {
               if (TYPE_ROTATION ^ type)// if (TYPE_VECTOR == type)
                   t = [(vector)("<" + item + ">")];
               else// if (TYPE_ROTATION == type)
                   t = [(rotation)("<" + item + ">")];
           }
           //when dealing with very long lists it might be advantagous to use the commented out line instead.
           //result = [result = t] + result;
           result = t + result;
       }
   }while(i);
   return result;

}

default {

   on_rez(integer i) {
       llListen(i, "", "", "");
   }
   listen(integer i, string n, key id, string m) {
       if (llGetOwnerKey(id) == llGetOwner()) {
           list l = unserializeList(m);
           num++;
           if (num == 1) {
               list l2 = [PRIM_TYPE] + l;
               llSetPrimitiveParams(l2);
           }
           if (num == 2) {
               llSetColor((vector)m, ALL_SIDES);
           }
           if (num == 3) {
               llSetRot((rotation)m);
           }
           if (num == 4) {
               llSetScale((vector)m);
           }
           if (num == 5) {
               llSetTexture(m, ALL_SIDES);
           }
           if (num == 6) {
               vector t = (vector)m;
               llScaleTexture(t.x, t.y, ALL_SIDES);
           }
           if (num == 7) {
               vector t = (vector)m;
               llOffsetTexture(t.x, t.y, ALL_SIDES);
           }
           if (num == 8) {
               llRotateTexture((integer)m, ALL_SIDES);
           }
           if (num == 9) {
               list l2 = [PRIM_BUMP_SHINY, ALL_SIDES] + l;
               llSetPrimitiveParams(l2);
           }
           if (num == 10) {
               while (llVecDist(llGetPos(), (vector)m) > .1) llSetPos((vector)m);
               llRemoveInventory(llGetScriptName());
           }
           
           
           
       }
   }

} </lsl>


Save Program (Script)

<lsl> string SERIALIZER_DELIMITER = "$!#";

string hexc="0123456789ABCDEF";//faster

string Float2Hex(float input) {// Copyright Strife Onizuka, 2006-2007, LGPL, http://www.gnu.org/copyleft/lesser.html

   if((integer)input != input)//LL screwed up hex integers support in rotation & vector string typecasting
   {//this also keeps zero from hanging the zero stripper.
       float unsigned = llFabs(input);//logs don't work on negatives.
       integer exponent = llFloor(llLog(unsigned) / 0.69314718055994530941723212145818);//floor(log2(b)) + rounding error
       integer mantissa = (integer)((unsigned / (float)("0x1p"+(string)(exponent -= (exponent == 128)))) * 0x1000000);//shift up into integer range
       integer index = (integer)(llLog(mantissa & -mantissa) / 0.69314718055994530941723212145818);//index of first 'on' bit
       string str = "p" + (string)((exponent += index) - 24);
       mantissa = mantissa >> index;
       do
           str = llGetSubString(hexc,15&mantissa,15&mantissa) + str;
       while(mantissa = mantissa >> 4);
       if(input < 0)
           return "-0x" + str;
       return "0x" + str;
   }//integers pack well so anything that qualifies as an integer we dump as such, supports netative zero
   return llDeleteSubString((string)input,-7,-1);//trim off the float portion, return an integer

}

string serializeList(list l) {

   integer i = (l != []);//This is a hack, it gets list lenght.
   if(i)
   {
       string serialized_data = "";
       integer type = 0;
       string result;
       {@loop;
           // this custom loop is about as fast as a while loop.
           // we build the string backwords for memory reasons.
           // My kingdom for select statements....
           if (TYPE_FLOAT == (type = llGetListEntryType(l, (i=~-i))))
               // floats get extra love
               result = Float2Hex(llList2Float(l, i));
           else if (TYPE_VECTOR == type) {
               vector v = llList2Vector(l, i);
               result = Float2Hex(v.x) + "," + Float2Hex(v.y) + "," + Float2Hex(v.z);
           } else  if (TYPE_ROTATION == type) {
               rotation r = llList2Rot(l, i);
               result = Float2Hex(r.x) + "," + Float2Hex(r.y) + "," + Float2Hex(r.z) + "," + Float2Hex(r.s);
           } else //if ((TYPE_INTEGER == type) || (TYPE_STRING ==  type) || (TYPE_KEY == type))
               result = llList2String(l, i);// integers, strings and keys required no voodoo
           if(i)
           {
               //This came to me after reverse engeneering LSL bytecode, the realization that LSL memory management sucks.
               serialized_data = SERIALIZER_DELIMITER + (string)type + (serialized_data = result = ",") + result + serialized_data;
               jump loop;
           }
       }
       return (string)type + (serialized_data = result = ",") + result + serialized_data;
   }
   return "";

}

Say(integer i, string m) {

   llSleep(.15);
   llShout(i, m);

}

default {

   state_entry() {
       llListen(-15, "", "", "Save Program");
   }
   listen(integer i, string s, key id, string m) {
       integer f = (integer)llFrand(10000) + 1691507124;
       llShout(-5, (string)f);
       llSleep(1);
       list total;
       string tot;
       total = llGetPrimitiveParams([PRIM_TYPE]);
       tot = serializeList(total);
       Say(f, tot);
       Say(f, (string)llGetColor(ALL_SIDES));
       Say(f, (string)llGetRot());
       Say(f, (string)llGetScale());
       Say(f, (string)llGetTexture(ALL_SIDES));
       Say(f, (string)llGetTextureScale(ALL_SIDES));
       Say(f, (string)llGetTextureOffset(ALL_SIDES));
       Say(f, (string)llGetTextureRot(ALL_SIDES));
       total = llGetPrimitiveParams([PRIM_BUMP_SHINY, ALL_SIDES]);
       total = [llList2Integer(total, 0), llList2Integer(total, 1)];
       tot = serializeList(total);
       Say(f, tot);
       Say(f, (string)(llGetPos()));
       llSleep(1);
       llDie();
   }

} </lsl>

Prefix Calculator

Created by Xaviar Czervik. Do whatever you wish with this function: Sell it (good luck), use it, or modify it.

Evaluates an expression in prefix notation. I will give a few examples, and let you figure it out yourself. You have a brain: use it.

+ 1 2 = 3

+ - 1 2 3 = 2

/ + 3 2 - +1 2 3 = 1.25


For more information visit http://en.wikipedia.org/wiki/Prefix_notation.

Another prefix calculator script is the Chatbot sample. That script is much less simple, because it handles many more varieties of input, but that script exhibits essentially this same control flow.


<lsl> list stack;

push(float i) { // Float To Integer - Not good to use for large values, but it works. Sue me...

   stack += (integer)(i*10000000); }

float pop() {

   float i = peek();
   stack = llList2List(stack, 0, -2);
   return i;

}

float peek() { // Float To Integer - Not good to use for large values, but it works. Sue me...

   return ((float)llList2Integer(stack, -1))/10000000;}

default {

   state_entry() {
       llListen(0, "", llGetOwner(), "");
   }
   listen(integer i, string n, key id, string m) {
       string data = m;
       
       list parsed = llParseString2List(data, [" "], []);
       
       integer i = llGetListLength(parsed);
       while (i--) {
           string data = llList2String(parsed, i);
           string check = (string)((float)data);
           while (llGetSubString(check, -1, -1) == "0") {
               check = llGetSubString(check, 0, -2);
           }
           if (llGetSubString(check, -1, -1) == ".")
               check = llGetSubString(check, 0, -2);
           if (check == data) { // Is it a number?
               push((float)data);
           } else {
               if (llStringLength(data) == 1) {
                   float first = pop();
                   float second = pop();
                   if (data == "+") {
                       push(first + second);
                   }
                   if (data == "-") {
                       push(first - second);
                   }
                   if (data == "*") {
                       push(first * second);
                   }
                   if (data == "/") {
                       push((float)first / (float)second);
                   }
               } else {
                   float first = pop();
                   if (data == "sin") {
                       push(llSin(first));
                   }
                   if (data == "cos") {
                       push(llCos(first));
                   }
                   if (data == "tan") {
                       push(llTan(first));
                   }
                   if (data == "sqrt") {
                       push(llSqrt(first));
                   }
               }
           }
       }
       llOwnerSay((string)pop());
   }

} </lsl>

Efficiency Tester

Written by Xaviar Czervik, Modified by Strife Onizuka.

This code will test the efficiency of what ever is in the while loop.

I've used i += 1 because I found it to be faster on the LSL Script Efficiency page.

Lots of people disagree with me that a += 1 is faster than ++a... If you don't like it, change it and then sue me :P.

<lsl> //IMPORTANT: Only perform tests in an empty region to reduce contamination and be sure to wearing no attachments.

integer time() {

   string stamp = llGetTimestamp();
   return (integer) llGetSubString(stamp, 11, 12) * 3600000 + 
          (integer) llGetSubString(stamp, 14, 15) * 60000 + 
          llRound((float)llGetSubString(stamp, 17, -2) * 1000000.0)/1000;

//llInsertString(llDeleteSubString(stamp, 19, 19) + "000000", 23, ".") }

default {

 state_entry() {
   //test variables
   float counter;
   //framework variables
   float i = 0;
   float j = 0;
   float max = 10000;
   float start = time();
   do {
     //test
     counter += 1;
     
   }while (++i < max);
   float delta = time();
   do ; while (++j < max);
   float end = time();//remove the time required by the framework
   float t = ((delta - start) - (end - delta))/max;
   llOwnerSay("The function in the loop took a total of " + (string)t + " milliseconds.");
 }

} </lsl>

Merge Sort

Created by Xaviar Czervik. Do whatever you wish with this function: Sell it (good luck), use it, or modify it.

This code sorts a list through use of a Merge Sort. I have no idea why you would want to use it as it is more than 150 times slower than llListSort(), but it is a good demonstration of how a Merge Sort works.

I realize I shouldn't be using iteration in a recursive method... Sue me.

<lsl> list sort(list l) {

   if (llGetListLength(l) > 1) {
       integer mid = llGetListLength(l)/2;
       list l2 = sort(llList2List(l, 0, mid-1));
       list l3 = sort(llList2List(l, mid, -1));
       return merge(l2, l3);
   }
   return l;

}

list merge(list l, list r) {

   integer lm = llGetListLength(l);
   integer rm = llGetListLength(r);
   integer lc;
   integer rc;
   list ret;
   while (lc < lm || rc < rm) {
       if (lc >= lm) {
           ret += llList2Integer(r, rc);
           rc++;
       } else if (rc >= rm) {
           ret += llList2Integer(l, lc);
           lc++;
       } else {
           if (llList2Integer(l, lc) <= llList2Integer(r, rc)) {
               ret += llList2Integer(l, lc);
               if (lc < lm)
                   lc++;
           } else {
               ret += llList2Integer(r, rc);
               if (rc < rm)
                   rc++;
           }
       }
   }
   return ret;

} </lsl>

String Compare

Created by Xaviar Czervik. Do whatever you wish with this function: Sell it (good luck), use it, or modify it.

The following code returns 1, -1 or 0. The 1 and -1 are essentially random, however it will return the same value every time the script is executed. 0 Is returned when, and only when, the strings are exactly equal. Completely re-designed to use a few tricks I learned in the past months. Also much easier to read now.

I have used this script for comparing the Keys of two objects in a dynamic set of sensors, to decide which one should be the "Master" in the region to tell me information. I'm sure there can be more uses to this...


<lsl> integer compare(string s1, string s2) {

   if (s1 == s2) {
       return 0;
   } else if (llStringLength(s1) < llStringLength(s2)) {
       return 1;
   } else if (llStringLength(s1) > llStringLength(s2)) {
       return -1;
   } else {
       list l = [s1, s2];
       l = llListSort(l, 0, 1);
       if (s1 == llList2String(l, 0))
           return 1;
       return -1;
   }

} </lsl>


Pseudo-random Number Generator

Here's a Pseudo-random Number Generator - I just made it up off the top of my head - so it has no mathematical research behind it to prove it's random... I've tested it for a while and it looks random to me, about the same as llFrand(). But what ever. Sue me. The main reason that I use it so that I can test scripts, and then when it blows up because of a math error, I can just run the script again an it will use the same numbers, in the same order.

I use this for determining a random channel for two (or more) objects to talk on. This allows the scripts to talk without users being able to intercept the messages - and even if they do - then the channel will change in a minute or two - so no harm done.


<lsl> // IMPORTANT: Change the following numbers before using! integer seed1 = 0x053FA20C; integer seed2 = 0x3B1264D5; integer seed1Mod = 0x71B5F252; integer seed2Mod = 0x56A0E61D;

integer rand(integer spread) {

   	seed1 = (seed1 * seed1Mod + 0xB);
   	seed2 = (seed2 * seed2Mod + 0xB);

integer answer = seed1 * seed2;

       seed2Mod = seed1Mod;
       seed1Mod = answer;

return answer % spread; }

</lsl>


Example code to test the randomness (Is that a word?) of the generator. <lsl> default { state_entry() { integer i = 0; integer min = 0x7FFFFFFF; integer max = -0x7FFFFFFF; integer total = 0; while (i < 100000000) { integer r = rand(); if (r < min) { min = r; } if (r > max) { max = r; } total += r; i++; } llOwnerSay("Min: " + (string)min); llOwnerSay("Max: " + (string)max); llOwnerSay("Average: " + (string)(total/100000000));

}

}