~$/>>%<>==&<=->=+>>>,#@()
All Sunya Commands At Your Command

Here is a complete list of the system signals and retrieving instructions with examples.
It is recommended to first experience the tutorial to get a grasp on the Sunya Sinthax
in order to have a better understanding on how these instructions operate.
"write." at the beggining means the access key can also be modified(rewritten) besides
from being available to be copied.


Entity Access Keys


~/name
write. The name of the entity.



~/now
When this access key is requested, it will generate a number which is the number of miliseconds
that transcurred since Sunya is being executed on the local machine.



~/orbs
Returns a list of names from all orbs currently existing on the canvas.
We can specify aspect to only look for aspect match orbs or "all" to look for in all aspects:
"~/orbs/text" - Lists all text orbs
"~/orbs/script"	 - Lists all script orbs
"~/orbs/all" or simply "~/orbs"	 - Lists all orbs
We can then use a pattern to match orb names partially:
"~/orbs/all/Star"  - Lists all orbs which have "Star" somewhere in the orb name.
This command will look for all orbs that have the pattern 'Star' somewhere written
on their names and print it. NorthStar, Starless, EastStar .. all these would be printed.
We can even add a second pattern to search for inside the orbs that match the criteria.
"~/orbs/aspect/namepattern/contentpattern"
We can also just look inside all orbs content for a specific pattern by writting
"~/orbs/all/all/pattern"		
This instruction looks for all orbs with any aspect or name and searches for data inside them to match the pattern.
All matches will return the orb name so the instruction always returns a list of orbnames that match the
instruction request.



~/memheat
Miliseconds taken by the system to perform all operations requested in a single heartbeat.
We can use this instruction to monitor how long is the machine taking to perform all operations
requested in a single heartbeat.



~/heartbeat
write. Miliseconds taken by a Sunya heartbeat.
We can read or modify this key to asign a new rythm into the system.
The recommended rythm is 60 which means, we give 60 milisecond to the system
to perform all operations demanded. This rythm is adequate to create the illusion
of fluid movement with animations. Higher values might be useful to perform analysis on the system
or work with less powerful machines. Values lesser than 60 might cause mallfunctions
depending on the local machine available processing power.
Use with this criteria in mind.



~/stance
write. Holds the orb name of the current stance. Change this value using an orb name to
change the entity stance.
When the entity has a particular stance, Sunya sinthax can use symbols to refference
the orb that is currently stanciated. Also some orbs will react to certain conditions
depending on their aspect.


//deprecat
~/dsignat
read. write. Holds a single partial beat to colour all new forms that manifest,
to be used once created by the entity by default. A signature.



~/in
The value sent using "ein" on prompt. Clears at the end of every heartbeat



~/out
The value sent using "entry" on prompt. Clears at the end of every heartbeat.



~/inline
write. The current value on input box at any moment.
We can use a script to modify this value directly or an instruction from the prompt as well.



~/history
Holds a history of instructions executed from prompt.
We can access entries directly using range and by number sinthax.
~/history/1-5
~/history/7



~/historylimit
A number to determine the maximum number of entries on the entity history.



~/focus
write.  Takes values "on" and "off" to focus/unfocus on the input box.



~/kaoz
write.
This key can prevent Sunya from clearing up the screen at every heartbeat.
Use 'on' to unlock your artistic potential.
Use 'off' to make Sunya clear the screen at every heartbeat.
Helps you think with clarity.
Possible values are 'on' and 'off'.



~/wev
write.
Toggles script activity feedback animations. possible values are 'on' and 'off'.



~/lnum
write.
Toggles line number visibility. possible values are 'on' and 'off'.



~/thl
write.
Toggles for text selection highlights. possible values are 'on' and 'off'.


~/bhl
write.
Toggles for beats highlights. possible values are 'on' and 'off'.


~/melol
write.
Toggles for stance highlight. possible values are 'on' and 'off'.



~/akw
This access key contains all keywords used by the Sunya sinthax.
We can access it just like we would access any other container, by number, or by range
~/akw/from-to   etc


//deprecat
~/anu
This access key contains numbers from 1 to 9 and 0.
We can access it just like we would access any other container, by number, or by range
~/anu/from-to   etc


~/ale
This access key contains all (english) letters in minus and mayus for users to access.
We can access it just like we would access any other container, by number, or by range
~/ale/from-to   etc



