Zxc

[Sphenocorona]

Here's a rule similar to Brian's Brain that can be used to construct stable circuitry and oscillators as well as guns and other such things:

Code: Select all

@RULE Zxc

State 0 is dead
State 1 is live/on
State 2 is sick/half-on
State 3 is zombie (once created, no live cells will be born nearby)

@TABLE

n_states:4
neighborhood:Moore
symmetries:permute

var a={0,1,2}
var b={a}
var c={a}
var d={a}
var e={a}
var f={a}
var g={a}
var h={a}
var i={0,2}
var j={i}
var k={i}
var l={i}
var m={i}
var n={i}
var o={i}
var p={i}
var q={1,2}
var r={q}
var s={q}
var t={q}

# birth
# 0,1,i,j,k,l,m,n,o,1
0,1,1,j,k,l,m,n,o,1
# 0,1,1,1,k,l,m,n,o,1
# 0,1,1,1,1,l,m,n,o,1
# 0,1,1,1,1,1,m,n,o,1
# 0,1,1,1,1,1,1,n,o,1
# 0,1,1,1,1,1,1,1,o,1
# 0,1,1,1,1,1,1,1,1,1

# recovery
# 2,i,j,k,l,m,n,o,p,1
# 2,q,j,k,l,m,n,o,p,1
# 2,q,1,k,l,m,n,o,p,1
# 2,q,r,1,l,m,n,o,p,1
# 2,q,r,1,1,m,n,o,p,1
# 2,q,r,s,1,1,n,o,p,1
# 2,q,r,s,1,1,1,o,p,1
# 2,q,r,s,t,1,1,1,p,1
2,q,r,s,t,1,1,1,1,1

# zombification of sick
# 2,i,j,k,l,m,n,o,p,3
# 2,1,j,k,l,m,n,o,p,3
# 2,1,1,k,l,m,n,o,p,3
# 2,1,1,1,l,m,n,o,p,3
# 2,1,1,1,1,m,n,o,p,3
# 2,1,1,1,1,1,n,o,p,3
2,1,1,1,1,1,1,o,p,3
# 2,1,1,1,1,1,1,1,p,3
# 2,1,1,1,1,1,1,1,1,3

# zombification of infected
q,3,a,b,c,d,e,f,g,3

# live to sick
1,a,b,c,d,e,f,g,h,2

# otherwise sick die 
2,a,b,c,d,e,f,g,h,0

@COLORS
1 255 0 0 r
2 255 255 0 y
3 192 0 192 p

