Rule request thread

[unname4798]

Rule request: TBlockLife but cells survive regardless of other cell types.

[confocaloid]

Rule request: TBlockLife but cells survive regardless of other cell types.

Code: Select all

#C Ruletable untested, appended after the pattern
x = 32, y = 32, rule = testing
.A.BA.4AB.B2ABAB.3BABA2.A.AB$3.BA3.A.B.B.BABAB.B.AB2.2AB$A.BA.A2.2B5.
AB.A3.B.B.A.3B$.A.A.B3.2A.2A.BA3.A6.A.2B$BA2.A.BA.A.B3.AB.BAB.BA3.B2.
A$2ABA.A.A.2A3.B.B3.A.A.A.B.B.A$A.B.B4.B5.B3.2B.2B.2B.BABA$2.B2.A2.A
2B2.2B3.2A2.B.A2BA.B.B$3.B.B2.3BA.2BA2.A6.A3.A$.BA4.B2.5B.B.BA.2BA3.A
.2A$BAB7.A2.2B2.2B.B2.B2ABAB.BA$ABA4.A.A5.A.A.B2.2AB2.AB.BA$2.B3.B3.A
B2.A.AB.AB2.BAB3.B$A4.A2.A2BA.2A.A2.B2.BA.2A.A.2B$3.2A2.B3AB2.B2.A2B.
A3.2A2.B.B$.2ABA3.A3.ABA3.A.2B4.ABA2.B$B2.ABA2B2.AB2.BA.BA.A.A2.BA.B$
A2.B.B2.2B.2A.B2.A.A.4A.B2.2B$B.BA2.BA6.ABA.2AB.A.A2.2A.B$.A2.A.B3.2A
B3.B2.A5.BA.B.A$2.2B.A2.3B2.AB3A.B3.2BA.AB.A$2.A.2A5.A.2B3.AB4.A4.2A$
4.2BA2.A4.A.2B2.BA2.B2A.AB.A$4.BA.B3.2A.ABA2.2B2.B.B3.B$.B2A.A2.A.A.B
.A2.A.B.5B2.3BA$2B.B2.B.2B.A.2BA.3B2.A.B.B.2B.A$.2BA.A6.B2.B.3BA.2BA.
B2.A.A$2B2A3.A3.A.B4.BA.2B.BA4.2B$BAB2.2A3.BAB.ABAB.2A.AB.B2.2A2B$A2.
B2.B4.A2B.B5.3BA2.BA2.B$2B.3B2A.A.A2.AB.B7.A.B2.A$2.B.2A2.BA.2A.A2.A.
A.2A.A4.B!

@RULE testing

An attempt to implement https://conwaylife.com/forums/viewtopic.php?p=183409#p183409
See also https://conwaylife.com/forums/viewtopic.php?p=164920#p164920

state 1: "approximately B3/S23"
state 2: "approximately B3/S2-i34q"
birth by majority (always unambiguous: two alive cellstates, three alive neighbours)
when an alive cell survives due to S3a, it changes to the other alive state
when deciding whether an alive cell survives, neighbours of the other alive state are treated as dead

@TABLE

n_states:3
neighborhood:Moore
symmetries:rotate4reflect

var a1={0,1}
var a2=a1
var a3=a1
var a4=a1
var a5=a1
var a6=a1
var b1={0,2}
var b2=b1
var b3=b1
var b4=b1
var b5=b1
var b6=b1
var c1={1,2}
var c2=c1
var x={0,1,2}
var x1=x
var x2=x
var x3=x
var x4=x
var x5=x
var x6=x
var x7=x
var x8=x

# Birth rules (only when there are =3 alive neighbours):
# * a state-1 cell is born when there are at least 2 state-1 neighbours
# * a state-2 cell is born when there are at least 2 state-2 neighbours
# The case "all three alive neighbours have the same state"
# doesn't need to be listed as a separate rule,
# because variables c1, c2 vary independently from each other
# and the outcome is the same in the 2:1 and 3:0 cases.

0,c1,c1,c2, 0, 0, 0, 0, 0,c1  # B3a
0,c1,c2,c1, 0, 0, 0, 0, 0,c1  # same rule, different colouring

0,c1,c1, 0,c2, 0, 0, 0, 0,c1  # B3n
0,c1,c2, 0,c1, 0, 0, 0, 0,c1  # same rule, different colouring
0,c2,c1, 0,c1, 0, 0, 0, 0,c1  # same rule, different colouring

0,c1,c1, 0, 0,c2, 0, 0, 0,c1  # B3r
0,c1,c2, 0, 0,c1, 0, 0, 0,c1  # same rule, different colouring
0,c2,c1, 0, 0,c1, 0, 0, 0,c1  # same rule, different colouring

0,c1,c1, 0, 0, 0,c2, 0, 0,c1  # B3q
0,c1,c2, 0, 0, 0,c1, 0, 0,c1  # same rule, different colouring
0,c2,c1, 0, 0, 0,c1, 0, 0,c1  # same rule, different colouring

0,c1,c1, 0, 0, 0, 0,c2, 0,c1  # B3j
0,c1,c2, 0, 0, 0, 0,c1, 0,c1  # same rule, different colouring
0,c2,c1, 0, 0, 0, 0,c1, 0,c1  # same rule, different colouring

0,c2,c1, 0, 0, 0, 0, 0,c1,c1  # B3i
0,c1,c2, 0, 0, 0, 0, 0,c1,c1  # same rule, different colouring

0,c1, 0,c1, 0,c2, 0, 0, 0,c1  # B3e
0,c1, 0,c2, 0,c1, 0, 0, 0,c1  # same rule, different colouring

0,c1, 0,c1, 0, 0,c2, 0, 0,c1  # B3k
0,c1, 0,c2, 0, 0,c1, 0, 0,c1  # same rule, different colouring

0, 0,c1, 0,c1, 0,c2, 0, 0,c1  # B3c
0, 0,c1, 0,c2, 0,c1, 0, 0,c1  # same rule, different colouring

0, 0,c1, 0, 0,c1, 0, 0,c2,c1  # B3y
0, 0,c1, 0, 0,c2, 0, 0,c1,c1  # same rule, different colouring

# Survival rules (cellstate 1, =2 alive neighbours)
1, 1, 1,b1,b2,b3,b4,b5,b6, 1  # S2a
1, 1,b1, 1,b2,b3,b4,b5,b6, 1  # S2e
1, 1,b1,b2, 1,b3,b4,b5,b6, 1  # S2k
1, 1,b1,b2,b3, 1,b4,b5,b6, 1  # S2i
1,b1, 1,b2, 1,b3,b4,b5,b6, 1  # S2c
1,b1, 1,b2,b3,b4, 1,b5,b6, 1  # S2n

# Survival rules (cellstate 1, =3 alive neighbours)
1, 1, 1, 1,b1,b2,b3,b4,b5, 2  # state-1 surviving due to S3a becomes state-2
1, 1, 1,b1, 1,b2,b3,b4,b5, 1  # S3n
1, 1, 1,b1,b2, 1,b3,b4,b5, 1  # S3r
1, 1, 1,b1,b2,b3, 1,b4,b5, 1  # S3q
1, 1, 1,b1,b2,b3,b4, 1,b5, 1  # S3j
1, 1, 1,b1,b2,b3,b4,b5, 1, 1  # S3i
1, 1,b1, 1,b2, 1,b3,b4,b5, 1  # S3e
1, 1,b1, 1,b2,b3, 1,b4,b5, 1  # S3k
1,b1, 1,b2, 1,b3, 1,b4,b5, 1  # S3c
1,b1, 1,b2,b3, 1,b4,b5, 1, 1  # S3y

