User:Toady Nakamura/Sandbox

From Second Life Wiki
Jump to navigation Jump to search

Operators

Arithmatic Operators

LSL has arithmetic operators which can be used with integers, floats, vectors and rotations.

The order of operation is

 result = left + right

The symbols, definition and examples of the operators:

=  ... denotes equality ... 1 = 1       
+  ... addition         ... 1 + 2 = 3
-  ... subtraction      ... 3 - 2 = 1
*  ... multiplication   ... 2 * 3 = 6
/  ... division         ... 6 / 3 = 2
%  ... remainder operator ... (see explanation below)

Since integers are whole numbers, if you divide 15/2 the answer is not a whole number and if you did that in a script the extra *remainder* is discarded as the answer is rounded toward zero. If you need the remainder, use the *remainder operator*, written as % to get what was otherwise lost.

This script snippet shows how the remainder operator works <lsl>

integer i;
i = 15 % 2;     // 15/2 = 7.5; 0.5 + 0.5 (for the two halves which were discarded) =1; 
                      // the remainder i is assigned the value 1
i = 15 % 4;     // 15/4 = 12; 15-12=3; 
                      //  the remainder i is assigned the value 3
i = -15 % 4;    // i is assigned the value -3

// remember to round toward zero not just "round down"! </lsl>

Vector data contains a set of three float values. In LSL adding vectors to vectors is done <x,y,z> + <x1,y1,z1> = the combined vector. The constant ZERO_VECTOR is equal to <0,0,0>. You can get to individual parts of a vector as shown in this snippet:

<lsl> vector vec; float x = vec.x; float y = vec.y; float z = vec.z; </lsl>

To combine rotations, you use the multiply and divide operators. Multiply * applies the rotation in the positive direction, the divide / does a negative rotation. The constant ZERO_ROTATION equals <0.0, 0.0, 0.0, 1.0>. Read the official wiki page for more on Rotations

Assignment using Arithmatic operators

There is a handy shorthand for adding repetitive values as seen in this snippet: <lsl> integer x; integer y;

x  +=  y;    //  means    x = x + y;  ... the new value of x is equal to x + y
x  -=  y;    //  means    x = x - y;  ... the new value of x is equal to x - y
x  *=  y;    //  means    x = x * y;  ... the new value of x is equal to x * y
x  /=  y;    //  means    x = x / y;  ... the new value of x is equal to x / y

</lsl>

Signed integers

Example: The plus integer (ex.: +1) is generally assumed. "It was -3 degrees today!" uses a negatively signed integer.

Comparison Operators

The comparison operators seek to determine equality (TRUE, value 1) or inequality (FALSE, value 0).

 !=  ...  not equal               ... 3 != 2 + 2
 <   ...  less than               ... 3 < 4
 >   ...  greater than            ... 4 > 3
 <=  ...  less than or equal      ... 2 <= 3
 >=  ...  greater than or equal   ... 3 >= 2

The result of a comparison operator is either 0 (FALSE) or 1 (TRUE).

Unary Operator

Because counting up or down by 1 is so common, a special *unary operator* has been created.

 ++ ... count up by one
 -- ... count down by one 

There are two ways to use the unary operators, but be careful, they are not identical. <lsl>

integer i = 0;
i++;     // i now has the value of 1 - because i++ means " evaluate then increment "
           // contributes its value before incrementation
++i;     // i now has the value of 2 -- because ++i means " increment then evaluate "

</lsl>

When used as part of a larger expression, i++ evaluates (values itself) and then increments but ++i counts up first, then adds its own value.

<lsl> *** NEEDS BETTER EXAMPLE >>>>> this has if/else and we havent' explained it yet

integer i = 0;
if (i++ == 0)  // Is evaluated then incremented.
   llSay( 0, "The value of i was 0 when the comparison was done" ) 
                // Will be said even though i ends up with the value of 1.
else
   llSay( 0, "The value of i was 1 when the comparison was done" )

</lsl> On the other hand, if we switch i++ to ++i, i.e. <lsl>

integer i = 0;
if (++i == 0) // Is incremented then evaluated.
   llSay( 0, "The value of i was 0 when the comparison was done" ) // Will not be said.
else
   llSay( 0, "The value of i was 1 when the comparison was done" )

</lsl> the chat output would be "The value of i was 1 when the comparison was done".

The operator minus-minus (written --) works similarly.

