The Wild West Sim that I mentioned before is, as far as I can tell, complete. I started out working on the project, but I had to stop because of school and other things. However, it looks like everyone else continued working and the whole place is done. At least, as done as it’s going to be.

The whole place actually looks worse than I left it last. But, what can you do? That’s life on the Teen Grid.

A pretty old flight assist that seems pretty popular. It’s not that good; I even made a better one (I might post mine soon), but it is important to put as much as I can up to help people learn as much as possible. This can just be put into an object and attached to your avatar.

//X-flight script for increased flying speed and control
//Developed by Goodwill Epoch on 6/12/2003
//Revision 1.9a
//For explicit use only by members of the Kazenojin Airship guild
//
//May be sold with explicit permission from Goodwill Epoch to non-members
//Settings must be set to no-modify no view to prevent theft of script
//script may not be modified without permission from Goodwill Epoch

//List of customizable commands
list commands = ["X", "go", "stop", "status", "speed", "accel", "pos", "accelmode", "turnmode", "hovermode", "posmode"];

//Help for commands
list com_help = ["Trigger for any commands to be entered", "Enable flight enhancements", "Disable flight enhancements", "List current modes and their state", "Current impulse, place a number after to set. limit 1-500", "Current acceleration, place a number after to set. limit 10-100", "Current coordinates", "Acceleration of movement. Use 'on' or 'off' to set.", "Slow down while turning. Use 'on' or 'off' to set.", "Allows hovering at all heights. Use 'on' or 'off' to set.", "Displays position over object. Use 'on' or 'off' to set."];

//Default movement variables
float speed = 050;
float accel = 10;
float move = 0;
float attached = 0;

//Counters and temp variables
float accel_count = 0;
string temp_newcommand;
integer temp_newcom_pos;
integer wait_for_conf = FALSE;
integer test_move = FALSE;

//Simplified say strings
string off = “off”;
string on = “on”;

//Default settings
integer accelmode = TRUE;
integer turnmode = TRUE;
integer hovermode = TRUE;
integer posmode = FALSE;

//Other variables
integer listen_num;
string notecard = “X-Flight enhanced flight info”;
string notehelp = “X-Flight enhanced flight help”;

//Returns a on/off string from a true/false pass
string on_off(integer test)
{
if(test)
{
return on;
}
else
{
return off;
}
}

//Returns a true/fals from an on/off string
integer true_false(string test)
{
if(test == on)
{
return TRUE;
}
else
{
return FALSE;
}
}

//Help menu handler
help()
{
llSay(0, “Current help”);
integer a;
for(a = 0; a < llGetListLength(com_help); a++)
{
llSay(0, llList2String(commands, a) + ” – ” + llList2String(com_help, a));
}
llSay(0, “customize – Allows you to customize certain commands. ‘” + llList2String(commands, 0) + ” customize [old command] [new command]‘ Be sure to use full words without spaces for commands. You will then need to type ‘yes’ to confirm.”);
llSay(0, “reset – Resets entire script. ‘” + llList2String(commands, 0) + ” reset’ WARNING: Will erase all customize data and settings.”);
}

//Allows customization of function names
customize(string old_com, string new_com)
{
//Checks for commands and proper commands
if((old_com == “”) || (new_com == “”))
{
llSay(0, “Not enough information, please try again or view help for more info.”);
}
else
{
integer listpos = llListFindList(commands, [old_com]);
if(listpos == -1)
{
llSay(0, “Command not found, please view help for more info on current command settings”);
}
else //Sets up wait to confirm changing commands
{
temp_newcommand = new_com;
temp_newcom_pos = listpos;
llSay(0, “Do you want command ‘” + old_com + “‘ to be changed to ‘” + new_com + “‘? Please say ‘yes’”);
wait_for_conf = TRUE;
}
}
}

//Take controls
get_controls()
{
llListenRemove(listen_num);
listen_num = llListen(0, “”, llGetOwner(), “”);
llSetTimerEvent(.5);
llSetText(“”, <0,0,0>, 0);
llRequestPermissions(llGetOwner(), PERMISSION_TAKE_CONTROLS);
}

