RubeFactory

Hello,

I've started a remake of Rubicon last week or so, the working title is RubeFactory.
RubeFactory works on two levels, the first one we're all familiar with, it's cargo and machines that manipulate cargo. The second one is connecting machine's IO ports with wires.

All machines (blocks that aren't walls, and actually do something) have some inputs and outputs and can be connected to other machines with wires. Here's an example screenshot that demonstrates connecting machines with wires. The block that looks like a chip is a utility box that provides a counter and toggle (when a non-zero signal is present on toggle input, the toggle output toggles). Toggle output is then connected to the up-pipe's "Enabled" input, and toggle is connected to true. This will make the pipe enabled every other cycle, so it will only pull every other box up, separating the boxes into two groups.

All wire I/Os are propagated in a single cycle.

Cargo can have any char value (although machines usually only work with 0-9, or treat any non-zero as true), or be a pair. A pair cargo contains two cargos which can also be composite (packer and unpacker are used for this).

Here are some of the machines I've made so far (note that all machines can be enabled and disabled):

Conveyor
The classic conveyor belt. Can change directions with "Right" and "Left" inputs.
Pusher
Pushes cargo directly in front of it, but doesn't move.
Pipe
Same as in rubicon
Copy machine
Same as in rubicon
Dematerializer
Takes cargo, and converts it's value to a wire value (destroying the cargo)
Materializer
Opposite of dematerializer. The two can be used to create portals.
Add, Subtract, Multiply, Devide, Mod
They work similar to add/subtract in rubicon, however they provide carry and borrow outputs (where this makes sense) so they can be used to form a full adder/substractor, etc.
Destroyer
Same as in rubicon. However, a cargo must enter it to be destroyed, not touch it (Some machines allow cargo to go through them).
Packer
Takes two cargos (below-left, and directly below) and creates a pair cargo containing the two. Works exatly like cons in lisp. The inputs are destroyed.
Unpacker
Takes one pair cargo (below-left) and unpacks the first value directly below, and the second below-right. Works like car and cdr in lisp. Destroys input.
Comparator
Works exactly like the one in rubicon
Sensor
Outputs true to one of it's outputs ("Left", "Up", "Right", "Down") if a box on that side touches the sensor.
Utility box
Provides a counter that can be reset, incremented and decremented. Also provides toggle (described above).
And, Or, Not
And and Or provide 3 gates each with 3 inputs. Not block provides 3 not inputs/outputs.
Edge detect
Provides "SignalNIncreased" and "SignalNDecreased" outputs for 3 signal inputs.
Memory
Provides storage for 10 values (addressable with cargo values 0-9). Can store pairs.

Blocks I'm yet to include :
Comparator for wires (would be useful)
Rangefinder for up to 9 blocks away (outputs 0-9)
Extender extends (or retracts) in it's direction based on input and pushes cargo. Not sure if this is needed yet.
Color box changes color based on inputs (R,G,B). Could be used to form displays.
Stdin, stdout blocks used to communicate to the outside world

. By default, connected to a small console below the game field. Anything that goes into the stdout block is printed to the console. Anything you type in would be created as cargo, char by char, on the game field.

Finally, here's a video of RubeFactory at work (full adder example, with zero padding).
http://www.youtube.com/watch?v=ox53DYkCDpU