ideas for engineered spaceships

[LLAMASKYWALKER]

Post you engineered spaceship ideas here if you think they have potential but you can't build them yourselves!
i have 1 idea, blue is blinker fuse+puffer and xwss slow salvo, red is boat fuse + crabstreacher and glider salvo, black is converter system constructed by the salvo https://www.mediafire.com/view/qosn76nz ... g.png/file

[hotdogPi]

This looks so much like a spambot post...

[LLAMASKYWALKER]

im not a spambot, i just had a idea that i wanted to share
spambots also dont have 82 posts

[dl-rs]

I have an idea. There's something called telegraph that can move hives, yeah? If we can let it circle...

[yujh]

I guess the last post was a bit too smart for me to understand…
Anyways, why not delete my post and merge this with another thread?

[wwei47]

I have an idea. There's something called telegraph that can move hives, yeah? If we can let it circle...

Interesting! So, I think that one end would have to receive the signal somehow, and move itself over. Afterwards, a signal would be sent to the other end, moving it over, while ALSO sending a new signal. This could lead to an adjustable spaceship! Nice!

[dvgrn]

I have an idea. There's something called telegraph that can move hives, yeah? If we can let it circle...

Interesting! So, I think that one end would have to receive the signal somehow, and move itself over. Afterwards, a signal would be sent to the other end, moving it over, while ALSO sending a new signal. This could lead to an adjustable spaceship! Nice!

You could make a closed-loop lightspeed signal that moves, but it actually just makes the problem about four times as complicated as it needs to be. Here's the "telegraph" move reaction (colored glider) --

Code: Select all

x = 55, y = 8, rule = LifeHistory
43.A$27.2D3.2A.2A4.A10.2A$.2A3.2A3.2A3.2A3.2A3.2C.D.6A3.A5.2A3.A2.A$A
2.A.A2.A.A2.A.A2.A.A2.A.C.DC.A6.A2.A6.A4.2A$.2A3.2A3.2A3.2A3.2A3.2C3.
6A3.A6.A$32.2A.2A4.A4.A$42.A3.A$44.A!

It's easiest to think of the reaction as moving the telegraph wire (1,-1) diagonally in Golly coordinates. You could also build a spaceship that moves both ends of the telegraph wire by (6, -1) or (-4, -1) or (-10,-1) or whatever, if you wanted to. This is because telegraph wires erode at either end quite a bit every time you use them -- so the decision of where to rebuild the beehives will determine the vector of the lightspeed wire.

The thing is, while it's perfectly possible to build a structure at either end that rebuilds itself after sending a lightspeed signal, it doesn't really make anything any easier. If you left out the lightspeed wire completely, you could still build a (-10,-1) spaceship that rebuilds itself after every cycle, just like Chris Cain's camelship.

It would be pretty cool to see a moving lightspeed wire, especially a looping one, but you'd have to do all of the recipe-building independently for both ends -- twice as much work. And it's not a small project to create two pretty much independent UC-based self-constructing spaceships. If you made the lightspeed wire into a loop, you'd need a whole whole whole lot more circuitry, basically because pushing a lightspeed wire by (1, -1) or whatever, doesn't use the same reaction as pulling the lightspeed wire by (1,-1).

[wwei47]

It would be pretty cool to see a moving lightspeed wire, especially a looping one, but you'd have to do all of the recipe-building independently for both ends -- twice as much work. And it's not a small project to create two pretty much independent UC-based self-constructing spaceships. If you made the lightspeed wire into a loop, you'd need a whole whole whole lot more circuitry, basically because pushing a lightspeed wire by (1, -1) or whatever, doesn't use the same reaction as pulling the lightspeed wire by (1,-1).

Solution: Both ends push, and the net movement is perpendicular to the wire. This means that we only have to deal with one mechanism total.

[dvgrn]

Solution: Both ends push, and the net movement is perpendicular to the wire. This means that we only have to deal with one mechanism total.

Well, two -- one at each end. Even if the net movement is perpendicular, the rebuilding problem is very different at the "source" end from at the "sink" end.

But, sure, it's absolutely doable! The thing is, the "source" end has to send in ten signals to get to a net perpendicular movement:

Code: Select all

