Script request thread

[hotcrystal0]

Reposting this:

Can someone create a script to generate such rules with three inputs: the rule when the background noise is off, the rule when it is on, and the background noise rule?

[confocaloid]

Reposting this:

Can someone create a script to generate such rules with three inputs: the rule when the background noise is off, the rule when it is on, and the background noise rule?

[...] Another interesting improvement is the chaining of universes. A newborn cell is new in a Level 0 and Level 1 universe. A dying cell dies in Level 0 and Level 1. Somehow related universes last longer and produce new types of co-ops (level0 + level1) gliders and spaceships.

Related discussion:
Codependent Game of Life
MultipleB3S23
Wandering spaceships and manipulation via ruleswitches

[Disaster16439]

Can someone create an apgsearch mod in python to search for orbits of the following 2c/5 puffer:

Code: Select all

 x = 15, y = 26, rule = B34q/S23-k
3b3o3b3o$3bobo3bobo$2bo3bobo3bo$b2ob2o3b2ob2o$2bo2bo3bo2bo3$3bo7bo$2bo
bo5bobo$b2o9b2o$b3o7b3o$o13bo$4b2o3b2o$5bo3bo$obo2b2ob2o2bobo$6bobo$2b
ob3ob3obo$2b2ob5ob2o$4bo5bo$2b2o7b2o$2b11o$4b7o2$6b3o$5b5o$4b3ob3o!

NOTE:USE PYTHON
So basically paste this onto a C1 soup and apg it.

[hotcrystal0]

A script that converts a ruletable with the “permute” symmetry to one with the “rotate4reflect” symmetry.

EDIT by dvgrn: Crossposting some notes about this from Discord:

- read the LifeSuper-or-whatever transition table, one line at a time;
- write out how ever many rotate4reflect transition lines are needed to be equivalent to each line.

It won't be the same number of lines every time -- depends on how many duplicate states there are in the list of neighbor states, for example.

Probably it's easiest to write the script in Python using itertools. The brute-force method will work fine: basically, just have the script generate every possible permutation of the eight neighbor state entries, define a canonical ordering for rotate4reflect, generate all rotations and reflections of each permutation, pick the canonical one out of the eight (the lexicographically smallest one, for example) and write it to the output rule table only if it hasn't already been written out.

There's a detail that makes it a bit harder to write a rotate4reflect conversion script that will always "Just Work" for any input permute-symmetry rule table. To do an efficient conversion, whenever multiple variables in a transition-table line resolve to the exact same list of states, the script will have to know that.

There are multiple possible syntaxes for defining variable a with the same list of states as variable b. It would require a significantly more complicated script to parse the variable definitions and do the right thing every time. So it might be a lot simpler to create just a "helper script" that produces a set of "rotate4reflect" output lines for each input "permute" line -- where the person running the script does a little extra work to say which variables are equivalent to each other.

[b-engine]

Golly script that:

1. Scatter a random amount of blocks at random positions, X and Y range defined by input.
2. Send a glider from a random position towards the constellation.
3. Run for 10000 generations.
4. If the exact blockic constellation reappears (even when shifted), return to generation 0 and halt the script, leaving the pattern with the constellation and the glider. Else, return to generation 0, remove the glider, and repeat step 2 to 4.

[unname4798]

Golly script that:

1. Scatter a random amount of blocks at random positions, X and Y range defined by input.
2. Send a glider from a random position towards the constellation.
3. Run for 10000 generations.
4. If the exact blockic constellation reappears (even when shifted), return to generation 0 and halt the script, leaving the pattern with the constellation and the glider. Else, return to generation 0, remove the glider, and repeat step 2 to 4.

Step 3 is replaced with:
"3. Run until stabilization"

[dvgrn]

If the exact blockic constellation reappears (even when shifted), return to generation 0 and halt the script, leaving the pattern with the constellation and the glider. Else, return to generation 0, remove the glider, and repeat step 2 to 4.

This is a fairly easy script to write. Unfortunately I suspect that everyone who might be likely to write it, is aware that the design spec as it's currently presented would be a very inefficient way to search for interesting single-glider collisions with Blockic constellations. So it probably won't get written as it stands.

1) A Golly script (i.e., Lua or Python) would probably be a couple of orders of magnitude slower than the best possible implementation. So you'd have to run it 100 times longer to find the same number of results as an optimized searcher.