~/prompt
write . The value of Entry. ~/prompt can process a text line written on the input box, 
acording to its value, after a send signal is executed wheter from a script or by pressing
the Enter key.
"eout" uses the value to be executed as a Sunya instruction and stores the instruction text on ~/out for a heartbeat.
"free" does not process the value.
"ein" uses the value to store the line on ~/in for a heartbeat.



Buffers

~/textbuffer
All text files requested from server or locally are stored here.
On its own, this instruction provides a list of all texts names we can work with.
We cannot directly add data in here, but all text buffers names requested from the local machine
or the server will be stored in here.
We can access each text by its name
and line range, from line specified to line specified.
~/textbuffer/textname/from-to
We can then copy these lines on to a target by its access key that can handle the amount of lines retrieved.
We can also modify buffered texts in here to create a permanently modified text document.
The sinthax is the same as with orbs, we simply create content and transfer it into the specified text.
#This line of text will be inserted on the textbuffer1 line number 10>>~/textbuffer/textbuffer1/10
We can also replace all specified lines like this:
:oneline anotherline yetanotherline >>~/textbuffer/textbuffer1/24-26
If content has less lines than specified range, then these lines will now hold the value of '' , which is
equivalent to "empty".





~/imagebuffer
read. Returns all names of loaded image files on the browser from local machine on a text list.



~/audiobuffer
read. Returns all names of loaded audio files on the browser on a text list as well.



~/mediabuffer
read. Returns a list of files requested using media interface.



~/x
read. write. Entity x coordinate. The center of the user screen.
We can request of modify the value stored in this key to relocate the view on the canvas
trough the x axis.


~/y
read. write. Entity y coordinate. The center as well.
We can request of modify the value stored in this key to relocate the view on the canvas
trough the y axis.



~/skeys
read. write. A list of shortcut keys to asign commands into keyboard symbols or
buttons for touchscreen users.
We can modify these lines and put them back to effectively modify all user keys
shortcuts.
~/skeys/new
We can use 'new' on this command to add a new shortcut to the list. example:
#name,MyButton,com1,~/orbs>>~/skeys/new,key,Digit4
The skeys container works with text lines in a specific format:
name,the name we want to asign to this button,com1,a command to execute,key,the name of the key on the keyboard
Each element needs to be separated by a comma.



~/kcode1
Holds the first key code value stroke on the keyboard.


~/kcode2
Holds a second key code value stroke on the keyboard while the first one is still being pressed.


~/kcode3
Holds a third key code value stroke on the keyboard while the first and second ones are still being pressed.


~/tchs1
Holds an accessible by number list of touch data lines to describe a touch performed on the screen, the
first touch detected.
The number of lines held will depend on the number of positions the gesture has registered on the touchscreen.

~/tchs2


~/tchs3


~/screenx
read. Returns the x coordinate of the top left corner of the screen at any moment.


~/screeny
read. Returns the y coordinate of the top left corner of the screen at any moment.


~/screenw
read. Returns the width of the screen in pixels.


~/screenh
read. Returns the height of the screen in pixels.



~/anchor
read. write. Orbs names that are stored in /anchor will replicate all the displacements
perfomed by the entity.
We can add multiple orb names using
~/anchor/new
so the system does not overide the names previously stored on the container.
we can use
~/anchor/clear
the same to remove the specified orbs names from ~/anchor.





Signals

localbuffertext
//sdfsdfsdsds
~/textbuffer



localbufferaudio
Loads an audio file from the local machine and creates a buffer we can work with
We can create an empty audio buffer from scratch as well. We need to specify its size
and its name.
localbufferaudio/size>>newbuffername
Audio buffers can be accessed trough the entity key
~/audiobuffer



localbufferimage
Asks the browser to load an image from local machine into the program for orbs with the "image" Aspect
unsealed to use, in order to create animations. Sprites are convenient to work
with but any image.png will do.
Once an image is loaded into the browser, image orbs 
that want to use it must transfer the image path file into their image/file access key and they are ready to go.
#filepath.png>>orbname/image/file
To request for data lines holding all names of currently loaded images in
the browser canvas, we can use the command
~/imagebuffer
We can put loaded images names into a text and then use the dataline holding the name
we want to set up the image orb.
~/imagebuffer/filename>>orb/text<>orb/text/1>>orb2/image/file



localorbin
Ask the local machine for a text file to use to recall Orbs.



