Echo is a programming language created by User:Charon25 consisting of instructions, executed one after the other, that create and receive sounds, sent from an audio source, which bounces off walls. They all contain a number value, and can be manipulated to make more complex operations.
Echo manipulates an audio source which can produce sounds in four different directions. Those sounds have a constant intensity, specified when they're created, and will bounce off a wall created when sending the sound, at a specified distance. The sounds always move at one unit per instruction. They start one unit after the source, and start to move only after the next instructions.
Walls are always situated between two units, which means the movement of a sound follows a path that looks like (
X is the audio source,
o is the sound, and
| is the wall) :
Xo | X o | X o | X o| X o | X o | Xo | X |
When a sound gets back to the source, it is absorbed and destroyed. At every instruction, the audio source can receive up to 4 different sounds. The intensities of those sounds are added up (modulo 256) and this sum is called the "sound sum" and used in some instructions.
There are two "kinds" of walls : the ones associated with a sound, and the independant ones. A wall associated with a sound disappear when the sound has bounced off it or has been destroyed. A sound always bounces off the first wall on its way, which means a wall may bounce a sound it was not destined for. An independant wall disappears when it has been hit by any sound.
In the following example,
o is the sound associated with the wall
u the one associated with
/. We can see that
o will bounce off
/ and not its own wall.
X o | Xu o / | (creation of a second sound which wall is closer than the first) X u o/ | X u o / |
When a sound is moving towards the source, it does not interect with walls anymore.
The code is written with one instruction per line only. One line of code consists of one word (case insensitive) followed by up to 3 parameters. The parameters are separated from each other and from the command by a space (
|Instruction||Description||Parameter 1||Parameter 2||Parameter 3|
||Does nothing (it still counts as a one or more steps for the sounds).||Number of steps to nop (> 0). Optional, default value is 1.||∅||∅|
||Send one or more sounds. The sounds all have the same intensity and their walls are at the same distances, but they can be sent in different directions.||Directions (4 LSB)||Wall distance (> 0)||Intensity (> 0)|
||Send the sound sum (modulo 256) or its complementary modulo 256 in the specified directions and distance.||Directions (4 LSB)||Wall distance (> 0)||0 on the LSB to send the sum, and 1 to send its complementary. Optional, default value is 0.|
|Print the sound sum directly or as an ASCII character.||∅||∅||∅|
||According to parameter 1, execute (or not) the n next instructions if the sound sum fulfills the condition compared to the specified value.||Condition (4 LSB)||Value||Instructions count (> 0)|
||Repeat the n next instructions as many times as specified.
When this instruction is completed, the instruction pointer will be at the next one, meaning the repeated instructions may be executed once more.
|Repetitions count (> 0)||Instructions count (> 0)||∅|
||Send a sound in the specified directions and distance with an intensity equals to the ASCII value of the character typed by the user.||Direction (4 LSB)||Wall distance (> 0)||∅|
||Create an independant wall in the specified directions and distance. They will disappear after one bounce.||Direction (4 LSB)||Distance (> 0)||∅|
||Exit the program.||∅||∅||∅|
Note : two more instructions exist,
pcondition, which are a combination of
p. Their parameters are exactly the same as the base version.
To define directions, the four LSB are used, each one indicating if the sound should be sent in that direction. At least of one those four bits must be 1 for the code to be valid.
For example, if a direction is
0000 1010 in binary), it means the sound should be sent in two directions (of index 4 and 2).
Parameter one of a condition is defined as follows in binary :
x: not used, can be anything.
D: 0 if we should not execute instructions only when the condition is fulfilled, and 1 otherwise.
i: 1 if the condition should check if the sound sum is strictly smaller than the specified value.
s: 1 if the condition should check if the sound sum is strictly greater than the specified value.
e: 1 if the condition should check if the sound sum is equal to the specified value.
When multiple bits are 1, the result is a logical OR of all of them. Conditions can then be combined to test for other conditions. For example :
xxxx1001: instructions will be executed only if the sound sum if equal to the value.
xxxx0100: instructions will not be executed is the sound sum is stricly smaller than the value.
xxxx1011: instructions will be executed if the sound sum if greater than or equal to the value.
xxxx0110: instructions will not be executed if the sound sum is either stricly greater or strictly smaller than the value (equivalent to inequality).
i=s=e=0 is an invalid condition.
send 1 1 72 send 2 1 101 print print send 3 2 108 wall 1 1 print send 1 1 111 print print send 1 1 44 send 2 1 32 print print send 1 1 119 send 2 1 111 print print send 1 1 114 send 2 1 108 print print send 1 1 100 send 2 1 33 print print
send 2 4 1 nop for 13 9 predirect 8 5 nop 5 redirect 1 8 nop 3 redirect 6 9 wall 4 3 nop 4 redirect 2 3 nop 5
send 2 3 3 ; Value of A nop send 8 2 255 send 1 4 5 ; Value of B nop 2 for 255 14 redirect 6 12 wall 4 1 condition 2 0 5 nop 2 redirect 3 6 wall 2 1 print exit nop send 8 4 255 redirect 3 6 wall 2 1 redirect 4 6 nop 4