abs(<-var) ->absvar

Calculates the absolute value of the item and pushes the result on the stack.

trace(abs(-1)) #prints '1' 

acos(-1) ->PiValue

Calculates the arccosine of the input, returns the result in radians.

trace(acos(-1)) #prints PI 

2 add (3) ->five

Adds two arguments together and pushes the result on the stack.

trace(add(21 21)) #prints 42 

<-bool1 and (<-bool2) ->boolResult

Pops two items from the stack and treats them as TRUE/FALSE (0/1 or Boolean) values. If they are both TRUE, 1 is pushed to the stack. Otherwise, 0 is pushed to the stack.

if (1 and (true)) 
    trace("1 and true are both true") 
endif 

AppendStackToList

Adds all values on the stack to the end of a list. The order of the values will be reversed.

Note that the stack will be empty after this call, so think before using it in functions.

Split("1,2,3,4,5,6" ",") ->list 
Split("1,2,3,4,5,6" ",") <-list AppendStackToList 
Trace(<-list) 

AppendToList( <-list <-var)

Adds a value to the end of a list.

Split("1,2,3,4,5,6" ",") ->list 
Split("1,2,3,4,5,6" ",") <-list AppendStackToList 
do (GetListCount(<-list) 0)
 Trace (<-list I GetListElement) 
loop

approximately(<-angle1 <-angle2)

Compares two floating point values and returns true if they are similar.

Floating point imprecision makes comparing floats using the equals operator inaccurate. For example, (1.0 == 10.0 / 10.0) might not return true every time. Approximately() compares two floats and returns true if they are within a small value (Epsilon*) of each other.

See Mathf.Approximately in Unity3D documentation

*Epsilon is defined as: The smallest value that a float can have different from zero.

if (approximately(1.000001 1)) 
    trace("1.000001 is approximately equal to 1") 
endif 

asfloat (<-integer1) ->float1

Converts an item on the stack to a floating point number and pushes it back onto the stack.

"1.23" asfloat ->val 

asin(<-one) ->halfPie

Calculates the arcsine of the input, returns result angle in radiants.

trace(asin(1)) #prints PI/2 

asint (<-floatval) ->intval

Converts an item on the stack to an integer, and pushes it back to the stack.

"42" asint ->val 

To be supplied

To be supplied

To be supplied

atan(<-toTarget)) ->targetRadians

Calculates the arctangent of the input, returns the angle in radians.

trace(atan(1)) #prints PI/4 

atan2(<-targetZ <-targetX) ->angleToTarget

Computes and returns the angle of the point y/x in radians. The return value is between positive pi and negative pi. Note that the first parameter to atan2 is always the z coordinate.

trace(atan2(1 2)) #prints '0.463647609' 

avg2(<-high <-low) ->average

Computes the average of two numbers.

40 ->low
44 ->high
avg2(<-high <-low) ->avg2
trace(<-avg2)  #outputs 42

break

Immediately exits the body of a ‘while/repeat/endwhile’ block or a ‘do/loop’ block.

do(5 0) 
    if (I mod(2) eq0) #divide inner loop with modulo 2 and test if zero 
        break 
    endif 
    trace(I) 
loop 

ceil(<-number) ->number

Takes one number from the stack, rounds it up, and pushes that number back on the stack.

trace(ceil(4.2)) #prints '5' 

ClearStack

Remove all items from the stack leaving it empty.

1 2 3 ClearStack #Stack is now empty 

ClearTraceLog

Removes all messages from the debug window.

ClearTraceLog  
"Fresh Message" Trace

Concat(“abc” “def”) ->sixLetters

Takes the first two items from the stack and concatenates them.

Trace(Concat("abc" "def")) # Prints "abcdef" 

CopyList (<-list1)->list2

Creates a copy of a list with the same contents. Note that if the list contains other lists, they will not be copied - for that you need DeepCopyList. See Copy vs Deep Copy for more info.

Split("1,2,3,4,5,6" ",") ->list 
<-list CopyList ->list2 
SetListElement(<-list2 0 "banana") 
Trace(<-list) 
Trace(<-lis2) 

cos(<-angle) ->cosAngleRadians

Calculates the cosine of the input angle in radians

trace(cos(PI)) #prints '-1' 

CR

Pushes a carriage return to the stack.

Trace( Concat (Concat("ABC" CR) "DEF")) 

CreateList ->list