x = 469, y = 15, rule = LifeHistory
175.A$161.A4.A4.A4.2A28.A$.2A3.2A3.2A3.2A3.2A3.2A3.2A3.2A3.2A3.2A3.2A
3.2A3.2A3.2A3.2A3.2A3.2A3.2A3.2A3.2A3.2A3.2A3.2C3.2C3.2C3.2C3.2C3.2C
3.2C3.2C3.2C3.2C3.A5.A2.2A4.2A14.A4.A4.A4.2A28.A$A2.A.A2.A.A2.A.A2.A.
A2.A.A2.A.A2.A.A2.A.A2.A.A2.A.A2.A.A2.A.A2.A.A2.A.A2.A.A2.A.A2.A.A2.A
.A2.A.A2.A.A2.A.A2.A.C2.C.C2.C.C2.C.C2.C.C2.C.C2.C.C2.C.C2.C.C2.C.C2.
C.A6.A.3A5.2A3.2A3.2A3.A5.A2.2A4.2A14.A4.A4.A4.2A28.A$.2A3.2A3.2A3.2A
3.2A3.2A3.2A3.2A3.2A3.2A3.2A3.2A3.2A3.2A3.2A3.2A3.2A3.2A3.2A3.2A3.2A
3.2A3.2C3.2C3.2C3.2C3.2C3.2C3.2C3.2C3.2C3.2C3.A5.A2.2A4.2A3.A2.A.A2.A
.A6.A.3A5.2A3.2A3.2A3.A5.A2.2A4.2A14.A4.A4.A4.2A28.A$161.A4.A15.2A3.
2A3.A5.A2.2A4.2A3.A2.A.A2.A.A6.A.3A5.2A3.2A3.2A3.A5.A2.2A4.2A14.A4.A
4.A4.2A28.A$192.A4.A15.2A3.2A3.A5.A2.2A4.2A3.A2.A.A2.A.A6.A.3A5.2A3.
2A3.2A3.A5.A2.2A4.2A14.A4.A4.A4.2A28.A$223.A4.A15.2A3.2A3.A5.A2.2A4.
2A3.A2.A.A2.A.A6.A.3A5.2A3.2A3.2A3.A5.A2.2A4.2A14.A4.A4.A4.2A28.A$
254.A4.A15.2A3.2A3.A5.A2.2A4.2A3.A2.A.A2.A.A6.A.3A5.2A3.2A3.2A3.A5.A
2.2A4.2A14.A4.A4.A4.2A28.A$285.A4.A15.2A3.2A3.A5.A2.2A4.2A3.A2.A.A2.A
.A6.A.3A5.2A3.2A3.2A3.A5.A2.2A4.2A14.A4.A4.A4.2A28.A$316.A4.A15.2A3.
2A3.A5.A2.2A4.2A3.A2.A.A2.A.A6.A.3A5.2A3.2A3.2A3.A5.A2.2A4.2A14.A4.A
4.A4.2A$347.A4.A15.2A3.2A3.A5.A2.2A4.2A3.A2.A.A2.A.A6.A.3A5.2A3.2A3.
2A3.A5.A2.2A4.2A$136.2D3.2D235.A4.A15.2A3.2A3.A5.A2.2A4.2A3.A2.A.A2.A
.A6.A.3A5.2A3.2A3.2A$135.D2.D.D2.D265.A4.A15.2A3.2A3.A5.A2.2A4.2A3.A
2.A.A2.A$136.2D3.2D297.A4.A15.2A3.2A!
#C [[ X 100 Y 0 Z 5 STOP 350 ]]

That's a lot of constructing -- no more than Jormungant's high-bandwidth telegraph, of course, or the older telegraphs. It's the same ten signals, except half of them are mirrored in Jormungant's pattern so that the wire ends up back where it started.

But if you want the signal in the loop to be the trigger that causes the rebuild, you don't get to use all those convenient rake periods and things from Jormungant's magnum opus.

It wouldn't be too difficult if each side had a single-channel recipe stored in a glider loop that was precisely the same speed as the lightspeed-wire loop -- but there again, the fact that the self-constructing spaceship moves (0,-10) or whatever, doesn't actually have a lot to do with the telegraph wire. You could fairly easily remove the telegraph wire, keep most of the recipes, and the two ends would keep moving independently of each other.

None of this, of course, is a reason not to work on this idea! It's just a reason to not think it will be terribly easy. The "right" way to do it would be to have a universal computer at each end that reads the exact same recipe ten times, but then manages to build the telegraph reaction in ten different locations.