localstatein
Ask the local machine for a text file to use to recall a previous Sunya state.
A "Sunya state" is all orbs and entity parameters running on a moment in the past.
Its a "clear all orbs and recreate this moment" instruction. Use with caution.



serverbuffertext/textpath>>newname
A signal to request a text file from the server and create a text buffer to be stored on
~/textbuffer



serverbufferaudio>>audiofilepath
We can request an audio file from server and create a buffer we can work with.
We need to specify the path of the file. If the path is valid, a buffer will be created
and acessible trough
~/audiobuffer



serverbufferimage
sefgef43t43gtregresgnfrdfrd
~/imagebuffer



serverorbin>>jsonfilepath
Ask the server for a text file specified by name as jsonfilepath to use to recall Orbs stored on the server.



serverstatein>>jsonfilepath
Ask the server for a text file specified by name as jsonfilepath to use to recall a previous Sunya state.
A "Sunya state" is all orbs and entity parameters running on a moment in the past.
Its a "clear all orbs and recreate this moment" instruction. Use with caution.


//deprecat
jsonout>>target orb
Stringify orb from an orb name alone, a target or a target list, to be available to be copied from input box
jsonout>>orb/text
Use a list of orbs from the target to be stringified.
jsonout
Use jsonout alone to stringify a Sunya state from the current session.



downloadstate
Create and download a single string as a text file on json format containing all data from the current Sunya session.
Can be used with localstatein or serverstatein to recreate a Sunya state of the past.



downloadorb>>orb...orbnameslist
Download a text file in json containing the structure of a specified Orb.



downloadlines>>accesskey
Create and download a text file with all datalines retrieved from a target access key.



send
This signal will make the system process the content on ~/inline
acording to prompt value



rmlet
Removes the last letter from ~/inline



clear
Clears ~/inline value and sets Entry to 'free'



canvaser
This signal will adjust the canvas manually to the whole screen and normalize it if the screen size is changed
during a sunya session for any reason.
If you want to see the Javascript console for example, calling up the console
interface might mess up the canvas so we can just run canvaser to normalize operations by readjusting the position
after we call up or close the console interface.




@aspect>>neworbname 
Create a named orb with its aspect unsealed.
An Orb is a memory structure designed to contain data lines with diferent formats.
Replace 'aspect' with any of the 7 aspects to create an specialized orb.
text, script, circle, rectangle, line, image, audio
An orb can also be named using a data line from an orb text like this:
@text>>orb/text/1
If we dont specify a line, we can create multiple orbs with a specified Aspect
with a single command, using each line in the text as an orb new name:
@circle>>orb/text
By default, new Orbs initial position is the same as the caster, that is:
If the Entity created an orb from an instrution sent from the input box,
then the Orb will be located at the center of the screen.
If the instruction was executed by another Orb(a script Orb), then
the new Orb will be initially located at the same position as the script Orb that created it.
Optionally, we can specify an offset on x and y as an initial position like this:
@rectangle>>NewRectname,x,100,y,200
This comma separated instruction will add 100 pixels to the x vector and 200 pixels
to the y vector on the new orb created.
We can use this initial location specification on text lists to create multiple orbs
with specified offsets at once as well.




ka/accesskey>>target
The ka signal is useful to learn memory orbs structures.
We can use ka(key access) signal to request deeper access keys inside the specified one
after a provided accesskey. example
ka/orbname/text>>target
This instruction will print all access keys available to work with that begin with
"orbname/text" . In this example we are accessing a text orb so we will get the lines:
orbname/text/font
orbname/text/style
orbname/text/size
orbname/text/spacer
and so on..
If we want the first level access keys we only need to specify the name of the orb like this:
ka/orbname>>target
Not all access keys have more access keys inside.




delete>>orbname
Deletes the target orb if possible.
We can use a text from a line to select our target. like this
delete>>orb/text/line
We can also delete multiple orbs using a multiliner if we have orb names to be used
as targets on the text.
delete>>orb/text




rmline>>target
Remove a target data line or beat from an orb.
If we wanted to remove the third line from a specific Orb text we could say:
rmline>>orb/text/3
We can remove the currently selected line by typing in:
rmline>>orb/text/current
To remove any number of lines we can do:
rmline>>orb/text/3-15 .. to remove from line 3 to line 15 at once.
We can also remove beats from aspects just the same:
rmline>>orb/circle/4
We can also remove a specific parameter from all specified beats
rmline>>orb/circle/4/r or
rmline>>orb/circle/all/radius	To delete the radius parameter from all beats on the circle
We can also remove all lines from an orb aspect container by simply running
rmline>>orb/aspect