# Survival rules (cellstate 2, =2 alive neighbours)
2, 2, 2,a1,a2,a3,a4,a5,a6, 2  # S2a
2, 2,a1, 2,a2,a3,a4,a5,a6, 2  # S2e
2, 2,a1,a2, 2,a3,a4,a5,a6, 2  # S2k
2, 2,a1,a2,a3, 2,a4,a5,a6, 0  # D2i
2,a1, 2,a2, 2,a3,a4,a5,a6, 2  # S2c
2,a1, 2,a2,a3,a4, 2,a5,a6, 2  # S2n

# Survival rules (cellstate 2, =3 alive neighbours)
2, 2, 2, 2,a1,a2,a3,a4,a5, 1  # state-2 surviving due to S3a becomes state-1
2, 2, 2,a1, 2,a2,a3,a4,a5, 2  # S3n
2, 2, 2,a1,a2, 2,a3,a4,a5, 2  # S3r
2, 2, 2,a1,a2,a3, 2,a4,a5, 2  # S3q
2, 2, 2,a1,a2,a3,a4, 2,a5, 2  # S3j
2, 2, 2,a1,a2,a3,a4,a5, 2, 2  # S3i
2, 2,a1, 2,a2, 2,a3,a4,a5, 2  # S3e
2, 2,a1, 2,a2,a3, 2,a4,a5, 2  # S3k
2,a1, 2,a2, 2,a3, 2,a4,a5, 2  # S3c
2,a1, 2,a2,a3, 2,a4,a5, 2, 2  # S3y

# Survival rules (cellstate 2, =4 alive neighbours)
2, 2, 2, 2,a1,a2, 2,a3,a4, 2  # S4q

# everything else goes to zero
x,x1,x2,x3,x4,x5,x6,x7,x8, 0

[hotcrystal0]

A rule called “IgnoranceMark” which is Ignorance but with mark states.
State 0: dead
State 1: orange
State 2: blue
State 3: mark dead
State 4: mark orange
State 5: mark blue
State 6: label (stays there until another state births on top of it)
Colors:

Code: Select all

x = 0, y = Infinity, rule = IgnM_colors
ABCDEF!

@RULE IgnM_colors

@TABLE
n_states: 7
neighborhood: Moore
symmetries: permute

@COLORS
0 0 0 0
1 255 150 0
2 0 92 255
3 255 255 255
4 255 200 140
5 76 184 255
6 255 0 0

[b-engine]

Code: Select all

x = 20, y = 12, rule = IgnoranceM
.A16.B$2.A14.B$3A14.3B$3.2F10.2F$3.2F.8C.2F$6.8C$6.8C$6.8C$6.8C$6.2C4F
2C$6.2C4F2C$6.8C!
@RULE IgnoranceM
@TABLE
n_states: 7
neighborhood: Moore
symmetries: permute
var a = {0,1,2,3,4,5,6}
var a1 = a
var a2 = a
var a3 = a
var a4 = a
var a5 = a
var a6 = a
var a7 = a
var a8 = a
var b = {0,2,3,5,6}
var b1 = b
var b2 = b
var b3 = b
var b4 = b
var c = {0,1,3,4,6}
var c1 = c
var c2 = c
var c3 = c
var c4 = c
var d = {2,5}
var d1 = d
var d2 = d
var e = {1,4}
var e1 = e
var e2 = e
var f = {0,1,2}
var g = {3,4,5}
var h = {0,3,6}
var h1 = h
var h2 = h
var i = {1,4}
var i1 = i
var i2 = i
var j = {2,5}
var j1 = j
var j2 = j
var k = {0,6}
h,d,d,d,e,e,e,h2,h1,h
k,i,i1,i2,b,b1,b2,b3,b4,1
3,i,i1,i2,b,b1,b2,b3,b4,4
k,j,j1,j2,c,c1,c2,c3,c4,2
3,j,j1,j2,c,c1,c2,c3,c4,5
e,e1,e2,a,b,b1,b2,b3,b4,e
d,d2,d1,a,c,c1,c2,c3,c4,d
f,a1,a2,a3,a4,a5,a6,a7,a8,0
g,a1,a2,a3,a4,a5,a6,a7,a8,3
@COLORS
0 0 0 0
1 255 150 0
2 0 92 255
3 255 255 255
4 255 200 140
5 76 184 255
6 255 0 0

[tommyaweosme]

Great! Now I would like (again! Sorry..) b3s123eik4ce
and B3-a4k5kai/S1e2-i34-eczt

Okay, time to write a non-totalistic rule builder script to throw into Golly's Rule-Generators folder.

Does anyone have a script already? Or at least a complete list of rotate4reflect neighbor lists and their letter equivalents, like

0,1,0,0,0,1,0,0,0,1 # B2i
0,0,1,0,0,0,1,0,0,1 # B2n

?

The only slightly annoying part of the script will be supporting the "-" format correctly, but even that isn't terribly complicated.

EDIT: Oh, that's right -- the list is here, as wildmyron pointed out recently. Just needs a little fixing up to work with the neighbors2 table instead of the neighbors table. EDIT2 ... which is already done in wildmyron's isotropicRulegen.py, which seems to have the correct "n" instead of the old Life32 "v". I knew that last week...

There's some hope of native Golly support for Hensel's neighbors2-format rules, but a Rule-Generator script will be a really good first step, to have a reasonably official implementation to test Golly against.

i made a script (you need to enter transitions like 2a2e if you want 2ae, and minus isnt possible, but it still works, i guess?)

Code: Select all

def tra(re,tr):
  if tr in tran:
    print("?,",re,"1")
print("use rotate4reflect symmetry")
while True:
  tran = input("transitions (i.e. 1e2e3k3a):")
  tra("0,0,0,0,0,0,0,0,","0")
  tra("0,0,0,0,0,0,0,1,","1c")
  tra("1,0,0,0,0,0,0,0,","1e")
  tra("0,1,0,0,0,0,0,1,","2c")
  tra("1,0,0,0,0,0,1,0,","2e")
  tra("1,0,0,1,0,0,0,0,","2k")
  tra("1,0,0,0,0,0,0,1,","2a")
  tra("1,0,0,0,1,0,0,0,","2i")
  tra("0,0,0,1,0,0,0,1,","2n")
  tra("0,1,0,1,0,0,0,1,","3c")
  tra("1,0,1,0,0,0,1,0,","3e")
  tra("1,0,0,1,0,0,1,0,","3k")
  tra("1,0,0,0,0,0,1,1,","3a")
  tra("0,0,0,0,0,1,1,1,","3i")
  tra("0,1,0,0,0,0,1,1,","3n")
  tra("0,1,0,0,1,0,0,1,","3y")
  tra("0,0,0,1,0,0,1,1,","3q")
  tra("0,1,1,0,1,0,0,0,","3j")
  tra("1,1,0,0,1,0,0,0,","3r")
  tra("0,1,0,1,0,1,0,1,","4c")
  tra("1,0,1,0,1,0,1,0,","4e")
  tra("1,1,0,1,0,0,1,0,","4k")
  tra("0,0,0,0,1,1,1,1,","4a")
  tra("0,1,1,0,0,0,1,1,","4i")
  tra("0,0,0,1,0,1,1,1,","4n")
  tra("0,1,0,0,1,1,0,1,","4y")
  tra("1,0,0,1,0,0,1,1,","4q")
  tra("0,1,1,0,1,0,1,0,","4j")
  tra("1,1,1,0,1,0,0,0,","4r")
  tra("1,1,0,0,1,0,0,1,","4t")
  tra("0,0,0,1,1,0,1,1,","4w")
  tra("1,0,0,1,1,0,0,1,","4z")
  tra("1,0,1,0,1,1,1,0,","5c")
  tra("0,1,0,1,1,1,0,1,","5e")
  tra("0,1,1,0,1,1,0,1,","5k")
  tra("0,1,1,1,1,1,0,0,","5a")
  tra("1,1,1,1,1,0,0,0,","5i")
  tra("1,0,1,1,1,1,0,0,","5n")
  tra("1,0,1,1,0,1,1,0,","5y")
  tra("1,1,1,0,1,1,0,0,","5q")
  tra("1,0,0,1,0,1,1,1,","5j")
  tra("0,0,1,1,0,1,1,1,","5r")
  tra("1,0,1,1,1,1,1,0,","6c")
  tra("0,1,1,1,1,1,0,1","6e")
  tra("0,1,1,0,1,1,1,1,","6k")
  tra("0,1,1,1,1,1,1,0,","6a")
  tra("0,1,1,1,0,1,1,1,","6i")
  tra("1,1,1,0,1,1,1,0,","6n")
  tra("1,1,1,1,1,1,1,0,","7c")
  tra("0,1,1,1,1,1,1,1,","7e")
  tra("1,1,1,1,1,1,1,1,","8")