Of course it would probably be a lot easier to just hard-code ten copies of the recipe as a single-channel stream, and the project would get done a lot faster. We just don't have stable technology that can conveniently be moved by (0,-10) every cycle -- not that it can't be done, just that it's a somewhat new design problem.

I think at least you don't have to have recipes on different colors -- you can just bump up a block elbow by (1,1) or whatever, and the same recipe will work just fine again. But it's still kind of tempting to just do the minimal (1,1) move of the wire with each cycle, and go with diagonal movement and a lightspeed wire that only goes in one direction.

[calcyman]

Solution: Both ends push, and the net movement is perpendicular to the wire. This means that we only have to deal with one mechanism total.

Well, two -- one at each end. Even if the net movement is perpendicular, the rebuilding problem is very different at the "source" end from at the "sink" end.

I think that wwei47 was suggesting a glide-reflective spaceship where there's a single lightspeed wire, and a pulse that bounces between the two ends of the wire. So each end receives the pulse, sends it back, repairs the correct number of beehives, and translates itself by (0, 2).

This would resemble an Orthogonoid in its motion, except the lightspeed pulse will only be used for timekeeping and not for transmitting a tape. The two ends of the spaceship could be equipped with static tapes.

[wwei47]

I think that wwei47 was suggesting a glide-reflective spaceship where there's a single lightspeed wire, and a pulse that bounces between the two ends of the wire. So each end receives the pulse, sends it back, repairs the correct number of beehives, and translates itself by (0, 2).

Correct.

[LLAMASKYWALKER]

Idea: using the same sawtooth-eating-toadstack mechanism in the extremely long-lived diehards we could have a sawtooth eat through a toadstack, and when the last toad is eaten, the next block pull will trigger a universal constructor that rebuilds the sawtooth and constructor and destroys the original copy, allowing for a ridiculously slow spaceship…. That could be used to make a extremely stupid and redundant sawtooth.

[AlbertArmStain]

Could a run length encoding based spaceship exist?

[dvgrn]

Could a run length encoding based spaceship exist?

I'm sure it could. But this is a highly vague idea. What data would be run-length encoded?

Seems like any design that matches this description would be based on a self-constructing UCC (Universal Computer-Constructor) -- something capable of reading in an encoded stream of data and decoding it on the fly to produce its construction recipes.

Self-constructing spaceships that we've built to date have almost all been plain universal-constructor recipes, no computer involved. The 0E0P metacell could be considered a partial exception, with its two "subroutines" that are extracted from the data stream and executed multiple times. But even that is all hard-wired -- the 0E0P isn't really designed to be reprogrammed.

In theory a self-constructing universal computer-constructor would be lots of fun, capable of doing lots of interesting things. In practice, though, the construction and destruction processes for all that circuitry would be complicated enough that any UCC-based pattern would probably run about as well as the 0E0P metacell does -- in Golly, anyway.

[AlbertArmStain]

Could a run length encoding based spaceship exist?

I'm sure it could. But this is a highly vague idea. What data would be run-length encoded?

Seems like any design that matches this description would be based on a self-constructing UCC (Universal Computer-Constructor) -- something capable of reading in an encoded stream of data and decoding it on the fly to produce its construction recipes.

Self-constructing spaceships that we've built to date have almost all been plain universal-constructor recipes, no computer involved. The 0E0P metacell could be considered a partial exception, with its two "subroutines" that are extracted from the data stream and executed multiple times. But even that is all hard-wired -- the 0E0P isn't really designed to be reprogrammed.

In theory a self-constructing universal computer-constructor would be lots of fun, capable of doing lots of interesting things. In practice, though, the construction and destruction processes for all that circuitry would be complicated enough that any UCC-based pattern would probably run about as well as the 0E0P metacell does -- in Golly, anyway.

Its very simular to what I posted here. I think the Chapman-Greene universal constructor might be the key. But anyways, the idea is devastated just like most of my ideas, because most my ideas only work in theory and not in practice.

[dl-rs]

I've got a silly idea:
first we have a few block tracks(the same block tracks as the silverfish), and we have loads of Herschels. The backend of this ship is easy to make: use a backrake plus a forwardrake to make another single track of blocks for one-time turners, and let another backrake fire the gliders into the blocks. The lane number of the blocks needs to be calculated so the gliders will turn back and cleanly destroy the blinkers.