Creates an empty list.

if (CreateList GetListCount eq0) 
    Trace("And lo, the list was empty.") 
endif 

createlist ->list
1 ->list[0]
4 ->list[1]
9 ->list[2]
trace(<-list)

createliststartingsize (<-size) ->list

Creates a list containing a specified number of null elements.

9 ->nullSize
createliststartingsize (<-nullSize) ->nullist
trace ( <-nullist)

createTable ->table

Creates an empty table and pushes it to the stack.

createTable ->table
1 ->table{"Larry"}
4 ->table{"Moe"}
9 ->table{"Curly"}
trace(<-table)

debug

Debug peeks at the stack and then prints out the datatype of the top item on the stack followed by the value coerced into an int, float, and string.

12
debug 
trace (mul (4)) #yields  48
# output_log.txt will contain 
#  INT 12 12 12
# 

DeepCopyList ( <-list) ->listDeepCopy

Creates a copy of a list with the same contents. Unlike CopyList, if the copied list contains other lists, those lists will be copied as well (and if those lists contain other lists, even those will be copied, etc, etc). See Copy vs Deep Copy for more info.

Split("A,B,C" ",") ->listInner
Split("1,2,3,4,5,6" ",") ->list
<-list <-listInner AppendToList
 
<-list CopyList ->listCopy
<-list DeepCopyList ->listDeepCopy
SetListElement(<-listInner 0 "banana") 
SetListElement(<-list 0 "orange") 

Trace(<-list) 
Trace(<-listCopy) 
Trace(<-listDeepCopy) 

mul(Deg2Rad <-angle)

Pushes the constant to use in converting from degrees to radians to the stack. Multiply this value with a value expressed as degrees to obtain radians.

trace(180 mul(Deg2Rad)) #prints PI 

distance(<-x <-z <-centerX <-centerZ) ->dist

Returns the distance between two given pairs of coordinates. (Or two sets of number pairs on the coordinate plane)

CurrentCoords 0 0 Distance ->Distance #Find the distance between itself and 0,0
<-Distance Trace

<-num1 div( <-num2) ->result

Divides the two arguments together and pushes the result on the stack. the output type (integer or float) depends on the input, except is the result is explicitly cast. See examples.

trace(5 div(4)) #prints '1'. Both arguments are integers so division is integer division 
trace(5 div(4.0)) #prints '1.2'. Handled as floating point division 
trace(5 div(4 asfloat)) #prints '1.2'. Handled as floating point division 

do(5 0)

The statements following the do, up to the loop statement, are executed repeatedly. Each iteration (loop), the initial value (Index) is incremented by one at the bottom of the loop and compared to Limit. When Index=Limit, execution will proceed at the first statement following Loop. Loops can be nested, but no more than 3 deep. See also: I, J and K.

NOTE: Limit comes first, then the initial value (index). This means that the first number should usually be bigger than the second number.

# single loop 
do(5 0) 
   trace(I) 
loop 
#  Prints:
#  0
#  1
#  2
#  3
#  4

Nested loops

do(2 0) 
    trace(I) 
    Do (4 2)
        Trace2 (J I)
        Do (6 4)
            Trace3 (K J I )
        loop
    loop
loop 

DQ

Pushes a double-quote (“) to the stack. This is the only way to create a string containing this character as they are normally used to delineate strings.

 DQ "Hello!" DQ concat concat trace

dup

Duplicates the item currently on the stack without removing the original item.

trace2(42 dup) #prints '42 42' 

dup2

Duplicates the top two items currently on the stack without removing the original pair.

trace4(42 1 dup2) #prints '42 1 42 1' 

e

Pushes the value of Euler’s number (e) to the stack (2.71828…)

trace(e) #prints 2.71828182845 

else

When an if statement evaluates to false, then the statements following the else, up to the endif, are executed instead. See if

if (<-var eq (1)) 
   #Do something 
else 
   #Do something else 
endif 

endif

Deimits the scope of an if-else-statement. Instructions between the if and endif statement are conditionally executed, depending on the results of the if evaluation. See if

if (<-var eq (1)) 
   #Do something 
else 
   #Do something else 
endif 

endonce

Ends a block defined by once. See once

once 
    trace("42") #Only prints once 
endonce 

Takes two strings from the stack and returns whether the first string ends with the second (case sensitive)

if (EndsWith("Hello there" "there")) 
    Trace("I went there") 