number/number>>target
If we want to simply create a number and send it into any specified container we can use
a "number" signal like this:
number/34>>text1/text/5
The number "34" would then be created and stored in line 5 of text1.
We can also use transfer sinthax to store this number at multiple lines like this:
number/9>>text2/text/3-12
This will create copies of the number 9 on the lines specified by range sinthax, that is,
from line number 3 all the way to line number 12.




Signals with retrieve sinthax

These are signals that begin with a special keyword and are then followed by a slash "/" , and then
a couple of access keys to work with.
Every signal uses the access keys provided in a different way to perform specific operations.
Some signals can even use literals "#" to create effects. Some signals need very specific values
provided by the access keys to work.
Gennerally, the first accesskey provided (thats the accesskey before ">>") will be used by the signal
to create a result to be channeled into the target provided by the second accesskey (thats the accesskey after ">>")
//but there might be exceptions.



scan/acesskey1>>accesskey2
scan is a signal that works with a list of names and 1 form orb name at the beggining of the list.
A circle, a rectangle, or a line orb, these are form aspects orbs.
accesskey1 first item should hold the name of the form orb we wish to use to scan the screen while
the rest of the items on accesskey1 should have the names of the orbs we wish to ask for their position.
We can use "$", "%" and "~" on this first list provided.
If any of these orbs happen to be inside the area of the form, then these names will be transfered to
the container provided by accesskey2 
If the signal produces no matches, then the target container provided by accesskey2 will be filled with empty
values ''.




append/acesskey>>target
if we say
append/orbname1/text/3>>orbname2/text/5
append grabs the third line from a source text orb, and appends the data into the line specified on the target line 5.
append can also produce multiple copies of its result. If we say
append/orb1/text/2>>orb2/text
the second line on orb1 will be appended to every single line on the target orb text.
we can also say
append/orb1/text/7>>orb2/text/3-6
so the result will only create enough copies to be added from line 3 to 6 on the target.
We can also extract a specific part of the source and append it on specific lines of target.
append/orb1/text/3-6>>orb/text/4
append will add all the lines of source(from 3 to 6 in this case) to the lines from target line 4 and forward.
Will create new lines if neccesary.
append/orb1/text/3-7>>orb2/text/9-20
append will try to fill from 9 to 20 lines on target using lines 3 to 7 from source. if not enough
lines from source to fill target, then line 7 will be repeated until target is filled.
append/#a literal data line>>target
append signal can simply append a literal line of text into a target using "#" after "append/".




random/accesskey1>>accesskey2
random signal takes 4 numbers as min, max, total and deci, and uses them to produce a total number of
random values in between min and max with as many decimals specified by deci.
The first line is the minimum value. The second line is the maximum value. So our random value is
somewhere between min and max. The third line is a number to specify how many results we want to produce,
how many random numbers we want to produce using the same range specified.
The fourth value, deci, is used to specify how many decimals we want to have on the results produced.
All 4 parameters of the signal need to be numbers.
acesskey2 is a text or a script container able to handle the number of results.
We can specify where we want to place the result of the command using the transfer sinthax.




interpol/accesskey1>>accesskey2
Stands for interpolarity. this command works with 4 parameters we provide using accesskey1.
first line is min, second line is max, third line is the number of
parts we want to be able to quantify. The fourth line is used to specify how many decimals we want to
print on our results.
Use min, max and desired number of parts to return as many lines as equidistant parts.
each line holding a value in between min and max.
accesskey2 is a text or a script container or any access key able to handle the values produced.
We can specify where we want to place the result of the command using the transfer sinthax.



orbit/accesskey1>>accesskey2.. orbname.. ~
orbit is a signal that produces 2 values, an x y coordinate using 5 lines as parameters:
ang, radx, rady, offsx and offsy.
line 1 , ang needs to be a number between 0 and 6.28 which are radians. This is the angle we want to express from
the center of orbit.
line 2, radx, and line 3, rady specifies how far from the center we want the position to be in pixels.
radx determines the range of the orbit horizontally whilest rady determines the range of the orbit vertically.
line 4, offsx and line 5, offsy are the offsets of the position. these are the x and y position coordinates of the center of the orbit.
Target can be the name of an orb or ~, in which case will inmediately update the position of the
orb or entity center ~ to the result of the instruction.
We can also use the transfer sinthax to place the result of the operation(x and y, 2 lines)
on the specified target using an accesskey.