2) After running the search for a few months or a few years, there would be no record of what search space had been covered -- and depending on the details, many configurations might have been tested dozens or hundreds of times each.

3) For any reasonable length of search, the expected amount of results that will be found is zero. A big question is: how long will anyone really be willing to run a speculative search that doesn't produce any definite results at all -- not even a report of how much space has been searched?

But that doesn't mean that something more workable couldn't be written!

Exhaustive enumeration

In the long run it might work much better to set up an enumeration of all possible glider collisions with all possible Blockic constellations inside an MxN rectangle. That way when a search run is complete, it will be possible to say definitely that

"No Blockic eaters or Blockic reflectors exist inside a 16x16 rectangle"

(or however far the enumeration extends before people get bored with running the tests.)

If a Golly script is really of interest here, I've already written non-optimized experimental code for the octohash-database project, that can easily be adapted to generate and test Blockic constellations. This code just needs to be adjusted slightly to reduce the number of objects -- i.e., delete out everything except the block! -- and increase the xsize, ysize, and MAXOBJ settings at the top.

Read through this 2020 negotiation with Hunting to get an understanding of what additional choices need to be made, and how to implement them in code.

[hth3]

A script that you select a still life and it puts random soups around it and shows the results.

[dvgrn]

A script that you select a still life and it puts random soups around it and shows the results.

What would the script be looking for, exactly? Would there be a "successful result", and the script keeps trying random soups until it finds the first example? Would it collect statistics about how often the soup interacted with the still life in a certain way?

Depending on the answer, this script may already exist. Scorbie did a lot of catalyst testing some years ago; I haven't found the specific code that was used to do the testing, but I haven't looked very hard.

[hth3]

A script which makes you select a glider collision and then it makes a c/10 construction based on it. For example, you input a 3g pentadecathlon synthesis and it makes a c/10 pentadecathlon puffer based on it.

[b-engine]

This is a fairly easy script to write. Unfortunately I suspect that everyone who might be likely to write it, is aware that the design spec as it's currently presented would be a very inefficient way to search for interesting single-glider collisions with Blockic constellations. So it probably won't get written as it stands.

The script doesn't necessarily work in environment of B3/S23. Certain other rules that support glider and block may have such reactions.

[Disaster16439]

I don’t know how Corderman managed to corderize the switch engine, and if it would be even possible to corderize such a messy puffer, but I would like a apgsearch stdin script that tries to corderize the century in the OCA B34q/S23-k. I think just 2 centuries and a block in a stdin script would work. It would open up a new area in B34q/S23-k, and would be a new 5s speed.

Edit 1: And oh i forgot, I don’t know how to setup apgluxe and stuff, I need a Python script
My 205th post!

205=5*41

[islptng]

Make a Golly script that takes birth and survival conditions in INT format and returns the following 3-state rule:

-A cell is born in state 2 if it satisfy one of the birth conditions, checking only state 1 cells.
-A cell in state 2 turns into state 1 if it satisfy one of the survival conditons, checking only state 2 cells. Else, it dies.
-State 1 cell always dies.

So like Bb/S|B/Ss alternating rules, but patterns from otherwise uncompatible generations can coexist.

Try it online!

[confocaloid]

I don’t know how Corderman managed to corderize the switch engine, and if it would be even possible to corderize such a messy puffer, but I would like a apgsearch stdin script that tries to corderize the century in the OCA B34q/S23-k. I think just 2 centuries and a block in a stdin script would work. It would open up a new area in B34q/S23-k, and would be a new 5s speed.

Edit 1: And oh i forgot, I don’t know how to setup apgluxe and stuff, I need a Python script
My 205th post!

205=5*41

Some manual exploration could work, methinks:

Code: Select all

x = 106, y = 79, rule = B34q/S23-k
58b2o$58bob2o$61bo$59b3o4$3b3o16b2o$22b2o3$9bo25b2o$3o6bo25b2o5b3o$9bo
$4bo$5bo$5bo$14b2o$13bo2bo$14b2o7$27b3o16b2o$46b2o3$33bo25b2o$24b3o6bo
25b2o5b3o$33bo$28bo$28bo21b2o$28bo21b2o3b2o$38b2o15b2o$37bo2bo$38b2o$
54b2o$53bo2bo$52bo2$53b3o2$70b2o$59b2o9b2o3$57bo$48b3o6bo21b2o9b3o$57b
o21b2o$52bo$52bo$52bo$62b2o$61bo2bo$62b2o10bo$74bo$74bo$99b2o$70b3o3b
3o20bobo$100b2o$74bo20bo$74bo19bobo$74bo4bo14bobo$79bo15bo$79bo2$75b3o
3b3o2$79bo14bobo6bo$79bo14bo2b2o3b3o$79bo17b2obobo2bo$94b2o2b3ob4o$94b
o3bobo2bo$95bo2bo2b3o$95bo2bo3bo$96b2o!