endif 

Returns execution to the ‘while’ statement. Note that endwhile is only executed, if ‘repeat’ evaluated to true. See While and repeat

5 ->y 
while 
    <-y gt(0)       #is y greater than zero? 
repeat              #repeat this section of code 
    trace(<-y) 
    <-y sub(1) ->y  #subtract 1 from y so we don't end in infinite loop 
endwhile 

eq

Top two items are popped from the stack and compared for equality. 0 or 1 is pushed back to the stack where 1 indicates equal and 0 (zero) ndicates not equal

the equal/not equal evaluation can also be performed with “true” (1) and false(0), respectively.

if (1 eq (1)) 
    trace("1 is equal to 1") 
endif 

#  alternate example 

1 dup eq 
if true 
  trace ("one is always one")
endif

eq0

Top item is popped from the stack and Compared to 0. 0 (false) or 1 (true) is pushed back to the stack.

if (0 eq0) 
    trace("0 is equal to 0") 
endif 

false

Pushes a 0 (false) nto the stack.

if (false) 
    trace("false") 
endif 

floor (<-num) ->num

Takes one number from the stack, rounds it down, and pushes that number back on the stack.

trace(floor(4.2)) #prints '4' 

GetListCount(<-list) ->listSize

Returns the number of entries in a list.

Split("There are four words" " ") ->list 
Trace(GetListCount(<-list)) 

GetListElement (I) ->element

Returns the value at the specified index of a list. Lists are indexed from zero.

Note: If a list is stored in a variable, this can be abbreviated to <-list[<-index].

Split("1,2,3,4,5,6" ",") ->list 
6 0 do 
    Trace (<-list I GetListElement)  #functionally equivalent
    Trace (<-list[I])                #functionally equivalent
loop 

To be supplied

GetType (<-something) ->typeOfSomething

Takes a value and returns a string of what type of value it is. Types: STRING INT FLOAT LIST NULL

"Value" GetType ->Type
<-Type trace #Would return STRING as the result 

5 gt (4)

The first item on the stack is compared to the second item on the stack. Both items are removed from the stack. If the first item is greater than the second, True (1) is pushed to the stack. If not, False (o) is pushed to the stack.

# Warp notation
if (42 gt (1)) 
    trace("42 is greater than 1") 
endif

5 gte (5)

The first item on the stack is compared to the second item on the stack. Both items are removed from the stack. If the first item is greater than or equal to the second, True (1) is pushed to the stack. If not, False (o) is pushed to the stack.

if (2 gte (2)) 
    trace("2 is greater than or equal to 2") 
endif 

HALFPI

Pushes the value of PI/2 to the stack.

trace(HALFPI) #prints '1.570796325' 

I

Current loop index. Pushes the value of the current “do” loop onto the stack. Only use within loops.

Note that I refers to the innermost loop. As loops are nested, I will continue to reference the innermost of the nested loops. See J K for other loop indexes. See Do and Loop

do(2 0) 
    trace(I) 
    Do (4 2)
        Trace2 (J I)
        Do (6 4)
            Trace3 (K J I )
        loop
    loop
loop 

if (<-var1 eq (<-var2))

Evaluate the first element on the stack. If True, then execute statements that follow, up to the endif or else statement. If False, execution skips to the first statement following the endif or else statement. Any nonzero value is considered True, a value of zero is False.

if (<-var eq (1)) 
   #Do Something 
endif 

InsertListElement(<-list 3 <-value)

Stores a value at the specified index of a list. The previously stored value, and all subsequent values have their indices shifted up by one.

Split("1,2,3,4,5,6" ",") ->list 
InsertListElement(<-list 3 "Spoon") 
Trace(<-list) 

J

First outer loop index. When loops are nested, this pushes the value of the first (or only) outer “do” loop onto the stack. Do not use outside nested loops.

Note: after the inner loop finishes, this value is accessed with I, it being now the innermost loop. See also: do, I, K, and Loop

do(6 5) 
    do(4 3) 
        trace4 ("Inner loop J=" J ", I=" I)
    loop 
     trace2 (" I =" I) #note: The value og I here will be the value of J when the loop above has terminated.
loop 

K

Outer loop index. When “do” loops are nested, this pushes the value of the third-innermost loop onto the stack. Do not use outside of triply-nested loops.

Note that before the inner loops begin, after they end, or between inner loops, this value may need to be referred to with J or even I. See also: Do, I, J, and Loop