Interactions with state 3 go like this (let's refer to the subject cell as C, refer to both states 1 and 2 as living, state 2 as 'sick', state 1 as 'healthy', and state 3 as 'zombie'):
- If the cell C is living and has one zombie neighbor, it becomes a zombie cell no matter what.
- If the cell C is not a zombie and has more than one zombie neighbor, it will permanently remain in that state. This means no birth or death around a zombie cell once it has appeared.
- If the cell C is sick and has 8 living neighbors, at least six of which are healthy, it will become a zombie.
Here is an example collection:

Code: Select all

x = 171, y = 125, rule = Zxc
99.C4.C$105.C2.C$109.2C$98.CA10.AC$98.C4.A2.A$98.C3.A4C5.C$98.CA2.C3.
CA3.2A$99.C6.C5.C$106.C3.AC$102.AC2.CA2.2C$74.BA22.BA3.C2.C$74.BA22.B
A3.C2.C$102.A4CA$103.A2.A3$152.C$149.CA$149.C$149.C$148.2CA6.C$149.A
8.2C$159.AC$152.A2.A$151.A4C5.C$152.C2.CA3.2A$155.C5.C$155.C3.AC$155.
CA2.C.CAC$155.C4.C.A2.C$155.C3.CA4.AC$154.2CA9.C$155.A11.C$159.A2.A5.
C$158.A5CA$154.BA3.C3.C$154.BA3.C3.C$158.A5CA$159.A2.A5.C$155.A11.C$
57.AC95.2CA9.C$58.C96.C3.CA4.AC$58.C96.C4.C.A2.C$57.AC96.CA2.C.CAC$
58.C9.C86.C3.AC$58.C8.AC86.C5.C$57.AC93.C2.CA3.2A$58.C4.CA86.A4C5.C$
58.C4.C88.A2.A$57.AC4.C3.C91.AC$3.C54.A5CA84.A8.2C$59.A2.A85.2CA6.C$C
A56.BA7.C81.C$CA64.C82.C$59.CA4.AC82.CA$3.C14.AC39.2C.A2.C86.C$19.C
41.CAC3$18.C2$106.C$11.CA$11.C91.CA$103.CA$14.A2.A133.2C$14.4C88.C14.
AC29.A$122.C35.C2$150.CA$121.C28.CA2$158.C$114.CA36.A$114.C36.2C2$
117.A2.A$117.4C10$151.2C$152.A$156.C2$150.CA$150.CA2$156.C$152.A$151.
2C7$152.2C$152.2A3$152.AC$152.2C8$143.C22.C$141.2CA2C18.2CA2C$139.C2.
A.2A19.A.2A$138.C4$147.C$170.C!

Why did I choose the name Zxc? Because on a QWERTY keyboard (like what I'm accustomed to) it is possible to type the rule name just by quickly sliding your finger from the shift key to C.

[Sphenocorona]

In addition, here is a prototype for creating rules similar to this with live, sick, and zombie cells:

Code: Select all

@RULE Zxclike

State 0 is dead
State 1 is live/on
State 2 is sick/half-on
State 3 is zombie (once created, nearby cells will not be born)

@TABLE

n_states:4
neighborhood:Moore
symmetries:permute

var a={0,1,2}
var b={a}
var c={a}
var d={a}
var e={a}
var f={a}
var g={a}
var h={a}
var i={0,2}
var j={i}
var k={i}
var l={i}
var m={i}
var n={i}
var o={i}
var p={i}
var q={1,2}
var r={q}
var s={q}
var t={q}
var u={q}
var v={q}
var w={q}
var x={q}

# birth
# 0,1,i,j,k,l,m,n,o,1
# 0,1,1,j,k,l,m,n,o,1
# 0,1,1,1,k,l,m,n,o,1
# 0,1,1,1,1,l,m,n,o,1
# 0,1,1,1,1,1,m,n,o,1
# 0,1,1,1,1,1,1,n,o,1
# 0,1,1,1,1,1,1,1,o,1
# 0,1,1,1,1,1,1,1,1,1

# recovery
# 2,i,j,k,l,m,n,o,p,1
# 2,1,j,k,l,m,n,o,p,1
# 2,1,1,k,l,m,n,o,p,1
# 2,1,1,1,l,m,n,o,p,1
# 2,1,1,1,1,m,n,o,p,1
# 2,1,1,1,1,1,n,o,p,1
# 2,1,1,1,1,1,1,o,p,1
# 2,1,1,1,1,1,1,1,p,1
# 2,1,1,1,1,1,1,1,1,1

# zombification of sick
# 2,i,j,k,l,m,n,o,p,3
# 2,1,j,k,l,m,n,o,p,3
# 2,1,1,k,l,m,n,o,p,3
# 2,1,1,1,l,m,n,o,p,3
# 2,1,1,1,1,m,n,o,p,3
# 2,1,1,1,1,1,n,o,p,3
# 2,1,1,1,1,1,1,o,p,3
# 2,1,1,1,1,1,1,1,p,3
# 2,1,1,1,1,1,1,1,1,3

# live to sick
# 1,i,j,k,l,m,n,o,p,2
# 1,1,j,k,l,m,n,o,p,2
# 1,1,1,k,l,m,n,o,p,2
# 1,1,1,1,l,m,n,o,p,2
# 1,1,1,1,1,m,n,o,p,2
# 1,1,1,1,1,1,n,o,p,2
# 1,1,1,1,1,1,1,o,p,2
# 1,1,1,1,1,1,1,1,p,2
# 1,1,1,1,1,1,1,1,1,2

# zombification of live and sick
# q,3,j,k,l,m,n,o,p,3
# q,3,3,k,l,m,n,o,p,3
# q,3,3,3,l,m,n,o,p,3
# q,3,3,3,3,m,n,o,p,3
# q,3,3,3,3,3,n,o,p,3
# q,3,3,3,3,3,3,o,p,3
# q,3,3,3,3,3,3,3,p,3
# q,3,3,3,3,3,3,3,3,3

# otherwise live and sick die 
q,a,b,c,d,e,f,g,h,0

@COLORS
1 255 0 0 red
2 255 255 0 yellow
3 192 0 192 purple

[TWLife]

when I tried the first rule it said that the 23rd line could not be understood....
And what algorithm is this??

[Sphenocorona]

The algorithm is RuleLoader, which replaced RuleTable and RuleTree in Golly 2.5 - I'll check for errors in the rule. Here's the bare rule table for anyone using Golly 2.4 or earlier:

Code: Select all

n_states:4
neighborhood:Moore
symmetries:permute

var a={0,1,2}
var b={a}
var c={a}
var d={a}
var e={a}
var f={a}
var g={a}
var h={a}
var i={0,2}
var j={i}
var k={i}
var l={i}
var m={i}
var n={i}
var o={i}
var p={i}
var q={1,2}
var r={q}
var s={q}
var t={q}

# birth
0,1,1,j,k,l,m,n,o,1

# recovery
2,q,r,s,t,1,1,1,1,1

# zombification of sick
2,1,1,1,1,1,1,o,p,3

# zombification of infected
q,3,a,b,c,d,e,f,g,3

# live to sick
1,a,b,c,d,e,f,g,h,2

# otherwise sick die 
2,a,b,c,d,e,f,g,h,0

[Sphenocorona]

Better stable reflector, with repeat time of 15:

Code: Select all

x = 21, y = 6, rule = Zxc
19.C$11.C6.A2C$19.AC2$BA13.BA$BA13.BA!

Diagonal ship gun:

Code: Select all

x = 20, y = 26, rule = Zxc
8.4C$8.A2.A19$8.B2.B$C4.B.2A2.2A.B4.C$3.C2.A2C2.2CA2.C$4.C.AC4.CA.C$
5.AC6.CA$5.C8.C!

Adjustable period signal generator/gun:

Code: Select all

x = 26, y = 16, rule = Zxc
19.C4.C$18.C6.C2$10.C4.C$.C4.C2.C6.C$C6.C2$3.2A7.2A7.2A$.BA2BAB3.BA2B
AB3.BA2BAB$3.2A7.2A7.2A$C6.C.C6.C.C6.C$.C.2B.C3.C.2B.C3.C.2B.C4$3.2C
7.2C7.2C!

This object takes an input signal and generates two signals, always on the same side regardless of which side the signal comes in. (I'm trying to see if I can make a diode with this; I already have a diode for wire signals which requires being placed at a curve in the wire):

Code: Select all

x = 22, y = 10, rule = Zxc
C17.C$.A2C15.A2C$2.AC16.AC2$4.AB9.BA$4.AB9.BA2$2.AC16.AC$.A2C15.A2C$C
17.C!

One half of the object becomes a 180 degree reflector, but only for one input direction.

Note that the known diode can make a bulky diode for free signals too:

Code: Select all

x = 21, y = 33, rule = Zxc
10.CAC$8.2C.A2.C$8.CA4.AC$15.C$16.C$8.A2.A5.C$7.A5CA$BA6.C3.C$BA6.C3.
C$7.A5CA$8.A2.A5.C$16.C$15.C$8.CA4.AC$8.2C.A2.C$10.CAC2$10.CAC$8.2C.A
2.C$8.CA4.AC$15.C$16.C$8.A2.A5.C$7.A5CA$8.C3.C6.AB$8.C3.C6.AB$7.A5CA$
8.A2.A5.C$16.C$15.C$8.CA4.AC$8.2C.A2.C$10.CAC!

It would be nice if this could be compacted further (diodes that are smaller but use minor p1 variants of the simple signal are ok as long as the signal is simple enough)

[Sphenocorona]

Here's a basic set of gates, including ANDNOT, AND, and OR/XOR:

Code: Select all

x = 122, y = 106, rule = Zxc
52.2B$52.2A11$10.B3.B3.B.3B3.B3.B2.3B2.5B9.2B$9.B.B2.B3.B.B2.B2.B3.B.
B3.B3.B11.2A$8.B3.B.2B2.B.B3.B.2B2.B.B3.B3.B$8.B3.B.B.B.B.B3.B.B.B.B.
B3.B3.B$8.5B.B2.2B.B3.B.B2.2B.B3.B3.B.BA4.BA$8.B3.B.B3.B.B2.B2.B3.B.B
3.B3.B.BA4.BA$8.B3.B.B3.B.3B3.B3.B2.3B4.B$53.C9$52.2B$52.2A7$52.2B$
52.2A3$56.C$57.C$28.B3.B3.B.3B11.CA$27.B.B2.B3.B.B2.B10.C$26.B3.B.2B
2.B.B3.B9.C$26.B3.B.B.B.B.B3.B9.CA$26.5B.B2.2B.B3.B14.C$26.B3.B.B3.B.
B2.B14.C$26.B3.B.B3.B.3B2$52.2A$52.2B17$54.C$54.CA6.C$53.CA7.C$63.AC$
64.AC2$BA21.BA41.AB13.AB37.AB$BA21.BA41.AB13.AB37.AB2$64.AC$64.C6$45.
3B2.4B6.B.B3.B2.3B2.4B$44.B3.B.B3.B4.B2.B3.B.B3.B.B3.B$44.B3.B.B3.B4.
B3.B.B2.B3.B.B3.B$44.B3.B.4B4.B5.B3.B3.B.4B$44.B3.B.B3.B2.B5.B.B2.B3.
B.B3.B$44.B3.B.B3.B2.B4.B3.B.B3.B.B3.B$45.3B2.B3.B.B5.B3.B2.3B2.B3.B
3$52.B2.B7.B8.B$52.B.B.B5.B.B7.B.B$51.2B.3B.2B2.3B.2B3.2B3.2B3.B$50.B
.B.B3.B.B.B3.B.B.B.B.B.B.B.B.B$51.B3.2B.2B3.2B.B.B2.B2.B.B.B2.2B$58.B
23.B$58.B21.2B$64.B7.B$52.B2.2B3.3B3.2B.B4.2B3.B$51.B.B.B.B3.B2.B.B.B
.B.B.B.B.B.B$52.B2.B.B3.B2.B.B.B.B.B.B.B2.2B$80.B$78.2B!

The OR and XOR gate combo is not perfect (timing of the signal sent depends on which signal combo is recieved) but oerall I think this shows that the rule has a good chance of being turing-complete if you ignore the near impossibility of contructing the circuitry (while this might be possible, it would be extremely difficult to create diodes)

[twinb7]

Really like this, I downloaded it a while ago and then kind of left it alone to collect dust, but I should look into this and maybe even make a little computer

[twinb7]

- If the cell C is sick and has 8 living neighbors, at least six of which are healthy, it will become a zombie

That doesn't seem accurate, running it on my comp...

Code: Select all

x = 10, y = 12, rule = Zxc
3A4.3A$ABA4.2BA$3A4.3A7$3A4.3A$.B5.2BA$3A4.B2A!

[twinb7]

Code: Select all

x = 35, y = 33, rule = Zxc
16.BA$16.A.BA$17.BA.BA$9.BA8.2A.BA$9.2CA8.B2.BA$7.A.2CB3.C5.B2.BA$.2C
2.4C.C3.C2.2C2.A2BA.BA$2.2C3.2CB.C.B2C2.2C3.C2A.BA4.BA$4C2.CB7.A4C2.C
B.B2.BA3.BA$C3.3CB8.C3.3CBA.B2.BA.BA$.C15.C6.B.A.BA.BA$15.A5.A.B2.BA$
5.A.A7.2B3.A2B2.BA$5.3B6.A4.B2A.BA$4.B8.B5.A$7.2B4.AB3.B$7.A.B4.A2.BA
$15.2BA$7.B7.2A12$10.CBA$12.BA$12.BA!