Crawlers

[Rhombic]

I also can't find a 1G reaction to get the block in the right spot.

I mean a reaction with the LoM before it settles into the blocks on the left hand side.

And for the reflection, I was thinking of something like this:

Code: Select all

x = 81, y = 173, rule = LifeHistory
2C$2C3$.2C$.2C16.2A$19.2A22$2C$2C3$.2C$.2C16.2A$19.2A10$79.2C$79.2C3$
78.2C$60.2A16.2C$60.2A6$2C$2C3$.2C$.2C16.2A$19.2A10$79.2C$79.2C3$78.
2C$60.2A16.2C$60.2A6$2C$2C3$.2C$.2C16.2A$19.2A10$79.2C$79.2C3$78.2C$
60.2A16.2C$60.2A6$2C$2C3$.2C$.2C16.2A$19.2A8$11.A$10.3A$10.A.2A65.2C$
79.2C3$78.2C$60.2A16.2C$60.2A22$79.2C$79.2C3$78.2C$60.2C16.2C$60.2C8$
69.A$68.3A$67.2A.A!

This reaction in particular doesn't give what we wanted, but you get the idea.

[Gamedziner]

And for the reflection, I was thinking of something like this:

The problem there is that the two tracks would eventually converge.

[Rhombic]

The problem there is that the two tracks would eventually converge.

Well yeah, but isn't that how 31/240 etc work? you set up something to delete the last B-heptomino and connect a synthesis at a translation.
What qualifies as a promising reaction otherwise? We've probably found most of the single transparent still-life mechanisms (and otherwise this should have been done by now!! someone get on with C++, I'll donate my CPU)

[biggiemac]

The problem there is that the two tracks would eventually converge.

Well yeah, but isn't that how 31/240 etc work? you set up something to delete the last B-heptomino and connect a synthesis at a translation.

Your understanding of the prior work seems wrong, the crawlers are not deleted in any of the fast ships. The only one where an crawler seems to be deleted and resynthesized is the HBK, since the glider is destroyed and rebuilt. But I argue that the glider isn't even the "crawler" in the HBK, but rather the "crawlee."

A reaction shifting two tracks relative to one another isn't a dealbreaker, but it makes things harder for sure. You probably want to work with non-mirrored track pairs in trying to patch this up.

What qualifies as a promising reaction?

The ideal is the following. Have some pair of objects at t=0, let's call them C1 and C2. C1 is the crawler and can be arbitrarily complex, C2 the "crawlee" and needs to be a regular pattern (periodic or periodic-with-offset like a spaceship).

At time t=T, the universe again consists of C1 and C2, but C1 is displaced by vector V1 with components (A1, B1), and C2 displaced by V2 with components (A2, B2), and possibly advanced by G2 generations. Examples:

C1 = Pi
C2 = Blinker
T = 45
V1 = (0, 17)
V2 = (0, -11)
G2 = 1

Code: Select all

x = 5, y = 17, rule = B3/S23
2bo$2bo$2bo12$b3o$o3bo$2ob2o!

C1 = Herschel
C2 = Block
T = 240
V1 = (0, 31)
V2 = (0, -22) or (-8, -4)
G2 = 0
Extra block and 2 gliders

Code: Select all

x = 10, y = 26, rule = B3/S23
8b2o$8b2o22$3o$bo$b3o!

C1 = Herschel
C2 = Glider
T = 79
V1 = (23, 5)
V2 = (-27, -29)
G2 = 1
Extra glider

Code: Select all

x = 16, y = 18, rule = B3/S23
15bo$13b2o$14b2o13$3o$bo$b3o!

C1 = Herschel
C2 = Glider
T = 72
V1 = (27, 1)
V2 = (-22, -38)
G2 = 0
Extra bunch of junk

Code: Select all

x = 14, y = 28, rule = B3/S23
11bobo$11b2o$12bo23$3o$bo$b3o!

C1 = Half-Bakery
C2 = Glider
T = Anything more than 62
V1 = (6,3)
V2, G2 = Depends on T

Code: Select all

x = 16, y = 14, rule = B3/S23
b2o$o2bo$bobo$2bob2o$3bo2bo$4bobo$5bo5$13b2o$13bobo$13bo!

In all of these cases, the spaceship speed is V1 divided by T. C1 objects are not created or destroyed at any point in the ship. The challenge is for objects of type C2 to be created at the front and destroyed at the back. The displacement and phase shift of the second object simply tells where the next crawler must be for the reaction to repeat, which is important for the construction aspect but doesn't say much about the possibility/impossibility of the ship except for maybe giving a good idea about coset problems.