edit: better script

Code: Select all

def tra(re,va,tr):
  if tr in tran[va]:
    print("?,",re,"1")
print("use rotate4reflect symmetry")
print("use all the numbers, put transitions on the ones you want")
print("0 is 0x and 8 is 8x if you want to use them")
print("put commas inbetween numbers")
while True:
    tran = input("transitions (i.e. 0,1e,2e,3ka,4,5,6,7,8):")
    tran = tran.replace("0","")
    tran = tran.replace("1","")
    tran = tran.replace("2","")
    tran = tran.replace("3","")
    tran = tran.replace("4","")
    tran = tran.replace("5","")
    tran = tran.replace("6","")
    tran = tran.replace("7","")
    tran = tran.replace("8","")
    tran = tran.split(",")
    print(tran)
    tra("0,0,0,0,0,0,0,0,",0,"x")
    tra("0,0,0,0,0,0,0,1,",1,"c")
    tra("1,0,0,0,0,0,0,0,",1,"e")
    tra("0,1,0,0,0,0,0,1,",2,"c")
    tra("1,0,0,0,0,0,1,0,",2,"e")
    tra("1,0,0,1,0,0,0,0,",2,"k")
    tra("1,0,0,0,0,0,0,1,",2,"a")
    tra("1,0,0,0,1,0,0,0,",2,"i")
    tra("0,0,0,1,0,0,0,1,",2,"n")
    tra("0,1,0,1,0,0,0,1,",3,"c")
    tra("1,0,1,0,0,0,1,0,",3,"e")
    tra("1,0,0,1,0,0,1,0,",3,"k")
    tra("1,0,0,0,0,0,1,1,",3,"a")
    tra("0,0,0,0,0,1,1,1,",3,"i")
    tra("0,1,0,0,0,0,1,1,",3,"n")
    tra("0,1,0,0,1,0,0,1,",3,"y")
    tra("0,0,0,1,0,0,1,1,",3,"q")
    tra("0,1,1,0,1,0,0,0,",3,"j")
    tra("1,1,0,0,1,0,0,0,",3,"r")
    tra("0,1,0,1,0,1,0,1,",4,"c")
    tra("1,0,1,0,1,0,1,0,",4,"e")
    tra("1,1,0,1,0,0,1,0,",4,"k")
    tra("0,0,0,0,1,1,1,1,",4,"a")
    tra("0,1,1,0,0,0,1,1,",4,"i")
    tra("0,0,0,1,0,1,1,1,",4,"n")
    tra("0,1,0,0,1,1,0,1,",4,"y")
    tra("1,0,0,1,0,0,1,1,",4,"q")
    tra("0,1,1,0,1,0,1,0,",4,"j")
    tra("1,1,1,0,1,0,0,0,",4,"r")
    tra("1,1,0,0,1,0,0,1,",4,"t")
    tra("0,0,0,1,1,0,1,1,",4,"w")
    tra("1,0,0,1,1,0,0,1,",4,"z")
    tra("1,0,1,0,1,1,1,0,",5,"c")
    tra("0,1,0,1,1,1,0,1,",5,"e")
    tra("0,1,1,0,1,1,0,1,",5,"k")
    tra("0,1,1,1,1,1,0,0,",5,"a")
    tra("1,1,1,1,1,0,0,0,",5,"i")
    tra("1,0,1,1,1,1,0,0,",5,"n")
    tra("1,0,1,1,0,1,1,0,",5,"y")
    tra("1,1,1,0,1,1,0,0,",5,"q")
    tra("1,0,0,1,0,1,1,1,",5,"j")
    tra("0,0,1,1,0,1,1,1,",5,"r")
    tra("1,0,1,1,1,1,1,0,",6,"c")
    tra("0,1,1,1,1,1,0,1,",6,"e")
    tra("0,1,1,0,1,1,1,1,",6,"k")
    tra("0,1,1,1,1,1,1,0,",6,"a")
    tra("0,1,1,1,0,1,1,1,",6,"i")
    tra("1,1,1,0,1,1,1,0,",6,"n")
    tra("1,1,1,1,1,1,1,0,",7,"c")
    tra("0,1,1,1,1,1,1,1,",7,"e")
    tra("1,1,1,1,1,1,1,1,",8,"x")

[CasperWen8805181]