do(2 1) 
    do(4 3) 
        do(6 5) 
            I J K Trace3
        loop 
    loop 
loop 

LF

Pushes a line feed to the stack. Useful for printing

Trace( Concat (Concat("ABC" LF) "DEF")) 

LN

The natural logarithm. Gives the magnitude of the number. On zero, returns -inf. Below zero, returns NaN, a special value that always causes failure when compared to other numbers. Eg. (NaN<0) -> false, (Nan>=0) -> false

other logarithms \  ln(x) = log(x, e) \
ln(x)/ln(10) = log10(x) \
ln(2)=0.6931… \
ln(e)=.999999 \
ln(10)=2.3026… \ 

trace(ln(-1)) #prints 'NaN' 
trace(ln(0))  #prints '-inf' 
trace(ln(1))  #prints '0' 
trace(ln(e))  #prints '1' 

log

Allows the performance of arbitrary based logarithms. See examples. On zero, returns -inf. Below zero, returns NaN, a special value that always causes failure when compared to other numbers. Eg. (NaN<0) -> false, (Nan>=0) -> false

other logarithms \
log(x,10) = log10(x) \
log(x,e) = ln(x)

trace(log(2 .5))   #prints '-1' 
trace(log(.25 .5)) #prints '2' 

LOG10

The base ten logarithm. Gives the number of digits in the number before the decimal point. On zero, returns -inf. Below zero, returns NaN, a special value that always causes failure when compared to other numbers. Eg. (NaN<0) -> false, (Nan>=0) -> false

other logarithms // log10(x) = log(x, 10) // log10(x)/log10(e) = ln(x) // log10(2)=0.3010-ish // log10(e)=0.4343-ish \
log10(10)=1 \

trace(log10(1))  # prints '0' 
trace(log10(10)) # prints '1' 

LOOP

Terminates the ‘do’ instruction loop . Control flow will return to the ‘do’ instruction until the Index is equal to the Limit.

do(5 0) 
   trace(I) 
loop 
 

LT

First item on the stack is compared to the second item on the stack.
0 (fasle) or 1 (true) is pushed to the stack depending on whether the first value was less than the second or not.

if (1 lt (42)) 
    trace("1 is less than 42") 
endif 

LTE

First item on the stack is compared to the second item on the stack.
0 (fasle) or 1 (true) is pushed to the stack depending on whether the first value was less or equal to the second or not. ## Examples

if (1 lte (1)) 
    trace("1 is less than or equal to 1") 
endif 

MAX

Push the greater of two arguments to the stack.

trace(max(4 5)) #prints '5' 

MIN

Push the smaller of two arguments to the stack.

trace(max(4 5)) #prints '4' 

MOD

Perform integer division and returns the value (modulo) of the difference.

trace(5 mod (3)) #prints '2' 

MUL

Multiplies the two arguments together and pushes the result on the stack.

trace(2 mul(3)) #prints '6' 

NEG

Calculates the negative value of the item and pushes the result on the stack. The result is effectively the same as multiplying the original number by -1.

trace(neg(42)) #prints '-42' 

NEQ

Top two items are popped from the stack and compared for equality. 0 or 1 is pushed back to the stack where 0 indicates false and 1 indicates true.

if (1 neq (2)) 
    trace("1 is not equal to 2") 
endif 

NEQ0

first item on the stack is compared to zero. If zero, true (1) is pushed on the stack, otherwise falsse (0) is pushed back to the stack.

if (1 neq0) 
    trace("1 is not equal to 0") 
endif 

NOT

Treats first item on the stack as a boolean value (true/false (1/0) , ‘nots’ it, and pushes 0 or 1 back to the stack. If the item is TRUE, 0 is pushed to the stack. If the item is FALSE, 1 is pushed to the stack.

if (not(false)) 
    trace("not false is true") 
endif 

NotPersist(“var_name”)

By default, variables persist across saves. Using this command makes them not persist across saves.

NotPersist("variableName")

ONCE

Start a block of instructions that are executed once only for the lifetime of the entity the script is associated with.

once 
    trace("42") #Only prints once 
endonce 

OR

Pops two items from the stack, treats them as boolean values, ‘ors’ them, and pushes 0 or 1 back to the stack. If one or both items evaluate to True, it returns TRUE (1) to the stack. If both items evaluate to FALSE, FALSE (0) is returned to the stack.

if (1 or (false)) 
    trace("1 or false is true") 
endif 

PI

Pushes the value of PI (3.14159265…) to the stack.

trace(PI) #prints '3.14159265' 

POP

Removes the item at the top of the stack.

42 pop #stack is now empty 

POW

Pops two arguments from the stack and raises the first to the second and pushes the result to the stack.

Trace (8 pow (3)) ) #prints '512' 