If C1 reappears but C2 is incompletely formed, it is usually really hard to do anything to salvage the crawler. If there is way too much junk, it's again usually really hard. If there is no junk at all, it depends on whether anything good comes out of rubbing multiple copies together.

If the goal is to dig up a ton of promising reactions, going into slightly more complex Cs would be a way to go. Either use multiple still lives and oscillators together as C2 (but bear in mind that the chance of having C2 fully rebuilt at any later T is way lower), or more exotic C1 (combinations of active objects, or just more odd ones).

[Mr. T]

By doubling muzik's crawler you get usable variations perhaps.

The second crawler restores the position of the blocks.

Code: Select all

x = 64, y = 387, rule = B3/S23
obo$obo$3o14b2o$17b2o2$4b2o$4b2o13$17bo$15bo2bo$14bo$17bo4bo$17b2o2bob
o$6b2o2b2o2bob2o4bo$6b2o2b2o3b2o3bo8$24b3o$24bobo$23bobo3$22bobo$22bob
o$22b3o3$8b2o16b2o$8b2o16b2o18$10b2o16b2o$10b2o16b2o18$12b2o16b2o$12b
2o16b2o18$14b2o16b2o$14b2o16b2o18$16b2o16b2o$16b2o16b2o18$18b2o16b2o$
18b2o16b2o18$20b2o16b2o$20b2o16b2o18$22b2o16b2o$22b2o16b2o18$24b2o16b
2o$24b2o16b2o18$26b2o16b2o$26b2o16b2o18$28b2o16b2o$28b2o16b2o18$30b2o
16b2o$30b2o16b2o18$32b2o16b2o$32b2o16b2o18$34b2o16b2o$34b2o16b2o18$36b
2o16b2o$36b2o16b2o18$38b2o16b2o$38b2o16b2o18$40b2o16b2o$40b2o16b2o18$
42b2o16b2o$42b2o16b2o18$44b2o16b2o$44b2o16b2o!

This produces gliders.

Code: Select all

x = 38, y = 219, rule = B3/S23
10bobo$10bobo$10b3o3$14b2o$14b2o2$2o$2o15$16b2o$16b2o2$2b2o$2b2o15$18b
2o$18b2o2$4b2o$4b2o15$20b2o$20b2o2$6b2o$6b2o15$22b2o$22b2o2$8b2o$8b2o
15$24b2o$24b2o2$10b2o$10b2o15$26b2o$26b2o2$12b2o$12b2o15$28b2o$28b2o2$
14b2o$14b2o15$30b2o$30b2o2$16b2o$16b2o15$32b2o$32b2o2$18b2o$18b2o15$
34b2o$34b2o2$20b2o$20b2o15$36b2o$36b2o2$22b2o$22b2o!

2 rows of blocks are fused to 1.

Code: Select all

x = 42, y = 239, rule = B3/S23
12bobo$12bobo$12b3o3$16b2o$16b2o3$2o$2o14$18b2o$18b2o3$2b2o$2b2o14$20b
2o$20b2o3$4b2o$4b2o14$22b2o$22b2o3$6b2o$6b2o14$24b2o$24b2o3$8b2o$8b2o
14$26b2o$26b2o3$10b2o$10b2o14$28b2o$28b2o3$12b2o$12b2o14$30b2o$30b2o3$
14b2o$14b2o14$32b2o$32b2o3$16b2o$16b2o14$34b2o$34b2o3$18b2o$18b2o14$
36b2o$36b2o3$20b2o$20b2o14$38b2o$38b2o3$22b2o$22b2o14$40b2o$40b2o3$24b
2o$24b2o!

[HartmutHolzwart]

Thank you for this clear explanation with examples! A couple of ideas:

1) Could you add the (obvious) space ships based on the repective direction?

2) I miss the (13,1)c/31 reaction

3) How do the reactions used in the caterloopillar fit in the picture?

4) Glider duplicating *WSS fleets would be another (hard to control) type of reaction wher both reaction partners move

[C28]

Code: Select all

x = 9, y = 14, rule = LifeHistory
.3D$D3.D$2D.2D3$2.2A$.A2.A$2.2A4$5.3C$4.C3.C$4.2C.2C!

[C28]

Code: Select all