vivo/accesskey1>>accesskey2
A signal to produce a value from a different value.
vivo allows us to create a value given a set of rules. We use 2 lists, a value input, and a value output.
The first value on list1 is "vi", the first value on list2 is "vo".
list1 is provided by accesskey1, whilest list2 is provided by accesskey2.
When the signal is fired up, "vi" is compared with all other values on list1. If these match, we use the position
of the match on list1 to get the value from list2 on the same position, then we store this new value on "vo".
so its a 1 to 1 transformation. We can use these lists to create visual controls by transforming pixel numbers
into decimal numbers to be used on audio structures. Or we could use vivo to scale up or down some values.
So we can have a number 1, produce a number 100, or 1000, or even a word. Values obtained will depend 
on values on list2 . We can repeat some values on list2 if we are interested in simplifying an operation:
So if ~/x equals 1, or 2, or 3, or 4, or 5... we can produce the value of 1.1.
and if ~/x equals 6, or 7, or 8, or 9, or 10... we can produce the value of 1.2  .. and so on.
vivo works perfectly with interpol , random, orbit and other signals to create many effects.



transfer/list1>>list2
A signal to create multiple specific effects in a single heartbeat.
This signal takes 2 equal number of access keys stored on 2 texts, and combines them to perform multiple
transfering commands at once. list1 should hold an access key with a value that willl be transfered
into list2 access key on the same line.




xy/orbname>>target
Position x and y can be translated directly into a target orb or entity location with
this signal. Target can be a list of orbs. We can also say
xy/~>>target
to bring a target orb or a list of orbs to the center of the screen.




x/offsetx/orb...entity>>orb...entity
Extracts the x position from and orb or entity and adds an offset to the target
orb or entity that will now take this new value.



y/offsety/orb...entity>>orb...entity
Extracts the y position from and orb or entity and adds an offset to the target
orb or entity that will now take this new value.



runtime/newplace>>orb
We can asign a new position on the aspect cue using the runtime command. newplace is the new number
we wish to asign to the target on the aspect cue. 0 is the first place.
The lower this number is on the orb, the sooner this orb will perform regarding other orbs.



synch/source/1 3 5 something 3 6 anything
An advanced signal that allows the construction of instructions using datalines from a source
specified by numbers,  and literals.
synch first parameter is the name of a script or a text orb. The second parameter is a literal
line which will become the instruction we want to create. Synch allows the instruction to recall datalines
values from the source specified trough its sinthax. When a number is written between 2 empty spaces like this:
' 3 ' , the instruction will add the value on the line number 3 instead of ' 3 ' . In this way, we can build dynamic
instructions by changing the values on the lines specified in the instruction and casting the command as many times
as desired.
examples. A script named "orb1", has some lines and a synch instruction. With numbered lines, the script
looks like this:
1 hello
2 world
3 synch/orb1/# 1 >>orb2/text
When we run the script, this instruction will be read like this:
#hello>>orb2/text
Effectively storing the word "hello" on the /text container in orb2.





Orb Keys

$
Access data from the orb currently running the command. If an orb runs a
script and uses this symbol, then the symbol will
hold the value of the orb name that is running the script.


%
Access data from the orb currently on entity stance.
If an orb runs a script
and uses this symbol, the symbol will now
hold the value of the entity stance orb at any moment.



orb/name
write. Returns the Orb name to be used somewhere else. Takes a value to
replace a target orb name if used like this:
#newname>>orb/name



orb/aspect
Returns the aspect of the orb.
We have 7 Aspects so far:
text, script, circle, rectangle, line, image, and audio.



orb/x , y
write We can access or modify the position of the orb center of activity.
All aspects use these values as refference to construct its animations.



orb/anchor
Orbs names that are stored in /anchor will replicate all the displacements
perfomed by the orb.
We can send multiple orb names using
orbnameslist>>orb/anchor/new
so the system does not overide the names previously stored on the container.
we can use
orbnameslist>>orb/anchor/clear
the same to remove the specified orbs names from /anchor.



orb/seal
Possible values: 1 and 0.
When an aspect is sealed (0), it will retain the data concerning
the aspect so we still might be able to modify it but animations, sounds, and
some other functionalities of the aspect will not be executed.
We can unseal an orb Aspect (1).
When an Aspect is unsealed, it becomes fully active. Not only we can modify the
aspect keys and containers but they will reflect changes instantly, run animations,
,create sounds and other funtionalities acording to the Aspect.