In the above pattern, select the century at the top (and nothing else), and press Shift+Space ("Advance outside selection") or Ctrl+Space ("Advance inside selection"); this will affect the result.

In addition to the advance selection/advance outside selection functionality, I'm using the following Golly scripts. (Without them, I would have to do alot of mouse-clicking and mouse-selecting and copy/pasting. With the scripts, I can do almost everything through the keyboard. I wouldn't be surprised if other people did independently invent/reinvent solutions to the same problems.)

All five files should go into a single directory. I suggest to make a separate subdirectory "shortcuts" for these five scripts, to avoid clutter.
Assigning the keyboard shortcuts mentioned in the comments should allow using "Ctrl+Space", "Shift+Space", "Alt+Left", "Alt+Right", "Alt+Up", "Alt+Down" to simplify constructing corderoid spaceships, manually testing collisions and other "similar" tasks.

Code: Select all

import golly as g

# Used by altup.py, altdown.py, altleft.py, altright.py
# Move the selection by (dx, dy) and re-select it accordingly.
def moveselection(dx, dy):
   r = g.getselrect()
   s = (len(r) > 0)
   if not s:
      r = g.getrect()
   cells = g.getcells(r)
   g.putcells(cells, 0, 0, 1, 0, 0, 1, "xor")
   g.putcells(cells, dx, dy, 1, 0, 0, 1, "or")
   if s:
      r = [r[0] + dx, r[1] + dy, r[2], r[3]]
      g.select(r)

Code: Select all

# I'm using the keyboard shortcut "Alt+Up" for this one.
import golly as g
import common
common.moveselection(0, -1)

Code: Select all

# I'm using the keyboard shortcut "Alt+Down" for this one.
import golly as g
import common
common.moveselection(0, 1)

Code: Select all

# I'm using the keyboard shortcut "Alt+Left" for this one.
import golly as g
import common
common.moveselection(-1, 0)

Code: Select all

# I'm using the keyboard shortcut "Alt+Right" for this one.
import golly as g
import common
common.moveselection(1, 0)

[PiSpaceships]

Try it online!

It works perfectly! Thank you!

[b-engine]

A Golly script that:

• Place 2 gliders at random positions toward the input pattern.

• Run the simulation and check if the population becomes periodic.

• If the population becomes periodic, repeat the process. Else, if population is 0, rewind back to generation 0 (while preserving both the gliders and input) then halt.

[dvgrn]

A Golly script that:

1. Place 2 gliders at random positions toward the input pattern.

• Run the simulation and check if the population becomes periodic.

• If the population becomes periodic, repeat the process. Else, rewind back to generation 0 (while preserving both the gliders and input) then halt.

This is a pretty good "spec" for a script. Just to double-check -- is the script looking for blobs that emit BLSEs and GPSEs? It seems like that's what it's going to find, very regularly, so if those aren't interesting it would be good to add something to the spec to rule them out.

In the current form, this is also an easy script to write, to the point where somebody who needs a little Golly scripting practice should write it. I can help, if someone else puts the initial effort into it, but I'm not going to just write the whole thing.

Just like the last request along these lines, this would be an extremely inefficient way to find interesting things. Depending on the size of the area where gliders are placed, there will be equivalence classes of hundreds or thousands of pairs of gliders that ultimately do exactly the same thing. So this design is 1/100th or 1/1000th as effective as a script that generates and tests an exhaustive enumeration of glider pairs.

An exhaustive enumeration would take a while to run, but when it was done you could confidently say that there are no pairs of gliders within such-and-such MxN bounding box that result in an output pattern with non-periodic population.

[b-engine]

This is a pretty good "spec" for a script. Just to double-check -- is the script looking for blobs that emit BLSEs and GPSEs? It seems like that's what it's going to find, very regularly, so if those aren't interesting it would be good to add something to the spec to rule them out.

In the current form, this is also an easy script to write, to the point where somebody who needs a little Golly scripting practice should write it. I can help, if someone else puts the initial effort into it, but I'm not going to just write the whole thing.