Life, but the neighborhood is:
o o o o o o x o o
o o o x o o o o o
x o o o o o o o o
o o o o o o o x o
o o o o c o o o o
o x o o o o o o o
o o o o o o o o x
o o o o o x o o o
o o x o o o o o o
(x is neighbor, o is non neighbor (doesn't affect behaviour), and C is the cell that is affected.)

Code: Select all

x = 9, y = 9, rule = B3/S23
6bo$3bo$o$7bo$4bo$bo$8bo$5bo$2bo!

[tommyaweosme]

Life, but the neighborhood is:
o o o o o o x o o
o o o x o o o o o
x o o o o o o o o
o o o o o o o x o
o o o o c o o o o
o x o o o o o o o
o o o o o o o o x
o o o o o x o o o
o o x o o o o o o
(x is neighbor, o is non neighbor (doesn't affect behaviour), and C is the cell that is affected.)

Code: Select all

x = 9, y = 9, rule = B3/S23
6bo$3bo$o$7bo$4bo$bo$8bo$5bo$2bo!

R4,C2,S2-3,B3,NW000000100000100000100000000000000010000000000010000000000000001000010000001000000

Code: Select all

x=0,y=0,rule=R4,C2,S2-3,B3,NW000000100000100000100000000000000010000000000010000000000000001000010000001000000
!
[[ RANDOMIZE ]]

[CasperWen8805181]

Life, but the neighborhood is:
o o o o o o x o o
o o o x o o o o o
x o o o o o o o o
o o o o o o o x o
o o o o c o o o o
o x o o o o o o o
o o o o o o o o x
o o o o o x o o o
o o x o o o o o o
(x is neighbor, o is non neighbor (doesn't affect behaviour), and C is the cell that is affected.)

Code: Select all

x = 9, y = 9, rule = B3/S23
6bo$3bo$o$7bo$4bo$bo$8bo$5bo$2bo!

R4,C2,S2-3,B3,NW000000100000100000100000000000000010000000000010000000000000001000010000001000000

Code: Select all

x=0,y=0,rule=R4,C2,S2-3,B3,NW000000100000100000100000000000000010000000000010000000000000001000010000001000000
!
[[ RANDOMIZE ]]

Why does everything fall down? Also how do you make these things?
Glider evolution fail:

Code: Select all

x = 8, y = 7, rule = R4,C2,S2-3,B3,NW000000100000100000100000000000000010000000000010000000000000001000010000001000000
o$7bo2$bo2$5bo$2bo!

[LaundryPizza03]

Life, but the neighborhood is:
o o o o o o x o o
o o o x o o o o o
x o o o o o o o o
o o o o o o o x o
o o o o c o o o o
o x o o o o o o o
o o o o o o o o x
o o o o o x o o o
o o x o o o o o o
(x is neighbor, o is non neighbor (doesn't affect behaviour), and C is the cell that is affected.)

Code: Select all

x = 9, y = 9, rule = B3/S23
6bo$3bo$o$7bo$4bo$bo$8bo$5bo$2bo!

R4,C2,S2-3,B3,NW000000100000100000100000000000000010000000000010000000000000001000010000001000000

Code: Select all

x=0,y=0,rule=R4,C2,S2-3,B3,NW000000100000100000100000000000000010000000000010000000000000001000010000001000000
!
[[ RANDOMIZE ]]

Why does everything fall down? Also how do you make these things?
Glider evolution fail:

Code: Select all

x = 8, y = 7, rule = R4,C2,S2-3,B3,NW000000100000100000100000000000000010000000000010000000000000001000010000001000000
o$7bo2$bo2$5bo$2bo!

The neighborhhod seems to be misaligned.

Code: Select all

x = 1, y = 1, rule = R4,C2,S,B1,NW000000100000100000100000000000000010000000000010000000000000001000010000001000000
o!

Corrections:

Code: Select all

x = 1, y = 1, rule = R4,C2,S,B1,NW000000100000100000100000000000000010000000000010000000000000001000001000001000000
o!

Code: Select all

x=0,y=0,rule = R4,C2,S2-3,B3,NW000000100000100000100000000000000010000000000010000000000000001000001000001000000
!
[[ RANDOMIZE ]]

This is just ten (=3^2+1^2) non-interacting Life universes.

[confocaloid]

[...]
Why does everything fall down? Also how do you make these things?
Glider evolution fail: [...]

Code: Select all

x = 8, y = 8, rule = R4,C0,S2-3,B3,NW000000100000100000100000000000000010000000000010000000000000001000001000001000000
2bo4$o$7bo$4bo$bo!

Alternatively, when all weights are either 0 or 1 (as in this case), you can use custom neighbourhood (N@) instead of weighted neighbourhood (NW). That can be done using the script "Scripts/Lua/create-custom-ltl.lua":

Code: Select all

x = 8, y = 8, rule = R4,C0,S2-3,B3,N@02082000200400041040
2bo4$o$7bo$4bo$bo!

[hotcrystal0]

This rule doesn't work yet. Can someone help fix it? It's intended to be pifricted's rule Cellmath with StateInvestigator States 2-5 added (as states 6-9 in this rule). State 9 is the only new state that seems to work fine.

Code: Select all

x = 40, y = 34, rule = ExtendedCM
23.2A$22.3A$22.2A.A$23.3A$24.A2$4.A$5.2A$4.2A3$16.2A$2.A$2.A6.G6.H7.I
$F.A19$39.A!

@RULE ExtendedCM
@TABLE
n_states:10
neighborhood:Moore
symmetries:permute
var a={0,1}
var a1 = {0,1,2,3,4,5,6,7,8,9}
var a2 = a1
var a3 = a1
var a4 = a1
var a5 = a1
var a6 = a1
var a7 = a1
var a8 = a1
var b={a,2,3,4,5,6,7,8,9}
var c=b
var d=b
var e1 = {1,6,8}
var e2 = e1
var e3 = e1
var e4 = e1
var e5 = e1
var f=b
var g=b
var h=b
var i=b
var j=b
var k = {2,3,4,5,6,7,8,9}
var l1 = {0,7,9}
var l2 = l1
var l3 = l1
var l4 = l1
var l5 = l1
var l6 = l1
var l7 = l1
var m1 = {6,7}
a,e1,e2,e3,l1,l2,l3,l4,l5,1
a,2,e1,l1,l2,l3,l4,l5,l6,1
a,3,l1,l2,l3,l4,l5,l6,l7,1
a,e1,3,4,l1,l2,l3,l4,l5,1
a,2,2,4,l1,l2,l3,l4,l5,1
a,e1,e2,2,4,l1,l2,l3,l4,1
a,e1,e2,e3,e4,4,l1,l2,l3,1
a,2,3,4,4,l1,l2,l3,l4,1
a,e1,2,2,4,4,l1,l2,l3,1
a,e1,e2,3,4,4,l1,l2,l3,1
a,e1,e2,e3,2,4,4,l1,l2,1
a,e1,e2,e3,e4,e5,4,4,l1,1
a,2,3,5,l1,l2,l3,l4,l5,1
a,e1,2,2,5,l1,l2,l3,l4,1
a,e1,e2,3,5,l1,l2,l3,l4,1
a,e1,e2,e3,2,5,l1,l2,l3,1
a,e1,e2,e3,e4,e5,5,l1,l2,1
1,2,l1,l2,l3,l4,l5,l6,l7,1
1,1,1,l1,l2,l3,l4,l5,l6,1
1,3,4,l1,l2,l3,l4,l5,l6,1
1,1,2,4,l1,l2,l3,l4,l5,1
1,1,1,1,4,l1,l2,l3,l4,1
1,2,2,5,l1,l2,l3,l4,l5,1
1,1,3,5,l1,l2,l3,l4,l5,1
1,1,1,2,5,l1,l2,l3,l4,1
1,1,1,1,1,5,l1,l2,l3,1
1,8,8,l1,l2,l3,l4,l5,l6,1
1,m1,l1,l7,l2,l3,l4,l5,l6,0
1,b,c,d,f,g,h,i,j,0
1,m1,l1,l2,l3,l4,l5,l6,l7,0
k,a1,a2,a3,a4,a5,a6,a7,a8,k
@COLORS
0 0 0 0
1 0 255 0
2 255 200 128
3 255 150 128
4 255 100 96
5 255 0 0
6 0 192 254
7 192 0 0
8 254 254 254
9 75 75 75

[confocaloid]

Make a four-state CA where every alive cell remembers whether or not it was alive in the preceding generation. All newborn cells are kids, and all alive non-kids are cells surviving from the previous generation. However, sometimes it should be possible for a surviving cell to remain a kid, even when it's no longer newborn. The exact condition or conditions for that to happen and other rules are TBD, but remaining a kid should be an uncommon transition.

Details:

• Cellstates: 0 = off, 1 = newborn, 2 = alive non-kid, 3 = a cell that survived and remained a kid.
• The ruleset should allow for interesting stuff to happen.
• Allowed transitions: 0 -> 0 (an off cell stays off), 0 -> 1 (a new cell is born), 1 -> 0 (a newborn cell goes off), 1 -> 2 (a newborn cell survives into a non-kid), 1 -> 3 (a newborn cell survives and remains a kid), 2 -> 0 (an alive cell goes off), 2 -> 2 (an alive non-kid survives), 3 -> 0 (an alive cell goes off), 3 -> 2 (a surviving kid survives again but doesn't remain a kid this time), 3 -> 3 (a surviving kid again survives and remains a kid)
• Forbidden transitions: 0 -> 2 (an off cell cannot immediately survive), 0 -> 3 (an off cell cannot immediately survive), 1 -> 1 (a newborn cell cannot stay newborn), 2 -> 1 (an alive cell cannot immediately become newborn), 3 -> 1 (an alive cell cannot immediately become newborn)
• 1 -> 2 should be a significantly more common transition, compared to 1 -> 3 (it's unusual for a surviving cell to remain a kid)
• 3 -> 2 should be a significantly more common transition, compared to 3 -> 3 (it's unusual for a cell that survived and remained a kid to manage to manage that again)
• Open question: should it be possible for an alive non-kid to become a kid again one tick later? (Is the transition 2 -> 3 allowed?)

Tabulated transitions (+ allowed, x forbidden, ? open question, row = current state, column = next state):

Code: Select all

\ | 0 | 1 | 2 | 3 |
--+---+---+---+---+
0 | + | + | x | x |
1 | + | x | + | + |
2 | + | x | + | ? |
3 | + | x | + | + |
--+---+---+---+---+

[H. H. P. M. P. Cole]

Make a four-state CA where every alive cell remembers whether or not it was alive in the preceding generation.[...]

Is this kind of CA what you intended? This CA is a modification of Holstein (B35678/S4678).

A state-1 cell with eight 'alive' (i.e. states 1, 2, 3) neighbours turns into state-3, and a state-3 cell with eight 'alive' (i.e. states 1, 2, 3) neighbours remains state-3.

Code: Select all

x = 64, y = 64, rule = HolsteinC
!
[[
RANDOMIZE
]]
@RULE HolsteinC
@TABLE
n_states: 4
neighborhood: Moore
symmetries: permute
var a = {0,1,2,3}
var a1 = a
var a2 = a
var a3 = a
var a4 = a
var a5 = a
var a6 = a
var a7 = a
var a8 = a
var b = {1,2,3}
var b1 = b
var b2 = b
var b3 = b
var b4 = b
var b5 = b
var b6 = b
var b7 = b
var b8 = b
0, b1,b2,b3,0,0,0,0,0, 1
0, b1,b2,b3,b4,b5,0,0,0, 1
0, b1,b2,b3,b4,b5,b6,0,0, 1
0, b1,b2,b3,b4,b5,b6,b7,0, 1
0, b1,b2,b3,b4,b5,b6,b7,b8, 1
1, b1,b2,b3,b4,0,0,0,0, 2
1, b1,b2,b3,b4,b5,b6,0,0, 2
1, b1,b2,b3,b4,b5,b6,b7,0, 2
1, b1,b2,b3,b4,b5,b6,b7,b8, 3
2, b1,b2,b3,b4,0,0,0,0, 2
2, b1,b2,b3,b4,b5,b6,0,0, 2
2, b1,b2,b3,b4,b5,b6,b7,0, 2
2, b1,b2,b3,b4,b5,b6,b7,b8, 2
3, b1,b2,b3,b4,0,0,0,0, 2
3, b1,b2,b3,b4,b5,b6,0,0, 2
3, b1,b2,b3,b4,b5,b6,b7,0, 2
3, b1,b2,b3,b4,b5,b6,b7,b8, 3
a, a1,a2,a3,a4,a5,a6,a7,a8, 0
@COLORS
0 0 0 0
1 0 0 255
2 0 255 255
3 255 255 255

Open question: should it be possible for an alive non-kid to become a kid again one tick later? (Is the transition 2 -> 3 allowed?)

I don't think so.

[tommyaweosme]

Open question: should it be possible for an alive non-kid to become a kid again one tick later? (Is the transition 2 -> 3 allowed?)

I don't think so.

ok. but i think that 2>3 should be allowed.
we should make a new rulespace like this called 23 kids where 2>3 is allowed.
it is a superset of the normal one

[Banananananan]

Life but if it has 5 neighbors it spawns a "birth forcer cell". This cell spawns 4 Life cells orthogonal adjacent it. Like a tub. If any cell in the range dies, it goes alive again. If 2 birth forcers are arranged in an obo! spark,both cells turn dead.

[confocaloid]

[...] If 2 birth forcers are arranged in an obo! spark,both cells turn dead.

I think that cannot be (directly) implemented in a cellular automaton using the range-1 Moore neighbourhood. If at some generation two "birth forcer" cells are arranged like this,

Code: Select all

x = 3, y = 1, rule = B3/S23
obo!

it is impossible to use that as a condition for both cells to turn dead in the next generation, because the two cells do not belong to each other's neighbourhood.

[Banananananan]

[...] If 2 birth forcers are arranged in an obo! spark,both cells turn dead.

I think that cannot be (directly) implemented in a cellular automaton using the range-1 Moore neighbourhood. If at some generation two "birth forcer" cells are arranged like this,

Code: Select all

x = 3, y = 1, rule = B3/S23
obo!

it is impossible to use that as a condition for both cells to turn dead in the next generation, because the two cells do not belong to each other's neighbourhood.

Ok instead how about a domino

[confocaloid]

Life but if it has 5 neighbors it spawns a "birth forcer cell". This cell spawns 4 Life cells orthogonal adjacent it. Like a tub. If any cell in the range dies, it goes alive again. If 2 birth forcers are arranged in an obo! spark,both cells turn dead.

[...]
Ok instead how about a domino

Seems to remain ambiguous:
Should state-2 cells be counted as "alive" or "dead", when counting alive neighbours to determine whether a Life cell is born / survives?
When the cell is currently dead and has exactly 5 alive neighbours and at least one birthforcer neighbour, should the rule "a birthforcer cell spawns adjacent cells" win over the rule "if it has 5 neighbours it spawns a birthforcer cell", or the other way round?
I don't think it's possible to require *only" domino-shaped "islands" to turn dead, but it's possible to add a rule that says "if the cell is currently state-2 and has exactly one state-2 neighbour which is orthogonally adjacent, then the cell becomes state-0 in the next generation". Then all domino-shaped state-2 "islands" will turn dead.

Anyway here is a possible interpretation, may or may not work as intended:

Code: Select all

x = 3, y = 3, rule = example
.2A$2A$.A!

@RULE example

@TABLE
n_states:3
neighborhood:Moore
symmetries:rotate4reflect

var x={0,1,2}
var x1=x
var x2=x
var x3=x
var x4=x
var x5=x
var x6=x
var x7=x
var x8=x
var d1={0,2}
var d2=d1
var d3=d1
var d4=d1
var d5=d1
var d6=d1
var c1={0,1}
var c2=c1
var c3=c1
var c4=c1
var c5=c1
var c6=c1
var c7=c1

# rule: if the cell is currently state-2
# and has exactly one state-2 neighbour,
# which is orthogonally adjacent,
# then the cell becomes state-0 in the next generation
2, 2,c1,c2,c3,c4,c5,c6,c7, 0

# rule: in all cases not covered by preceding rules,
# a state-2 cell remains state-2 in the next generation
2, x1,x2,x3,x4,x5,x6,x7,x8, 2

# rule: if a state-0 cell currently has at least one orthogonally adjacent state-2 neighbour,
# then the cell becomes state-1 in the next generation
0, 2,x2,x3,x4,x5,x6,x7,x8, 1

# rule: if a state-0 cell currently has exactly 5 state-1 neighbours,
# then the cell becomes state-2 in the next generation
0, d1,d2,d3,1,1,1,1,1, 2  # B5a
0, d1,d2,1,d3,1,1,1,1, 2  # B5n
0, d1,d2,1,1,d3,1,1,1, 2  # B5r
0, d1,d2,1,1,1,d3,1,1, 2  # B5q
0, d1,d2,1,1,1,1,d3,1, 2  # B5j
0, d1,d2,1,1,1,1,1,d3, 2  # B5i
0, d1,1,d2,1,d3,1,1,1, 2  # B5e
0, 1,d1,1,d2,1,d3,1,1, 2  # B5c
0, d1,1,1,d2,1,1,d3,1, 2  # B5k
0, 1,d1,1,1,d2,1,1,d3, 2  # B5y

# rule: if a state-0 cell currently has exactly 3 state-1 neighbours,
# then the cell becomes state-1 in the next generation
0, 1,1,1,d1,d2,d3,d4,d5, 1  # B3a
0, 1,1,d1,1,d2,d3,d4,d5, 1  # B3n
0, 1,1,d1,d2,1,d3,d4,d5, 1  # B3r
0, 1,1,d1,d2,d3,1,d4,d5, 1  # B3q
0, 1,1,d1,d2,d3,d4,1,d5, 1  # B3j
0, 1,1,d1,d2,d3,d4,d5,1, 1  # B3i
0, 1,d1,1,d2,1,d3,d4,d5, 1  # B3e
0, d1,1,d2,1,d3,1,d4,d5, 1  # B3c
0, 1,d1,d2,1,d3,d4,1,d5, 1  # B3k
0, d1,1,d2,d3,1,d4,d5,1, 1  # B3y

# rule: if a state-1 cell currently has exactly 2 state-1 neighbours,
# then the cell remains state-1 in the next generation
1, d1,1,d2,1,d3,d4,d5,d6, 1  # S2c
1, 1,d1,1,d2,d3,d4,d5,d6, 1  # S2e
1, 1,d1,d2,1,d3,d4,d5,d6, 1  # S2k
1, 1,1,d1,d2,d3,d4,d5,d6, 1  # S2a
1, 1,d1,d2,d3,1,d4,d5,d6, 1  # S2i
1, d1,1,d2,d3,d4,1,d5,d6, 1  # S2n

# rule: if a state-1 cell currently has exactly 3 state-1 neighbours,
# then the cell remains state-1 in the next generation
1, 1,1,1,d1,d2,d3,d4,d5, 1  # S3a
1, 1,1,d1,1,d2,d3,d4,d5, 1  # S3n
1, 1,1,d1,d2,1,d3,d4,d5, 1  # S3r
1, 1,1,d1,d2,d3,1,d4,d5, 1  # S3q
1, 1,1,d1,d2,d3,d4,1,d5, 1  # S3j
1, 1,1,d1,d2,d3,d4,d5,1, 1  # S3i
1, 1,d1,1,d2,1,d3,d4,d5, 1  # S3e
1, d1,1,d2,1,d3,1,d4,d5, 1  # S3c
1, 1,d1,d2,1,d3,d4,1,d5, 1  # S3k
1, d1,1,d2,d3,1,d4,d5,1, 1  # S3y

# rule: everything else goes to zero or remains zero
x, x1,x2,x3,x4,x5,x6,x7,x8, 0

[Banananananan]

Life but if it has 5 neighbors it spawns a "birth forcer cell". This cell spawns 4 Life cells orthogonal adjacent it. Like a tub. If any cell in the range dies, it goes alive again. If 2 birth forcers are arranged in an obo! spark,both cells turn dead.

[...]
Ok instead how about a domino

Seems to remain ambiguous:
Should state-2 cells be counted as "alive" or "dead", when counting alive neighbours to determine whether a Life cell is born / survives?
When the cell is currently dead and has exactly 5 alive neighbours and at least one birthforcer neighbour, should the rule "a birthforcer cell spawns adjacent cells" win over the rule "if it has 5 neighbours it spawns a birthforcer cell", or the other way round?
I don't think it's possible to require *only" domino-shaped "islands" to turn dead, but it's possible to add a rule that says "if the cell is currently state-2 and has exactly one state-2 neighbour which is orthogonally adjacent, then the cell becomes state-0 in the next generation". Then all domino-shaped state-2 "islands" will turn dead.

Anyway here is a possible interpretation, may or may not work as intended:

Code: Select all

x = 3, y = 3, rule = example
.2A$2A$.A!

@RULE example

@TABLE
n_states:3
neighborhood:Moore
symmetries:rotate4reflect

var x={0,1,2}
var x1=x
var x2=x
var x3=x
var x4=x
var x5=x
var x6=x
var x7=x
var x8=x
var d1={0,2}
var d2=d1
var d3=d1
var d4=d1
var d5=d1
var d6=d1
var c1={0,1}
var c2=c1
var c3=c1
var c4=c1
var c5=c1
var c6=c1
var c7=c1

# rule: if the cell is currently state-2
# and has exactly one state-2 neighbour,
# which is orthogonally adjacent,
# then the cell becomes state-0 in the next generation
2, 2,c1,c2,c3,c4,c5,c6,c7, 0

# rule: in all cases not covered by preceding rules,
# a state-2 cell remains state-2 in the next generation
2, x1,x2,x3,x4,x5,x6,x7,x8, 2

# rule: if a state-0 cell currently has at least one orthogonally adjacent state-2 neighbour,
# then the cell becomes state-1 in the next generation
0, 2,x2,x3,x4,x5,x6,x7,x8, 1

# rule: if a state-0 cell currently has exactly 5 state-1 neighbours,
# then the cell becomes state-2 in the next generation
0, d1,d2,d3,1,1,1,1,1, 2  # B5a
0, d1,d2,1,d3,1,1,1,1, 2  # B5n
0, d1,d2,1,1,d3,1,1,1, 2  # B5r
0, d1,d2,1,1,1,d3,1,1, 2  # B5q
0, d1,d2,1,1,1,1,d3,1, 2  # B5j
0, d1,d2,1,1,1,1,1,d3, 2  # B5i
0, d1,1,d2,1,d3,1,1,1, 2  # B5e
0, 1,d1,1,d2,1,d3,1,1, 2  # B5c
0, d1,1,1,d2,1,1,d3,1, 2  # B5k
0, 1,d1,1,1,d2,1,1,d3, 2  # B5y

# rule: if a state-0 cell currently has exactly 3 state-1 neighbours,
# then the cell becomes state-1 in the next generation
0, 1,1,1,d1,d2,d3,d4,d5, 1  # B3a
0, 1,1,d1,1,d2,d3,d4,d5, 1  # B3n
0, 1,1,d1,d2,1,d3,d4,d5, 1  # B3r
0, 1,1,d1,d2,d3,1,d4,d5, 1  # B3q
0, 1,1,d1,d2,d3,d4,1,d5, 1  # B3j
0, 1,1,d1,d2,d3,d4,d5,1, 1  # B3i
0, 1,d1,1,d2,1,d3,d4,d5, 1  # B3e
0, d1,1,d2,1,d3,1,d4,d5, 1  # B3c
0, 1,d1,d2,1,d3,d4,1,d5, 1  # B3k
0, d1,1,d2,d3,1,d4,d5,1, 1  # B3y

# rule: if a state-1 cell currently has exactly 2 state-1 neighbours,
# then the cell remains state-1 in the next generation
1, d1,1,d2,1,d3,d4,d5,d6, 1  # S2c
1, 1,d1,1,d2,d3,d4,d5,d6, 1  # S2e
1, 1,d1,d2,1,d3,d4,d5,d6, 1  # S2k
1, 1,1,d1,d2,d3,d4,d5,d6, 1  # S2a
1, 1,d1,d2,d3,1,d4,d5,d6, 1  # S2i
1, d1,1,d2,d3,d4,1,d5,d6, 1  # S2n

# rule: if a state-1 cell currently has exactly 3 state-1 neighbours,
# then the cell remains state-1 in the next generation
1, 1,1,1,d1,d2,d3,d4,d5, 1  # S3a
1, 1,1,d1,1,d2,d3,d4,d5, 1  # S3n
1, 1,1,d1,d2,1,d3,d4,d5, 1  # S3r
1, 1,1,d1,d2,d3,1,d4,d5, 1  # S3q
1, 1,1,d1,d2,d3,d4,1,d5, 1  # S3j
1, 1,1,d1,d2,d3,d4,d5,1, 1  # S3i
1, 1,d1,1,d2,1,d3,d4,d5, 1  # S3e
1, d1,1,d2,1,d3,1,d4,d5, 1  # S3c
1, 1,d1,d2,1,d3,d4,1,d5, 1  # S3k
1, d1,1,d2,d3,1,d4,d5,1, 1  # S3y

# rule: everything else goes to zero or remains zero
x, x1,x2,x3,x4,x5,x6,x7,x8, 0

Hmmm, how about change the birthforcer birth to be 6 cells? So a ship would spawn one.

[tommyaweosme]

thats what i thought too, but for a different reason:
glider

[confocaloid]

[...]
Anyway here is a possible interpretation, may or may not work as intended:
[...]

Hmmm, how about change the birthforcer birth to be 6 cells? So a ship would spawn one.

No other changes compared to the previous ruletable, you can try modifying it further to see what works:

Code: Select all

x = 3, y = 3, rule = example
.2A$2A$.A!

@RULE example

@TABLE
n_states:3
neighborhood:Moore
symmetries:rotate4reflect

var x={0,1,2}
var x1=x
var x2=x
var x3=x
var x4=x
var x5=x
var x6=x
var x7=x
var x8=x
var d1={0,2}
var d2=d1
var d3=d1
var d4=d1
var d5=d1
var d6=d1
var c1={0,1}
var c2=c1
var c3=c1
var c4=c1
var c5=c1
var c6=c1
var c7=c1

2, 2,c1,c2,c3,c4,c5,c6,c7, 0
2, x1,x2,x3,x4,x5,x6,x7,x8, 2

0, 2,x2,x3,x4,x5,x6,x7,x8, 1

0, 1,d1,1,d2,1,1,1,1, 2  # B6c
0, d1,1,d2,1,1,1,1,1, 2  # B6e
0, d1,1,1,d2,1,1,1,1, 2  # B6k
0, d1,d2,1,1,1,1,1,1, 2  # B6a
0, d1,1,1,1,d2,1,1,1, 2  # B6i
0, 1,d1,1,1,1,d2,1,1, 2  # B6n

0, 1,1,1,d1,d2,d3,d4,d5, 1  # B3a
0, 1,1,d1,1,d2,d3,d4,d5, 1  # B3n
0, 1,1,d1,d2,1,d3,d4,d5, 1  # B3r
0, 1,1,d1,d2,d3,1,d4,d5, 1  # B3q
0, 1,1,d1,d2,d3,d4,1,d5, 1  # B3j
0, 1,1,d1,d2,d3,d4,d5,1, 1  # B3i
0, 1,d1,1,d2,1,d3,d4,d5, 1  # B3e
0, d1,1,d2,1,d3,1,d4,d5, 1  # B3c
0, 1,d1,d2,1,d3,d4,1,d5, 1  # B3k
0, d1,1,d2,d3,1,d4,d5,1, 1  # B3y

1, d1,1,d2,1,d3,d4,d5,d6, 1  # S2c
1, 1,d1,1,d2,d3,d4,d5,d6, 1  # S2e
1, 1,d1,d2,1,d3,d4,d5,d6, 1  # S2k
1, 1,1,d1,d2,d3,d4,d5,d6, 1  # S2a
1, 1,d1,d2,d3,1,d4,d5,d6, 1  # S2i
1, d1,1,d2,d3,d4,1,d5,d6, 1  # S2n

1, 1,1,1,d1,d2,d3,d4,d5, 1  # S3a
1, 1,1,d1,1,d2,d3,d4,d5, 1  # S3n
1, 1,1,d1,d2,1,d3,d4,d5, 1  # S3r
1, 1,1,d1,d2,d3,1,d4,d5, 1  # S3q
1, 1,1,d1,d2,d3,d4,1,d5, 1  # S3j
1, 1,1,d1,d2,d3,d4,d5,1, 1  # S3i
1, 1,d1,1,d2,1,d3,d4,d5, 1  # S3e
1, d1,1,d2,1,d3,1,d4,d5, 1  # S3c
1, 1,d1,d2,1,d3,d4,1,d5, 1  # S3k
1, d1,1,d2,d3,1,d4,d5,1, 1  # S3y

x, x1,x2,x3,x4,x5,x6,x7,x8, 0

[ababa11e]

Ternary Wireworld, its just Wireworld where there's 3 different types of Signal, red, green, and blue. If two of the same signal collide, they stay the same color, if red and green collide, it makes blue, if blue and red collide, it makes green. if blue and green collide, it makes red and vice versa. These signals will be interpreted as ternary, red OR no input at all being 0, green being 1, and blue being 2, for any machines and ternary 'logic gates'.
[EDIT 1: WOOPS forgot to specify the ADD part is for a functional ternary full adder, the other part is what happens when 2 signals collide]
Example:

Code: Select all

x = 168, y = 70, rule = B3/S012345678Super
38.3F.2F2.2F$38.F.F.F.F.F.F$38.3F.F.F.F.F$38.F.F.2F2.2F2$3.F4.3F38.D13.
D13.D16.D13.D13.D16.D13.D13.D$D.3F.D5.D10.3F$3.F4.3F9.D2.F.F12.D2.F2.
D.2F.D2.D2.F2.D.2F.D2.D2.F2.D.2F.D5.D2.F2.A.2F.A2.D2.F2.A.2F.A2.D2.F2.
A.2F.A5.D2.F2.B.2F.B2.D2.F2.B.2F.B2.D2.F2.B.2F.B$23.3F14.3F11.3F11.3F
14.3F11.3F11.3F14.3F11.3F11.3F$3.F4.3F27.D2.F2.D.2F.D2.A2.F2.D.2F.A2.
B2.F2.D.2F.B5.D2.F2.D.2F.D2.A2.F2.D.2F.A2.B2.F2.D.2F.B5.D2.F2.D.2F.D2.
A2.F2.D.2F.A2.B2.F2.D.2F.B$D.3F.A5.B11.F$3.F4.3F9.A3.F$24.F24.D13.D13.
D16.D13.D13.D16.D13.D13.A$3.F4.3F$D.3F.B5.A10.2F13.D2.F2.D.2F.D2.D2.F
2.D.2F.D2.D2.F2.D.2F.A5.D2.F2.A.2F.A2.D2.F2.A.2F.A2.D2.F2.A.2F.B5.D2.
F2.B.2F.B2.D2.F2.B.2F.B2.D2.F2.B.2F.D$3.F4.3F13.F15.3F11.3F11.3F14.3F
11.3F11.3F14.3F11.3F11.3F$20.B2.F14.D2.F2.A.2F.A2.A2.F2.A.2F.B2.B2.F2.
A.2F.D5.D2.F2.A.2F.A2.A2.F2.A.2F.B2.B2.F2.A.2F.D5.D2.F2.A.2F.A2.A2.F2.
A.2F.B2.B2.F2.A.2F.D$3.F4.3F12.2F$A.3F.D5.B$3.F4.3F38.D13.D13.D16.D13.
D13.D16.D13.A13.A2$3.F4.3F27.D2.F2.D.2F.D2.D2.F2.D.2F.A2.D2.F2.D.2F.A
5.D2.F2.A.2F.A2.D2.F2.A.2F.B2.D2.F2.A.2F.B5.D2.F2.B.2F.B2.D2.F2.B.2F.
D2.D2.F2.B.2F.D$A.3F.A5.A27.3F11.3F11.3F14.3F11.3F11.3F14.3F11.3F11.3F
$3.F4.3F27.D2.F2.B.2F.B2.A2.F2.B.2F.D2.B2.F2.B.2F.A5.D2.F2.B.2F.B2.A2.
F2.B.2F.D2.B2.F2.B.2F.A5.D2.F2.B.2F.B2.A2.F2.B.2F.D2.B2.F2.B.2F.A2$3.
F4.3F$A.3F.B5.D$3.F4.3F$49.D13.D13.D16.D13.D13.D16.A13.A13.A$3.F4.3F$
B.3F.D5.A25.A2.F2.D.2F.A2.A2.F2.D.2F.A2.A2.F2.D.2F.A5.A2.F2.A.2F.B2.A
2.F2.A.2F.B2.A2.F2.A.2F.B5.A2.F2.B.2F.D2.A2.F2.B.2F.D2.A2.F2.B.2F.D$3.
F4.3F29.3F11.3F11.3F14.3F11.3F11.3F14.3F11.3F11.3F$38.D2.F2.D.2F.D2.A
2.F2.D.2F.A2.B2.F2.D.2F.B5.D2.F2.D.2F.D2.A2.F2.D.2F.A2.B2.F2.D.2F.B5.
D2.F2.D.2F.D2.A2.F2.D.2F.A2.B2.F2.D.2F.B$3.F4.3F$B.3F.A5.D$3.F4.3F38.
D13.D13.D16.D13.D13.A16.A13.A13.A2$3.F4.3F27.A2.F2.D.2F.A2.A2.F2.D.2F
.A2.A2.F2.D.2F.B5.A2.F2.A.2F.B2.A2.F2.A.2F.B2.A2.F2.A.2F.D5.A2.F2.B.2F
.D2.A2.F2.B.2F.D2.A2.F2.B.2F.A$B.3F.B5.B27.3F11.3F11.3F14.3F11.3F11.3F
14.3F11.3F11.3F$3.F4.3F27.D2.F2.A.2F.A2.A2.F2.A.2F.B2.B2.F2.A.2F.D5.D
2.F2.A.2F.A2.A2.F2.A.2F.B2.B2.F2.A.2F.D5.D2.F2.A.2F.A2.A2.F2.A.2F.B2.
B2.F2.A.2F.D3$49.D13.D13.D16.D13.A13.A16.A13.A13.A2$38.A2.F2.D.2F.A2.
A2.F2.D.2F.B2.A2.F2.D.2F.B5.A2.F2.A.2F.B2.A2.F2.A.2F.D2.A2.F2.A.2F.D5.
A2.F2.B.2F.D2.A2.F2.B.2F.A2.A2.F2.B.2F.A$40.3F11.3F11.3F14.3F11.3F11.
3F14.3F11.3F11.3F$38.D2.F2.B.2F.B2.A2.F2.B.2F.D2.B2.F2.B.2F.A5.D2.F2.
B.2F.B2.A2.F2.B.2F.D2.B2.F2.B.2F.A5.D2.F2.B.2F.B2.A2.F2.B.2F.D2.B2.F2.
B.2F.A5$49.D13.D13.D16.A13.A13.A16.A13.A13.A2$38.B2.F2.D.2F.B2.B2.F2.
D.2F.B2.B2.F2.D.2F.B5.B2.F2.A.2F.D2.B2.F2.A.2F.D2.B2.F2.A.2F.D5.B2.F2.
B.2F.A2.B2.F2.B.2F.A2.B2.F2.B.2F.A$40.3F11.3F11.3F14.3F11.3F11.3F14.3F
11.3F11.3F$38.D2.F2.D.2F.D2.A2.F2.D.2F.A2.B2.F2.D.2F.B5.D2.F2.D.2F.D2.
A2.F2.D.2F.A2.B2.F2.D.2F.B5.D2.F2.D.2F.D2.A2.F2.D.2F.A2.B2.F2.D.2F.B3$
49.D13.D13.A16.A13.A13.A16.A13.A13.A2$38.B2.F2.D.2F.B2.B2.F2.D.2F.B2.
B2.F2.D.2F.D5.B2.F2.A.2F.D2.B2.F2.A.2F.D2.B2.F2.A.2F.A5.B2.F2.B.2F.A2.
B2.F2.B.2F.A2.B2.F2.B.2F.B$40.3F11.3F11.3F14.3F11.3F11.3F14.3F11.3F11.
3F$38.D2.F2.A.2F.A2.A2.F2.A.2F.B2.B2.F2.A.2F.D5.D2.F2.A.2F.A2.A2.F2.A
.2F.B2.B2.F2.A.2F.D5.D2.F2.A.2F.A2.A2.F2.A.2F.B2.B2.F2.A.2F.D3$49.D13.
A13.A16.A13.A13.A16.A13.A13.A2$38.B2.F2.D.2F.B2.B2.F2.D.2F.D2.B2.F2.D
.2F.D5.B2.F2.A.2F.D2.B2.F2.A.2F.A2.B2.F2.A.2F.A5.B2.F2.B.2F.A2.B2.F2.
B.2F.B2.B2.F2.B.2F.B$40.3F11.3F11.3F14.3F11.3F11.3F14.3F11.3F11.3F$38.
D2.F2.B.2F.B2.A2.F2.B.2F.D2.B2.F2.B.2F.A5.D2.F2.B.2F.B2.A2.F2.B.2F.D2.
B2.F2.B.2F.A5.D2.F2.B.2F.B2.A2.F2.B.2F.D2.B2.F2.B.2F.A!

[b-engine]

Hexagonal Langton's ant with 2 types of ant, one turns 60° and the other turns 120°.

[wirehead]

Ternary Wireworld, its just Wireworld where there's 3 different types of Signal, red, green, and blue. If two of the same signal collide, they stay the same color, if red and green collide, it makes blue, if blue and red collide, it makes green. if blue and green collide, it makes red and vice versa. These signals will be interpreted as ternary, red OR no input at all being 0, green being 1, and blue being 2, for any machines and ternary 'logic gates'.

I don’t think making an adder is possible with the rules listed in the first half of your paragraph, since the rule there is inherently symmetric: when any two different colors collide, they turn into the third color. If you want to make an adder the collision rules will have to be inherently asymmetric. Is that what you intended?

[ababa11e]

Sorry, that is what i mean.