Personal project randomly generating different cellular automata rulesets

[murderofescrows]

Hi all,

I'm a total amateur in this field so please excuse my ignorance.

As an exercise in improving my programming ability, I've made a program that assists in randomly generating and displaying different sets of cellular automata rules. The cells are dead or alive, and the alive count around each cell dictates what new state the cells transition to.

I did a writeup here on my project: https://lockwood.dev/automata/2020/03/2 ... olang.html

I'm interested in your general thoughts on the approach. I'm also trying to figure out if there are any heuristics I could use to prune game rulesets that look "uninteresting". Your advice and thoughts are appreciated!

Thanks for your time,
Tom

[Hunting]

Very nice! Not all Lifenthusiast likes OCA. I will write a longer post later.

EDIT: Firstly, I still didn't quite understand what exactly are your "two-rule" rules. Are they cellular automaton that alternatively applies the first rule and the second rule?

Secondly, it's good to randomize rules and investigate (I sometimes get rulegolf ideas by randomizing too) but it will be also good to know about how the "transistions" in the rule affect the rule's behaviour. For example, as you probably already know, if there's no birth at 0 neighbours (that kind of rule is usually excluded), birth at 1 neighbours forces the rule to explode (because every pattern have to grow), birth at 2 neighbours forces the rule to explode (because the lightspeed chaotic puffer engine) too but not as explosive as B1, etc.

(to be continued)

[murderofescrows]

Hi! Thanks for your response!

EDIT: Firstly, I still didn't quite understand what exactly are your "two-rule" rules. Are they cellular automaton that alternatively applies the first rule and the second rule?

I don't know if I quite understand, but if the game has two rules, its transitioning between the two? I assume conway's is an example of a two-rule game?

Secondly, it's good to randomize rules and investigate (I sometimes get rulegolf ideas by randomizing too) but it will be also good to know about how the "transistions" in the rule affect the rule's behaviour. For example, as you probably already know, if there's no birth at 0 neighbours (that kind of rule ), birth at 1 neighbours forces the rule to explode (because every pattern have to grow), birth at 2 neighbours forces the rule to explode (because the lightspeed chaotic puffer engine) too but not as explosive as B1, etc.

(to be continued)

Interesting! I didn't think that a birth at 1 rule would always be explosive!!! Thank you!

Is there a good resource where I can learn more about the logical implications of transitions? For example is there some behaviour we always logically expect with a death on 8 neighbours?

Thanks for you time

[Saka]

I don't know if I quite understand, but if the game has two rules, its transitioning between the two? I assume conway's is an example of a two-rule game?

No, Conway's Game of Life has a single rule, B3/S23, which means if a dead cell has 3 neighbors it becomes alive and if a live cell has 2 or 3 neighbors it stays alive, otherwise it dies. I'm not sure how you're interpreting this as 2 rules.

Is there a good resource where I can learn more about the logical implications of transitions? For example is there some behaviour we always logically expect with a death on 8 neighbours?

Not really, except B1 and B2 will always be explosive (If we exclude Non-Totalistic CA). But of course if you put S5678 you should expect a blobby "white-out" rule. Otherwise, not really.

[murderofescrows]

I don't know if I quite understand, but if the game has two rules, its transitioning between the two? I assume conway's is an example of a two-rule game?

No, Conway's Game of Life has a single rule, B3/S23, which means if a dead cell has 3 neighbors it becomes alive and if a live cell has 2 or 3 neighbors it stays alive, otherwise it dies. I'm not sure how you're interpreting this as 2 rules.

My program might be considered to generate one-rule games then?

However, it might transition to a different cell type if it has 2 alive neighbours versus 3. And that new cell type might transition differently on each of the 9 different alive neighbour counts. Each cell type is considered either alive or dead for the neighbour counts, but may transition to other cell types.

Is there a good resource where I can learn more about the logical implications of transitions? For example is there some behaviour we always logically expect with a death on 8 neighbours?

Not really, except B1 and B2 will always be explosive (If we exclude Non-Totalistic CA). But of course if you put S5678 you should expect a blobby "white-out" rule. Otherwise, not really.

Interesting! Thanks!

[Saka]

My program might be considered to generate one-rule games then?

However, it might transition to a different cell type if it has 2 alive neighbours versus 3. And that new cell type might transition differently on each of the 9 different alive neighbour counts. Each cell type is considered either alive or dead for the neighbour counts, but may transition to other cell types.

I'm not sure what you mean here, yes, each cell state turns into a different state based on it's neighbors, that's how CA works. However, the rules governing what states should turn into which states on what neighbors stay the same. In B3/S23, on every generation, the same transitions are applied:

Code: Select all

Cell's State     | Number of Alive Neighbors                | Resulting state
0                | 0                                        | 0
0                | 1                                        | 0
0                | 2                                        | 0
0                | 3                                        | 1
0                | 4                                        | 0
0                | 5                                        | 0
0                | 6                                        | 0
0                | 7                                        | 0
0                | 8                                        | 0
1                | 0                                        | 0
1                | 1                                        | 0
1                | 2                                        | 1
1                | 3                                        | 1
1                | 4                                        | 0
1                | 5                                        | 0
1                | 6                                        | 0
1                | 7                                        | 0
1                | 8                                        | 0

[Hunting]

EDIT: Firstly, I still didn't quite understand what exactly are your "two-rule" rules. Are they cellular automaton that alternatively applies the first rule and the second rule?

I don't know if I quite understand, but if the game has two rules, its transitioning between the two? I assume conway's is an example of a two-rule game?

I see, in your article, you refer to it as two rules. But that's not our usual definition. A rule is the combination of the birth condition and the survival condition. I mean, what does your program do when it have "four rules"?

Is there a good resource where I can learn more about the logical implications of transitions? For example is there some behaviour we always logically expect with a death on 8 neighbours?

Thanks for you time

Here you go. You might want to take a look at this too.

I agree with Saka's statement, but as a (sort-of) experienced rulegolfer, I can provide more information about non-B8/S8 rules.

1. Like what Saka mentioned, S8 plays a role in the "blob" rules like Day&Night.

2. Adding B8/S8 may tame explosive rules that is explosive because of moderate-to-high period replicators.

3. I usually divide rules into categories, because in different categories the effect of the same transistion can be very different. Explain later.

EDIT: 4. Also, promoting my semi-totalistic rulespace. Having 25 birth condition and 25 survival condition, it's a super set of totalistic rules that can fit in two 32-bit integer. (One for birth and another for survival)

[murderofescrows]

EDIT: Firstly, I still didn't quite understand what exactly are your "two-rule" rules. Are they cellular automaton that alternatively applies the first rule and the second rule?

I don't know if I quite understand, but if the game has two rules, its transitioning between the two? I assume conway's is an example of a two-rule game?

I see, in your article, you refer to it as two rules. But that's not our usual definition. A rule is the combination of the birth condition and the survival condition. I mean, what does your program do when it have "four rules"?