Text Aspect

orb/text
write. Returns or rewrites all text lines at once. We can dump any kind of
data into a text orb. We can also retrieve all lines
of text in the orb at once. examples:
orb/text>>orb2/text  Will copy all text lines from orb to orb2.
~/orbs>>orb/text Will dump a list of Orbs into an orb text target for us to see.
orb/x>>orb2/text  Will overwrite and put the value of orb x
into orb2 text.



orb/text/in
write. Returns input produced when the entity sends a line into a text orb from
input box. It can also be used to write a line
into the orb currently selected line position like this:
#some words here>>orb/text/in
The literal will now go into the selected current number line position on the target orb
and will also be available for any other orb listening to this input for
a heartbeat.



orb/text/cn
write. The number of the active, currently selected line on the orb text.
Change this number to change the currently selected line.



//deprecated... or not?
orb/text/total
read. The number of total lines in the container.



orb/text/1..2..3..4..1-5..4-12..last..current
write. Access lines by number or by keywords . "last" , and "current" .
When we dump a data line into a specific target like this, then the previous
line is overwriten. example:
#these eleven words will replace the fifth line on orb1 text>>orb1/text/5



orb/text/new
write. We can add the 'new' key like this in order to specify that we want to create a new line
at the end or the text. We only use this key when the command is writen on the right
side of '>>' ;
#This fourteen words will be added at the end of the target orb text>>target/text/new



//deprecat
orb/text/signat
read, write. signat holds a beat line which will be used to create all new lines on the text
by default. Changes in this container will also reflect on currently existing lines.
basic format looks like this:
r,200,g,200,b,200,a,1,layer,2




orb/text/hltextn
Creates a number to easily identify the lines on the text orb. Takes 'on' and 'off' values.



orb/text/hltexts
Highlights text selected, active line. Takes 'on' and 'off' values.



orb/text/wheel
read. write. Accept "on" or "off" to move text up and down when current line is polarized
upwards or downwards trough the y axis. Facillitates working with texts with lines numbers that
go beyond the screen size.



orb/text/inop
on insert operation. if value is 'insert', then the line we add to the text
using orb/in will be added directly on the place specified by orb/text/cn .
If we use 'replace', then the line we add will replace the currently selected
line text.



orb/text/spacer
A number to determine how much space we want to see between lines on a text.


orb/text/size
A number to determine the size of the text. Minimum value is 3.
Maximum value is 10000... which is pretty dope.


orb/text/font
The font of the text. What font families will be available will depend on the local machine
but it doesnt hurt to try all these:
"courier", "georgia", "arial", "webdings", "verdana", "trebuchet ms", "sans-serif", "monospace", "comic sans ms", "cursive", "impact" 
Try using polarity signals to scroll trough these.



orb/text/style
The style of the text. These are the most common on browsers:
"normal", "italic", "bold"
Polarity signals also allor scrolling trough these.



orb/text/align
Text align.
'left', 'right', 'center'


orb/text/r


orb/text/g


orb/text/b

	
orb/text/a





Script Aspect

orb/script
write. Returns or rewrites all command lines stored in the orb at once.


orb/script/run
write, The value in this orb key will determine the behavior of the script. 'off' ,'once' and 'loop'.
'off' will stop the execution of the script.
'once' will execute the script contained in the orb once.
'loop' will execute over and over in a loop.


orb/script/cn
write. The number of the active line. Current number line that contains the instruction being executed.


orb/script/1..2..3..4.. last..current
write. Access command lines on script container.


orb/script/new
write. append a new command line at the end of the script.





Circle Aspect

orb/circle
write. Holds all circle aspect beats formated lines only.
A beat format line for circle aspects look like this:
r,200,g,120,b,210,a,0.8,radius,100


orb/circle/tchs
This access key transforms the area of the form aspect(circle in this case) into a button
for touchscreens.
tchs accesskey can be filled with a maximum of 4 lines and a minimum of 2 lines.
The first line always correspond to a word which becomes a keycode that can be used to
call an instruction everytime we touch the area of the form. This keycode can be included
in a shortkey instruction to create a button.
The second line needs to specify the touch that will request the command asociated to the shortkey.
If we use "1", then the command will be called when the first finger on the screen touches the area.
If we use "2", then the command will only be called when a second finger on the screen touches the area.
If we use "3", then the command will only be called when a third finger on the screen touches the area.