x = 18, y = 122, rule = B3/S23
16b2o$16b2o34$2o$2o34$16b2o$16b2o34$2o$2o12$11b3o$11bobo$10bo2bo$10b2o
!

[MathAndCode]

Code: Select all

x = 18, y = 122, rule = B3/S23
16b2o$16b2o34$2o$2o34$16b2o$16b2o34$2o$2o12$11b3o$11bobo$10bo2bo$10b2o
!

I found that a while back.

[C28]

(17,2)c/57

Code: Select all

x = 86, y = 14, rule = B3/S23
83b2o$83bobo$83bo$67b2o$66b2o$68bo$50b3o$50bo$35bo15bo$34b2o$34bobo$b
3o14b2o$o2bo14bobo$2obo14bo!

edit: so close...

Code: Select all

x = 16, y = 81, rule = B3/S23
b2o$o2bo$b2o24$11b2o$10bo2bo$11b2o24$b2o$o2bo$b2o24$6bo7b2o$5b3o6b2o$
5bo!

edit2: hmmm...

Code: Select all

x = 15, y = 81, rule = B3/S23
b2o$o2bo$b2o24$11b2o$10bo2bo$11b2o24$b2o$o2bo$b2o23$14bo$6bo7bo$5b3o6b
o$5bo!

edit 3: a blinker can clean up the debris left by the r-pentomino. maybe i should start a separate thread.

Code: Select all

x = 14, y = 81, rule = B3/S23
b2o$o2bo$b2o24$11b2o$10bo2bo$11b2o24$b2o$o2bo$b2o21$12bo$12bo$12bo$6b
o$5b3o$5bo!

edit 4: not the best but ok

Code: Select all

x = 15, y = 83, rule = B3/S23
2b2o$bo2bo$2b2o24$12b2o$11bo2bo$12b2o24$2b2o$bo2bo$2b2o24$7bo$6b3o$o5b
o$o$o!

edit 5: this is better

Code: Select all

x = 16, y = 81, rule = B3/S23
3b2o$2bo2bo$3b2o24$13b2o$12bo2bo$13b2o24$3b2o$2bo2bo$3b2o24$8bo$7b3o$
3o4bo!

edit 6: i'll have to keep searching...

Code: Select all

x = 19, y = 81, rule = B3/S23
6b2o$5bo2bo$6b2o24$16b2o$15bo2bo$16b2o24$6b2o$5bo2bo$6b2o24$o10bo$o9b
3o$o9bo!

[C28]

this looks somewhat promising

Code: Select all

x = 68, y = 112, rule = B3/S23
2bo$obo$b2o29$66b2o$66b2o17$21bobo$22b2o$22bo8$66b2o$66b2o27$66b2o$66b
2o9$43bo$44bo$42b3o10$58bo$57b3o$57bo!

[dvgrn]

this looks somewhat promising

Code: Select all

x = 68, y = 112, rule = B3/S23
2bo$obo$b2o29$66b2o$66b2o17$21bobo$22b2o$22bo8$66b2o$66b2o27$66b2o$66b
2o9$43bo$44bo$42b3o10$58bo$57b3o$57bo!

That's an interesting one, for sure -- an orthogonal 28c/83 R-pentomino crawler! Produces two gliders for every input glider. I don't think that one has been seen before.

Code: Select all

x = 155, y = 335, rule = LifeSuper
2.M$M.M$.2M47$21.M.M$22.2M$22.M46$43.M$44.M$42.3M43$149.2M$149.2M3$
63.M$64.2M$63.2M22$149.2M$149.2M24$85.M$83.M.M$84.2M$149.2M$149.2M27$
149.2M$149.2M17$104.M.M$105.2M$105.M8$149.2M$149.2M27$149.2M$149.2M9$
126.M$127.M$125.3M8$146.M$144.M$141.M$140.3M2.M.M$140.M5.M9$138.M$
137.M$137.3M2$152.3M$154.M$153.M9$138.2M$138.2M$141.D$140.3D$140.D!

It's fast enough that it will need a helix to support the front end (>c/4).

I don't immediately see how to turn it into a set of trails that can support a choice of rakes (producing gliders) and rephasers (not producing any gliders). Seems like there ought to be some sneaky trick or other available, but how might we suppress the forward glider stream coming from the rightmost block trail?

[C28]

this looks somewhat promising

Code: Select all

