dvgrn wrote: ↑September 22nd, 2020, 12:20 pm

MathAndCode wrote: ↑September 22nd, 2020, 11:48 am

MathAndCode wrote: ↑September 21st, 2020, 5:43 pm

A honey farm predecessor reacting with a block edgeshoots a block a long way off.

Code: Select all

```
x = 7, y = 7, rule = B3/S23
2o$2o4bo$5bo$6bo2$4b2o$5bo!
```

Here's a similar example:

Code: Select all

```
x = 8, y = 8, rule = B3/S23
o$o$o5bo$7bo$7bo2$5b2o$5bo!
```

A LifeHistory version of the first example, to show how good it is -- I think this one has been seen quite often before:

Code: Select all

```
x = 22, y = 30, rule = LifeHistory
8.B$3.2C5B$3.2C4BC2B$5.3BC2.3B$4.5BC.4B$4.10B$4.3B2C5B$4.4BC4B$5.7B$
5.6B$5.5B$2A3.6B$.A2.7B2.2A$A3.7B3.A$2A2.6B3.A$.A2.6B3.2A$A4.5B4.A$2A
3.6B2.A$.A3.6B2.A.A2.2A$A4.6B3.2A2.A2.A$2A2.7B5.2A2.2A$.A3.6B3.2A$A5.
4B3.A.A$2A4.B2DB3.A$2.A4.2D3.2A$2.3A6.A$5.A5.A.3A$4.2A4.2A.A2.A$6.2A.
A5.2A$6.A.2A!
```

The main reason that I figured that it might not be known is that this would be most useful in unidirectional glider syntheses, which would typically be done by a computer, and most would likely be too long for humans to bother looking through the individual steps. I was sure that at least one computer had come up with it, but I was unsure whether or not any people actually knew about it.

The method uses the same c/2 forward movement mechanism as the B heptomino. (A B heptomino is visible at generation 25, but it soon interacts with the ash behind it.) Like the B heptomino, the c/2 forward movement is unstable (in that particular case) and decays, but while the B-heptomino's decay forms a Herschel, this instance decays into a block. There are probably other instances that can edgeshoot different common objects,

maybe even a traffic light.

Edit: I tried looking for other similar mechanisms by putting random soups behind a B heptomino. Here's one example:

Code: Select all

```
x = 6, y = 6, rule = B3/S23
bo$3bo$o2b2o$b2ob2o$2ob2o$b3o$2bo!
```

