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

Here is a complete list of the system commands with examples. It is recommended to first read the text
Sunya Sinthax in order to have a better understanding on how these instructions operate.


Entity Keys


~/name
read. write. The name of the entity.



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



~/orbs
read. 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/all		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
read. 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
read.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
read. write. Holds the orb name of the current stance. Change this value 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.



~/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
read. The value sent using "ein" on prompt. Clears at the end of every heartbeat



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



~/inline
read. write. The current value on input box at any moment.



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



~/prompt
read.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.
"entry" 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.
"jsonin" uses the text in input box to process json notation data. We can recall orbs from a json text.
Makes input box receptive to read json orbs or a whole Sunya state in json.
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.



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


~/simage
read. Returns all names of loaded image files on the browser from server on a text list.


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



~/saudio
read. Returns all names of loaded audio files on the browser from server on a text list.


~/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
read.Holds the first key code value stroke on the keyboard.


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


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



~/tchs1


~/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


localimageload
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
~/limage
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.
~/limage>>orb/text<>orb/text/1>>orb2/image/file


localaudioload
Loads an audio file to the browser for Orbs to access and useto play sounds. 
...(incomplete)


serverimageload


serveraudioload


localtextload


servertextload



kaoz
This command will prevent Sunya from clearing up the screen at every heartbeat.
Use it to unlock your artistic potential.
Run again to make Sunya clear the screen at every heartbeat.
Use it to help you think with clarity.


wev
A command to toggle script activity feedback animations.


lnum
A command to toggle line number visibility.


thl
Toggle for text selection highlights.


bhl
Toggle for beats highlights.


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'



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.



@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.
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 located at the same position as the script Orb that created it.




ka/accesskey>>target
We can use ka(key access) signal to request deeper access keys inside the specified one
after "ka/". example
ka/orbname/text>>target
This instruction will print all access keys available to work with that begin with
"ka/orbname/text" . In this example we are accessing a text orb so we will get the lines:
ka/orbname/text/font
ka/orbname/text/style
ka/orbname/text/size
ka/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




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




seal>>targetorb
When an aspect is sealed, it will retain the data concerning
the aspect so we still might be able to modify it but animations and sounds will not be
produced.
We can seal multiple targets at once the same as unseal.
seal>>orb/text



unseal>>targetorb
We can unseal an orb Aspect.
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,
and create sounds.
We can unseal multiple targets at once by storing orbs names on a target text.
unseal>>orb/text



scan/formorb/sourcetext>>target
scan is a signal that works with 2 texts and 1 form: A circle or a rectangle orb.
Checks for every orb by name on a source list text orb, and asks if its located inside the area of the form.
If so, it pushes the names into the target text orb list.



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/min/max/total/deci>>target
random signal takes 4 numbers as min, max, total and deci, and uses them to produce
random values in between min and max.
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.
Target is a text or a script container. We can specify where we want to place the result of the command
using the transfer sinthax.



//deprecated
percent/source/line>>orb/text/line
this command works with 2 lines, starting from the specified source line and the next one.
first line is the percentage value we want to extract, a number between 1 and 100.
the second line is the total from which we want the percentage from.
the result is stored on the target.



interpol/min/max/parts/deci>>target
Stands for interpolarity. this command works with 4 parameters.
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.
Target is a text or a script container. We can specify where we want to place the result of the command
using the transfer sinthax.



//deprecated
screenxy/source/line>>orb  ,  orb/text
screenxy is used to work with the screen position using percentages. it uses 2 lines from a source,
both percentages desired. First line corresponds to x, second line corresponds to y.
The result can be applied directly on an orb target to relocate its position inmediately,
or it can be stored as 2 lines,x and y, in a text orb.



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.



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.




orbit/ang/radx/rady/offsx/offsy>>target.. orb
orbit is a signal that produces an x y coordinate using the parameters:
ang, radx, rady, offsx and offsy.
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.
radx and rady represent how far from the center we want the position to be in pixels.
offsx and offsy are the offsets of the position. these are the position coordinates of the orbit.
Target can be the name of an orb in which case will inmediately update the position of the
orb 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.




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
read, 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
read.Returns the aspect of the orb.
We have 7 Aspects so far:
text, script, circle, retangle, image, oscillator, and audio.