Next, the front end: it is easy to use one track to cleanly make the other(multiple rakes will do), but it is harder to self-support. The simplest way I thought of before was to use a slow-salvo recipe to turn one block into two orthogonally separated blocks. But it can be simplified:

Code: Select all

#C [[ VIEWONLY ]]
x = 23, y = 37, rule = B3/S23
14bo3bo3bo$14bo3bo3bo$14bo3bobobo$14b3o2bobo2$10bo$10bo$5bo4bo$10bo$5b
o4bo$10bo$5bo4bo$10bo4bo$5bo4bo$10bo4bo$5bo4bo6b3o$b3o6bo4bo3bo$bo3bo
4bo3bo3b3o$3o3bo3bo2bobo$5bobo2bobo$8bob2o3bo$5bo3b2o$9b2o4bo$5bo3b2o
$11bo3bo$5bo6bo4b3o$13bobo3bo$5bo8bo3b3o$15bo$5bo$15bo$5bo$15bo2$15bo
2$15bo!

As shown in this picture, two glider streams from the main lane crash into a glider stream from another lane. This lane can be supported by the main lane:

Code: Select all

#C [[ VIEWONLY ]]
x = 21, y = 63, rule = B3/S23
15bo2$15bo$14bo$13bobo$12bo$11bo3bo$10bo$9b2o4bo$8bobo$6b2o2bo4bo$5b2o
3bo$7bo2bo4bo$5bo2bobo$9b2o4bo$5bo4bo$10b2o3bo$5bo4bobo$10bo2bobo$5bo
4bo3bo$10bo4bo$5bo4bo$10bo4bo$5bo4bo$10bo4bo$5bo4bo$10bo4bo$5bo4bo$10b
o4bo$5bo4bo6b3o$b3o6bo4bo3bo$bo3bo4bo3bo3b3o$3o3bo3bo2bobo$5bobo2bobo
$8bob2o3bo$5bo3b2o$9b2o4bo$5bo3b2o$11bo3bo$5bo6bo4b3o$13bobo3bo$5bo8b
o3b3o$15bo$5bo$15bo$5bo$15bo$5bo$15bo$5bo$15bo$5bo$15bo$5bo$15bo$5b3o
$7b2o6bo$9bo$10bo4bo$11bo$12bo2bo$13bo$14b2o!

The LWSS stream intersects with the glider stream but they mustn't crash.
The left lane(not-so-important-lane) will construct the right(main) lane, and the right lane will use a destroyable and creatable lane to generate a LWSS stream with a forward glider stream to make the left track.
By the way, here's a demonstration of the back end of this "new silverfish":

Code: Select all

#C [[ VIEWONLY ]]
x = 24, y = 77, rule = B3/S23
2o$2bo$o2b2o$5b2o$o6b2o$9b2o$o10b2o$13b2o$o14b2o$17b2o$o18b2o$21b2o$o
21bo$21bo$o19bobo$20bo$o18bo2bo$18bo$o17bo3bo$17bo$o15bo5bo$16bo$o14b
o6bo$14bo$o13bo7bo$13bo$o11bo9bo$12bo$o10bo10bo$10bo$o9bo11bo$9bo$o7b
o13bo$8bo$o6bo14bo$6bo$o5bo15bo$5bo$o3bo17bo$4bo$o2bo18bo$2bo$obo19bo
$bo$o21bo2$o21bo2$o21bo2$o21bo2$o21bo2$2o20bo$2bo$o2b2o17bo$5b2o$o6b2o
13bo$9b2o$o10b2o9bo$13b2o$o14b2o5bo$17b2o$o18b2o2bo$21b2o$o18b2obo$17b
2o$o14b2o$13b2o$o10b2o$9b2o$o6b2o$5b2o$o2b2o$b2o$o!

Annnnnnnnnnnnnnd the front end design:

Code: Select all