//Handle Commands
com_handle(integer com_num, string message)
{
if(com_num == 1) //Go
{
get_controls();
}
else if(com_num == 2) //Stop
{
llReleaseControls();
llSay(0, “All stop”);
}
else if(com_num == 3) //Status
{
llSay(0, “Current settings:”);
llSay(0, llList2String(commands, 4) + ” – ” + (string)((integer)speed));
llSay(0, llList2String(commands, 5) + ” – ” + (string)((integer)accel));
llSay(0, llList2String(commands, 7) + ” – ” + on_off(accelmode));
llSay(0, llList2String(commands, + ” – ” + on_off(turnmode));
llSay(0, llList2String(commands, 9) + ” – ” + on_off(hovermode));
llSay(0, llList2String(commands, 10) + ” – ” + on_off(posmode));
}
else if(com_num == 4) //Speed
{
float tempvar = (integer)message;
if((tempvar > 0) && (tempvar <= 500))
{
speed = tempvar;
llSay(0, llList2String(commands, com_num) + ” is now ” + (string)((integer)speed));
}
else
{
llSay(0, llList2String(commands, com_num) + ” is currently ” + (string)((integer)speed));
}
}
else if(com_num == 5) //Acceleration
{
float tempvar = (integer)message;
if((tempvar >= 10) && (tempvar <= 100))
{
accel = tempvar;
llSay(0, llList2String(commands, com_num) + ” is now ” + (string)((integer)accel));
}
else
{
llSay(0, llList2String(commands, com_num) + ” is currently ” + (string)((integer)accel));
}
}
else if(com_num == 6) //current pos
{
vector pos = llGetPos();
llSay(0, “<” + (string)((integer)pos.x) + “, ” + (string)((integer)pos.y) + “, ” + (string)((integer)pos.z) + “>”);
}
else if(com_num == 7) //Acceleration mode
{
if((message == “off”) || (message == “on”))
{
accelmode = true_false(message);
llSay(0, llList2String(commands, com_num) + ” is now ” + message);
}
else
{
llSay(0, llList2String(commands, com_num) + ” is currently ” + on_off(accelmode));
}
}
else if(com_num == //Turning mode
{
if((message == “off”) || (message == “on”))
{
turnmode = true_false(message);
llSay(0, llList2String(commands, com_num) + ” is now ” + message);
}
else
{
llSay(0, llList2String(commands, com_num) + ” is currently ” + on_off(turnmode));
}
}
else if(com_num == 9) //Hover Mode
{
if((message == “off”) || (message == “on”))
{
hovermode = true_false(message);
llSay(0, llList2String(commands, com_num) + ” is now ” + message);
}
else
{
llSay(0, llList2String(commands, com_num) + ” is currently ” + on_off(hovermode));
}

}
else if(com_num == 10) //Position display mode
{
if((message == “off”) || (message == “on”))
{
posmode = true_false(message);
llSay(0, llList2String(commands, com_num) + ” is now ” + message);
}
else
{
llSay(0, llList2String(commands, com_num) + ” is currently ” + on_off(posmode));
}
}
}

//Check for flight and altitude for hover
set_flight()
{
vector pos = llGetPos();
float ground = llGround(<0,0,0>);
if(llGetAgentInfo(llGetOwner()) & AGENT_FLYING)
{
move = 1;
if(hovermode && ((pos.z > 55) && (pos.z > (ground + 35))))
{
llSetForce(<0,0,9.8> * llGetMass(), FALSE);
}
else
{
llSetForce(<0,0,0>, FALSE);
}
}
else
{
move = 0;
llSetForce(<0,0,0>, FALSE);
}
// Display position over object if position mode is on
if(posmode)
{
llSetText(“<” + (string)((integer)pos.x) + “, ” + (string)((integer)pos.y) + “, ” + (string)((integer)pos.z) + “> \n \n \n”, <1,1,1>, 1);
}
else
{
llSetText(“”, <0,0,0>, 0);
}
}

//Handle Listen Messages
listen_handler(string message)
{
list lst_msg = llParseString2List(message, [" "],[]);
if(llList2String(lst_msg, 0) == llList2String(commands, 0))
{
wait_for_conf = FALSE;
if(llList2String(lst_msg, 1) == “help”) //If help pass to help
{
help();
}
//If customize pass to customize
else if(llList2String(lst_msg, 1) == “customize”)
{
customize(llList2String(lst_msg, 2), llList2String(lst_msg, 3));
}
//If reset reset script
else if(llList2String(lst_msg, 1) == “reset”)
{
llSay(0, “Reseting Script”);
llResetScript();
}
//Pass to command handler if a command
else
{
integer listpos = llListFindList(commands, llList2List(lst_msg, 1, 1));
if(listpos != -1)
{
com_handle(listpos, llList2String(lst_msg, 2));
}
}
}
//If Response to customize, confirm
else if((llList2String(lst_msg, 0) == “yes”) && wait_for_conf)
{
llSay(0, “Changing command to ” + temp_newcommand);
commands = llDeleteSubList(commands, temp_newcom_pos, temp_newcom_pos);
commands = llListInsertList(commands, [temp_newcommand], temp_newcom_pos);
}
else
{
wait_for_conf = FALSE;
}
}

control_handler(integer levels, integer edges)
{
test_move =TRUE;
accel_count ++;
if(accel_count > accel)
{
accel_count = accel;
}
float acc_percent = 1;
if(accelmode)
{
accel_count ++;
if(accel_count > accel)
{
accel_count = accel;
}
acc_percent = accel_count / accel;
}
float turning = 1;
vector impulse = <0,0,0>;
if (levels & CONTROL_UP)
{
impulse += <0,0,speed>;
}
if (levels & CONTROL_DOWN)
{
impulse += <0,0,-speed>;
}
if (levels & CONTROL_FWD)
{
impulse += <speed,0,0>;
}
if (levels & CONTROL_BACK)
{
impulse += <-speed,0,0>;
}
if (levels & CONTROL_LEFT)
{
impulse += <0,speed,0>;
}
if (levels & CONTROL_RIGHT)
{
impulse += <0,-speed,0>;
}
if (levels & CONTROL_ROT_RIGHT)
{
if(turnmode)
{
turning = 0;
}
}
if (levels & CONTROL_ROT_LEFT)
{
if(turnmode)
{
turning = 0;
}
}
llApplyImpulse((vector)(impulse * move * turning * acc_percent), TRUE);
}

//Default State, sets up basic listens, and events
default
{
state_entry()
{
get_controls();
}

on_rez(integer param)
{
get_controls();
}

listen(integer channel, string name, key id, string message)
{
listen_handler(message);
}

control(key id, integer levels, integer edges)
{
control_handler(levels, edges);
}

timer()
{
set_flight();
if(!test_move)
{
accel_count = -1;
}
test_move = FALSE;
}

//Detect touch, if not owner then give info. If owner display help.
touch(integer total_touched)
{
integer a = 0;
key toucher;
for(a = 0; a < total_touched; a++)
{
toucher = llDetectedKey(a);
if(toucher == llGetOwner())
{
llGiveInventory(toucher, notehelp);
llSay(0, “Please type ‘” + llList2String(commands, 0) + ” help’ for more help with commands”);
}
else
{
llGiveInventory(toucher, notecard);
}
}
}

//Detect if permission to take controls is enabled
run_time_permissions(integer permissions)
{
if (llGetPermissions() & PERMISSION_TAKE_CONTROLS)
{
llSay(0, “All Go”);
llTakeControls(CONTROL_DOWN|CONTROL_UP|CONTROL_FWD|CONTROL_BACK|CONTROL_LEFT|CONTROL_RIGHT|CONTROL_ROT_LEFT|CONTROL_ROT_RIGHT, TRUE, TRUE);
}
}
}

This is the only working invisiprim script I have found. Retrieved from LSL Wiki. Just add it to an object and the object will become an avatar hiding invisiprim!

///////Created by Joker Opus, November 8th//////
//Feel free to mod this, do not steal//

default
{
state_entry()
{
key owner = llGetOwner();
llListen(0,”",owner,”");
llSetTexture(“38b86f85-2575-52a9-a531-23108d8da837″, ALL_SIDES);
llSetTexture(“e97cf410-8e61-7005-ec06-629eba4cd1fb”, ALL_SIDES);                     //This is all the textures and functions that formulate the invisiprim
llSetPrimitiveParams([PRIM_BUMP_SHINY, ALL_SIDES, PRIM_SHINY_NONE, PRIM_BUMP_BRIGHT]);
llOffsetTexture(0.468, 0.0, ALL_SIDES);
llScaleTexture(0.0, 0.0, ALL_SIDES);
llSetAlpha(1.0, ALL_SIDES);
llSetTimerEvent(5);
}
listen(integer channel, string name, key id, string msg)
{
if( msg== “uncloak” )
{                                          //When you say uncloak, it will go back to a non-invisiprim.
llSetTexture(“4c1ce202-4196-f1c1-0409-367b3a71543e”, ALL_SIDES);
}
}
}

Note: I did not make this script, Zindorf Yossarian did. Stick the script in an object and start calculating!

// Calculator
// By Zindorf Yossarian (Please include my name with any version of this script – I worked hard on it.)
//
// CAPABILITES
//
// My aim with this calculator was to make it capable of most of the basic functions of a scientific calculator. Its capablilies are as follows:
// Basics: All the functions addition, subtraction, multiplication, division, exponents, and radicals are supported, as well as negative numbers.
// Parentheses: Any number of parentheses may be used in an expression.
// Trigonometry: Sine, Cosine, Tangent, Arcsine, Arccosine, and Arctangent are supported.
// Angle modes: Answers can computed using degrees or radians.
// pi and e are preset constants, and can be used in your expressions.
// Variables: The user can define and use variables.
// Answer Memory: The calculator will remember the answer to the last problem, and the term “ans” can be used in the next expression to refer to the last answer.
//
// USING THE CALCULATOR
//
// To compute an expression, type the expression, followed by an equals “=” sign. Spacing does not matter.
// ex. “2+2 =” will return 4. “3^3 =” will return 9. “3*(4/-2)=” will return -6.
// For radicals, use sqrt. It will take the square root of the value directly following it.
// ex. “sqrt 4 =” will return 2. “sqrt (20*5) =” will return 10.
// Trigonometric functions too will use the value directly following it.
// The trigonometric functions this calculator uses are sin, cos, tan, asin, acos, & atan.
// asin, acos, and atan are arcfunctions, or 1/sin, 1/cos, and 1/tan. They are the opposite of the sin, cos, and tan.
// ex. “sin 90 =” will return 1. “tan 45 =” will return 1. “atan(tan 30) =” will return 30.
// Angle mode can be toggled between degree and radian mode. To change the mode, say “degree mode” or “radian mode”.
// The default mode is degree.
// To store variable, say “store”, followed by the desired variable name, followed by the equals “=” sign, followed by the desired variable value.
// The variable name will appear in hovertext, followed by its value. You may also use mathematical expressions to define variables.
// ex. “store foo = 6″ will store foo as six, for later use. Text will appear with “foo = 6″.
// you may then use foo in an expression: “foo ^ 2 =” will return 36.
// then you may say, “store bar = foo + 3″. bar will be stored as 9, and the text will add another line with “bar = 9″.
// To delete a variable, say “delete” follwed by the variable name.
//

list storedVariables = ["ans", 0, "pi", 3.141593, "e", 2.718282]; // This list is used to store the user-defined variables, and always has three variables for
// the last answer “ans” variable, pi, and e. It is strided, so it has the variable name followed by that variable’s
// value in the list. For now, the value of “ans” is 0, but it will change when expressions are solved.

list variableNames = ["ans", "pi", "e"]; // This list holds only the names of the user-defined variables, as well as “ans”. It does not include their values.
integer angleMode = 1; // angleMode can be either 1 or 0, 1 being degrees mode, and 0 being radian mode. For now we are in degree mode.

debug(string debugInput) // This function exists as a convienient way to debug the script.
{ // All you need to do is pass a string to it, and it will say the string to the owner.
llOwnerSay(debugInput); // This is preferable to many decentralized ownersays, because with this you can stop
} // the debugs by commenting out one line.

update_text() // This function updates the hovertext which displays your variables.
{
list unstridedVars; // This list will hold in each entry a string consisting of the variable name, then an equals sign, then the value. We use this list for
// setting the hovertext that tells the value of each variable.
integer indexCounter; // The indexCounter is used as we scan the strided storedVariables list, and put the names of the variables into the unstridedVars list.

// We start this loop with the counter at 6, the index in the storedVariables list where the first user-defined variable name is. (remember the first six entries
// are for stored answers and constants) the counter is incremented by 2 each time, so that we go to the next name in the strided list, and skip the numbers.
for (indexCounter = 6; indexCounter < llGetListLength(storedVariables); indexCounter = indexCounter + 2)
{
// We get a list comprising of the variable name and the value after it from the storedVariables list, which is made elsewhere.
// Then we convert those two name and value entries to a string, and insert an “=” between them.
// That string with “name = value” is added to the unstridedVars list.
unstridedVars += [llDumpList2String(llList2List(storedVariables, indexCounter, indexCounter + 1), " = ")];

// Remember that list just for holding the variable names? Here’s where we put in all those names. First we reset the list to get rid of old, possibly deleted names.
variableNames = ["ans", "pi", "e"];
// Now that we have a nice clean slate, we just grab the variable name entry from the storedVariables list, and add it to the variableNames list.
variableNames += llList2List(storedVariables, indexCounter, indexCounter);
}

// Finally, the loop finishes, so we can display our variables. The unstridedVars list (with the “name = value” strings) is converted into a string, and “\n” newlines are
// inserted to put each variable on its own line.
llSetText(llDumpList2String(unstridedVars, “\n”) + “\n \n \n “, <.7, 0, 0>, 1);

// “What about the variableNames list?”, you ask, “You never used it!” Don’t worry, we just piggybacked off of this function to set it up. It’s used a bit later, in both
// the solving_initiator and the variables_handler functions.
}

// Here is where it all begins. When the calculator recognizes some speech as a mathematical expression being put in, that expression gets sent here, in raw string form.
list solving_initiator(string initiatorInput)
{
// First things first. We have to convert that big string to something the calculator can understand, like a list. llParseString2List is perfect for this. We can
// look at our string, and make list entries for each mathy thing, while throwing out spaces. But due to some limitations in the number of things the function can parse
// a string into all at once, we divide this parsing business into three parts, converting to strings in between each parsing.

// The first think that gets put into list form is the variables. We parse the string, throwing out nothing, and list-o-fying all the variable names.
list math = llParseString2List(initiatorInput, [], variableNames);
// Now our list probably looks something like this: ["mathy stuff, like 6+2 * sin 3", "some variable name NOT its value.", "some more mathy stuff", "another variable name"]

// The list is put into the variables_handler function, which converts all the variable names to their numerical values. That list is then made into a string, with “, “
// between each element.
string CSVmath = llList2CSV(variables_handler(math));
// And we parse the string again, this time for operators and parenthesis. And we throw out commas, spaces, and that equals sign you put at the end of the expression.
math = llParseString2List(CSVmath, [",", " ","="], ["(", ")", "+", "-", "*", "/", "^"]);
// Now the list looks like this: ["number", "operator", "another number", "another operator", "a variable"]
CSVmath = llList2CSV(math); // Again, the list is converted to a string with “, ” between each element.
// Now for the final parsing, for all the trigonometric functions.
math = llParseString2List(CSVmath, [",", " ", "="], ["sqrt", "asin", "acos", "atan", "sin", "cos", "tan"]);

// Yay! we have a list with all the the parts of the expression separated, and with actual numbers instead of variable names.
// It’s time to do some math.

// We look for parenthesis in the math list. If there are parentheses, we need to deal with them. If not, we can skip a step and just do the math.
if(llListFindList(math, ["("]) != -1)
{
// Yes, there are parenthesis. Go to the parentheses_handler function, and save whatever it spits back.
math = parentheses_handler(math);
}
else
{
// Nope, no parenthesis. Go to the math_handler function, and save whatever it spits back.
math = math_handler(math);
}

return math; // Finally, return that math list. By now, it should be only one number: The solution.
}

// This function is for finding the variable names in a list, and replacing them with their value. The function is always called from the solving_initiator,
// and is supplied with a list with the variable names parsed out. You will notice that through this function, I just modify the input variable, variablesInput,
// until it is what I want to output. Yes, I know this is kinda lame, since most the time it isn’t really the input, but why waste extra variables when you already
// have a perfectly good one. I do this a lot with input variables, so be aware of it.
list variables_handler(list variablesInput)
{
integer tempInteger; // We use this mostly in the for loop, to look at each part of the input list, checking for variables.
// The loop will consecutively go through each element in the input list.
for (tempInteger = 0; tempInteger < llGetListLength(variablesInput); tempInteger ++)
{
// We look for the current element in the input list, checking to see whether it is in the variables list.
// llListFindList returns -1 if the thing looked for does not exist.
integer tempIndex = llListFindList(variableNames, llList2List(variablesInput, tempInteger, tempInteger));
if (tempIndex != -1)
{
// The index was not -1, so there was a variable! Replace the name with its value.
variablesInput = llListReplaceList(variablesInput, llList2List(storedVariables, tempIndex*2 + 1, tempIndex*2 + 1), tempInteger, tempInteger);
}
}

// The entire input list has been scanned through, so we return the result to the solving_initiator.
return variablesInput;
}

// The parentheses_handler. It is the backbone of this calculator, and also happens to be the most complicated part. It systematically goes through the expression,
// finding sets of parentheses, and handing the contents of them over to the math_handler to be solved. The answer it gets from the math_handler then replaces that
// set of parentheses, and it looks for the next set. This is called from the solving_initiator, and takes a fully parsed list with the mathematical expression.
list parentheses_handler(list parenInput)
{
while (TRUE) // We just keep going through this loop over and over until all the parentheses are gone.
{
// We find the index of the first forward parentheses, and the first backward parentheses.
integer forwardParenIndex = llListFindList(parenInput, ["("]);
integer backwardParenIndex = llListFindList(parenInput, [")"]);
if (forwardParenIndex != -1 && forwardParenIndex < backwardParenIndex) // If a forward parenthesis occurs before the backward one.
{
// This finds the backwards parentheses opposite to the forward one.
integer corrParenIndex = corresponding_paren_finder(parenInput, forwardParenIndex, backwardParenIndex);

// Everything after the forward parentheses is sent to the parentheses_handler, and the result, which will be a single number, is put into the original
// list, in place of the set of parentheses. Yes, this does call upon itself. Another copy of itself. And that copy might call on another copy, and so on.
// But each time, everything before the first forward parentheses, and the forward parentheses itself is cut off. Eventually, the backwards
// parentheses will come first, or there will be no more forward parentheses. And then that bit of math inside the parentheses is solved, and returned.
// And the next copy solves and returns and the next copy solves and returns until we are all the way back here. If all that hurts your head, don’t worry:
// It hurts mine too.
parenInput = llListReplaceList(parenInput, parentheses_handler(llList2List(parenInput, forwardParenIndex + 1, -1)), forwardParenIndex, corrParenIndex);
}

else if (backwardParenIndex != -1 && (forwardParenIndex == -1 || forwardParenIndex > backwardParenIndex)) // There is a backward parentheses, and it is either in
{ // front of the forward one, or there is no forward one.
parenInput = llDeleteSubList(parenInput, backwardParenIndex, -1); // Everything behind and including the backwards parenthesses is deleted.
}
else // If neither of the above two ifs are true, there are no parenthesis. The list is now ripe for the solving.
{
parenInput = math_handler(parenInput); // And solved it is, with the math_handler.
return parenInput; // The solved thing is returned. It should be a single number.
}
}

return ["Something really exploded here."]; // This is just here for the compiler. Obviously, it will never get triggered, there is an “always” loop just above it!
}

// This function takes a list with a forward parentheses, and finds the backward one that corresponds, then returns the corresponding parentheses’ index.
// It is also passed the forward and backward parentheses indexes, as found in the parentheses_handler.
integer corresponding_paren_finder(list corrParenInput, integer forwardParenIndex, integer backwardParenIndex)
{
// Since llListFindList only gets the index of the first occurance of something, like our parentheses, we need to replace those parentheses with something else,
// so we can find the next one. Here, we replace forward parentheses with “f” and backwards ones with – you guessed it! – “b”. So let’s replace the first forward
// parentheses with an “f”…
corrParenInput = llListReplaceList(corrParenInput, ["f"], forwardParenIndex, forwardParenIndex);
forwardParenIndex = llListFindList(corrParenInput, ["("]); // … and find the next one.
integer level = 0; // “level” is used to keep track of the level or layer of parenthesis we are in, in case parentheses are nested.
do
{
if (forwardParenIndex != -1 && forwardParenIndex < backwardParenIndex) // There is a forward parentheses, and it comes before the backward one. There is a
{ // nested set of parenthesis!
corrParenInput = llListReplaceList(corrParenInput, ["f"], forwardParenIndex, forwardParenIndex); // Replace that forward parentheses with “f”…
forwardParenIndex = llListFindList(corrParenInput, ["("]); // … find the next forward parentheses…
level ++; // … and increase the level
}
else if (level > 0 && (forwardParenIndex == -1 || backwardParenIndex < forwardParenIndex)) // There is a backwards parenthesis before any forward ones, and
{ // the level is greater than 0. We need to check the level so that if
// this is the last backwards parentheses we don’t replace it, thereby
// losing the index.
corrParenInput = llListReplaceList(corrParenInput, ["b"], backwardParenIndex, backwardParenIndex); // Replace the parentheses with a “b”…
backwardParenIndex = llListFindList(corrParenInput, [")"]); // … find the next one…
level –; // … and decrease the level.
}
} while (level > 0); // Now, after all that is done, the level is checked. If is is more than zero, it repeats, or else it breaks from the loop.

return(llListFindList(corrParenInput, [")"])); // Return the index of the corresponding backwards parentheses.
}

// Ahh, the math_handler! So good for doing… math. This will take a list, which is by now free of parenthesis and variables, and is just numbers and operators,
// and computes the expression’s value, using the proper order of operations.
list math_handler(list mathInput)
{
integer tempIndex; // tempIndex is used a lot, in the many “for” loops here, as the index of an operator.
float tempSolution; // the solution to each small bit of the expression is put here for about .001 seconds, and then is moved into the main mathInput list, which
// slowly but surely gets solved.

// Each part of the math_handler represents a different calculator function. They all use “for” loops to check for the existence and location of the operator
// or trig function. Many are almost exactly similar to each other. The stuff inside the loop will only happen if the operator it is looking for exists.

// negatives – this looks for each “-”, and then checks out what comes before it to see whether it should be a negative number or a minus sign.
for (tempIndex = llListFindList(mathInput, ["-"]); tempIndex != -1; tempIndex = llListFindList(mathInput, ["-"]))
{
// If the “-” appears before anything else, or an operator appears before it, it must be a negative.
if (tempIndex == 0 || -1 != llListFindList(["(", "*", "/", "^", "sqrt", "sin", "cos", "tan", "asin", "acos", "atan", "+", "-"], llList2List(mathInput, tempIndex – 1, tempIndex – 1)))
{
tempSolution = (-1 * (float)llList2String(mathInput, tempIndex + 1)); // So multiply the number after the “-” by negative one…
mathInput = llListReplaceList(mathInput, [tempSolution], tempIndex, tempIndex + 1); // … and replace both the “-” and the number with that negative.
}
else // It’s a minus sign, but we still replace it with “m”, to distinguish it from negatives. Remember, that “for” loop checks for “-” each time. If we don’t
{ // replace the “-” with something else, it will loop endlessly.
mathInput = llListReplaceList(mathInput, ["m"], tempIndex, tempIndex);
}
}
// sines
for (tempIndex = llListFindList(mathInput, ["sin"]); tempIndex != -1; tempIndex = llListFindList(mathInput, ["sin"]))
{
// This is a compressed if/else statement, to save space. It uses an if/else to provide an answer in radians or degrees, depending on the mode.
// If the value of mode is 1, then input is converted to degrees before being processed. Or, if mode equals 0, no conversion occurs.
// The sin of the list element after the “sin” in the list is found, and that answer is put into the mathInput list. The next 5 trig functions
// are all roughly the same, so I won’t bother explaining them.
if (angleMode) { tempSolution = llSin((float)llList2String(mathInput, tempIndex + 1) * DEG_TO_RAD); }
else { tempSolution = llSin((float)llList2String(mathInput, tempIndex + 1)); }
mathInput = llListReplaceList(mathInput, [tempSolution], tempIndex, tempIndex + 1);
}
// cosines
for (tempIndex = llListFindList(mathInput, ["cos"]); tempIndex != -1; tempIndex = llListFindList(mathInput, ["cos"]))
{
if (angleMode) { tempSolution = llCos((float)llList2String(mathInput, tempIndex + 1) * DEG_TO_RAD); }
else { tempSolution = llCos((float)llList2String(mathInput, tempIndex + 1)); }
mathInput = llListReplaceList(mathInput, [tempSolution], tempIndex, tempIndex + 1);
}
// tangents
for (tempIndex = llListFindList(mathInput, ["tan"]); tempIndex != -1; tempIndex = llListFindList(mathInput, ["tan"]))
{
if (angleMode) { tempSolution = llTan((float)llList2String(mathInput, tempIndex + 1) * DEG_TO_RAD); }
else { tempSolution = llTan((float)llList2String(mathInput, tempIndex + 1)); }
mathInput = llListReplaceList(mathInput, [tempSolution], tempIndex, tempIndex + 1);
}
// arcsines
for (tempIndex = llListFindList(mathInput, ["asin"]); tempIndex != -1; tempIndex = llListFindList(mathInput, ["asin"]))
{
if (angleMode) { tempSolution = llAsin((float)llList2String(mathInput, tempIndex + 1)) * RAD_TO_DEG; }
else { tempSolution = llAsin((float)llList2String(mathInput, tempIndex + 1)); }
mathInput = llListReplaceList(mathInput, [tempSolution], tempIndex, tempIndex + 1);
}
// arccosines
for (tempIndex = llListFindList(mathInput, ["acos"]); tempIndex != -1; tempIndex = llListFindList(mathInput, ["acos"]))
{
if (angleMode) { tempSolution = llAcos((float)llList2String(mathInput, tempIndex + 1)) * RAD_TO_DEG; }
else { tempSolution = llAcos((float)llList2String(mathInput, tempIndex + 1)); }
mathInput = llListReplaceList(mathInput, [tempSolution], tempIndex, tempIndex + 1);
}
// arctangents
for (tempIndex = llListFindList(mathInput, ["atan"]); tempIndex != -1; tempIndex = llListFindList(mathInput, ["atan"]))
{
if (angleMode) { tempSolution = llAtan2((float)llList2String(mathInput, tempIndex + 1), 1) * RAD_TO_DEG; }
else { tempSolution = llAtan2((float)llList2String(mathInput, tempIndex + 1), 1); }
mathInput = llListReplaceList(mathInput, [tempSolution], tempIndex, tempIndex + 1);
}
// squareroots
for (tempIndex = llListFindList(mathInput, ["sqrt"]); tempIndex != -1; tempIndex = llListFindList(mathInput, ["sqrt"]))
{
tempSolution = llSqrt((float)llList2String(mathInput, tempIndex + 1)); // This finds the squareroot of the number after “sqrt”,
mathInput = llListReplaceList(mathInput, [tempSolution], tempIndex, tempIndex + 1); // and puts it into the mathInput list.
}
// exponents
for (tempIndex = llListFindList(mathInput, ["^"]); tempIndex != -1; tempIndex = llListFindList(mathInput, ["^"]))
{
tempSolution = llPow((float)llList2String(mathInput, tempIndex – 1) , (float)llList2String(mathInput, tempIndex + 1)); // This finds the number before “^”
mathInput = llListReplaceList(mathInput, [tempSolution], tempIndex – 1, tempIndex + 1); // to the power of the number after,
} // and puts it into the mathInput list.
// multiplication
for (tempIndex = llListFindList(mathInput, ["*"]); tempIndex != -1; tempIndex = llListFindList(mathInput, ["*"]))
{
tempSolution = (float)llList2String(mathInput, tempIndex – 1) * (float)llList2String(mathInput, tempIndex + 1); // Multiplies the number before “*”
mathInput = llListReplaceList(mathInput, [tempSolution], tempIndex – 1, tempIndex + 1); // by the number after, and puts it into
} // the mathInput list.
// division
for (tempIndex = llListFindList(mathInput, ["/"]); tempIndex != -1; tempIndex = llListFindList(mathInput, ["/"]))
{
tempSolution = (float)llList2String(mathInput, tempIndex – 1) / (float)llList2String(mathInput, tempIndex + 1); // Follows the same format as multiplication
mathInput = llListReplaceList(mathInput, [tempSolution], tempIndex – 1, tempIndex + 1);
}
// addition
for (tempIndex = llListFindList(mathInput, ["+"]); tempIndex != -1; tempIndex = llListFindList(mathInput, ["+"]))
{
tempSolution = (float)llList2String(mathInput, tempIndex – 1) + (float)llList2String(mathInput, tempIndex + 1); // Follows the same format as division
mathInput = llListReplaceList(mathInput, [tempSolution], tempIndex – 1, tempIndex + 1);
}
// subtraction
for (tempIndex = llListFindList(mathInput, ["m"]); tempIndex != -1; tempIndex = llListFindList(mathInput, ["m"]))
{
tempSolution = (float)llList2String(mathInput, tempIndex – 1) – (float)llList2String(mathInput, tempIndex + 1); // Follows the same format as addition
mathInput = llListReplaceList(mathInput, [tempSolution], tempIndex – 1, tempIndex + 1);
}
// We have now gone through the list and solved everything. There is one number left in the list.
return mathInput;
}

// That’s all the functions. Now into the friendly old default state.
default
{
state_entry()
{
llSetText(“”, <0,0,0>, 0); // Clears all hovertext with the variables.
llListen(0, “”, llGetOwner(), “”); // Listens to the owner.
}
listen(integer channel, string name, key id, string message)
{

if (llGetSubString(message, -1, -1) == “=”) // If an “=” sign comes last in the message, the user wants us to compute something!
{
list math = solving_initiator(message); // Send the message all the way up to the solving_initiator, where it begins its long journey to solvedom.
// After said long journey, the answer is put into the math list.

llWhisper(0, llDumpList2String(math, ” “)); // Whisper the answer. (You could use ownersay, but then you can’t show off the calculator.)

storedVariables = llListReplaceList(storedVariables, [llList2Float(math, 0)], 1, 1); // We just got a new answer, so put that in for the value of “ans”

}
else if (llGetSubString(message, 0, 4) == “store”) // The user wants to store something.
{
integer equalsIndex = llSubStringIndex(message, “=”); // Get the index of the equals sign.

// Get whatever comes after the equals sign, and solve it. Then store that solution to the variableValue list.
list variableValue = solving_initiator(llGetSubString(message, equalsIndex + 2, -1));
integer tempIndex = llListFindList(storedVariables, [llGetSubString(message, 6, equalsIndex - 2)]); // See if the variable is already stored.
if (tempIndex == -1) // If it is not…
{
storedVariables = storedVariables + [llGetSubString(message, 6, equalsIndex - 2), llList2String(variableValue, 0)]; // Add the variable and its value to the list.
update_text(); // Update the hovertext. (and the variableNames list too.)
}
else if (tempIndex > 7) // The variable was already in the list, and is not “ans” or a constant…
{
// So we just replace the old value with the new one
storedVariables = llListReplaceList(storedVariables, [llList2String(variableValue, 0)], tempIndex + 1, tempIndex + 1);
}
}
else if (llGetSubString(message, 0, 5) == “delete”) // The user wants to delete a variable.
{
integer tempIndex = llListFindList(storedVariables, [llGetSubString(message, 7, -1)]); // Find where that variable is
if (tempIndex > 5) // If the variable is in the list, and is not the answer variable or a constant…
{
storedVariables = llDeleteSubList(storedVariables, tempIndex, tempIndex + 1); // Delete the name and value of the variable
update_text(); // And update the text and variableNames
}
}
else if (llGetSubString(message, -4, -1) == “mode”) // The user wants to change the mode.
{
if (llGetSubString(message, 0, -6) == “radian”) // And he wants radian mode.
{
llWhisper(0, “Calculator set to radian mode.”); // Acknowledge the change, so the user knows the calculator heard him.
angleMode = 0; // And change the mode integer to 0. Since radians are used by the LSL functions, no conversion will occur
}
else if (llGetSubString(message, 0, -6) == “degree”) // He wants degree mode.
{
llWhisper(0, “Calculator set to degree mode.”); // Acknowledge the change.
angleMode = 1; // Change the mode integer so that the angles will be converted.
}
}
}
}

// Whew! All done commenting.

The Fur Tool, one of the most popular multi-tools on the grid (alongside the NK tool), is just about dead. When I first started SL, I visited the Fur Plateau, where a big sign handed out fur tools for free. Just about everyone on the grid had one, and the NK tool was only just appearing on the scene.

As the creators of the Fur Tool stopped support for the tool and ultimately removed the inventory giver, the Fur Tool lost popularity. It was impossible to get one if you didn’t already have it, and after the giver was gone for a little while, the only name in multi tools was NK. Half the people on the grid hadn’t even heard of the Fur Tool.

Now, only a select few SL veterans still have one, mostly as mementos of a time long gone in TSL. The functions on the Fur Tool have been reverse engineered (not really, but that sounds cool), and now there are free, open source multi tools that, though not as elegantly, offer the same features.

Here is the complete help file included in the Fur Tool. As you can see, it is chock full of useful, and useless, but equally cool, feaures. (It looks to me like a few of them are taken from the MG, though how, I don’t know)

Here is a picture of the fur tool while it is attached to my forearm:

The Fur.Light feature:

The Fur platform:

The help file from the Fur Tool:

=-[Fur.Tool] Help-=
=-Version: 2.4-=

Any case is accepted for all commands. For sensor features, short names are accepted.
The [Fur.Tool] listens on channel 2 as well as the default typing channel, 0.
Any abuse caused by this tool cannot be blamed on the creator and can only be blamed on the owner. Use at your own risk.

Optional HUD Attachment: Wear the “Fur Hud 2.0″ for a HUD that is quick and easy to use and that can do lots of the commands with the push of a button. Pressing the button on the side labeled “[FUR.TOOL]” will hide or show the HUD.

User Features
=========
Setting Theme “fur.theme.Name of Color”. (Added 2.0) – Colors are listed below.
Setting Theme Manually “fur.theme.<R,G,B>”. (Added 2.1)
Setting Random theme “fur.theme.random”. (Added 2.0)
Theme Colors “red”, “blue”, “green”, “white”, “black”, “orange”, “grey”, “yellow”, “gold”, “pink”, “cyan”, “purple”, “brown”, “dark red”, “navy”, “dark green”, “light blue”, “aquamarine”, “tan”, “hot pink”, “silver”, “orchid”, “slate grey”, “flesh”, and “copper”. (Added 2.0 – Updated 2.1)
Afk Ring “afk”. (Added 2.0)
Brb Ring “brb”. (Added 2.0)
Autoshield “fur.as:on” “fur.as:off”. (Added 1.6 – Updated 2.1)
Flight Enhacement Default On – Allows you to fly to any height “fur.fe:on” “fur.fe:off”. (Added 1.7)
Graphical User Interface “fur.menu”. (Added 1.6)
Goto Position “fur.gpos.<X,Y,Z>”. (Added 2.1)
Help Notecard “fur.help”. (Added 1.0)
Last (Does Last [Fur.Tool] Command Said) “fur.last”. (Added 1.6)
Locking to Position “fur.lock” “fur.unlock”. (Added 1.0 – Updated 2.2 – Now works even if you exit the sim)
Name2Key a Person “fur.n2k.Full And Exact name”. (Added 1.6)
News “fur.news”. (REMOVED)
Privacy Platform at Height “fur.pplat.height”. (Added 2.1)
Tool Hiding “fur.thide” “fur.tshow”. (Added 1.5)
Updating Tool “fur.update”. (Added 1.2 – Updated 2.3)
Animation Player “fur.anim.Animation Name” starts the dance/animation of your choice. (Added 1.2)
Just put any dance/animation you want into the gadget, and replace “Animation Name” with the dance/animation you put.
Current Dances Preset: chicken, funky, getdown, hiphop, zombie, and boogie.
“fur.anim off” stops the dance/animation.
“fur.anim all off” stops all animation you are doing. (Added 2.2)

Sensor Features
==========
Beaconing People “fur.beacon.avatarname”. (Added 1.0 – Updated 2.1)
Beacon Off “fur.beacon off”.
Bouncing People Away “fur.bounce.avatarname”. (Added 1.0)
Bouncing Self Away “fur.bounce.self”. (Added 1.7)
Follower “fur.follower” – to rez it. Then after rezzed, SIT on it and then say “fur.follow.avatarname” to follow. “fur.stop follow” to stop follow. “kill follower” to kill follower.
Goto a Person “fur.goto.avatarname”. (Added 2.0)
Hopping on People “fur.hopon.avatarname”. (Added 2.1)
Hugging People “fur.hug.avatarname”. (Added 1.2)
Inverse Bounce “fur.ibounce.avatarname”.( Added 2.4)
Kissing People “fur.kiss.avatarname”. (Added 1.2)
Pushing People Away “fur.push.avatarname”. (Added 1.0)
Pushing Self Away “fur.push.self”. (Added 1.7)
Requesting an Avatar To Your Position “fur.request.avatarname”. (Added 1.7)
Sitting on People “fur.siton.avatarname”. (Added 2.1)
Troning People In a Cone shaped Trap “fur.trap.avatarname”. (Added 2.4) – It traps them basically but in a cone.
Trone Features: Turn View of Person On “view on” View of Person Off “view off”.

Gravity Features
==========
No Gravity “fur.gravity off”. (Added 2.1 – Updated 2.2)
Gravity Normal “fur.gravity normal”. (Added 2.1 – Updated 2.2)
Gravity Medium “fur.gravity medium”. (Added 2.2)
Gravity High “fur.gravity high”. (Added 2.2)

Scanning Features (Updated 2.2)
============
Scan for Agents “fur.scan” “fur.scan.agent”. (Added 1.0)
Scan for Active Objects “fur.scan.active”. (Added 2.0)
Scan for Passive Objects “fur.scan.passive”. (Added 2.0)
Scan for Scripted Objects “fur.scan.scripted”. (Added 2.0)

Fur.Text Feature
==========
A feature which set texts that shows name, species, gender, orientation, and status above the gadget.
Make Text Visible “fur.text on”. (Added 1.0)
Make Text Invisible “fur.text off”. (Added 1.0)
Clear Text “fur.text clear”. (Added 2.4)
Setting Name “set name NAME”. (Added 1.0)
Setting Species “set species SPECIE”. (Added 1.0)
Setting Gender “set gender GENDER”. (Added 1.0 – Updated 2.1)
Setting Orientation “set orientation ORIENTATION”. (Added 1.0)
Setting Status “set status STATUS”. (Added 1.2)
Setting Color “set color <R,G,B>” “set color theme” “set color COLOR”. (Added 1.4)
(Theme – Applies Current Theme’s Color, COLOR – Replace with a color on the themes list)

Calculator Features (Added 1.4)
====================
“fadd x y” adds x and y.
“fsubtract x y” subtracts y from x.
“fmultiply x y” multiplies x and y.
“fdivide x y” divides x by y.
“fhalf x” halves x.
“fsqrt x” finds the square root of x.

Memo and Web Features (Added 1.6 & 1.7)
===========================
“fur.memo.MEMO HERE” to add a memo.
“fur.list memos” to list all memos.
“fur.rmemo.Memo #” to remove a memo. The memo numbers are listed beside the memo on the list.
“fur.aweb.website name~website url” to add a quick website.
“fur.list web” to list all sites.
“fur.rweb.Web #” to remove a website. The website numbers are listed beside the websites on the list.
“fur.web.Website Name” to go to the specified website name. The website name should be the one you put on the list.
“fur.web.URL” to go to a site even though it isn’t on the list.

Rezzing Features
===========
Platform “fur.platform”. (Added 1.0 – Updated 2.0)
Sphere Shield “fur.shield”. (Added 1.0 – Updated 2.0)
Posing Stand “fur.pose”. (Added 1.0 – Updated 2.0)
Meditation Mat “fur.mat”. (Added 1.3 – Updated 2.0)
Workspace “fur.workspace”. (Added 1.3 – Updated 2.0)
Light “fur.light”. (Added 2.0)
Hide “fur.hide”. (Added 1.0)
Reappear “/5reapp”. (Added 1.0)

Manual Mode Just drop an item in it and say “fur:rez:Object:velocity:rotation”. (Added 1.0 – Updated 1.7)
The velocity should be a vector. The rotation should look like <0,0,0,0> for example.
Just say “fur:rez:Object” for both these things not to apply.
Just say “fur.rez:object: : rotation” to skip velocity and go to rotation.

“R.A.T” Rez at Target Feature (Added 1.7):
“fur:rat:person:object:velocity”.
Again, velocity should look like a vector <1,1,1>.
You, also, do not have to specify a velocity.
Note: Object must be physical for the R.A.T to even work.

Killing Commands:

Platform “kill platform”
Sphere Shield “kill shield”.
Posing Stand “kill pose”.
Meditation Mat “kill mat”.
Workspace “kill workspace”.
Light “kill light”.
Kill All “kill all”.

Rezzed Sphere Shield Commands:

Turning the sphere shield’s push/follow features on “shield.on”.
Turning the sphere shield’s push/follow features off “shield.off”.

[Fur.Tool] Credits
===========
Scripter: Bhavin Poindexter.
Model Designer: Inuyasha Overlord.
Objects Designer: Reggie Clifton.
Beta Testers: Copper Shriner, Reggie Clifton, and Sesshomaru Takakura.
Fur.Hide Scripts by: Wolfy Fielding.
Privacy Platform Script: JacobX Goff.
Hug and Kiss Scripts from Hug and Kiss Attachment: Scripted by Francis Chung.

Yesterday, I spent a couple hours working on a new avatar for myself. I always cringe when I have to say that I am wearing items that others have made (I like to make everything myself), but I never really had the skills to make a good looking human. I didn’t really want a furry, mostly because of what they suggest on the main grid (it is not so much like that on the teen grid, but I still avoid them anyway). After reading the Plywood web comic, I decided I really wanted a robot avatar. They are simple, they almost always look good, and it kind of goes with my techie, scripting personality.

Here is the culmination of all my efforts:

It’s pretty basic, but, seeing as it is my first full avatar, I am pretty darn proud!

My new project, Dark Matter, is well underway. We are an initiative focused on helping with skill building and education in the teen grid and beyond. We will offer many resources for developers in SL and out to help them improve their skills and be better set to improve the world around them. Right now, the website is almost complete. All that is left is to find one more member for the team.

Eye4You has recently added a new sim connected to the original Eye4You island on the teen grid. The new are is meant to become a Wild West themed sim created almost entirely by teens. As far as I understand, any teen who wants to and has the necessary skills is welcome to help out on the build is whatever way they want. This will look pretty cool when it’s done!

SLurl: Land of LincolnTG