DOBELA

DOBELA: DOt-Based Esoteric LAnguage. This is a language made by User:asiekierka in 2008.

Idea and Pronouncing
Idea came up one day on #esoteric. I thought about a language having dots, walls and I/O. Then we all extended it. DOBELA is now quite surely (on #esoteric) 99% TC (due to the command set), but we're not sure about the remaining 1%.

You pronounce it like "do-BEE-lah" where BEE is pronounced like the english "Bee", and "do" is pronounced like the "do" in "don't".

Overview
DOBELA is based on binary dots and commands, all placed on a two-dimensional grid. Dots travel on the grid, whereas commands stay still. Most commands are interacted with solely by having dots collide with them.

Additional storage is provided in the form of the global FIFO, a queue.

Specification
This is version v13 of the specification.

Rules
Conceptually, every dot moves simultaneously in a cycle. After the dots have moved, collisions are handled and commands are executed in order, from the northwesternmost to the next, first columnwise and then linewise.

Dot-dot collision rules (using arrows,, to show the direction dots are moving in):


 * If two dots of different types moving in opposite directions collide, they are both destroyed.
 * If two dots of the same type moving in opposite directions collide such that they enter the same space, they are destroyed and a wall is created in that space. For example:

#>, ,< ,.#                                  #  #     #
 * 1) >. .< vv#                                  #  #     #
 * 1) >. .< vv#                                  #  #     #
 * 1)        #  On the next cycle this will be:  #      ###


 * If a Zero and a Zero moving in opposite directions collide such that they pass over each other, they are destroyed and a wall is created where the northwesternmost dot was. For example:

#>,,< v#                                  # #    #
 * 1)     ,#  On the next cycle this will be:  #      #
 * 1)     ,#  On the next cycle this will be:  #      #


 * If a One and a One moving in opposite directions collide such that they pass over each other, they are destroyed and a wall is created where the southeasternmost dot was. For example:


 * 1) >..< v#                                  #  #   #
 * 2)     .#  On the next cycle this will be:  #     ##
 * 1)     .#  On the next cycle this will be:  #     ##
 * 1)     .#  On the next cycle this will be:  #     ##


 * If two dots that are not moving in opposite directions collide, the southeasternmost dot is blocked from moving, but neither is destroyed. For example:

#,  ,#                                   #  ,  v#
 * 1) >.  v#                                   # >.   #
 * 1) >.  v#                                   # >.   #
 * 1)  ^>. #  On the next cycle this will be:  #  ^>.,#


 * If a dot moves onto a dot which then finds that it cannot move that cycle, both dots are destroyed and a wall is put in their place. For example:

# >,.# #                                  #   ## #
 * 1) >..# #  On the next cycle this will be:  #   ## #

Multiple dot collisions are resolved starting from the northwesternmost, as described previously.

Miscellaneous rules that don't pertain to any command in particular:


 * Dots, by default, move one space to the east.
 * If dots venture outside the bounds of the initial source file, they are destroyed.
 * The program ends when there are no more dots moving and no more dots will be emitted from any, i.e. standard input has reached EOF.
 * A proper DOBELA program must have at least two lines and one column.
 * Non-command characters in the initial source file are ignored: they do not exist, as far as the program is concerned.
 * If a dot would be created on top of a  or , it is destroyed instead. There is one exception to this: for  , the dot instead reverses direction and ends up on the other side of the  . For instance,   with the One moving east turns into  , with the Zero now moving west.

History

 * 21st October 2008 : DOBELA docs v1-v9 created, wiki entry published.


 * 22nd October 2008 : DOBELA docs v10-v11 created.


 * 7th March 2009 : DOBELA spec v11b released, thanks to akiross's interest in DOBELA.


 * 21st March 2009 : Specification version v12 released by User:Deewiant, thanks to many clarifications from User:asiekierka. See the logs of #esoteric on 2009-03-20 for the discussion which prompted this.


 * 9th April 2009 : Specification version v13 (added !) released by User:Deewiant due to more clarifications: see discussion at #esoteric on 2009-04-05.

Hello!
,,,,.,.,,,.,,,,.,..,....,..,..,,,..,..,,,..,,.,.,.,,.,,,$^ .                                                        # This outputs just "Hello!" and a line feed.

More complicated version, same output:

# #+           #   #                                                                         #                                                                           #  ^ ,,,,.,.,,,.,,,,.,..,....,..,..,,,..,..,,,..,,.,.,.,,.,,,$              #    ^ $ :v                                                                      # ,                                                               #  #                                                          = = == +     #  $                                                                       #                                                                        #   #                                                                  #          #                                                                         #        #

Cat
These cat programs don't actually work since they never flush output using. They do, however, collect the input into the queue in the correct order.

(|, x and - show the path, 0 shows the way 0 goes, and 1 shows the way 1 goes.) _  $ Ones end up here. |  |   #x--0-1--x# |  #    $ Zeros end up here. Uncommented: $      _   #       #       #    $

Short version: _  $

Implementations
dobelx64, interpreter written in x86-64 asm. Source and ELF binary available.