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


Here is a complete list of the system commands with examples.
Some commands are simple words with no '/' , these create very specific effects.
Many signal commands can use orbs texts to perform operations on datalines
to be used by other aspects animations as well.

Signals


loadimage
Loads an image from local machine into the browser for orbs with the image Aspect
unsealed to request in order to create animations. Sprites are convenient to work
with but any image will do. Once an image is loaded into the browser, orbs 
that want to use it must transfer the image name into their image
'file' key and they are ready to go.
filename>>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


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


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 a single letter from ~/inline

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


jsonout>>target
Stringify orb from 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 all orbs 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


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>>orbname/aspect/line
Remove a target 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 all lines from an orb aspect container by simply running
rmline>>orb/aspect


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


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


localt/source/line>>orb/text/line
uses a line as a text file name to be fetched from the local server and puts result on target
text line


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/source..>>target..
if we say
append/source/line>>orb/text/line
append grabs a single line from a source text orb, and appends the text into the line specified on the target text orb.
append can also produce multiple copies of its result. If we say
append/source/line>>orb/text
the source line will be added into every single line on the target orb text.
we can also say
append/source/line>>orb/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/source>>orb/text/4
append will add all the lines of source to the lines from target line 4 and forward.
Will create new lines if neccesary
append/source/3-7>>orb/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.


random/source/line>>orb/text/line
random signal takes 4 numbers counting from the specified line on source, and uses them to produce
random values in between.
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 peoduce using the same range.
And the fourth value is used to specify how many decimals we want to have on the results produced.
All 4 lines on source text need to be numbers.


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/source/line>>orb/text/line
stands for interpolarity. this command works with 4 lines, starting from the specified source line.
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.


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/source>>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. place is the new number
we wish to asign to the target on the aspect cue. 0 is the first place.


anchor/source>>target
Anchor requires 3 lines from a specified source. First line is an Orb name. Second line is X and third
line is Y. target is a list of orbs names. The anchor signal will register any displacements on the Orb
specified on the first line from source and reproduce the same displacement on all orbs listed on target
in a single beat.
anchor will also update the second and third line to match the position of the anchor orb specified
on the first line.


algo01/source>>orb/text
algo01 works with 2 text orbs.
Grabs 6 lines from a source orb and produces 2 values x and y. 
tldr; Change parameters from source to produces wifferent positions. somewhat experimental.
we can use this algorythm to create funny movements.


Entity Keys


~
Returns all access keys from the entity on a single text with multiple data lines.


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


~/now
read


~/orbs
read. 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
~/orbs/all
We can then use a pattern to match orb names partially:
~/orbs/all/Star
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
so we look inside all aspects that match all names to look for the pattern.


~/memheat
read. Miliseconds taken by the system to perform all operations requested in a single heartbeat.


~/heartbeat
read.write. Miliseconds taken by a Sunya heartbeat.


~/stance
read. write. Holds the orb name of the current stance. Change this value to
change the entity stance.


~/dsignat
read. write. Holds a single partial beat to colour all new forms that demand it,
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 on the input box.


~/prompt
read.write . The value of Entry. ~/prompt can process a line acording to its value
after a send signal is triggered.
"entry" uses the value to be executed as an instruction and stores the value 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 value to process json notation data. Create orbs from a json text.
Makes input box receptive to read json orbs or sunya states in json.
A "Sunya state" is all orbs running on a moment in the past.
Its a "clear all orbs and recreate this moment" instruction. Use with caution.


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


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


~/x
read. write. Entity x coordinate. The center of the user screen.


~/y
read. write. Entity y coordinate. The center as well.


~/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,key,Digit4,com1,~/orbs>>~/skeys/new
The skeys container works with text lines in a specific format:
name,the name we want to asign to this button,key,the name of the key on the keyboard,com1,a command to execute
Each element needs to be separated by a comma.

~/kcode
read.Holds the las key code stroke on the keyboard


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


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

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

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

~/tchs1


~/tchs2


~/tchs3



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.
If the current stance holds the name of an orb with its text Aspect unsealed,
then this command will print data on this orb text container inmediately.

%
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.
If the current stance holds the name of an orb with its text Aspect unsealed,
then this command will print data on the stance orb text container inmediately.


orbname
Returns all main access keys from the named orb on a multiliner.
If the current stance holds the name of an orb with its text Aspect unsealed,
then this command will print data of the named orb on the stance text container
inmediately. We can also redirect the data requested into any other orb
with text aspect unsealed to be printed by it.
example:
orbname>>orb2/text


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.


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.



Text Aspect
The text aspect allows Orbs to manage,contain, and manipulate text and numbers. Text
aspect can be used to retrieve values stored
in other orbs to work with.
When the entity ~/stance key matches the name of an existing orb, we say this is the
entity stance.
(inprompt deprecated, this needs update)
When the stance orb has its text Aspect unsealed, we can call inprompt and write a text
line into the currently selected line.
Also, if we execute commands that retrieve data without using '>>' , then the
content retrieved is dumped in the stance text right away. like this;
Create a text orb and make it the entity stance inmediately after by chaining 
a second instruction using the '<>' symbol and '#' with the literal name of the orb:
@text>>MyOrb<>#MyOrb>>~/stance
Now press call inprompt and type in some some words and then enter.
You just created a line in the text.
Now press Enter once, and try using any retrieving comands;
~, $, $/name, ~/x... and so on.


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/in
read, 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.


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
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
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
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.


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.

orb/text/font
The font of the text. currently accepts 3 different values:
"arial" , "serif" , and "courier"

orb/text/style
The style of the text. currently accepts 3 different values:
"normal", "italic", "bold"


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


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/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/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
read, write. Retrieve beat format line or write a beat into it to modify the beat parameters of the rectangle.

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


Image Aspect
The image aspect allows Orbs to create animations using image files loaded into the browser.
The image beat format line with all its possible parameters defined with an example
value look like this:
x,0,y,0,w,200,h,200,px,0,py,0,pw,200,ph,200,cx,0,cy,0,a,1,layer,2
Image beats need a few more specifications than a rectangle beat. x and y parameters
determines the coordinate from which we will
extract the part of the image that concerns us. w and h will determine the size of this
extracted part.
We then use cx and cy to locate the center point from which we will start drawing the
extracted image part into the canvas.
cx and xy are used to create a refference point from which we can work with the animation.
Once the animation is ready we can relocate
the whole animation by changing these values again.
pw and ph are used to determine the size if we want to expand or reduce the image part
already extracted.
px and py are values in pixel unit to determine how much we want to get away or get close
to from the image center refferenced by cx and cy.

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
read, write. Retrieve beat format line or write a beat format line into it to modify it.

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)


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