PrependStackToList (“Hello” “Creeper” “World” <-list)

Inserts the contents of the stack at the beginning of L1 (at index 0) and shifts the index of all other elements in the list up by the number of elements on the stack.

createlist ->list
AppendStacktoList ("foo" "bar" <-list)
PrependStackToList ("Hello" "Creeper" "World" <-list)
print (<-list)

PrependToList ( <-list item)

Adds a value to the beginning of a list. Any values previously stored in the list are shifted up by one.

Split("1,2,3,4,5,6" ",") ->list 
PrependToList( <-list 0) 
Trace(<-list) 

PRINT (“Hello World”)

Takes one item from the stack and writes it on a new line in a file called PRPL.txt in the game’s root content folder, preceded by the identifying information that indicates which unit or component called the PRINT function. Note that this file is truncated (cleared) each time a map is loaded.

To avoid having to constantly re-open the RPL.txt file to refresh it, a Windows Powershell commad (or Linus shell command) can be written to monitor the file and show new output.

Eg. Create a file in the game’s root directory named ShowRPL.PS1. Put this single line in the file

Get-Content RPL.txt -wait

Now, in the context menu for the file, click on “Run with PowerShell”.

#  Assume this core is at map coordinates (100, 50). Assume this script is named "Hello.prpl"
"Hello World!" print
#  Each time this line is invoked, a new line appears in PRPL.txt:
#  [100,50] Hello.prpl: Hello World!

PRINT2 (“Hello” “World”)

Prints 2 values from the stack into the rpl.txt output file. See PRINT or more details

Print2 ("X" <-x)

PRINT3 (“Hello” “World” ” Again“)

Prints 3 values from the stack into the rpl.txt output file. See PRINT for more details

Print3 ("Coords:" <-x <-y )

PRINT4 (“Oh” “Hello” “World” ” Again“)

Prints 4 values from the stack into the rpl.txt output file. See PRINT for more details

Print4  ("Coords and angle:" <-x <-y <-angle )

PRINT4 (“not” “another” “Hello” “world” “example”)

Prints 5 values from the stack into the rpl.txt output file. See PRINT for more details

Print5 (<-x "plus" <-y "is" <-x  add (<-y))  

PrintAll

Removes all values from the stack and prints them in the RPL.txt file The values will be on a single line and not separated by a space when printed. See PRINT for more details

PRINTALL ("cat" "dog" "rat" "mouse" "flea" "tick" "worm" "caterpillar" )
 

PrintAllSp

Removes all values from the stack and prints them into the RPL.txt file The values will be on a single line and will be separated by a space when printed. See PRINT] for more details

PRINTALLSP ("cat" "dog" "rat" "mouse" "flea" "tick" "worm" "caterpillar" )
 

PrintStack

Prints all the values from the stack to the RPL.txt file without removing them. The top and bottom of the stack will be identidfied, and the data type of each item will be provided. See PRINT for more details

Note ## Examples

PrintStack ("cat" "dog" "rat" "mouse" "flea" "tick" "worm" "caterpillar" )

QuarterPI

Pushes the value of PI/4 to the stack.

trace(HALFPI) #prints '0.7853981625' 

Rad2Deg

Pushes the constant to use in converting radians to degrees onto the stack. Multiply this value with a value expressed in radians to obtain degrees.

trace(PI mul(Rad2Deg)) #prints '180' 

randfloat (Hrando )

Gives a random floating-point number between 0 and 1

Trace ( RandFloat mul ( 2 mul (PI)))

randInt¹⁾ ->randi

Returns a random integer from a range of two numbers Inclusive of the lower number, but exclusive of the higher number. A workaround for between 0 and 10 both inclusive is in the example below. is to do 0 11 RandInt, so 11 will exclude but 10 will include [basically, 0 10 1 add RandInt]

# get a random integer between 1 and 10 (both numbers inclusive) 
RandInt(0 11)
# 
# or 
#   
RandInt( 0 10 add (1)) # functionally equivalent. 