orb/x , y
read,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
orb/anchor/new
so the system does not overide the names previously stored on the container.
we can use
orb/anchor/clear
the same to remove the specified orbs names from /anchor.




Text Aspect



orb/text
read, 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
read, 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/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
read, write. The number of the active, currently selected line on the orb text.
Change this number to change the currently selected line.



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



orb/text/1..2..3..4..1-5..4-12..last..current
read, 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 or insert 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



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



//requires update
orb/text/hltextn
Highlight text number. The word in this access key determines if the lines in the text will be
numbered. So far the only valid value is 'text' so a text
number will be drawn next to each line for user feedback.



//requires update
orb/text/hlbeats
Highlight beats. The word in this access key determines if the text will react to beat lines
currently active. Highlight beats. So far the only valid value is 'line', so a line
will draw a highlight feedback.



orb/text/wheel
read. write. Accept "on" or "off" to move text up and down when current line is polarized
upwards or downwards trough 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'



//needs review
Text Beats

'beats' is a special container that can be accessed after the 'line' key.
This contaner holds beat formated lines. They look like this:
r,34,g,70,b,43,a,0.7
The beat format line has parameters followed by their value and they are all separated
by comas. We only need to specify the changes we want to see.


orb/text/1..2..3..last..current/beats
read, write. Access or returns all beats of a specific line key.
Each line has beats to determine how the line will look. We can control
rgba values and layer directly on every beat.


orb/text/1..2..last..current/1..2..last..current..cn
read, Returns a single text line beat formated properly from the specified line
using a number or a keyword, "last" or "current".

(experimental)
orb/text/1..2..last..current/mirror
write, Creates a mirror image using data from location and a custom beat.
To create a mirror state image that lasts a hearbeat, we feed a beat formated
line into this command to use the state reffered by the line key as base ,
and modify it with the changes specified. example:
This command will create an exact copy of the currently selected line state of the
orb and modify its red parameter by adding 23, and substracting 67 to its green parameter.
The copy will last for a heartbeat.
r,23,g,-67>>orb/text/current/mirror


	
Script Aspect


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


orb/script/run
read , 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
read, write. The number of the active line. Current number line that contains the instruction being executed.

orb/script/1..2..3..4.. last..current
read, 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
read, write. Holds all circle aspect beats formated lines only.


orb/circle/new


orb/circle/run	
read , 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
read, 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
read, 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
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.


//deprecated
orb/cirle/1..2..last..current/mirror
write. Create a mirror state using beat accessed data and a beat format text line.



Rectangle Aspect

orb/rectangle
read, 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/run	
read , 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
read, 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
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.


//deprecated
orb/rectangle/1..2..last..current/mirror
write. Create a mirror state using beat accessed data and a beat format text line.



Image Aspect



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


orb/image/file
read,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.




//deprecated
orb/image/1..2..last..current/mirror
write. Create a mirror state using beat accessed line and a beat in text line format
provided by the data on the left side of '>>'. example:
x,230,y,456>>targetorb/image/current/mirror



Oscillator Aspect
Oscillator aspect is able to manifest the capacity of orbs to build oscilators to be run
on demand.
Audio aspects differenciate from visual Aspects because Audio would be limited if we
could only synch using the heartbeat of Sunya.
Due to human audio sensitivity, audio scripts can be programmed in miliseconds and
tone lines(the beat line of oscilator orbs) are
all run at once when the script is executed. But we can specify all timmings at once or
modify an oscilator parameter once its playing.
(incomplete)


orb/osc
read,write All oscillator lines at once. Tone lines.

orb/osc/run
read,write . We use 'off' to set all tones off. We use 'play' to create all tones at
once stored on the oscillator container. As long as tone lines
are playing, orb/osc/run will return 'play'.

orb/osc/1..2../gain
read,write We can adress a specific tone line playing to modify its parameters in real time.
gain range possible value.... incomplete

orb/osc/1..2../freq
read, write The frequency of the tone. 


Audio Aspect
Audio aspect is used to manage audio structures created using Audio files loaded into
the browser

(incomplete)


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