>>>> NEED BETTER EXAMPLE HERE

See for a list of all LSL operators and for a generalized discussion about Operators.

Cautions

  • If you try to divide (/) or remainder (%) anything by zero, you will get a run-time error and script fail.
  • If any arithmatic returns a value outside the range −2147483648 to 2147483647, different rules apply.

A good explanation can be foundhere.

  • Hexadecimal is rarely used in LSL, if you desire to learn more about it, click here .

Truth Values (Booleans)

Truth values (Booleans) are either 0 (FALSE) or 1 (TRUE).

Truth Value Operators

 !  ... means "not"
 && ... means "and"
 || ... means "or" 

These snippets show some of the ways statements evaluate to TRUE or FALSE <lsl> //The ! operator takes a single operand and evaluates to TRUE if the operand is false, and FALSE otherwise.

integer i;
i = !(3 == 7);     // 3 == 7 is FALSE, so i gets the value TRUE

//The && operator takes two operands and evaluates to TRUE if both its operands are true, and FALSE otherwise.

i = (3 < 7) && (3 > 7);     // 3 < 7 is TRUE, but (3 > 7) is FALSE, so i gets the value FALSE

//The || operator takes two operands and evaluates to TRUE if either one of its operands are true, and FALSE otherwise.

i = (3 < 7) || (3 > 7);     // one of the operands (3 < 7) is TRUE, so i gets the value TRUE

</lsl>

Like the binary arithmetic operators, && and || have a corresponding assignment type operator.

 x &&= y;    // Synonymous with x = x && y;
 x ||= y;    // Synonymous with x = x || y;

Statements Requiring Truth Values

There are four statement types that require a truth value condition:

  • if
  • for
  • while
  • do-while

There are three operators which look similar but have different meanings.

 =  ... assignment          ... "equal to"
 == ... test for equality   ... "exactly equal to"
 != ... test for inequality ... "not equal to"

if

An "if-then-else" command does a test (written inside parentheses), and if that test is TRUE, then the command will do something {written in brackets}, else the command will do something else - or nothing - when the test is FALSE. The command is formatted like these snippets:

<lsl> if (test)

    {do this} 

else

    {do that}

</lsl> You can leave off the "else" part if there's nothing for it to do, instead write <lsl>

if (test) 
    {do this}

</lsl>

Here's an example of how to set an integer as a switch, you can think of it as an iSwitch, and this script shows you how to use it.

<lsl> integer i = FALSE; // defined as off globally // and the value of off/on to FALSE (aka i=0;)

             // notice one * = * equals sign above, because the value is being set

default {

    state_entry()
    {
         llParticleSystem([ ]); // starts with particles off
    }
    touch_start(integer total_number)
    {
         if (i==FALSE)  // notice two *==* because this is testing for
                                // exact equality
        { 
              llParticleSystem([
                  PSYS_PART_FLAGS,
                        PSYS_PART_WIND_MASK | PSYS_PART_EMISSIVE_MASK,
                   PSYS_SRC_PATTERN, PSYS_SRC_PATTERN_EXPLODE,
                   PSYS_PART_START_COLOR, <1,0,0>
                                  ]);
              i=TRUE; // flip the iSwitch to the other setting & wait for next touch
                            // notice one * = * because the value is being set
         }
         else   // if the touch happened when particles were on 
         { 
              llParticleSystem([ ]); // turn particles off
              i=FALSE; // flip the iSwitch to the off position & wait for next touch
                            // notice one * = * because the value is being set
         }
    }

} </lsl>

<lsl> integer Counter; // define an integer to hold a value later default {

    state_entry()
    {
    llSay(0, "..I can count to myself, up to 10!..");
    }
    touch_start(integer total_number)
    {
         for (Counter=1; Counter<=10; ++Counter) //**
         {
              llOwnerSay((string)Counter);
         }
    }
    llOwnerSay("That wasn't so hard!");

} // ** This line contains the instructions for how many times to do this loop // First ... set initial value ... Counter = 1; // Second ... do the loop if the counter is less than or equal to 10 ... Counter <=10 // Third ... after each loop, add 1 to Counter ... ++Counter. </lsl>

These examples were originally on (http://wintermute.linguistics.ucla.edu/lsl/loop.html Ed Boost) which is unfortunately a dead link.

for

In programming, a "test" is something that comes out True or False (Yes or No and/or 1 & 0 ).

while

do while

Conclusion