x = 68, y = 112, rule = B3/S23
2bo$obo$b2o29$66b2o$66b2o17$21bobo$22b2o$22bo8$66b2o$66b2o27$66b2o$66b
2o9$43bo$44bo$42b3o10$58bo$57b3o$57bo!

That's an interesting one, for sure -- an orthogonal 28c/83 R-pentomino crawler! Produces two gliders for every input glider. I don't think that one has been seen before.

Code: Select all

x = 155, y = 335, rule = LifeSuper
2.M$M.M$.2M47$21.M.M$22.2M$22.M46$43.M$44.M$42.3M43$149.2M$149.2M3$
63.M$64.2M$63.2M22$149.2M$149.2M24$85.M$83.M.M$84.2M$149.2M$149.2M27$
149.2M$149.2M17$104.M.M$105.2M$105.M8$149.2M$149.2M27$149.2M$149.2M9$
126.M$127.M$125.3M8$146.M$144.M$141.M$140.3M2.M.M$140.M5.M9$138.M$
137.M$137.3M2$152.3M$154.M$153.M9$138.2M$138.2M$141.D$140.3D$140.D!

It's fast enough that it will need a helix to support the front end (>c/4).

I don't immediately see how to turn it into a set of trails that can support a choice of rakes (producing gliders) and rephasers (not producing any gliders). Seems like there ought to be some sneaky trick or other available, but how might we suppress the forward glider stream coming from the rightmost block trail?

well i'll do some searching. maybe i'll find something useful. so far i have this

Code: Select all

x = 74, y = 113, rule = B3/S23
2bo$obo$b2o30$72b2o$72b2o16$21bobo$22b2o$22bo9$72b2o$72b2o27$72b2o$72b
2o8$43bo$44bo$42b3o11$64bo$63b3o$63bo!

[MathAndCode]

this looks somewhat promising

One column of blocks can support two R-sequences if they're synchronized (although gliders are still needed to clean up the mess).

Code: Select all

x = 20, y = 81, rule = B3/S23
9b2o$9b2o27$9b2o$9b2o27$9b2o$9b2o21$bo16bo$3o14b3o$o18bo!