Removes an element from a list at a given position. Position are indexed from 0.

Elements after the removed one will be shifted towards the start of the list.

createlist ->list
"a" ->list[0]
"b" ->list[1]
"c" ->list[2]
RemoveListElement(<-list 1)  #["a", "c"]

To be supplied

Repeat

Part of the “while: loop construct. Pops an item from the stack. If true, execute the following statements. If false, jump to the statement following ‘endwhile’.

5 ->y 
while 
    <-y gt(0)       #is y greater than zero? 
repeat              #repeat this section of code 
    trace(<-y) 
    <-y sub(1) ->y  #subtract 1 from y so we don't end in infinite loop 
endwhile 

Return

Stops execution of a function call and returns immediately. If called from some place other than a function, it will stop the script execution and ‘return’ immediately. Useful for aborting function execution or script execution when necessary.

trace(42) 
@MyFunc 
trace (43)
 
:MyFunc 
    trace("1") 
    return 
    trace("2") 

Round (<-value 2)

Rounds off a number to the specified number of decimal places. This always returns a float, even when you are rounding to a whole number.

trace(PI round(2)) #print '3.14' 

SetListElement(<-list <-index <-value)

Stores a value at the specified index of a list. The previously stored value is overwritten.

If a list is stored in a variable, this can be abbreviated to <-value ->list[<-index].

Split("1,2,3,4,5,6" ",") ->list 
SetListElement(<-list 2 "G") 
"R" ->list[4] 
Trace(<-list) 

To be supplied

ShortestAngle(<-cur <-new) ->rotAngle

Given two angles, calculates the shortest angle between the two. Useful for determining which direction a unit should rotate in order to turn to a given direction. A positive or negative value will be returned in the range of PI to -PI. Negative values indicate clockwise rotation.

trace(ShortestAngle(1.1 2.5)) 

SignalGenerator(<-interval <-sigFrequency <-phaseShift false -<signalType) ->sigValue

Computes the value for a given signal waveform and pushes it to the stack.

A function to derive the y-coordinate for a given x-co-ordiante on a graph line following one of the indicated wave patterns. Uselful to animate an object or to a given pattern over time. Could be used for instance to vary output from an emitter. Oscillating rightness of light source or beacon; Oscillating strength of an emitter over time - both of these can be thought of as a a use case for this function.

Arguments and type in order: 1: Integer. the X coordinate in the waveform (Eg. time) \
2: Float. Frequency of the waveform \
3: Float. PhaseShift of the waveform \
4: Bool. invert the waveform \  5: Integer. Signal type (0 to 6 in types, below) \ 

Signal types. 0 = NONE <br/> 1 = SINE <br/> 2 = SQUARE <br/> 3 = TRIANGLE <br/> 4 = SAWTOOTH <br/> 5 = RANDOM <br/> 6 = CONSTANT <br/>

#  On a map with terrain of 200 in X direction and at least 150 in Z direction (3D coordinates) 
# generate a sine wave of creeper across the map.
200    ->numFrames
      ->frequency (1 div (AsFloat (<-numFrames))) 
0     ->phaseShift
false ->invert
1     ->signalType #sine

do  (<-numFrames 0)
    SignalGenerator(I <-frequency <-phaseShift <-invert <-signalType )  ->sigValue
    round (<-sigValue) 2) ->sigValue
    print3 (I " : " <-sigValue )
    SetCreeper(I 75 add (<-sigValue mul (50)) 15 true)
loop

sin (PI)

Calculates the sine of the input angle

trace(sin(PI)) #prints 0 

Split (<-string <-delimiter) ->list

Takes two strings from the stack and splits the first wherever the second occurs. Returns a list of strings.

Split("Here is a sentence with some words in." " ") ->wordsList 
<-wordsList GetListCount 0 do 
    Trace(<-wordsList[I]) 
loop 

SQRT (<-value)

Pops an item from the stack and pushes the square root of that number to the stack.

trace(sqrt(9)) #prints '3' 

StackSize <stackDepth

Returns the number of items currently on the stack

1 2 3 trace(StackSize) #prints '3' 

StartsWith (<-thisString <-preamble)

Takes two strings from the stack and returns whether the first string starts with the second (case sensitive)

if (StartsWith("Hello there" "Hello")) 
    Trace("I opened with hello") 
endif 

Stringlength (<-thisString) ->numchar

