Huuuuuuge replicator/ universal constructor in WWEJ3

For discussion of other cellular automata.
Post Reply
User avatar
Posts: 221
Joined: June 18th, 2022, 2:37 pm
Location: Under a thinking cap

Huuuuuuge replicator/ universal constructor in WWEJ3

Post by wirehead » June 20th, 2022, 10:22 am

Inspired by all the random constructors/replicators and codon encodings that Haymanizer/tan x dx came up with I created a very large replicator that uses a Nx29 two-dimensional tape.

Best to run in Golly. Pattern file is attached.
In an old Markdown file, I wrote:
February 27th, 2022, 1:48 pm
Each column of the data tape is read in from bottom to top.

There are 3 parts to each line of the data tape:

The bottom-most 5 bits: Repeat count, MSB on bottom. Each of the next two parts - the 'commands' - are repeated alternately this many times. Since each command alternates, if this is an odd number then the next row will do command B first if this row did A first (or vice versa). For example, if this is set to 5 (state 4-3-4-3-3) on the first row, the machine will run commands A-B-A-B-A and the next line will start with B. If 32 or more alternations are needed you will need multiple lines.

The remaining 24 bits are divided into two 12-bit commands (with A on the left, this is the first.)

Each command is subdivided into two parts: the left 4 bits describe what to do (MSB on BOTTOM), and the right 8 bits describe how many times to do it (MSB on TOP). Note the difference in bit order.

The left 4 bits (what to do) determine the special heads sent to the construction arm, according to the following tabe:

0: Nothing, useful for a delay (a 'pass' or 'noop' in programming terms)
1: Normal head (state 1)
2: Extend head (state 5)
3: Retract head (state 6)
4: Write head (state 8)
5: Isolate head (state 9)
6: Turn left head (state 11)
7: Turn right head (state 12)

8-11 are 'convenience' commands that simplify printing an object one row at a time. To print a row of wire cells that are close to other cells, normally you would need to program the constructor to do right, write, retract, retract, extend over and over again which would not be well compressed by this machine and be very slow if only commands 1-7 are used. Each of these commands abstracts that away to a single electron, which passes through a mechanism that converts it to that exact series of special electrons. All possible combinations of right/left and isolate/write can be used:

8. right, write, etc.
9. right, isolate
10. left, write
11. left, isolate

12-15 are identical to 8-11, except the arm extends twice each time (by adding another extend electron to the start) so you get 010101010101... instead of 11111111... Can't exactly say where it will be useful, but I'm sure it will.
I've yet to write a description of how the actual machine works (yet!) but if anyone is interested I can do that too.
Run at step size of 8^7 or faster.
(92.78 KiB) Downloaded 32 times
Langton's ant: Can't play the drums, can be taught.

Post Reply