By the way, a pentadecathlon forms (although it's helped by the symmetry).

[Sphenocorona]

That's an interesting one, for sure -- an orthogonal 28c/83 R-pentomino crawler! Produces two gliders for every input glider. I don't think that one has been seen before.

I've seen the underlying reaction before, but I didn't look into it too much in regular B3/S23 because R sequences are so incredibly messy. The reaction is much better behaved in B38/S23, where I've been able to find a rake and a spacer. Unfortunately, I wasn't really able to make further progress because the old helix building tools have been mostly lost by the wayside (it involves a Golly script in Perl, which is really difficult to set up now - I was completely unable to do it after trying multiple versions of both the old Perl-supporting Golly and StrawberryPerl).

However, it's worth nothing that there's room for variation in what the front is actually crawling on. If we're lucky, there might be a way to chain multiple together (one crawling the smoke cloud of the previous) such that it becomes reburnable (or at least, able to be arranged to cancel out debris in a more standard fashion).

Under certain circumstances, it's possible to spawn a clean R wave that at the end spits out a glider, along with a new block trail:

Code: Select all

x = 655, y = 95, rule = B3/S23
4b2o$4b2o9b2o$15bobo$15bo4b2o$20bobo$20bob2o$19bob2o$19b3o3$18b2o8b2o
2b2o$18b2o8b2o2b3o$27b3o2b2o$28b2o2bo6$37b2obo$32b3o2b2o2bo$33b2o6bo$
34b2o4b2o$39bo$36b2o5$38b3o4bo$38b2o5b2o$39b2o5b2o$38bobo3bobo$36b4o4b
2o$36b2o2bo3bo$37b2obo$38b3o$39bo$39b2o$39bobo$52b2o$51b3o$51bo2bo$52b
2o9$57b3o$57bo4bo$58bo3b2o$63b2o$60bo2bo$61b2o2$72b2o$60b2o9b4o$60b2o
9bob3o$70bob3o$71b3o$71b2o7$b2o26b2o$obo25bobo27b2o$bo27bo27bo2bo2b2o$
57bobo2bo2bo$10bo27bo19bo4b2o12bo$9bobo25bobo35b2ob2o$9bobo25bobo29bo
8b5o$10bo27bo29b3o8bo2bo$67b5o7bo2bo$66b2o3b2o7b2o$37bo29b5o$8b3o26bo
30b3o$37bo31bo9b2o11bo$72b3o4b2o9b3o$20bo50bo3bo14bobo$20bo26b3o21bo3b
o14bo$20bo50bo3bo$72b3o5$93b2o26b2o26b2o26b2o26b2o26b2o26b2o26b2o26b2o
26b2o26b2o26b2o26b2o26b2o26b2o26b2o26b2o26b2o26b2o26b2o26b2o$93b2o26b
2o26b2o26b2o26b2o26b2o26b2o26b2o26b2o26b2o26b2o26b2o26b2o26b2o26b2o26b
2o26b2o26b2o26b2o26b2o26b2o!

Unfortunately, this is roughly the best I've come up with so far in terms of maximizing useful output to junk output. That said, there may be something better that ends up being workable.

[C28]

That's an interesting one, for sure -- an orthogonal 28c/83 R-pentomino crawler! Produces two gliders for every input glider. I don't think that one has been seen before.

I've seen the underlying reaction before, but I didn't look into it too much in regular B3/S23 because R sequences are so incredibly messy. The reaction is much better behaved in B38/S23, where I've been able to find a rake and a spacer. Unfortunately, I wasn't really able to make further progress because the old helix building tools have been mostly lost by the wayside (it involves a Golly script in Perl, which is really difficult to set up now - I was completely unable to do it after trying multiple versions of both the old Perl-supporting Golly and StrawberryPerl).

However, it's worth nothing that there's room for variation in what the front is actually crawling on. If we're lucky, there might be a way to chain multiple together (one crawling the smoke cloud of the previous) such that it becomes reburnable (or at least, able to be arranged to cancel out debris in a more standard fashion).

Under certain circumstances, it's possible to spawn a clean R wave that at the end spits out a glider, along with a new block trail:

Code: Select all

x = 655, y = 95, rule = B3/S23
4b2o$4b2o9b2o$15bobo$15bo4b2o$20bobo$20bob2o$19bob2o$19b3o3$18b2o8b2o
2b2o$18b2o8b2o2b3o$27b3o2b2o$28b2o2bo6$37b2obo$32b3o2b2o2bo$33b2o6bo$
34b2o4b2o$39bo$36b2o5$38b3o4bo$38b2o5b2o$39b2o5b2o$38bobo3bobo$36b4o4b
2o$36b2o2bo3bo$37b2obo$38b3o$39bo$39b2o$39bobo$52b2o$51b3o$51bo2bo$52b
2o9$57b3o$57bo4bo$58bo3b2o$63b2o$60bo2bo$61b2o2$72b2o$60b2o9b4o$60b2o
9bob3o$70bob3o$71b3o$71b2o7$b2o26b2o$obo25bobo27b2o$bo27bo27bo2bo2b2o$
57bobo2bo2bo$10bo27bo19bo4b2o12bo$9bobo25bobo35b2ob2o$9bobo25bobo29bo
8b5o$10bo27bo29b3o8bo2bo$67b5o7bo2bo$66b2o3b2o7b2o$37bo29b5o$8b3o26bo
30b3o$37bo31bo9b2o11bo$72b3o4b2o9b3o$20bo50bo3bo14bobo$20bo26b3o21bo3b
o14bo$20bo50bo3bo$72b3o5$93b2o26b2o26b2o26b2o26b2o26b2o26b2o26b2o26b2o
26b2o26b2o26b2o26b2o26b2o26b2o26b2o26b2o26b2o26b2o26b2o26b2o$93b2o26b
2o26b2o26b2o26b2o26b2o26b2o26b2o26b2o26b2o26b2o26b2o26b2o26b2o26b2o26b
2o26b2o26b2o26b2o26b2o26b2o!

Unfortunately, this is roughly the best I've come up with so far in terms of maximizing useful output to junk output. That said, there may be something better that ends up being workable.

well, we can delete blinkers with this

Code: Select all

x = 22, y = 81, rule = B3/S23
20b2o$20b2o21$bo$bo$bo4$20b2o$20b2o22$3o5$20b2o$20b2o21$bo10bo$bo9b3o
$bo9bo!

edit: so the above is more convert than delete. this is more delete than convert

Code: Select all

x = 23, y = 81, rule = B3/S23
21b2o$21b2o27$21b2o$21b2o27$21b2o$21b2o21$o12bo$o11b3o$o11bo!

edit 2: this deletes beehives

Code: Select all

x = 22, y = 82, rule = B3/S23
20b2o$20b2o27$20b2o$20b2o27$20b2o$20b2o21$bo10bo$obo8b3o$obo8bo$bo!

edit 3: this produces blinkers

Code: Select all

x = 73, y = 118, rule = B3/S23
2bo$obo$b2o35$71b2o$71b2o11$21bobo$22b2o$22bo14$71b2o$71b2o27$71b2o$71b
2o3$43bo$44bo$42b3o16$63bo$62b3o$62bo!

edit 4: this one's similar to above, but makes loafs instead of blinkers

Code: Select all

x = 74, y = 122, rule = B3/S23
2bo$obo$b2o39$72b2o$72b2o7$21bobo$22b2o$22bo18$72b2o$72b2o27$43bo28b2o
$44bo27b2o$42b3o20$64bo$63b3o$63bo!

edit 5: this seems useful

Code: Select all

x = 55, y = 81, rule = B3/S23
53b2o$53b2o17$bo$2bo$3o8$53b2o$53b2o27$53b2o$53b2o10$21bo$22b2o$21b2o
9$45bo$44b3o$44bo!

[C28]

all that is needed is to clean up the leftover blocks

Code: Select all

x = 219, y = 210, rule = B3/S23
bo215bo$2bo213bo$3o213b3o47$21bo175bo$22b2o171b2o$21b2o173b2o22$107b2o
b2o$107b2ob2o24$43bo131bo$41bobo131bobo$42b2o131b2o$107b2ob2o$107b2ob
2o27$107b2ob2o$107b2ob2o17$62bobo89bobo$63b2o89b2o$63bo91bo8$107b2ob2o
$107b2ob2o27$107b2ob2o$107b2ob2o9$84bo49bo$85bo47bo$83b3o47b3o10$99bo
19bo$98b3o17b3o$98bo21bo!

[praosylen]

all that is needed is to clean up the leftover blocks

Code: Select all

x = 219, y = 210, rule = B3/S23
bo215bo$2bo213bo$3o213b3o47$21bo175bo$22b2o171b2o$21b2o173b2o22$107b2o
b2o$107b2ob2o24$43bo131bo$41bobo131bobo$42b2o131b2o$107b2ob2o$107b2ob
2o27$107b2ob2o$107b2ob2o17$62bobo89bobo$63b2o89b2o$63bo91bo8$107b2ob2o
$107b2ob2o27$107b2ob2o$107b2ob2o9$84bo49bo$85bo47bo$83b3o47b3o10$99bo
19bo$98b3o17b3o$98bo21bo!

Not really... The primary issue here with the original glider+block crawler, as I gather it, is not that there are more outputs than inputs to the crawler, or that the blocks show up again in a different position, but that the crawler as it stands has multiple inputs that need to be aligned and synchronized right. In an ideal world a crawler for a macro-spaceship would travel along a single line of still lives or a single glider stream or whatnot, which is very nice because you can just plunk down a bunch of crawler units on a single track at nearly arbitrary relative timings. The issue with this crawler is that you can't chain multiple at arbitrary timings because the gliders move relative to the trail of blocks... What's needed instead is to figure out some complicated arrangement of multiple crawlers that uses either (only gliders from one direction) or (only still lives + blinkers) as inputs, and then reproduces those inputs behind it in the same relative positions after the crawlers have passed — which would allow chaining multiple crawlers at whatever timing you wanted. The block+blinker versions you posted earlier are a nice start, since they give ways to actually generate gliders from an trail of only still lives/oscillators (so "later" crawlers can use the glider+block version, which is over-unity), but something like the thing you posted here doesn't help anything since it has glider inputs from two directions rather than zero (or even one).

[Sphenocorona]

all that is needed is to clean up the leftover blocks

Not really... The primary issue here with the original glider+block crawler, as I gather it, is not that there are more outputs than inputs to the crawler, or that the blocks show up again in a different position, but that the crawler as it stands has multiple inputs that need to be aligned and synchronized right.

While I absolutely agree with this, I think there might still be some value to be found in sufficiently clean over-unity reactions with 2 inputs, as part of a larger complex crawler. To explain what I mean, let's take the (34,7)c/156 crawler reaction as an example. On its own, it climbs either gliders or blocks, and spits out 2 more gliders, along with some junk which contains copies of a block trail, as well as some other junk. Unfortunately, it's difficult to clean up the debris from one of the sides. The current plan for that ship gets around this by having some of its components shoot gliders directly into other crawler components' active regions, suppressing the junk. This is somewhat comparable to some of C28's block + glider input reactions, in that the glider can't arrive at any other time or position, adding additional constraints to where the reaction can be used.

In this case, the fuse is at best even messier, and usually releases fewer gliders. However, once we have one copy of the messy burning fuse, we have a glider that we know is tied to the crawler's position, and so we could use it to clean up another copy of the fuse, and get out even more gliders, which can then be used to clean even more fuses, etc. until we can get all the gliders we need to clean up that initial dirty fuse. The engineering challenges associated with this sound like they could end up being rather difficult, but it sounds to me like it could be vaguely plausible.

[praosylen]

Not really... The primary issue here with the original glider+block crawler, as I gather it, is not that there are more outputs than inputs to the crawler, or that the blocks show up again in a different position, but that the crawler as it stands has multiple inputs that need to be aligned and synchronized right.

While I absolutely agree with this, I think there might still be some value to be found in sufficiently clean over-unity reactions with 2 inputs, as part of a larger complex crawler. To explain what I mean, let's take the (34,7)c/156 crawler reaction as an example. On its own, it climbs either gliders or blocks, and spits out 2 more gliders, along with some junk which contains copies of a block trail, as well as some other junk. Unfortunately, it's difficult to clean up the debris from one of the sides. The current plan for that ship gets around this by having some of its components shoot gliders directly into other crawler components' active regions, suppressing the junk. This is somewhat comparable to some of C28's block + glider input reactions, in that the glider can't arrive at any other time or position, adding additional constraints to where the reaction can be used.

In this case, the fuse is at best even messier, and usually releases fewer gliders. However, once we have one copy of the messy burning fuse, we have a glider that we know is tied to the crawler's position, and so we could use it to clean up another copy of the fuse, and get out even more gliders, which can then be used to clean even more fuses, etc. until we can get all the gliders we need to clean up that initial dirty fuse. The engineering challenges associated with this sound like they could end up being rather difficult, but it sounds to me like it could be vaguely plausible.

Oh, I very much agree with you there. That's essentially what I meant by

The issue with this crawler is that you can't chain multiple at arbitrary timings because the gliders move relative to the trail of blocks... What's needed instead is to figure out some complicated arrangement of multiple crawlers that uses either (only gliders from one direction) or (only still lives + blinkers) as inputs, and then reproduces those inputs behind it in the same relative positions after the crawlers have passed — which would allow chaining multiple crawlers at whatever timing you wanted.

except you put what I was intending to say much more clearly and eloquently. For sure it's a task that's reasonable to imagine attempting, even if (having no real experience with this kind of thing) I personally have trouble envisioning all the steps required to put together a clean, reusable crawler, or maybe some kind of quasi-reusable set of similar types of crawlers, from the compilation of messy, timing/spacing-dependent, or destructive reactions we have now...

[C28]

I personally have trouble envisioning all the steps required to put together a clean, reusable crawler, or maybe some kind of quasi-reusable set of similar types of crawlers, from the compilation of messy, timing/spacing-dependent, or destructive reactions we have now...

well there is this

Code: Select all

x = 47, y = 90, rule = B3/S23
45b2o$45b2o27$45b2o$45b2o27$45b2o$45b2o21$37bo$bo34b3o$b2o33bo$obo6$21b
3o$23bo$22bo!

the block track can sorta be reused, but the excess blocks are a bit of a problem. i'll have to keep searching
edit: this doesn't use gliders, but the blocks need to be restored

Code: Select all

x = 19, y = 90, rule = B3/S23
17b2o$17b2o27$17b2o$17b2o3$2o$2o23$17b2o$17b2o3$2o$2o17$9bo$8b3o$8bo8$
2o$2o!

edit 2: makes gliders, but it has the same problem as the above pattern

Code: Select all

x = 20, y = 85, rule = B3/S23
18b2o$18b2o26$2o$2o16b2o$18b2o26$2o$2o16b2o$18b2o21$10bo$9b3o$9bo3$2o
$2o!

edit 3: this has the opposite problem. the blocks that aren't part of the track are restored, but not the blocks that are part of the track.

Code: Select all

x = 21, y = 88, rule = B3/S23
19b2o$19b2o27$19b2o$19b2o$2o$2o25$19b2o$19b2o$2o$2o19$11bo$10b3o$10bo
6$2o$2o!

[PHPBB12345]

well there is this

Code: Select all

x = 47, y = 90, rule = B3/S23
45b2o$45b2o27$45b2o$45b2o27$45b2o$45b2o21$37bo$bo34b3o$b2o33bo$obo6$21b
3o$23bo$22bo!

Code: Select all

x = 192, y = 283, rule = B3/S23
190b2o$190b2o27$190b2o$190b2o27$190b2o$190b2o27$190b2o$190b2o27$190b2o
$190b2o27$190b2o$190b2o27$190b2o$3o187b2o$2bo$bo5$21b2o$22b2o$21bo5$
42b2o$41bobo$43bo5$63bo$63b2o$62bobo4$190b2o$190b2o$83b3o$85bo$84bo5$
104b2o$105b2o$104bo5$125b2o$124bobo$126bo2$187bo$185bo$182bo$146bo34b
3o2bobo$146b2o33bo5bo$145bobo$3o$2bo$bo3$166b3o$168bo$21b2o144bo11bo$
22b2o154bo$21bo156b3o5$42b2o$41bobo$43bo136b2o$180b2o4$63bo$63b2o$62bo
bo3$190b2o$190b2o2$83b3o$85bo$84bo5$104b2o$105b2o$104bo5$125b2o$124bob
o53b2o$126bo53b2o5$146bo$146b2o$145bobo2$190b2o$190b2o$159bo$157b2o$
158b2o6b3o$168bo$167bo!

[C28]

52c/140 works with loafs

Code: Select all

x = 14, y = 82, rule = B3/S23
12bo$11bobo$10bo2bo$11b2o23$bo$obo$o2bo$b2o23$12bo$11bobo$10bo2bo$11b
2o24$7bo$6b3o$8bo!

[C28]

some glider+(10,7)c/75 pi crawler interactions

glider to boat

Code: Select all

x = 116, y = 145, rule = B3/S23
2bo$obo$b2o27$26bobo$27b2o$27bo26$53bo$54bo$52b3o27$78bo$79b2o$78b2o27$
105bo$103bobo$104b2o13$113bo$112bobo$111bo3bo$112bobo5$112bo$111bobo$
112bo2$74bo$74b2o$73bobo!

glider to boat facing another way

Code: Select all

x = 116, y = 149, rule = B3/S23
2bo$obo$b2o27$26bobo$27b2o$27bo26$53bo$54bo$52b3o27$78bo$79b2o$78b2o27$
105bo$103bobo$104b2o13$113bo$112bobo$111bo3bo$112bobo5$112bo$111bobo$
112bo6$74b2o$73bobo$75bo!

glider to b

Code: Select all

x = 116, y = 151, rule = B3/S23
2bo$obo$b2o27$26bobo$27b2o$27bo26$53bo$54bo$52b3o27$78bo$79b2o$78b2o27$
105bo$103bobo$104b2o13$113bo$112bobo$111bo3bo$112bobo5$112bo$111bobo$
112bo8$79b2o$80b2o$79bo!

edit: some block+(10,7)c/75 pi crawler interactions
block to glider and b

Code: Select all

x = 131, y = 141, rule = B3/S23
2bo$obo$b2o27$26bobo$27b2o$27bo26$53bo$54bo$52b3o27$78bo$79b2o$78b2o27$
105bo$103bobo$104b2o11$129b2o$129b2o$113bo$112bobo$111bo3bo$112bobo5$
112bo$111bobo$112bo!

block to block and glider

Code: Select all

x = 126, y = 141, rule = B3/S23
2bo$obo$b2o27$26bobo$27b2o$27bo26$53bo$54bo$52b3o27$78bo$79b2o$78b2o27$
105bo$103bobo$104b2o13$113bo$112bobo$111bo3bo$112bobo$124b2o$124b2o3$
112bo$111bobo$112bo!

edit 2: glider is reflected

Code: Select all

x = 116, y = 149, rule = B3/S23
2bo$obo$b2o27$26bobo$27b2o$27bo26$53bo$54bo$52b3o27$78bo$79b2o$78b2o27$
105bo$103bobo$104b2o13$113bo$112bobo$111bo3bo$112bobo5$112bo$111bobo$
112bo6$97b2o$96bobo$98bo!

[Gustone]

caterpillarable?

Code: Select all

x = 74, y = 106, rule = B3/S23
2bo$obo$b2o21$15bo$16b2o$15b2o21$30bo$31bo$29b3o22$43bobo$44b2o$44bo
21$59bo$57bobo$58b2o8$71b3o$72bo$70b3o!