Just like the last request along these lines, this would be an extremely inefficient way to find interesting things. Depending on the size of the area where gliders are placed, there will be equivalence classes of hundreds or thousands of pairs of gliders that ultimately do exactly the same thing. So this design is 1/100th or 1/1000th as effective as a script that generates and tests an exhaustive enumeration of glider pairs.

An exhaustive enumeration would take a while to run, but when it was done you could confidently say that there are no pairs of gliders within such-and-such MxN bounding box that result in an output pattern with non-periodic population.

I don't have tools and means to write a script.

This script is intended to search for a glider destruction of a pattern, not an exhaustive enumeration. However I forgot to add a condition to check if the population becomes 0.

[dvgrn]

This script is intended to search for a glider destruction of a pattern, not an exhaustive enumeration. However I forgot to add a condition to check if the population becomes 0.

It's always good to say in your spec what the script is supposed to be used for. Can you update your original post? Population 0 seems like a really important detail.

Why don't you have the tools to write a script? If you can run a Golly script, you can write a Golly script -- all you need is a text editor, like Notepad on Windows. Technically you could even write a script in a code block in one of these forum messages. It's a really handy thing to learn how to do -- and maybe more importantly, once you have a little practice writing scripts, you'll be able to write script-request specs that look more interesting to other people, so that they're more likely to get implemented.

We've had gameoflifeboy's 1G destruction script for a long time now, and honestly we're long overdue for a 2G destruction script. If someone starts a thread to try to collaboratively produce a script like that, it might really get some contributions -- especially if the thread owner (could be anyone, not necessarily b-engine) makes a good initial effort on the coding.

[Yoel]

I see references to shipcolls in this thread, but I was not able to find this software. Can anyone provide a download link, please?

[confocaloid]

I see references to shipcolls in this thread, but I was not able to find this software. Can anyone provide a download link, please?

It is probably this (to be compiled with g++ and used with apgluxe compiled for a "stdin" census):
viewtopic.php?p=135476#p135476

[Yoel]

I see references to shipcolls in this thread, but I was not able to find this software. Can anyone provide a download link, please?

It is probably this (to be compiled with g++ and used with apgluxe compiled for a "stdin" census):
viewtopic.php?p=135476#p135476

Wow, what an esoteric hack, I love it! Thank you very much!

[confocaloid]

[...] Wow, what an esoteric hack, I love it! [...]

Recent events are visible on the page https://catagolue.hatsya.com/census but for anyone else interested, the idea is that if apgsearch is compiled for a target census name that contains "stdin" as a substring (for example "stdin_test" or "test_stdin"), then instead of autogenerating soups and evolving and censusing them, the program will expect RLEs to be given through the standard input, and will evolve and census the input patterns.

I think the "stdin" functionality is significantly less esoteric, compared to the local jargon often incorrectly referring to Catagolue/apgsearch census names as "symmetries" regardless of whether or not it has anything to do with symmetry. (That includes G* and H* censuses which do not add any new symmetry types but instead have to do with GPU searching, that includes the "8x32", "4x64", "2x128", "1x256" censuses which are for specific soup sizes rather than symmetry types, that includes "inflated soups" (iC1, iiC1 and so on), and that also includes various "stdin" and "test" censuses which typically aren't about symmetry.)

[dl-rs]

Can anybody help me with a C++ function to input any stable bool[][] 2d list(or as .cells) and output the standard RLE of it?

[Citation needed]

Are there Python functions for Golly that can simulate each of these commands without putting a size limit (the grammar can be different but it should be easy to learn)? "showinviewer.lua" is in Lua, but it unfortunately also had the size limit from LifeViewer, and ColorfulGalaxy knows nothing about Lua.

Code: Select all

PASTE
PASTET (EVERY)
PASTEMODE
PASTEDELTA
PASTE RANDCELLS (unfortunately LifeViewer can't repeat pasting random cells indefinitely, pasting different cells each time)
T (and other waypoints features)
X
Y
Z
ANGLE
TILT (this one may be difficult)
PAUSE
LINEAR ALL
COLOR
T COLOR (or COLORT. LifeViewer can't do this!)
LABEL
LABELT
LABELALPHA
LABELANGLE
LABELDELTA
POLYGON, POLYGONT (and other annotations)
GPS (I do hope non-integer values are supported. I also hope that GPS and STEP can coexist, which won't work in LifeViewer.)
STEP
NOTHROTTLE