#C [[ VIEWONLY ]]
x = 27, y = 130, rule = B3/S23
bo$obo$o2bo$2obo$obobo$o2b2o$2obobo$o3b2o$o3bobo$o4b2o$o4bobo$o5b2o$o
5bobo$o6b2o$o6bobo$o7b2o$o7bobo$o7b3o$o7b2obo$o7bob2o$o7b3obo$o8bob2o
$o8bobobo$o8bo2b2o$o8bo2bobo$o8bo3b2o$o8bo3bobo$o8bo3b3o$o8bo3b2obo$o
8bo4b3o$o8bo4b2obo$o8bo5b3o$o8bo4b3obo$o8bo3bob4o$o8bo2bo3b2obo$o8bob
o5b3o$o8b2o6b2obo$o8b2o7b3o$o8bob3o4b2obo$o8bo3b2o4b3o$o8bo4bo5bob3o$
o8bo5b3o2b3obo$o8bo7b2ob2ob2o$o8bo8bo2b4o$o8bo11b2ob2o$o8bo11bobo2bo$
o8bo8b3o2bobo$o8bo11bob3o$o8bo10bo2b4o$o8bo8b2o2bob2o$o8bo7bo3b2o$o8b
o5b2o3bob2obo$o8bo4bo3b6obo$o8bo2b2o3bo2bob2obo$o8bobo3b2o3bo2b3o$o8b
2o3bo5b2obobo$o7b2o2b2o6b3ob2o$o6bobobo8bo2bobo$o8b2o9bo3b2o$2ob2o3b2o
10b2o3bo$obo3b2obo12b2obo$3o2bo2b2o14b2o$o2b2o4bo15bo$obo6bo15bo$2o7b
o15bo$o8bo15bo$o8bo15bo$o8bo15bo$o8bo15bo$o8bo15bo$o8bo15bo$o8bo15bo$
o8bo15bo$o8bo15bo$o9bo14bo$o10bo13bo$o11bo12bo$o12bo11bo$o13bo10bo$o14b
2o8bo$o16bo7bo$o17bo6bo$o18bo5bo$o19bo4bo$o20bo3bo$o21bo2bo$o22bobo$o
23b2o$o24bo$o24bo$o24bo$o24bo$o24bo$o24bo$o24bo$o24bo$o24bo$o24bo$o24b
o$o24bo$o24bo$o24bo$o24bo$o24bo$o24bo$o24bo$o24bo$o24bo$o24bo$o24bo$o
24bo$o24bo$o24bo$o24bo$o24bo$o$o$o$o$o$o$o$o$o10b3o$o10bo2bo$11bo2bo$
11b3o$11bo2bo$11bo2bo$11b3o!

From some rough calculation, it should be about 10000*5000.
EDIT: Sorry, there should be two not-so-important lanes.The glider should fire forwardly.
VERY IMPORTANT EDIT 2:
Main design change. We have to adjust lanes beside the major lane, and the two lanes fire forward gliders to construct the main lane. The main lane will construct and destruct two short assist lanes, and they will fire gliders that crashes with two other streams to make LWSSs. The LWSSs can be used to collide with gliders coming from the back to make blocks that constructs the two adjust lanes.
Final edition:
the front end design draft

Code: Select all

#C [[ VIEWONLY ]]
x = 55, y = 52, rule = B3/S23
46bo$47bo$48bo2bo$49bobo$25b4o21b2o$23b2ob2ob2o17b4o$21b2o3b2o3b2o$19b
2o5b2o5b2o$17b2o7b2o7b3o$15b2o9b2o10b2o$13b2o9b4ob2o9b2o$11b2o10bo2b2o
3bo10b2o$9b2o11bo3b2o4bo6bo4b2o$7b2o13b2o2b2o3b2o7bo5b2o$5b2o15bobob2o
2bobo3b6o6b2o$3b2o17bo2b3obob2o7bo9b2o$b2o19b2o2b2ob4o6bo12b2o$28ob26o
$3o19bo3b2o3b2o18b2obo$o2b2o18bo2b2o3bo17b2o3bo$o4b2o17bob2o2bo16b2o5b
o$o6b2o16b3obo15b2o7bo$o8b2o15b2o15b2o9bo$o10b2o13b2o13b2o11bo$o12b2o
11b2o11b2o13bo$o14b2o9b2o9b2o15bo$o16b2o7b2o7b2o17bo$o18b2o5b2o5b2o19b
o$o20b2o3b2o3b2o9b4o8bo$o22b2ob2ob2o13b2o8bo$o24b4o14bobo8bo$o25b2o14b
o2bo8bo$o25b2o13bo12bo$o25b2o12bo13bo$o25b2o26bo$o25b2o26bo$o25b2o26b
o$o25b2o26bo$o25b2o26bo$o25b2o26bo$o25b2o26bo$o25b2o26bo$o25b2o26bo$o
25b2o26bo$o25b2o26bo$o25b2o26bo$o25b2o26bo$o25b2o26bo$o25b2o26bo$26b2o
$26b2o$26b2o!