However, it's starting to be difficult to find latest details in among all the clutter in existing RCT threads.
The relevant threads include Binary slow salvos, Goucher-Grankovskiy construction arm,Extreme compression construction arm, and the Coding Practice thread.
Here's the current list of details that haven't been sorted out yet, in the context of what we've completed already. Corrections welcome as usual.
Last updated 9 November 2022.
(1) DONE (MathAndCode, calcyman): RCT starts out with 1 GPSE in its northwest corner, 2 GPSEs in the southwest corner, and 1 GPSE in the southeast corner.
(2) DONE (calcyman, Pavgran): The RCT construction arm builds a Goucher-Grankovskiy construction arm, a.k.a. the DBCA, including a carefully calculated N-glider absorber.. (See calcyman's most recent recipe, and then Pavgran's most recent recipe.) The DBCA starts processing signals from the RCT construction arm.
(3) DONE (calcyman): The DBCA builds two blocks near the RCT construction-arm lane and a ship near the DBCA's p8 reflectors. The blocks stop the incoming GPSEs, and the ship stops two escaping gliders from the crash.
(4) DONE (Pavgran): Using slow^1 gliders, the DBCA builds the epicentre end of the pseudo-BSRD, including the new p8 reflectors and a seed that produces correctly-timed gliders to shoot down the old p8 reflectors as shown in this link.
(5) DONE (calcyman): Using slow^1 gliders, the DBCA builds a second construction arm, the ECCA (Extreme Compression Construction Arm), described here and in more detail here -- a safe distance south of the DBCA, facing in the opposite direction. The ECCA includes self-destruct circuitry for itself, easily triggered by a single glider.
(6) DONE (Pavgran): Using slow^1 gliders, the DBCA builds a seed for a switching system that re-routes incoming bits from the RCT construction arm to the (not yet constructed) pseudo-BSRD (see (10)). EDIT: I think this is basically the same task as (4), on another re-reading. (?)
(7) DONE (calcyman): Using slow^1 gliders, the DBCA builds and triggers the seed that removes its elbow block near the epicentre and creates one at the southeast corner.
(8) DONE (Pavgran): The DBCA uses slow^1 gliders to clean up the southeast GPSE launch ash blob.
(9) DONE (dvgrn): The DBCA uses slow^1 gliders to build the SE Corderabsorbers in the place of the ash blob.
(10) DONE (actually happens before (9)) (Pavgran): The DBCA uses slow^1 gliders to build the far southeast end of a pseudo-BSRD unit (two 90-degree reflectors, routing the output of the routing system constructed in (6) to the input of the ECCA constructed in (5)).
(11) DONE (Pavgran): With the carefully calculated N-glider absorber used up, the DBCA produces a signal triggering the seed from (6) and redirecting all subsequent gliders into the pseudo-BSRD, ultimately destined for the ECCA.
(12) DONE (calcyman): The GPSEs crash into the block created in step (3), leaving a big mess but no escaping gliders.
(13) DONE Pavgran: All remaining recipe gliders, which were emitted by the RCT construction arm before the GPSE crash and diverted into the pseudo-BSRD, complete the trip one parsec out to the BSRD far end, and start the trip back. The first glider makes the trip one parsec back to the epicentre again, and begins to activate the ECCA.
(14) DONE: Using northeast monochrome slow gliders, the ECCA cleanly destroys the DBCA.
(15) DONE (simeks, Pavgran): The ECCA is toggled so that all future slow gliders from this arm are southwest.The ECCA then shoots down all the non-repetitive ash created by crashing GPSEs in step (12), leaving a target off to the side for use in (17).
(16) DONE (dvgrn): The ECCA uses slow^1 gliders to create a slow^2 elbow block in the far southwest at a safe distance from the GPSE launch ash blob. Gliders making use of this slow^2 elbow block in (19) and (20) will pass the SW-traveling Corderships very early on in the Corderships' c/12 cleanup journey.
(17) DONE (AlbertArmstain): The ECCA uses slow^2 gliders to create an extra elbow (or at least a one-time turner) in the far northwest (for construction of the NW bank of Corderabsorbers at step (22)).
(18) DONE (dvgrn): The ECCA fires all of the Corderships for cleanup -- SE, then SW, then NW.
(19) DONE (simeks, dvgrn): Using the elbow from (16), the ECCA uses slow^2 gliders to delete the SW GPSE launch ash blob and build the SW bank of Corderabsorbers in the same location.
(20) DONE (dvgrn): The ECCA builds the ATBC seed with a leftover block from (18), placing it in the open area to the west of the ECCA (the nearby ash trails have all been cleaned up now, with the cleanup Corderships receding into the distance at c/12).
(21) DONE: The ECCA deletes its current elbow so that the rest of the recipe will head towards the far northwest elbow.
(22) DONE: Using slow^1 gliders, the ECCA cleans up the NW GPSE launch ash blob.
(23) DONE: Using slow^1 gliders, the ECCA builds the NW bank of Corderabsorbers (the approaching NW-directed Corderships have already been built, but they're safely to the southwest of the construction arm), plus a small seed attached to the final Corderabsorber (see (25) below).
(24) DONE: The ECCA receives the incomplete '111111' codon to return its bistable switch register to a convenient state for cleanup.
(25) DONE: the last Corderabsorber in the far northwest, when it absorbs its Cordership, triggers a small seed constellation, resulting in two gliders: one is directed SE back to the epicentre, and one is aimed NE to destroy the ECCA elbow block. Four aeons later, the return glider from the northwest causes the ECCA to self-destruct completely.
(26) DONE: A west-directed MWSS from the ECCA's self-destruct mechanism triggers the ATBC seed. By the time the seed is triggered, it is the only thing left in the Life universe. (All Corderships and Corderabsorbers have already mutually annihilated, roughly four aeons ago.)
Might as well include an auxiliary list of software tools that will help with the completion of the above items. These RCT-related programming tasks can also be marked as DONE, MOSTLY/PARTLY DONE, NOT DONE, etc. If I don't know the current status, I'll put a red ?, in which case anyone who knows can please enlighten me.
The ultimate target format for compiler scripts will be "semilator format", which is currently a string of 1s and 2s -- not a string of 0s and 1s, though I'd be equally happy with that (but only if a new semilator script is published, along with new official RLE for the DBCA and ECCA and BSRD, with labels showing where the two types of gliders enter the circuitry -- and where they exit in the BSRD's case.
The nice thing about the current semilator 1s-and-2s format is that it's pretty easy to remember what it means. Whenever you see a "1", there will be only one glider coming in from the RCT mechanism, the "carrier glider". When you see a "2", there are two gliders coming in: the carrier glider, plus an additional "coding glider".dvgrn wrote: ↑July 12th, 2022, 12:06 pmNotice that the original RCT arm has either 1 glider or 2 gliders coming into it, and that the "carrier" glider (the one that's always present) has sometimes been called the "1" signal, whereas a glider on the carrier lane plus one on the coding lane has been called the "2" glider. This same pattern of "either one glider, or both gliders" carries over into the DBCA and the ECCA.
But when calcyman notated the inputs of the ECCA, the carrier glider got labeled "C" and the coding glider got labeled "1". I believe the idea is that the ECCA is basically accepting binary data, and that the absence or presence of the coding glider basically represents "0" or "1", respectively.
It seems potentially very confusing to have the old "1" input channel for the RCT and the DBCA not match up with the "1" input channel for the ECCA. Can we maybe come up with an alternate label for that channel in the ECCA, quick, and change the documentation as much as possible so that that confusion stops existing?
Mostly I don't care what notation people decide to use, but from here on out it would be great if it could be consistent!
(100) DONE (calcyman) "Semilator" RCT emulator pattern creation script. Uses crashing *WSSes to "bootstrap" a valid RCT pattern to add more bits in the middle of the sequence without making an unmanageably large pattern, but also demonstrating the first and last bits being retrieved from the RCT mechanism without any modification.
(101) DONE (Pavgran) Compiler script that converts a slow salvo into raw RCT construction arm data (in semilator script format?)
(102) DONE (Pavgran) Compiler script to convert a slow salvo recipe into input DBCA codons in semilator script format
(103) DONE (Pavgran) Compiler script to convert a slow salvo recipe into input ECCA codons in semilator script format
(104) DONE (dvgrn) Corderfleet recipe compiler scripts
(105) MOSTLY DONE (dvgrn) More efficient binary-search slow salvo optimizer script. This is just a more or less cosmetic helper script: a slow salvo is a slow salvo, but sometimes it's nice to pack the gliders a little closer together (safely!) so that a recipe can be run in LifeViewer or Golly more easily.
(106) DONE RCT viewer script -- alpha version here -- it would be nice if it could be adjusted to automatically work the same way for any size RCT pattern.
(107) DONE (Pavgran) Script to take a slow^1 salvo in standard "EOlane" quarter-diagonal format, and produce a slow^2 salvo that produces that salvo at right angles, when aimed at a honeyfarm.