Here's an example:

Code: Select all

var r0 = Rule{
  Alive:       true,
  Transitions: [9]uint8{0,3,0,1,2,2,2,1,0}}

var r1 = Rule{
  Alive:       true,
  Transitions: [9]uint8{1,0,1,0,3,1,1,3,3}}

var r2 = Rule{
  Alive:       false,
  Transitions: [9]uint8{3,1,1,2,1,3,1,2,3}}

var r3 = Rule{
  Alive:       true,
  Transitions: [9]uint8{3,3,0,1,1,3,0,0,0}}

So, based on there being 0 alive neighbours, rule 0, 1 and 3 stay the same (survives?). However, rule 2 transitions to rule 3. The transitions are different for each different rule. Those 4 different sets of transitions leads to this:



Edit: I think this may address Saka's post, too?

[Hunting]

I don't know if I quite understand, but if the game has two rules, its transitioning between the two? I assume conway's is an example of a two-rule game?

I see, in your article, you refer to it as two rules. But that's not our usual definition. A rule is the combination of the birth condition and the survival condition. I mean, what does your program do when it have "four rules"?

Here's an example:

Code: Select all

var r0 = Rule{
  Alive:       true,
  Transitions: [9]uint8{0,3,0,1,2,2,2,1,0}}

var r1 = Rule{
  Alive:       true,
  Transitions: [9]uint8{1,0,1,0,3,1,1,3,3}}

var r2 = Rule{
  Alive:       false,
  Transitions: [9]uint8{3,1,1,2,1,3,1,2,3}}

var r3 = Rule{
  Alive:       true,
  Transitions: [9]uint8{3,3,0,1,1,3,0,0,0}}

So, based on there being 0 alive neighbours, rule 0, 1 and 3 stay the same (survives?). However, rule 2 transitions to rule 3. The transitions are different for each different rule. Those 4 different sets of transitions leads to this:

Ohhh, you mean a 4-state totalistic rule. Wait a minute...

(Sometimes, rules with 2-state is interesting enough.)

EDIT: Then what counts as "alive"? All of state 1, 2, and 3?

[murderofescrows]

Ohhh, you mean a 4-state totalistic rule. Wait a minute...

(Sometimes, rules with 2-state is interesting enough.)

Ah! Cool! My understanding of the terminology was lacking! Sorry!

[Hunting]

Ohhh, you mean a 4-state totalistic rule. Wait a minute...

(Sometimes, rules with 2-state is interesting enough.)

Ah! Cool! My understanding of the terminology was lacking! Sorry!

Then what counts as "alive"? All of state 1, 2, and 3?

[murderofescrows]

0,1,3

In my code that's the Alive property of each Rule aka state.

[Saka]