orb/circle/new


orb/circle/run	
write, The value in this orb key will determine the behavior of the circle animation.
'off' ,'once' and 'loop'.
'off' will stop the execution of the circle animation.
'once' will execute the circle animatino contained in the orb once.
'loop' will execute over and over in a loop.


orb/circle/cn
write,toggle. The number of the active beat line. Holds the value of the circle current beat number.


orb/circle/1..2..3..4.. last.. current
write. Retrieve beat format line or write a beat into it to modify the beat parameters of the circle.


orb/circle/1..2..3..4.. last.. current..all..from-to../parameter
write. A parameter on a beat can be read or modified directly.
We can also use polarity signals to increase or decrease a specified parameter
from the specified beat or beats.






Rectangle Aspect

orb/rectangle
write. Holds all rectangle aspect beats formated lines only.
The rectangle beat format line with all its possible parameters defined looks like this:
x,0,y,0,w,200,h,200,r,255,g,255,b,255,a,1,layer,2,inside,empty



orb/rectangle/tchs
This access key transforms the area of the form aspect(rectangle in this case) into a button
for touchscreens.
tchs accesskey can be filled with a maximum of 4 lines of a minimum of 2 lines.
The first line always correspond to a word chich becomes a keycode that can be used to
call an instruction everytime we touch the area of the form. This keycode can be included
in a shortkey instruction to create a button.
The second line needs to specify the touch that will request the command asociated to the shortkey.
If we use "1", then the command will be called when the first finger on the screen touches the area.
If we use "2", then the command will only be called when a second finger on the screen touches the area.
If we use "3", then the command will only be called when a third finger on the screen touches the area.



orb/rectangle/run	
write, The value in this orb key will determine the behavior of the rectangle animation. 'off' ,'once' and 'loop'.
'off' will stop the execution of the rectangle animation.
'once' will execute the rectangle animatino contained in the orb once.
'loop' will execute over and over in a loop.


orb/rectangle/cn
write,toggle. The number of the active beat line. Holds the value of the rectangle current beat number.


orb/rectangle/1..2..3..4.. last.. current..all..from-to../parameter
write. A parameter on a beat can be read or modified directly.
We can also use polarity signals to increase or decrease a specified parameter
from the specified beat or beats.



Line Aspect

orb/line


orb/trace
This container...


orb/tchs
This access key transforms the area of the form aspect(line in this case) into a button
for touchscreens.
tchs accesskey can be filled with a maximum of 4 lines of a minimum of 2 lines.
The first line always correspond to a word chich becomes a keycode that can be used to
call an instruction everytime we touch the area of the form. This keycode can be included
in a shortkey instruction to create a button.
The second line needs to specify the touch that will request the command asociated to the shortkey.
If we use "1", then the command will be called when the first finger on the screen touches the area.
If we use "2", then the command will only be called when a second finger on the screen touches the area.
If we use ""3, then the command will only be called when a third finger on the screen touches the area.




Image Aspect

orb/image
read, write. Holds all beat formated lines only.


orb/image/file
write. Image buffer. Holds the image file name to synch orb image Aspect with beats
stored on /image. If the name does not match a name
of a file already uploaded to the browser, then the beats wont draw anything.


orb/image/run
read, write. 'off' 'once' 'loop'. Same as circle and rectangle aspects.


orb/image/cn
read, write,toggle. The number of the active beat line. current number



orb/image/1..2..3..4.. last.. current..all..from-to../parameter
read,write. A parameter on a beat can be read or modified directly.
We can also use polarity signals to increase or decrease a specified parameter
from the specified beat or beats.





Audio Aspect



orb/source
Audio orbs will unlock specific access keys depending on the value stored on /source.
'oscillator' value on /source is able to manifest the capacity of orbs to build oscilators to be run
on demand. When /source is asigned the value of 'oscillator' , the orb unlocks access keys to work
with the oscillator system.


Oscillator Keys



Audio Buffer Keys


orb/position


orb/loop


orb/run


orb/emit


orb/from


orb/to







~$/%#?>>==<>~$/%#?>>>==<>~$/%#?>>==<>~$/%#?>>>==<>~$/%#?>>==<>~$/%#?>>==<>~$/%#?>>==<>~$/%#?>>>==<>~$/%#?>>==<>~$/%#?>>>==<>~$/%#?>>==<>~$/%#?>>==<>