In this case, the initial c/2 movement mechanism didn't last very long, but other pops up from generation 193 to generation 207, which then fluctuates between c/2, c/3, and possible 2c/5 or something else more complicated until generation 239 except from a brief hiccup around generation 217. (There's also an unstable c/4 forward movement mechanism from generation 102 to generation 110.) (None of these should be particularly surprising, but it's interesting that unstable forward movement mechanisms are fairly common.)

By the way, the reason that I was crashing honey farms into other objects was because when I read

this, I noticed that the long boat predecessor was half of a honey farm predecessor, so I wondered whether or not a long boat could form if a honey farm predecessor crashed into an object that then destroyed about half of said honey farm predecessor, similarly to how a half-bakery commonly forms when a bakery predecessor hits some other object that then destroys half of said bakery predecessor. The northeast part of the pattern that I posted has three long boats at generation 1421 (as well as a pattern that would probably be a long boat or a very long boat if the junk that formed it had gone away from it after forming it), but none of those three were formed that way: The two long boats in the far northeast were formed from the same six-cell predecessor but not as a result of a honey farm predecessor crashing into something, and the long boat that was more east than northeast formed from a blinker predecessor interacting with a barge. (Also, a half-bakery forms at generation 359 from a corrupted bakery predecessor, but instead of the bakery predecessor hitting something then becoming corrupted, it was simply formed corrupted from a double corrupted ∏ sequence.

Code: Select all

```
x = 6, y = 7, rule = DoubleB3S23
.A$3.C$A.B2C$.2C.2C$2C.2C$.3C$2.C!
```

The only real lesson from this paragraph is that the pattern that I posted develops interesting patterns, which is definitely true (such as the queen bee beginning shortly after generation 1250), but that's true for virtually all patterns that last for long enough. I only tracked this pattern to about generation 1500, but I'm sure that it spawns more interesting patterns before it settles. (At generation 1426, the eastern longboat is destroyed by a c/2 movement mechanism (which originated from another corrupted ∏ sequence) that looks like it would have either died or transitioned to c/3 just before hitting the long boat.)

Various edits: I got a traffic light.

Code: Select all

```
x = 6, y = 5, rule = B3/S23
3b3o$o3b2o$bob2o$b3o$2bo!
```

A c/2 movement mechanism starts at generation 17 and lasts until generation 45, after which it starts to fluctuate between c/2 and c/3 but ends at generation 50. It ends up placing a blinker fairly far off.

Code: Select all

```
x = 6, y = 6, rule = B3/S23
o4bo$bo3bo$2o2b2o$bob2o$b3o$2bo!
```

This one births a century fairly far off. (Normally, I wouldn't record something so messy, but centuries are common enough that there are already century converters and other century-handling circuitry.) The century itself develops a corrupted ∏ sequence that develops a c/2 movement mechanism at generation 126 (53 century time) and lasts until generation 138 (65 century time), after which it moves between c/2 and c/3 until generation 144 (71 century time). After a brief hiccup, it has another period of c/2 forwards movement from generation 152 (79 century time) to generation 158 (85 century time) and then dissipates soon afterwards.

The weekender's forward movement mechanism appears just after generation 680.

Code: Select all

```
x = 6, y = 6, rule = B3/S23
b3o$2o2b2o$b2obo$bob2o$b3o$2bo!
```

The western movement starting on generation 409 looks like it might be useful.

This one isn't optimal, but I haven't found anything better that places a beehive yet.

Code: Select all

```
x = 6, y = 8, rule = B3/S23
bo2bo$obo$ob2obo$obo2$bob2o$b3o$2bo!
```

This one backtracks a little at the end but is still fairly good considering that the tub is less common than the other patterns that I've edgeshot so far.

Code: Select all

```
x = 6, y = 8, rule = B3/S23
2bo$ob3o$b3o$b3obo2$bob2o$b3o$2bo!
```

Less than a minute later, I have found another B-based edgeshooting of a tub, although this one later destroys the tub.

Code: Select all

```
x = 6, y = 8, rule = B3/S23
b2ob2o$o2b2o$2bo$4b2o2$bob2o$b3o$2bo!
```

By the way, if someone figures out how to make tubs with period 84 or 168, this could be made into an oscillator. Maybe we can edgeshoot the tub…

This one edgeshoots a blinker in the initial direction of movement.

Code: Select all

```
x = 5, y = 8, rule = B3/S23
bo$2bo$2bo$b3o2$bob2o$b3o$2bo!
```

This edgeshooting has increased distance at the cost of increased messiness.

Code: Select all

```
x = 6, y = 8, rule = B3/S23
3b2o$o4bo$bobobo$ob2o2$bob2o$b3o$2bo!
```

This is even more exaggerated than the previous one: It's amazingly directional but very messy.

Code: Select all

```
x = 6, y = 8, rule = B3/S23
bo2bo$2bob2o$2bo2bo$o2b3o2$bob2o$b3o$2bo!
```

This also edgeshoots a traffic light.

Code: Select all

```
x = 6, y = 8, rule = B3/S23
bo3bo$ob2obo$3b3o$bobo2$bob2o$b3o$2bo!
```

Messy but far edgeshooting of a blinker:

Code: Select all

```
x = 6, y = 8, rule = B3/S23
bo2bo$bo$ob4o3$bob2o$b3o$2bo!
```

Why have I edgeshot three tubs (although two were later destroyed) but no loaves or boats, each of which is more common?

Code: Select all

```
x = 6, y = 8, rule = B3/S23
b3o$2o$o2b3o$5o2$bob2o$b3o$2bo!
```

A messy edgeshooting of a blinker with about 20 cells clearance:

Code: Select all

```
x = 6, y = 8, rule = B3/S23
$o$b3obo$o2bo2$bob2o$b3o$2bo!
```

Why do I not get boats shot out far with good clearance?

Code: Select all

```
x = 7, y = 8, rule = B3/S23
6o$5b2o$2b2o2bo3$2bob2o$2b3o$3bo!
```

Sends out a boat-beehive-blinker constellation rather far but is messy:

Code: Select all

```
x = 7, y = 8, rule = B3/S23
ob2obo$5obo$5b2o3$2bob2o$2b3o$3bo!
```

This one somewhat edgeshoots backwards (and mostly diagonally).

Code: Select all

```
x = 7, y = 8, rule = B3/S23
2o4bo$b4obo$2ob4o3$2bob2o$2b3o$3bo!
```

If only that spark coalesced into something besides a vacuum. The blinker could still be useful, though.

Code: Select all

```
x = 6, y = 8, rule = B3/S23
3ob2o$ob3o$3b3o3$bob2o$b3o$2bo!
```

There are quite possibly the best loaves that I've seen so far.

Code: Select all

```
x = 7, y = 8, rule = B3/S23
4o2bo$3ob3o$2bo3$2bob2o$2b3o$3bo!
```

This one edgeshoots a fleet backwards.

Code: Select all

```
x = 9, y = 9, rule = B3/S23
9o$ob2obo2bo$bo2b4o$o2bo2bo3$3bob2o$3b3o$4bo!
```

Just look at that beehive at generation 1000 or so.

Code: Select all

```
x = 9, y = 9, rule = B3/S23
2b2obobo$obob3o$3ob2o2bo$b4o2bo3$3bob2o$3b3o$4bo!
```

Finally, a boat edgeshot fairly decently.

Code: Select all

```
x = 11, y = 10, rule = B3/S23
2o2bobo3bo$5o2b4o$4o3b2obo$o3bobo2bo4$4bob2o$4b3o$5bo!
```

I think that long boats are rare enough for this to be worth adding.

Code: Select all

```
x = 11, y = 10, rule = B3/S23
2b2o4b3o$4bobo2b2o$obo4b4o$2obo3bo2bo4$4bob2o$4b3o$5bo!
```

One of these blocks is diagonally edgeshot.

Code: Select all

```
x = 13, y = 10, rule = B3/S23
obobo3b4o$2b2o3b2ob3o$bo3bobo4bo$b2obobob3obo4$5bob2o$5b3o$6bo!
```

This one edgeshoots a traffic light.

Code: Select all

```
x = 7, y = 10, rule = B3/S23
2o3b2o$2o3b2o3$b3o$bo$4b2o$2o$2o$bo!
```

Here's the run that it came from.

Code: Select all

```
x = 13, y = 10, rule = B3/S23
obo3bo$3obob3obobo$2o3bo2bobobo$ob3obobo4$5bob2o$5b3o$6bo!
```

I shall end (at least for now) with a good edgeshooting of a boat.

Code: Select all

```
x = 15, y = 13, rule = B3/S23
b2o$b2o2bo$2b2obo$3bo2bo$4b3o3bo$10bo$2o$8bobobo$b2o5b5o$2b2o2b2ob3ob
2o$4bo2b2obob3o$4bobo2bobo$4b3o3bo!
```

Here is the pattern that it came from.

Code: Select all

```
x = 13, y = 10, rule = B3/S23
ob3o2b3o2bo$3bobo2bo3bo$obo3bobob2o$2bobo7bo4$5bob2o$5b3o$6bo!
```