User:Quincunx

= Esolangs I made =


 * Circuit Diagram

= Esolangs I am working on =

Manufactoria
Based on the game. I do have permission from pleasingfungus. I intend on making two versions, a basic one and a more complex one. The basic one would be a translation from the game, while the complex would include more features.

Roguelike
The idea is that the program will be a roguelike, with multiple levels, monsters, etc. Similar to MarioLANG, execution is from the  moving around. I definitely want the language to be deterministic.

Current thoughts:
 * Dungeon crawl style for the map. Sorta nethack for the rest
 * 'Player' moves by LH wall follow
 * Include certain metacharacters telling the 'Player' to equip, unequip, etc
 * Commands involve attacking / moving.
 * Every time a monster is killed, the corresponding ascii value is pushed
 * 0-9 are all monsters too. Instead of pushing their ascii value, they push 0-9
 * ' (the golem). It eats the square to its right to begin with. Killing it pushes the item to its right.
 * Reading a scroll randomizes the stack
 * Opening a door adds the top two values
 * Closing a door subtracts them
 * Zapping a wand divides
 * Eating finds the remainder
 * picking up valuable stones multiplies
 * putting on rings does an equality check, pushing 1 if equal and 0 otherwise
 * quaffing potions changes a 0 to a 1 and everything else to a 0
 * ^ for XOR
 * | (staff; just made it up) for OR
 * & (this does not push the ascii value. Kill the demon and) AND
 * picking up money ($) removes the top value on the stack.


 * You have to keep the 'Player' alive.
 * Every X turns, 'Player' has to eat.
 * Player has Y health and loses Z from fighting {monsters}, replenish by time, potions?


 * _ only allows the player to continue if (s)he last killed a nonzero monster (carries the last killed monster for sacrifice)
 * Up and down staircases move to other levels of the dungeon. The also rotate the stack in the corresponding direction.
 * ^ can bring the player up a level without rotating the stack, but it is the bitwise XOR of the top two numbers
 * Program exits from up staircase on top floor
 * Comments would be any code outside of the executable area (reachable by 'Player')
 * , prints the unicode value (UTF 8). . prints the integer value.

Toying with the idea:


 * 1) @ > >l  >#
 * 2) oW>+rld'!,<#
 * 1) oW>+rld'!,<#
 * 1) oW>+rld'!,<#

############ #<H<  e <l # ########## # #<   '   o # The ' should fetch the value of the next character along the Player's path, as well as change the next character into a no-op ############

Proofs
A language with syntax based off of mathematical proofs.

Circuit Diagram 10
Circuit Diagram taken to a whole new level.


 * Wiring is only in the orthogonal directions, no diagonal. + is a corner which does exactly the same thing as . . = is still a bridge.
 * Multi-wires are replaced with buses. A bus is signified with #, which connects to adjacent #'s. Buses have wire naming. Buses without wire naming work the same as the multi-wires (mostly). Buses can also be buses of buses. In other words, multi-wires are replaced with arrays.
 * Comments are indicated with _comment_. Each of those characters acts as a space. Can be multi-line.
 * Gates and blocks now have a direction, signified with ^, <, >, or v. Default direction is >
 * Built in registers, signified with %
 * Another kind of memory storage: Stack ($). Takes two inputs, if the push is high, it pushes the value, otherwise, it pops and outputs. This should make the language turing complete.
 * Functions are improved:

Now using [] to indicate a function. Inputs are shown with a $; the following character shows the direction. It is easier to specify multi-inputs. For example:

[fadd _Full Adder_ $v_carry in_ | $---+.  +--= _a_ | x>-+  |    x>:_sum_ |.  |  +.--- $---=.   ++   a>. _b_ | a>\ +--. o>:_carry_ +.  .--. ] which can be used like this: )--. _this can be anywhere above the [add]_ )-#!add!#-_sum_ (-#    #-_carry_

With a long enough name, you can input / output many wires from above / below without making a bus:

[longAbsurdName _takes the inputs from above and puts them into a bus on the right._ $v$v$v$v$v$v ]

Example Usage:

)--+ )-+| )+|| )---+||| )--+|||| )-.||||| !longAbsurdName!####

One more addition: use of "c-dots". It is allowable to use a  (or any other direction) to indicate a repeating pattern. This needs to be better defined.