Returns the number of characters in a string.

Trace( StringLength ("PRPL")) #Prints 4 

StringReplace (<-inputString <-match <-replace)

string ARG1: The string to be searched string ARG2: The string to search for in ARG1 string ARG3: The string to replace ARG2 with

Searches a string for all instances for another string, and replaces them with a different string.

Trace(StringReplace ("Where there's a will, there's a way." "will" "way")) 

StringToList (<-inputstring) ->charList

Takes a string from the stack and returns the list of characters in the string.

StringToList("Hello human") ->charactersList 
<-charactersList GetListCount 0 do 
    Trace(<-wordsList[I]) 
loop 

44 sub (2) ->result

Subtracts the two arguments together and pushes the result on the stack.

trace(44 sub(2)) #prints '42' 

Substring (<-aString <-startAt <-lenth) ->aPiece

Extracts a portion of a string into a new item on the stack.

The command has 3 arguments. First the string to be examined, second the starting position of the substring within the original string, starting from offset 0 (zero) and thirdly the length of the extrated string.

Trace( Substring("Particle" 1 3)) # Prints "art" 

swap

Swaps the order of the top two items on the stack.

trace2(swap(1 2)) #prints '2 1' 

tan (PI) ->tangent

Calculates the tangent of the input angle.

trace(tan(PI)) #prints 0 

TAU

Pushes the value of TAU (2PI) to the stack (6.2831853…)

trace(TAU) #prints '6.2831853' 

ToLower(<-string) ->string

Converts a string to lowercase.

Trace( ToLower("CRACKER")) 

ToUpper (<-string) ->string ## Description Converts a string to uppercase.

Trace( ToUpper("knuckle")) 

Trace (“ABC”)

Prints a value from the stack into the debug window.

Trace ("ABC") 

 if (<-value lt (0))
     Trace ("Warning: value is less than zero")
endif

Trace2 (<-thing1 <-thing2)

Prints 2 values from the stack into the debug window.

Trace2 ("X:" <-x )

Trace3 (<-thing1 <-thing2 <-thing3)

Prints 3 values from the stack into the debug window.

Trace3 ("Coords:" <-x <-z )

Trace4 (<-thing1 <-thing2 <-thing3 <-thing4)

Prints 4 values from the stack into the debug window.

Trace3 ("3 Coords:" <-x <-z <-y )

Trace5 (<-thing1 <-thing2 <-thing3 <-thing4 <-thing5)

Prints 5 values from the stack to the debug window.

Trace5 (<-x " plus " <-y " is " <-x  add  (<-y))

TraceAll

Removes all the values from the stack and prints them into the debug console. The values will be on a single line and not separated by a space when printed. Compare to TraceAllSP

"Where"
"is"  
"Waldo?"

traceAll  

TraceAllSp

Removes all the values from the stack and prints them into the debug console. The values will be on a single line and will be separated by a space when printed. Comparae to TraceAll

"Where"
"is"  
"Waldo?"

traceAllSp 

TraceStack

Prints all the items from the stack to the debug window without removing them. Items are printed one per line and the type of each is also provided.

# inspect what a function does to the stack
TraceStack # see stack before the call
@MyFunction
TraceStack # see stack after the call

true

Pushes a 1 onto the stack.

if (true) 
    trace("True") 
endif 

TwoPI

Pushes the value of TAU (2PI) to the stack (6.2831853…)

trace(TWOPI) #prints '6.2831853' 

While

Beginning of a while loop. The statements between a ‘while’ and a ‘repeat’ should ultimately push a value to the stack that will determine if the loop executes the body of the ‘repeat’ block.

A while loop is a control flow statement that allows code to be executed repeatedly based on a given Boolean condition. The while loop can be thought of as a repeating if statement.

5 ->y 
while   <-y gt(0)   #is y greater than zero? 
repeat              #repeat this section of code 
    trace(<-y) 
    <-y sub(1) ->y  #subtract 1 from y so we don't end in infinite loop 
endwhile 

XOR

Pops two items from the stack, treats them as boolean values, ‘xors’ them, and pushes 0 or 1 back to the stack. If both items are TRUE, 0 is pushed to the stack. If both items are FALSE, 0 is pushed to the stack. If one item is TRUE and the other is FALSE, 1 is pushed to the stack.

if (1 xor (false)) 
    trace("1 xor false is true") 
endif