When we have a set of constant transitions (doesn't matter how many) that are applied every generation, that counts as one rule. One rule can have multiple cell states (what you call cell types).

[Hunting]

0,1,3

In my code that's the Alive property of each Rule aka state.

Oh yeah. I'll make a Golly ruletable for it. I'm going to call it "Lockwood4s"

EDIT: Meanwhile I reproduced your Maze rule:

Code: Select all

x = 6, y = 4, rule = B3/S12356
bo$bo2bo$o2b3o$3o!

Your rule contains B0, I converted it to a non-B0 equivalent form.

[murderofescrows]

0,1,3

In my code that's the Alive property of each Rule aka state.

Oh yeah. I'll make a Golly ruletable for it. I'm going to call it "Lockwood4s"

I might write some code that outputs a valid Golly file!

Is this the right place to read if I want to generate that? https://github.com/GollyGang/ruletabler ... /TheFormat

[murderofescrows]

When we have a set of constant transitions (doesn't matter how many) that are applied every generation, that counts as one rule. One rule can have multiple cell states (what you call cell types).

Gotcha! Thanks.

I'll attempt to alter my code to make it consistent with the correct terminology.

[Saka]

I might write some code that outputs a valid Golly file!

Is this the right place to read if I want to generate that? https://github.com/GollyGang/ruletabler ... /TheFormat

Yes

[Hunting]

Done.

Code: Select all

@RULE Lockwood4s
@TABLE
n_states:4
neighborhood:Moore
symmetries:permute
var a={0,1,3}
var b={0,1,3}
var c={0,1,3}
var d={0,1,3}
var e={0,1,3}
var f={0,1,3}
var g={0,1,3}
var h={0,1,3}

0,2,2,2,2,2,2,2,2,0
0,a,2,2,2,2,2,2,2,3
0,a,b,2,2,2,2,2,2,0
0,a,b,c,2,2,2,2,2,1
0,a,b,c,d,2,2,2,2,2
0,a,b,c,d,e,2,2,2,2
0,a,b,c,d,e,f,2,2,2
0,a,b,c,d,e,f,g,2,1
0,a,b,c,d,e,f,g,h,0

1,2,2,2,2,2,2,2,2,1
1,a,2,2,2,2,2,2,2,0
1,a,b,2,2,2,2,2,2,1
1,a,b,c,2,2,2,2,2,0
1,a,b,c,d,2,2,2,2,3
1,a,b,c,d,e,2,2,2,1
1,a,b,c,d,e,f,2,2,1
1,a,b,c,d,e,f,g,2,3
1,a,b,c,d,e,f,g,h,3

2,2,2,2,2,2,2,2,2,3
2,a,2,2,2,2,2,2,2,1
2,a,b,2,2,2,2,2,2,1
2,a,b,c,2,2,2,2,2,2
2,a,b,c,d,2,2,2,2,1
2,a,b,c,d,e,2,2,2,3
2,a,b,c,d,e,f,2,2,1
2,a,b,c,d,e,f,g,2,2
2,a,b,c,d,e,f,g,h,3

3,2,2,2,2,2,2,2,2,3
3,a,2,2,2,2,2,2,2,3
3,a,b,2,2,2,2,2,2,0
3,a,b,c,2,2,2,2,2,1
3,a,b,c,d,2,2,2,2,1
3,a,b,c,d,e,2,2,2,3
3,a,b,c,d,e,f,2,2,0
3,a,b,c,d,e,f,g,2,0
3,a,b,c,d,e,f,g,h,0

(Unnecessary transistions for easy modification)

EDIT: Added into LifeViewer.

Code: Select all

x = 89, y = 102, rule = Lockwood4s
B.ABA2BC6.BC2.C3.2CA.AB.C2.BAC6.A3.BA3.2A.2C.AB.B2.A3.CA.BA.AC.ABA2.C
B3.C.A$ACA2.2BC4.BC2.CAB2.CB4AB2CA.A.C.C2.2A4.2C.2C.C2.B.BA.C.B.B.B.B
4.2AB2.C.ABA3.A$.C8.A3.CBA.B.2C3.BA.C3.C3.B.2A5.CA2.C.2B2.2B2.C2.C2.C
B2.B.2A.C6.CB$B3.C5.2BA2.C.ABA.B.A3.C4.A2C2.B2.A3.B3.ABAB3.B3.2B3.2A.
BA.BABC2A4.CB2A2C2.C$2AB2C2.B.C2.C.AC.CB2.2A2.A.B.BAC.A.A8.BA4.ABC2.A
2.BCAB.3B.2CB.A5.BC.CB2.A.2C$.C2BC3B3.B.C.BAB3.2ACA.C2.A3.BCA.C4.C.BC
.B2.B.A2.2B2.2C.A.3C3.B.B4.AC3.BC.A.B$.B3.B4.BC2.ACAB2.C2.B.A2CB5.A2.
C.A2BAC3.C.BA2.A.2B6.B.C.C.C2.B2C.AC.C3.C.CA2C$2C2A2.2A.C2.BC.B2.B3.C
B.A2.AC2AB3.2C3B.A.2C3.A.2A2.A.B.C3.A.A2.AB.BC2.2C2.A.A2.A.C.C$3.BCAC
.C3.B.A2.B4.B2.C3.CA.BA4.BC.AB4.AC.B.CABC2.CBAC.CB2.CB2.3C3A2.2B2.C.
2B$C.ACB.ACABA4.ACA.A.2B.A3.2A.A.B3.C.B2.A.BA2.CA9.B.BAB2.A2.A2.A.2B
4.A5.2C$B.B3.B.BC2B2.2BC3.A.B.A.C2ABC.A2.A.B.CB.B2.B6.2CA3.BC.C2.B6.C
3.CAC3.2B2.2BAC$.C.2C2.BAC.CA3.C.AC.2BA.2C.C.B2.B4.B.C.C.AB.A.BAB4.2C
.C4.2C2.C3.3BC.AB2ABC.C.C.B$C.2C5.C2.2AC2.B4.A5.A2.ACA.C3.C2.ACA2.A2B
C5.A2.B4.C.BA.A.CAB6.BA2.C.AC$.B.B5.C2B2C.2C2.A2.C5B.C.2C.2C.CA3.2AC
2.2A.C3.A.B.A.A2.CB.B.AB2C3.BC3B.BAB3.BC$C2.B5.A.2CB.2BA.CA.2C5.A2.2C
AC.3A.CBA2.A.2AB.A3B.A3C4.ABCB2.2B4.CB.BACA3.C$2.CB.C.C2.CBA3.B.C.C.B
3.A.A2.B2.A.C4.2B4.C.AB3.A5.A.A.B.C4.2B2.A3.A.A2B.2C.B$.C4.2A.B.C2.2B
.2CA2.C.A2.AC2.AB2.B3.CB2.A2.A.A.C.A.A2.2B2.C.BA2C2A2.AB2CAC2.C.B.C4.
A$2ABA.BA2.2CB2A.A.C2BC5.B2.C2.C.CACB2.2B4.B.B.2C2.CB.A.3C.B.2BA.A.A.
A2B.C2.A4.AC.B$B.B.B2.C4.A2.AB4.C.CA.C2A.C.A.AC3ABC.C3.AB.BAB.2CA3.AB
CA3.A.BAB3.ACBAB5.BC$B2.AB3C.CB4.B7.A.2A.B4.2C3.2BACA.C2.5BA3.CB3.C4.
2B2.C2.A4.2AC5.C2B$.A.B5.2A.B2.C.BACABCA.CBA.2CA2.CABC.C2AB3A3.B2.B5.
A.C2A.AB.BCA.2B3.CA.AB2.C3.2C$.C.A.A2CB3.2B3.2A2.B2.A3.A.C.C.3A2.B.CA
CA.A3.A.A.2ABA.2CB2.C2.A4.A5.CA5.2A$2.B2.C.A.AC3.C.A5.C.C2B2.2B4.CB.
2B2C2.B.ACBC3.B2.C.2B.2A3B.BC.B2C.A3.AC.ABAC.ACA$CBC.CA2CB.CB.2C2.A3.
BAB3.B3.CA.CA2.2C2.A4.AB.C4.2A2.C3.AB.C5.A3.C2.C.2C2.2A.A$AB2C2.C2B2.
2C2.C.B2.A.B2.A.A.A.3B.A.CB2.B2.C2.BA2B.C3.A.C.B2.C2B.C.2B2C6.BA.ACAB
AB$AC.BA2B.C.B5.2A3.A4.A2.A2.2CB.CBA2.2ACA3.BC.B.C.A.A.BC4.B.AB6.CBC
3.CA2.AC.C$C2B3.B.C.B.BA.BC.B6.2AB2.B6.2B4.AB2.C5.A.B4.A.A.BC2A.BAC2.
CB.CAB6.A.C$C2.CAC2.A.BA.AB2C3.C.B.CA.C7.A2.A.C.A.2B2.C.A4.A4.C2.3A.B
.C.B.BC.2B.AB3A3.AC$B.A.B.BA.CB.2B.C.2B.C2.CA.B.B2.B.2B.ACB3.A2.B2.AC
.A3C2AB2.2C2.A2.A2.A.CB.B.2B3.ABCB2CB$CA3.BA8.BA2.B.CAB.A.B.2C2.B2.BA
BA2.C2B.CA.B4.2B2.ACA.B3.B4.A2.A2.C2.2BCACB.AB$B2.A.C.A2B2.A.CB.B.C3A
C2B.2B2C2.AB2.B.CAC.B.B.CA.A.AB2.C.C.AB.A2B2.AC6.BC.CB2.A4.B$AC.BC2.B
A.A.BC.AC.2C2.A.BC3.2BA2BA2.C.2A2.B.AB.A4.CAB.B.C.ACB.B3.2B.A3.C.BCAC
3.A$2.CABAC.AB3.B.ACA8.CB4.BAB.C3A.CA2.B.2A2.2BC.BC.C.A.A.B2AB.B4.2A
3.B2A.CB.B.A$.A.C2AB2.2CA2.B2.C.A2.B.A4.2B.B2A.B3.C.B2.2C2.2A.C3.AB2.
B.3CB2.C.2BC.B7.A.2C$.BA.C5.AC.2C3.C3.C.C5.C2.C2B.C2.A.A9.A3.A.C.B2.B
CBA2.ACA4.B2C4.AB.CAC$.2A2.B2.BA3.2C2.C.A.C2.C5.CA.A.ABC2.A2.C3.A.B3.
2CA.2B.BAB.A5.B2.2CA2.C.C.2B.2AC$CA.AB2.C.A.2B2.2B2.B2.BA.AB5.B3.B2CB
2.C3.B.AB2A4.B2.BCACAB4.B.A.BCA.BC2.BA3.C$4.B.ABA4.C2.2BC.A2.B2A.ABA
2.A2.C2.C.A2.A2.B.C4.C4.BA.BA4.CB2A2.B2.BC2.A2.B.2BA$.A.2A2.3C.2BA.B.
CAB4.C2.B2.2B.2C2.CA2B2.C2.C.2A.BC2.A2.2B2.2A.C2.2A2.2C.B.A2.C$2.CB.C
A.C3.C.CA.C2A.C2.A3.A.B4.2BC4.A.A.B.CB.BA.CB2.A.B.3AC.ABA.B.A.B2.2A.C
AB.A2CA$B2.A2.CB3ACABA2B3.BC4.C2.A4.B.A3.A2C.2C.C3.A.A3.C.A.A.ABCA.2B
.B2.ABA.BC2.2C2.2B$B.B.AC.C.C.BCA.B.B3.C4.A.B3.A2.B2.B2.A4.C.2ACA3.2A
3B.CA2.B2.A.CB.C2AB2.A.A.2B2.AB$.CA2.B4.A2.CBA2.B3.C4.CA.BCA3CB5.AB.C
A2C.C.BA7.A2.AB2.B.A3.2ABCB.2CBABA.2B$.C.CB.2C5.B2.C.3B.BA.C2.2C.C.C
2.2B.B.B.B.A2C4.C.AB.BA2.2CB.B.3C4.B.CA3.B4.A.C$B.ACBAC.2B2.B6.2CA.BA
3.A.B2.A.CA4.2AC5.A3.B11.BA.AB2A3.A.ABA.BC.2C.BA$3.C2.B2C.A2.2C5.2C.B
C.3B2.C.C.2A2.C3A.A.C.2A2.2A2.A2.2AC2.ACA4B.BC.2C.C.B2.C2.B.C$2.2ABA
5.CA.B.CB2.ABC.AC.AB3.A.C2AC3.C.B2CB.3C.2B.BC2.AC.3AB2ABAC.C.B3.2B4.
2B2.B$2A2BA.2BCA.A2.BA2.C2.C.A2.2AC3.A6.B.CB3.B.A.A2.AB.ACA2.BC2A3.A.
C.B4.A.C5.2CBA$2.2ABA2.AC2B.BA3.A.A2.CB7.C.B2.A.A.3B.BCACB.2A.B2C4.C.
CB.B.B.C2.B.C.B.3BC5.C$C.2A2.BA.C4.BC.A4.C.A5.BC.A2.BA2.B2.CAB.ABC.B.
BA3.B.AB6.B.2A.CB2CB.C.2A3.A$A.2AB2ABA.B.BA.BC.BAC.A.ABABA.B.CA.CB3.A
2B.A.B2C.CB2.A.A.AC.AB4.A.C2A.BA3.A.ACA2.CB2A$2B2.B.3B3.B3.AC.B.A5.C.
CA.2B.A3.A2.CA.BA3.A2.B3.B2.BA2CBCBA.AB3.BCA3.B3.B.3B$2.BA2B8.2A2.A2.
A4.BA2.A.A.A.CA4.B2.BABC2.2B4.AB.A3.A.2CBC4.A2.AC.AC.2A.C$.B2CABAB.C
2.C3.C.CBA.B3.AB.CA.2C.A3.A.C.C.BC.2CAB4.C.CBA4.B5.A.B.A2.BA2C2.3B$A.
C3BA2.C.A4.C4.C.CABC2.A6.B2.2BAB.BA.B2A2.C3.B.B.BC.A8.B.BC3.2B.2CB2.C
$CA.C.A2C6.2B2.C.A.B.3B.2CBACA9.C2.ACBC3.A.A2C2.AC2.C.B2.A2.A2.C2A.BC
2.CAC.BC$A.A3.CB2.C.B2.CB.BA2.2AB2.C2BABC2.CA3.C3.ABA.BAC3.CA2.A.C.B
3.AC.2A2B2A3.C2BA3.2A$.2A5.C2.B5.B.C2.BC.C.A5.B.A.2B.C.C.ACB4.2A.BCBC
2A.C.CB2.2A3.CBA2B.AC3.A.C.C$2.2AC3.A2.BAB2.C3.2B.C4.B5.AB3.3AB.2CBC.
2B2.ABCBC3.B3.AC6.ABC.C3.AB3C.C$CA.B5.2CACA2.3B2.C.BCB.3C2.AB.CAC2B.C
.CB.B4.A.AC2.A3.A.AC.B.2A3.AC.B.2B3.A.B2.A$4.C2.A.A.BA.A.B.ACABCB2.B
2.C2.ABCB2.AB.2A2.A3.2C.A.BA5.AB3.B.A.CB.A.A3.A.A3BCA$.2C.ACA2.BC2AC
4.AB.B2C3.CA5.BAB.C2A.BC2.A.C.A.2B.C2.C.B.3C.CBA.B4.CB.A.2AB.2A2.B$B.
ABC.2CA.B2A4.2A.2CB2.2BAB6.C.C.2A.C.AC.2C4B2ABA2B3.2A.A3.2C2.2C2.B.C
2.C.CBA$.C.AC.ABCBC.A2.2BC2.A3BC.C.B2.2C2.B2C.B3.AB.A5.2C2B2AB3.A4.A.
CBA.2C2.C.CAC4.ABC$2.A2BAB.BCAB.AB3.C.2CB2CBAC5.BC2AC.A.2C.C.2CB4.CAC
.B.C.C2.CA.CAC2.CB.C2.B.ABA.BC.C$3B.A2.2B2.C.A2BC2.B.2AB3.C4.CB2ABC.
2A3.BCB3.B.2CB3.CAB.B.C3.B.BA.A2.C7.AC2.B$BACA.A2.B2.B2C2.B7.C4.2CB6.
2B.BC.A.B7.ACA.A.C.2C.2CBA3.C2B2C.A.BA.A3.A$CB2CB.A2.C.A2.A.2AC2.C2.A
.C.BC3.BC.CB2.BC.A2B2.B5.2B3.BA.B3.A3.2BC2AB3.CACB3.A.B$2BA.B3.A.B.A.
B.2B2.2CBA.C.BC.BAC.B2.B.CBAB3.A2.B2.2B2C.BC2BCA.CA.A4.3B2.CB.ABA.A.C
.B$BAB.C.3A.C4.A.BA.A.A.A2.A3.ABA.BA2.A.BC2.ACB.ACA2B2.2C.A7.2B3.3BC
2.A2.B2.C.C2A$.A2BC.B.C2A3.2B.2C.AB2.CA2.A.B.B2.2BCBCA.B.CBC2A.2AC2.A
C2.CA.AC.2A.BA2B2.AB.B2C3.BA2.BA$2B2.AC2.BCA4.A.AB3.C.2ABA2.2AB.2B4.
3B.B2.A.CBAC.2B2.C2BA2CA.CBCB2.B.A.ABAC.B.A3.A$C2.B5.B2.B.CBCAC.ABC4.
BCAC.BA2.2C2.BA2.C.B.B2.2B2A.B2.C2B2A.A.BACBACA2.B.A3.A3BC.C$A.2BC.A
4.A2.BCB.A.C2.2B.B.B2.AB2.B2.B2AC.ACB.BC2A.C2.C2ABC2A2.2A.B.BA.A2.C.B
2.C.2B2.BC$B2.C3A2.C.2B.A.A2.C10.2B2.A.BAC.ABA.3A.CB2.B2.A.B.C2.AC.A
3.BC2.A3.CA2.B.B.C.A$.2C.CAC.2C.BA2.C.2CA2.A2B5.B.2A.3BCA2.CB.A.B.BA.
BCA.C.BC3.BA2.B2C4.A6.AC.2CBA$.BC7.A2.B.AB.CBC2.ABC2.B.AC2.AC5.A2C5.B
.3B.C2.C.C.C2BCB4.C2B.CB3.A2.2A2.2C$AC2.A.CABC2.A4.BC.B2.2A2.BA.A4B7.
B.CA3.2C3.A3.C4.BC4A2.3C.C2.2B2.ACB$.2C3.A.ACBC2B.B4.BA.CA.B.C2.CABCB
A2.CB3.ACBABAB.B.B2.C.BCABA.ACA2.A3.AB2C.B2.2C.A2.B$5.C2B3.B2A3.B2C2.
B.A.B.B2.A2BA.A.3A3.B.B2A2.A2.AB3A.C.C.BC.2B5.AC.2BA4.C3.B$7.2C2.2AC
3.AC.A2.CA3.ACB4.B3.C2.B.CB.2A.AC2B2.C.ACAC2.2CA.B.CA.A2.2CB2.AB$B.BA
.BCB2.BA3.BACB2A7.C2.3C.C.A.CA.C5.BA2CA4.A4.B.2A.2B.2C.C.B.C2AC.C.CAC
$4.2CBC2ACB6.BC.C.A2B3.AB.A.C5.B.C2.BA.B5.B5.2BC3.C2.C2.2C.C2.CB2.CBC
$.C.2C.C2.B.C.A2.ABA.C.AC.A2C4.C5.2B2.A.CB.B.2AC2.2A.A3.C.B.A.A4.B.AB
.C4.B2.A.B$.CBA4.C3.B.B2.C.CB2.A.BA.CB.A.B5.AB.B3.A3.C.B3.C.A2BCA.A6.
2A2.A.CB.A.B3.2BA$B.C.B2.A4.B2.C2.A.C.B4.B2.A.A3.C2.C2A.ABC3.C3.AC.CA
B3A3.3B5.B.A.CB2.ABA.AC$5.ABA3.3C.A2.C2.AC.B2.A4.2BAB2A.A3.C7.B3.CA3.
2AC.A.2A4.C.CB.2BCA4.C.2B$A2B.3AB2.C.CABCB2C.BA.BAB2.A.C.A.BC.C4.CBC.
AB.C.CBACB2.B.CA.AB4.C.A3.A.C.ACAB2.C$.C.B2.AB.C.C.BC.BC2ABCB.C.2C2.A
BC.B2.ACBA2BACAC.C.A3.C2BA.2A.BC.C2.C2.B.CA4.2A.B3.C2B$.A3.BA.BCA.A2.
AB2.C2B.A3.C4.C.A.ABA2.AB3A3.2C.C2B2.B2.C2.B2.2CB.C2.CA2B4.A.C.BA$BA
4.C.A2.B.A.A.CA.A.C.A.C2.A2.B2.A4.C.A.CACBC2.C2.C.ABA.A.CB.A2.2B.B2.A
.C5.2C.CB.A$A2.C2.A.C2.A2C.B2A.BA.ACA2.BCA3.B3.B2.C2A5.3A.2B4.A3.BCAB
.AB3.CA.2BC2.A2.2AC.BA$B.C4.CA2.A.2CA9.CB3.A3.A3.2B.2B5.2B2.B3AC.C3.B
.BA.AB2.BA2.BCA.BAC2.A2.A$.B.3B2.CB.2A.C.A3.CA.C2.B2C2.A.ABA.C2.A.C.A
2.B.C3.B.3B.C2.C3.CA.B2.A.AB2.ACB2AC.B2.B$A.C2A2B2CABCB4.B2CA2.CB.AC.
C.2BAC.A2.BA8.B2.A.BA6.B.B2.C2.B2.CACB2C2.CA3.B$2.2C3.A3.A.B.B.2AB.2A
C2.A.BA2.B2.B.A2.C2.A.BC.A5.A.B5.C.A4.A2.ACB4.CBCBA.BCBA$.C.B.BA3.2BA
C2.C.C.ABA.CA.A.A2C4.2ACB.A2BCB5.AC2.C.B2.A.A.BA.A.C3.B4.3A2BAB.CB$2B
ACA2.B.B.B.CB3.A2.BA2.CB2C.CBAC.C.C2.B.A2C.A2.B4.AC.A.C.A2B.B.B.B3.A.
B4.2C.A.B$5.B.B.B2.B2.A.B2.BCB3.2A2.A2.B.CA2.BCB.B2.C2BCA2.A3.AC5.A.B
C2.A.C.C.A.BC2.C$3.2CB4.CA2.A.BC2B5.BA2.B.A2.C2BA3CB.BAC.AC2.C2B2.B.
2A2.CA.B3.BC3.A2.BA4.BA$CB.A2C2A.C2.A.B2.BCA2.C.C3.AB2.2B6.4B.3C4.CA
2C3.BC2.B6.BCAC.BAC2ACB2.B.AB$B3.A2.2B.C3.C.ACABC.C.C.A2BABC.C2.AC2.B
5.CBCAB.C2A.C.3A3.2ABAC3.B.ABC.B5.AC.C!

There's a lot of interesting things there. I noticed this wickstrecher plus wickeater:

Code: Select all

x = 13, y = 241, rule = Lockwood4s
4.C$C2.CABA$4.3A$3A3BA$C2B4A$C2BCABA2.2C$.2B.ABA.A2.A$.2C.A2.A.2A.A$A
2C3A.AB2CBA$A2B2AB2AC2ACA$4.ABA2.2B$5.2C2.2C$6.C.A2CA$4.ABA.A2BA$4.AB
A$4.C2A$4.2CA$4.ABA$4.ABA$4.A$4.2A$4.ABA$4.ABA$5.2C$6.C$4.ABA$4.ABA$
4.C2A$4.2CA$4.ABA$4.ABA$4.A$4.2A$4.ABA$4.ABA$5.2C$6.C$4.ABA$4.ABA$4.C
2A$4.2CA$4.ABA$4.ABA$4.A$4.2A$4.ABA$4.ABA$5.2C$6.C$4.ABA$4.ABA$4.C2A$
4.2CA$4.ABA$4.ABA$4.A$4.2A$4.ABA$4.ABA$5.2C$6.C$4.ABA$4.ABA$4.C2A$4.
2CA$4.ABA$4.ABA$4.A$4.2A$4.ABA$4.ABA$5.2C$6.C$4.ABA$4.ABA$4.C2A$4.2CA
$4.ABA$4.ABA$4.A$4.2A$4.ABA$4.ABA$5.2C$6.C$4.ABA$4.ABA$4.C2A$4.2CA$4.
ABA$4.ABA$4.A$4.2A$4.ABA$4.ABA$5.2C$6.C$4.ABA$4.ABA$4.C2A$4.2CA$4.ABA
$4.ABA$4.A$4.2A$4.ABA$4.ABA$5.2C$6.C$4.ABA$4.ABA$4.C2A$4.2CA$4.ABA$4.
ABA$4.A$4.2A$4.ABA$4.ABA$5.2C$6.C$4.ABA$4.ABA$4.C2A$4.2CA$4.ABA$4.ABA
$4.A$4.2A$4.ABA$4.ABA$5.2C$6.C$4.ABA$4.ABA$4.C2A$4.2CA$4.ABA$4.ABA$4.
A$4.2A$4.ABA$4.ABA$5.2C$6.C$4.ABA$4.ABA$4.C2A$4.2CA$4.ABA$4.ABA$4.A$
4.2A$4.ABA$4.ABA$5.2C$6.C$4.ABA$4.ABA$4.C2A$4.2CA$4.ABA$4.ABA$4.A$4.
2A$4.ABA$4.ABA$5.2C$6.C$4.ABA$4.ABA$4.C2A$4.2CA$4.ABA$4.ABA$4.A$4.2A$
4.ABA$4.ABA$5.2C$6.C$4.ABA$4.ABA$4.C2A$4.2CA$4.ABA$4.ABA$4.A$4.2A$4.A
BA$4.ABA$5.2C$6.C$4.ABA$4.ABA$4.C2A$4.2CA$4.ABA$4.ABA$4.A$4.2A$4.ABA$
4.ABA$5.2C$6.C$4.ABA$4.ABA$4.C2A$4.2CA$4.ABA$4.ABA$4.A$4.2A$4.ABA$4.A
BA$5.2C$6.C$4.ABA$4.ABA$4.C2A$4.2CA$4.ABA$4.ABA$4.A$4.2A$4.ABA$4.ABA$
5.2C$6.C$4.ABA$4.ABA$3.2C2A$2.4CA$3.2ABA$3.CABA$2.B2C$2.A2.C$2.C2.A3C
$2.C2B4AC$2.A2B2ACBC$5.A3BA!

This rule's glider is this photon:

Code: Select all

x = 5, y = 5, rule = Lockwood4s
2.C$.C.C$C3AC$CBABC$A3BA!

[wildmyron]

I don't know if I quite understand, but if the game has two rules, its transitioning between the two? I assume conway's is an example of a two-rule game?

No, Conway's Game of Life has a single rule, B3/S23, which means if a dead cell has 3 neighbors it becomes alive and if a live cell has 2 or 3 neighbors it stays alive, otherwise it dies. I'm not sure how you're interpreting this as 2 rules.

My program might be considered to generate one-rule games then?

However, it might transition to a different cell type if it has 2 alive neighbours versus 3. And that new cell type might transition differently on each of the 9 different alive neighbour counts. Each cell type is considered either alive or dead for the neighbour counts, but may transition to other cell types.

What you refer to as two-rule and three-rule games are usually referred to by number of states, e.g. CGoL is a 2-state CA. A commonly explored family of multi-state CA is generations: https://conwaylife.com/wiki/Generations but there are many others.

As for heuristics, this is a tricky field, I don't think there is any one heuristic that works well for understanding the behaviour of all rules. Langton's lambda parameter is probably the most widely used, there's a nice description here http://math.hws.edu/xJava/CA/EdgeOfChaos.html You can find other parameters which have been used if you explore the academic literature. Neural networks have also been trialed by many people, with varying success. The most accessible description of this idea - which showed some promising results - that I know of is here: https://softologyblog.wordpress.com/201 ... -automata/
Actually, that article also has a good overview of some alternative heuristics, so I think you might be interested. Jason, the author of Visions of Chaos, has been posting a lot of interesting articles on his blog recently, I recommend reading more of his articles to anyone interested in these topics.

Edit: a lot happened while I was typing this message on my phone, oh well - hopefully still something of interest here.

[murderofescrows]

Thanks Hunting! So cool to see it in there!

Thanks wildmyron, I'll look into that after work!

[Hunting]

G backrake:

Code: Select all

x = 11, y = 9, rule = Lockwood4s
.A2BA.A2BA$.C2BC.C2BC$.C2.C.C2.C$.A2.A.A2.A$.A3BA3BA$C.2ACAC2A.C$C.AB
3ABA.C$C.C2BA2BC.C$3.A3.A!

This can be attached to the rake:

Code: Select all

x = 11, y = 72, rule = Lockwood4s
.A2BA.A2BA$.C2BC.C2BC$.C2.C.C2.C$.A2.A.A2.A$.A3BA3BA$C.2ACAC2A.C$C.AB
3ABA.C$C.C2BA2BC.C$3.A3.A3$5.C$4.C.C$3.C3AC$3.CBABC$3.A3BA4$5.C$4.C.C
$3.C3AC$3.CBABC$3.A3BA4$5.C$4.C.C$3.C3AC$3.CBABC$3.A3BA4$5.C$4.C.C$3.
C3AC$3.CBABC$3.A3BA4$5.C$4.C.C$3.C3AC$3.CBABC$3.A3BA4$5.C$4.C.C$3.C3A
C$3.CBABC$3.A3BA4$5.C$4.C.C$3.C3AC$A2BABABA2BA$C2BA3BA2BC$C2.C3.C2.C$
A2.C3.C2.A$BC3A.3ACB$.CBCACACBC$.A.CA.AC.A$3CA.A.A3C$.CA2CA2CAC$.A7BA
!

EDIT: Head-on collisions:

Code: Select all

x = 108, y = 68, rule = Lockwood4s
2.2CA10.A2C14.2CA9.A2C15.2CA10.2A15.2CA9.2A$.CA2B10.2BAC12.CA2B9.2BAC
13.CA2B10.B2AC12.CA2B9.B2AC$C.2AB10.B2A.C10.C.2AB9.B2A.C11.C.2AB10.BA
.A11.C.2AB9.BA.A$.CA2B10.2BAC12.CA2B9.2BAC13.CA2B10.B2AC12.CA2B9.B2AC
$2.2CA10.A2C14.2CA9.A2C15.2CA10.2A15.2CA9.2A16$2.2CA27.2CA27.2CA27.2C
A$.CA2B10.A2C13.CA2B9.A2C14.CA2B10.2A14.CA2B9.2A$C.2AB10.2BAC11.C.2AB
9.2BAC12.C.2AB10.B2AC11.C.2AB9.B2AC$.CA2B10.B2A.C11.CA2B9.B2A.C12.CA
2B10.BA.A12.CA2B9.BA.A$2.2CA10.2BAC13.2CA9.2BAC14.2CA10.B2AC13.2CA9.B
2AC$15.A2C26.A2C28.2A27.2A15$2.2CA27.2CA27.2CA27.2CA$.CA2B26.CA2B26.C
A2B26.CA2B$C.2AB10.A2C12.C.2AB9.A2C13.C.2AB10.2A13.C.2AB9.2A$.CA2B10.
2BAC12.CA2B9.2BAC13.CA2B10.B2AC12.CA2B9.B2AC$2.2CA10.B2A.C12.2CA9.B2A
.C13.2CA10.BA.A13.2CA9.BA.A$15.2BAC25.2BAC27.B2AC25.B2AC$15.A2C26.A2C
28.2A27.2A14$2.2CA27.2CA27.2CA27.2CA$.CA2B26.CA2B26.CA2B26.CA2B$C.2AB
25.C.2AB25.C.2AB25.C.2AB$.CA2B10.A2C13.CA2B9.A2C14.CA2B10.2A14.CA2B9.
2A$2.2CA10.2BAC13.2CA9.2BAC14.2CA10.B2AC13.2CA9.B2AC$15.B2A.C24.B2A.C
26.BA.A25.BA.A$15.2BAC25.2BAC27.B2AC25.B2AC$15.A2C26.A2C28.2A27.2A!

G is somewhat edge-repairing. It also have a strong backspark.

Code: Select all

x = 15, y = 22, rule = Lockwood4s
2.2CA$.CA2B$C.2AB$.CA2B$2.2CA13$10.A3BA$10.CBABC$10.C3AC$11.C.C$12.C!

[yujh]

Cool rule!
I noticed this:

Code: Select all

x = 17, y = 114, rule = Lockwood4s
3$4.A2BA$4.C2BC$4.C2.C$.A3B2.A$.C2B3CB$.C.2ABAC$.A.ABCA$.ACACA2C$2.2A
$4.2C2A$3.2CABA$3.2CB2A$4.3A$6.2C$5.ABC$5.BAC$4.3C$5.A$4.2AB$4.ABA2$
5.C2A$4.CABA$4.CB2A$4.3A$6.2C$5.ABC.A2BA$5.BAC.A2CA$4.3C3.2C$5.A4.2B$
4.2AB.AC2ACA$4.ABA.AB2CBA$8.A.2A.A$5.C2A.A2.A$4.CABA2.2C$4.CB2A$4.3A$
6.2C$5.ABC.A2BA$5.BAC.A2CA$4.3C3.2C$5.A4.2B$4.2AB2.C2BC$4.ABA2.C2BC$
9.4A$5.C2A$4.CABA.C2.C$4.CB2A$4.3A$6.2C$5.ABC.A2BA$5.BAC.A2CA$4.3C3.
2C$5.A4.2B$4.2AB.AC2ACA$4.ABA.AB2CBA$8.A.2A.A$5.C2A.A2.A$4.CABA2.2C$
4.CB2A$4.3A$6.2C$5.ABC$5.BAC$4.3C$5.A$4.2AB$4.ABA2$5.C2A$4.CABA$4.CB
2A$4.3A$6.2C$5.ABC$5.BAC$4.3C$5.A$4.2AB$4.ABA2$5.C2A$4.CABA$4.CB2A$4.
3A$6.2C$5.ABC$5.BAC$4.3C$5.A$4.2AB$4.ABA$7.A2BA$7.B2CA$8.2C$7.ABA2$7.
CA$5.3CB2A$5.2CACB$5.3CA$7.AB$6.A2CA$6.B2CA$6.C2AC2$6.C$6.C$6.C.C!

[Hunting]

Cool rule!
I noticed this:

Code: Select all

x = 17, y = 114, rule = Lockwood4s
3$4.A2BA$4.C2BC$4.C2.C$.A3B2.A$.C2B3CB$.C.2ABAC$.A.ABCA$.ACACA2C$2.2A
$4.2C2A$3.2CABA$3.2CB2A$4.3A$6.2C$5.ABC$5.BAC$4.3C$5.A$4.2AB$4.ABA2$
5.C2A$4.CABA$4.CB2A$4.3A$6.2C$5.ABC.A2BA$5.BAC.A2CA$4.3C3.2C$5.A4.2B$
4.2AB.AC2ACA$4.ABA.AB2CBA$8.A.2A.A$5.C2A.A2.A$4.CABA2.2C$4.CB2A$4.3A$
6.2C$5.ABC.A2BA$5.BAC.A2CA$4.3C3.2C$5.A4.2B$4.2AB2.C2BC$4.ABA2.C2BC$
9.4A$5.C2A$4.CABA.C2.C$4.CB2A$4.3A$6.2C$5.ABC.A2BA$5.BAC.A2CA$4.3C3.
2C$5.A4.2B$4.2AB.AC2ACA$4.ABA.AB2CBA$8.A.2A.A$5.C2A.A2.A$4.CABA2.2C$
4.CB2A$4.3A$6.2C$5.ABC$5.BAC$4.3C$5.A$4.2AB$4.ABA2$5.C2A$4.CABA$4.CB
2A$4.3A$6.2C$5.ABC$5.BAC$4.3C$5.A$4.2AB$4.ABA2$5.C2A$4.CABA$4.CB2A$4.
3A$6.2C$5.ABC$5.BAC$4.3C$5.A$4.2AB$4.ABA$7.A2BA$7.B2CA$8.2C$7.ABA2$7.
CA$5.3CB2A$5.2CACB$5.3CA$7.AB$6.A2CA$6.B2CA$6.C2AC2$6.C$6.C$6.C.C!

Neat! The ships on the side of the wick is unnecessary, though.

perpendicular 2G:

Code: Select all

x = 45, y = 141, rule = Lockwood4s
2.2CA27.2CA$.CA2B26.CA2B$C.2AB25.C.2AB$.CA2B26.CA2B$2.2CA27.2CA6$10.A
3BA25.A3BA$10.CBABC25.5A$10.C3AC26.A.A$11.C.C27.CAC$12.C6$2.2CA27.2CA
$.CA2B26.CA2B$C.2AB25.C.2AB$.CA2B26.CA2B$2.2CA27.2CA7$10.A3BA25.A3BA$
10.CBABC25.5A$10.C3AC26.A.A$11.C.C27.CAC$12.C5$2.2CA27.2CA$.CA2B26.CA
2B$C.2AB25.C.2AB$.CA2B26.CA2B$2.2CA27.2CA8$10.A3BA25.A3BA$10.CBABC25.
5A$10.C3AC26.A.A$11.C.C27.CAC$12.C4$2.2CA27.2CA$.CA2B26.CA2B$C.2AB25.
C.2AB$.CA2B26.CA2B$2.2CA27.2CA9$10.A3BA25.A3BA$10.CBABC25.5A$10.C3AC
26.A.A$11.C.C27.CAC$12.C3$2.2CA27.2CA$.CA2B26.CA2B$C.2AB25.C.2AB$.CA
2B26.CA2B$2.2CA27.2CA10$10.A3BA25.A3BA$10.CBABC25.5A$10.C3AC26.A.A$
11.C.C27.CAC$12.C2$2.2CA27.2CA$.CA2B26.CA2B$C.2AB25.C.2AB$.CA2B26.CA
2B$2.2CA27.2CA11$10.A3BA25.A3BA$10.CBABC25.5A$10.C3AC26.A.A$11.C.C27.
CAC$12.C$2.2CA27.2CA$.CA2B26.CA2B$C.2AB25.C.2AB$.CA2B26.CA2B$2.2CA27.
2CA12$10.A3BA25.A3BA$10.CBABC25.5A$10.C3AC26.A.A$11.C.C27.CAC$12.C!

3G synth of an oscillator:

Code: Select all

x = 33, y = 17, rule = Lockwood4s
2.2CA23.A2C$.CA2B23.2BAC$C.2AB23.B2A.C$.CA2B23.2BAC$2.2CA23.A2C9$10.A
3BA$10.5A$11.A.A$11.CAC!

Wide extensible ship:

Code: Select all

[yujh]

G to G2 to G to most common big ship

Code: Select all

x = 17, y = 160, rule = Lockwood4s
.A2BA.A2BA$.C2BC.C2BC$.C2.C.C2.C$.A2.A.A2.A$.A3BA3BA$C.2ACAC2A.C$C.AB
3ABA.C$C.C2BA2BC.C$3.A3.A3$5.C$4.C.C$3.C3AC$3.CBABC$3.A3BA4$5.C$4.C.C
$3.C3AC$3.CBABC$3.A3BA4$5.C$4.C.C$3.C3AC$3.CBABC$3.A3BA4$5.C$4.C.C$3.
C3AC$3.CBABC$3.A3BA4$5.C$4.C.C$3.C3AC$3.CBABC$3.A3BA4$5.C$4.C.C$3.C3A
C$3.CBABC$3.A3BA4$5.C$4.C.C$3.C3AC$3.CBABC$3.A3BA2$8.A2BA$8.A2CA$5.C
3.2C$4.C.C2.2B2.A2BA$3.C3A2C2BC.A2CA$3.CBAB2C2BC2.2C$3.A3B.4A2.2B$9.A
3.C2BC$7.3C.C.C2BC$9.C3.4A$8.C$4.C.A6.C2.C$3.C4A$3.CBC2A$3.A3BA2$8.A
2BA$8.A2CA$9.2C$4.3C2.2B$3.C3A2C2AC2A2BA$3.CBC2AB2CBAC2BC$3.A4B.2A.AC
2.C$7.C.A.A.A2.A$7.C2.C2.B2CB$7.C2.C2.C2BC$6.C2.2C3.2C$4.C3.ACA2.C2AC
$3.C2A.2C$3.CBABC$3.A3BA4$5.C$4.C.C$3.C3AC$3.CBABC$3.A3BA4$5.C$4.C.C$
3.C3AC$3.CBABC$3.A3BA4$5.C$4.C.C$3.C3AC$3.CBABC$3.A3BA4$5.C$4.C.C$3.C
3AC$3.CBABA2BA$3.A3B4A$6.CACA$6.2C.A$6.A.A$4.2C$6.C$3.C2.C$3.A2CA$3.A
2CA$3.C2.C$3.C2.C$4.2C$3.B2CB$3.A2.A$3.C2.C$3.C2BC$3.A2BA9$3.C2AC$4.
2C$3.C2BC$3.B2CB$3.A2.A$3.C2.C$3.C2BC$3.A2BA!

SIde rake:

Code: Select all

x = 22, y = 11, rule = Lockwood4s
18.A2BA$18.A2CA$19.2C$2A2.2CA.C10.2B$B2C3BA7.A2BAC2BC$B2C3BA7.A2CAC3A
$2A2.2CA.C6.2C.4A$9.A3.CB3A.3A$8.B2C3BA$8.B2C3BA$8.2A2.2CA.C!

[Hunting]

I'm going to finish my previous posts.

Very nice! Not all Lifenthusiast likes OCA. I will write a longer post later.

EDIT: Firstly, I still didn't quite understand what exactly are your "two-rule" rules. Are they cellular automaton that alternatively applies the first rule and the second rule?

Secondly, it's good to randomize rules and investigate (I sometimes get rulegolf ideas by randomizing too) but it will be also good to know about how the "transistions" in the rule affect the rule's behaviour. For example, as you probably already know, if there's no birth at 0 neighbours (that kind of rule is usually excluded), birth at 1 neighbours forces the rule to explode (because every pattern have to grow), birth at 2 neighbours forces the rule to explode (because the lightspeed chaotic puffer engine) too but not as explosive as B1, etc.

(to be continued)

Rules without birth at 0, 1, 2 and 3 cannot escape its bounding box. For example:

Code: Select all

x = 20, y = 20, rule = B45678/S012345678
3o2bobo5bobo3bo$bob4ob2o2b2o2bob2o$4o2bob4obo2bobo$3o2b2o5b3obo$4o2b2o
b2obo2bob2o$3o4bob5o3bo$o4b3o3b2obo$3o3b5o2bob4o$2o4b2o2bob7o$2o2bob2o
b7o2b2o$2o2b3o3bobo4bobo$2bo2bo2b3obo2b5o$ob2ob6obo$4bo6b3ob3obo$obo3b
o3bo4bob3o$2bob2o2bobo2bobob3o$b6o2b3ob2obobo$o3b4obo6bobo$b2o2bo3b3ob
ob5o$o2b3o4b2obo2bob2o!

Code: Select all

x = 20, y = 20, rule = B45678/S23456
3o2bobo5bobo3bo$bob4ob2o2b2o2bob2o$4o2bob4obo2bobo$3o2b2o5b3obo$4o2b2o
b2obo2bob2o$3o4bob5o3bo$o4b3o3b2obo$3o3b5o2bob4o$2o4b2o2bob7o$2o2bob2o
b7o2b2o$2o2b3o3bobo4bobo$2bo2bo2b3obo2b5o$ob2ob6obo$4bo6b3ob3obo$obo3b
o3bo4bob3o$2bob2o2bobo2bobob3o$b6o2b3ob2obobo$o3b4obo6bobo$b2o2bo3b3ob
ob5o$2ob3o4b2obo2bob2o!

(Funny how the latter rule wants to create blobs with B5678, but they cannot survive, creating big "bubbles".)

This behaviour means it's impossible to have ship or guns etc. So a good, non-explosive rule must have B3.