Radius 2 INT rules

CARuler · Post by **CARuler** » December 18th, 2024, 8:15 pm

p28

x = 4, y = 3, rule = BeeLife2
.2A$A2.A$3A!

[[ STEP 2 ]]
@RULE BeeLife2
@COLORS
0 255 255 0 0 255
1 255 255 255
@NAMES
0 dead
1 alive
@TABLE
n_states:13
neighborhood:Moore
symmetries:rotate4reflect
var a={0,1,2,3,4,5,6,7,8,9,10,11,12}
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 b1 = {0,2,3,4,5,6}
var b2 = b1
var b3 = b2
var b4 = b3
var b5 = b4
var b6 = b5
var c1 = {7,8,9,10,11,12}
var c2 = c1
var c3 = c2
var c4 = c3
var c5 = c4
var c6 = c5
# transition setup
0 a1,1,a2,0,a3,0,a4,0 2
0 a1,1,a2,1,a3,0,a4,0 3
0 a1,1,a2,0,a3,1,a4,0 4
0 a1,1,a2,1,a3,1,a4,0 5
0 a1,1,a2,1,a3,1,a4,1 6
1 a1,0,a2,0,a3,0,a4,0 7
1 a1,1,a2,0,a3,0,a4,0 8
1 a1,1,a2,1,a3,0,a4,0 9
1 a1,1,a2,0,a3,1,a4,0 10
1 a1,1,a2,1,a3,1,a4,0 11
1 a1,1,a2,1,a3,1,a4,1 12
# transitions
0,0,4,0,4,0,4,0,4,1
12,12,12,12,12,12,9,9,9,1
3,3,0,8,9,9,9,8,0,1
2,2,0,0,8,0,2,0,0,1
0,2,3,2,4,2,3,2,0,1

# cgol
b1 b2,c1,b3,c2,b4,c3,b5,b6 1
b1 c1,b2,c2,b3,c3,b4,b5,b6 1
b1 c1,b2,c2,b3,b4,c3,b5,b6 1
b1 c1,c2,c3,b2,b3,b4,b5,b6 1
b1 b2,c1,c2,c3,b3,b4,b5,b6 1
b1 c1,c2,b2,c3,b3,b4,b5,b6 1
b1 c1,b2,c2,c3,b3,b4,b5,b6 1
b1 c1,c2,b2,b3,b4,c3,b5,b6 1
b1 c1,c2,b2,b3,c3,b4,b5,b6 1
b1 c1,b2,b3,c2,b4,c3,b5,b6 1
c1 b1,c2,b2,c3,b3,b4,b5,b6 1
c1 c2,b1,c3,b2,b3,b4,b5,b6 1
c1 c2,b1,b2,c3,b3,b4,b5,b6 1
c1 c2,c3,b1,b2,b3,b4,b5,b6 1
c1 c2,b1,b2,b3,c3,b4,b5,b6 1
c1 b1,c2,b2,b3,b4,c3,b5,b6 1
c4 b2,c1,b3,c2,b4,c3,b5,b6 1
c4 c1,b2,c2,b3,c3,b4,b5,b6 1
c4 c1,b2,c2,b3,b4,c3,b5,b6 1
c4 c1,c2,c3,b2,b3,b4,b5,b6 1
c4 b2,c1,c2,c3,b3,b4,b5,b6 1
c4 c1,c2,b2,c3,b3,b4,b5,b6 1
c4 c1,b2,c2,c3,b3,b4,b5,b6 1
c4 c1,c2,b2,b3,b4,c3,b5,b6 1
c4 c1,c2,b2,b3,c3,b4,b5,b6 1
c4 c1,b2,b3,c2,b4,c3,b5,b6 1
# added transitions
3,9,0,8,8,3,8,8,0,1
12,12,9,9,8,9,8,9,9,1
a, a1, a2, a3, a4, a5, a6, a7, a8, 0

edit:
eater

Code: Select all

x = 34, y = 11, rule = BeeLife2
30.A2.A$29.A$29.A3.A$29.4A5$2.A4.A$2A.4A.2A$2.A4.A!

edit2:

Code: Select all

x = 3, y = 2, rule = LifeStep2-test
3A$.A!


@RULE LifeStep2-test
@COLORS
 0 255 255   0   0 255
1 255 255 255
@NAMES
0 dead
1 alive
@TABLE
n_states:103
neighborhood:Moore
symmetries:rotate4reflect
var al = {2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102}
var al1 = al
var al2 = al
var al3 = al
var al4 = al
var al5 = al
var al6 = al
var al7 = al
var al8 = al
var all = {1,al}
var a = {0,all}
var b = a
var c = a
var d = a
var e = a
var f = a
var g = a
var h = a
var s0 = {2}
var s1c = {3}
var s1e = {4}
var s2c = {5}
var s2e = {6}
var s2a = {7}
var s2k = {8}
var s2i = {9}
var s2n = {10}
var s3c = {11}
var s3e = {12}
var s3a = {13}
var s3k = {14}
var s3i = {15}
var s3n = {16}
var s3y = {17}
var s3q = {18}
var s3j = {19}
var s3r = {20}
var s4c = {21}
var s4e = {22}
var s4a = {23}
var s4k = {24}
var s4i = {25}
var s4n = {26}
var s4y = {27}
var s4q = {28}
var s4j = {29}
var s4r = {30}
var s4t = {31}
var s4w = {32}
var s4z = {33}
var s5c = {34}
var s5e = {35}
var s5a = {36}
var s5k = {37}
var s5i = {38}
var s5n = {39}
var s5y = {40}
var s5q = {41}
var s5j = {42}
var s5r = {43}
var s6c = {44}
var s6e = {45}
var s6a = {46}
var s6k = {47}
var s6i = {48}
var s6n = {49}
var s7c = {50}
var s7e = {51}
var b1c = {52}
var b1e = {53}
var b2c = {54}
var b2e = {55}
var b2a = {56}
var b2k = {57}
var b2i = {58}
var b2n = {59}
var b3c = {60}
var b3e = {61}
var b3a = {62}
var b3k = {63}
var b3i = {64}
var b3n = {65}
var b3y = {66}
var b3q = {67}
var b3j = {68}
var b3r = {69}
var b4c = {70}
var b4e = {71}
var b4a = {72}
var b4k = {73}
var b4i = {74}
var b4n = {75}
var b4y = {76}
var b4q = {77}
var b4j = {78}
var b4r = {79}
var b4t = {99}
var b4w = {100}
var b4z = {101}
var b5c = {80}
var b5e = {81}
var b5a = {82}
var b5k = {83}
var b5i = {84}
var b5n = {85}
var b5y = {86}
var b5q = {87}
var b5j = {88}
var b5r = {89}
var b6c = {90}
var b6e = {91}
var b6a = {92}
var b6k = {93}
var b6i = {94}
var b6n = {95}
var b7c = {96}
var b7e = {97}
var b8 = {98}
var s8 = {102}
1,0,0,0,0,0,0,0,0,s0
1,1,0,0,0,0,0,0,0,s1e
1,0,1,0,0,0,0,0,0,s1c
1,0,1,0,1,0,0,0,0,s2c
1,1,0,1,0,0,0,0,0,s2e
1,1,1,0,0,0,0,0,0,s2a
1,1,0,0,1,0,0,0,0,s2k
1,1,0,0,0,1,0,0,0,s2i
1,0,1,0,0,0,1,0,0,s2n
1,0,1,0,1,0,1,0,0,s3c
1,1,0,1,0,1,0,0,0,s3e
1,1,1,1,0,0,0,0,0,s3a
1,1,0,1,0,0,1,0,0,s3k
1,0,1,1,1,0,0,0,0,s3i
1,1,1,0,1,0,0,0,0,s3n
1,1,0,0,1,0,1,0,0,s3y
1,1,1,0,0,0,1,0,0,s3q
1,1,0,1,1,0,0,0,0,s3j
1,1,1,0,0,1,0,0,0,s3r
1,0,1,0,1,0,1,0,1,s4c
1,1,0,1,0,1,0,1,0,s4e
1,1,1,1,1,0,0,0,0,s4a
1,1,0,1,1,0,1,0,0,s4k
1,1,1,0,1,1,0,0,0,s4i
1,0,1,1,1,0,1,0,0,s4n
1,1,1,0,1,0,1,0,0,s4y
1,1,1,1,0,0,1,0,0,s4q
1,1,0,1,0,1,1,0,0,s4j
1,1,1,1,0,1,0,0,0,s4r
1,1,0,0,1,1,1,0,0,s4t
1,0,1,1,0,1,1,0,0,s4w
1,1,1,0,0,1,1,0,0,s4z
1,1,1,1,0,1,0,1,0,s5c
1,0,1,1,1,0,1,0,1,s5e
1,0,1,1,1,1,1,0,0,s5a
1,0,1,1,0,1,1,0,1,s5k
1,1,1,1,1,1,0,0,0,s5i
1,1,1,1,0,1,1,0,0,s5q
1,1,0,1,1,0,1,1,0,s5y
1,0,1,1,1,1,0,1,0,s5n
1,1,1,1,1,0,1,0,0,s5j
1,0,1,1,1,0,1,1,0,s5r
1,1,0,1,1,1,1,1,0,s6c
1,0,1,1,1,1,1,0,1,s6e
1,1,1,1,1,1,1,0,0,s6a
1,1,1,1,1,0,1,1,0,s6k
1,0,1,1,1,0,1,1,1,s6i
1,1,1,1,0,1,1,1,0,s6n
1,0,1,1,1,1,1,1,1,s7e
1,1,1,1,1,1,1,1,0,s7c
0,0,1,0,0,0,0,0,0,b1c
0,1,0,0,0,0,0,0,0,b1e
0,0,1,0,1,0,0,0,0,b2c
0,1,0,1,0,0,0,0,0,b2e
0,1,1,0,0,0,0,0,0,b2a
0,1,0,0,1,0,0,0,0,b2k
0,1,0,0,0,1,0,0,0,b2i
0,0,1,0,0,0,1,0,0,b2n
0,0,1,0,1,0,1,0,0,b3c
0,1,0,1,0,1,0,0,0,b3e
0,1,1,1,0,0,0,0,0,b3a
0,0,1,1,1,0,0,0,0,b3i
0,1,0,1,0,0,1,0,0,b3k
0,1,1,0,1,0,0,0,0,b3n
0,1,0,0,1,0,1,0,0,b3y
0,1,1,0,0,0,1,0,0,b3q
0,1,0,1,1,0,0,0,0,b3j
0,1,1,0,0,1,0,0,0,b3r
0,0,1,0,1,0,1,0,1,b4c
0,1,0,1,0,1,0,1,0,b4e
0,1,1,1,1,0,0,0,0,b4a
0,1,0,1,1,0,1,0,0,b4k
0,1,1,0,1,1,0,0,0,b4i
0,0,1,1,1,0,1,0,0,b4n
0,1,1,0,1,0,1,0,0,b4y
0,1,1,1,0,0,1,0,0,b4q
0,1,0,1,0,1,1,0,0,b4j
0,1,1,1,0,1,0,0,0,b4r
0,1,0,0,1,1,1,0,0,b4t
0,0,1,1,0,1,1,0,0,b4w
0,1,1,0,0,1,1,0,0,b4z
0,1,1,1,0,1,0,1,0,b5c
0,0,1,1,1,0,1,0,1,b5e
0,0,1,1,1,1,1,0,0,b5a
0,0,1,1,0,1,1,0,1,b5k
0,1,1,1,1,1,0,0,0,b5i
0,0,1,1,1,1,0,1,0,b5n
0,1,0,1,1,0,1,1,0,b5y
0,1,1,1,0,1,1,0,0,b5q
0,1,1,1,1,0,1,0,0,b5j
0,0,1,1,1,0,1,1,0,b5r
0,1,0,1,1,1,1,1,0,b6c
0,0,1,1,1,1,1,0,1,b6e
0,1,1,1,1,1,1,0,0,b6a
0,1,1,1,1,0,1,1,0,b6k
0,0,1,1,1,0,1,1,1,b6i
0,1,1,1,0,1,1,1,0,b6n
0,0,1,1,1,1,1,1,1,b7e
0,1,1,1,1,1,1,1,0,b7c
0,1,1,1,1,1,1,1,1,b8
1,1,1,1,1,1,1,1,1,s8
#transitions

#cgol-step2
#b3-qy4t6c7e/s2-n3-ky5iy
var on = {s2c,s2e,s2c,s2a,s2k,s2i,s3c,s3e,s3a,s3i,s3n,s3q,s3j,s3r,b3c,b3e,b3a,b3k,b3i,b3n,b3j,b3r,b4t,b6c,b7e,s5i,s5y}
var on1 = on
var on2 = on
var on3 = on
var on4 = on
var on5 = on
var on6 = on
var on7 = on
var on8 = on
var off = {0,s0,s1c,s1e,s4c,s4e,s4a,s4k,s4i,s4n,s4y,s4q,s4j,s4r,s4t,s4w,s4z,s5c,s5e,s5a,s5k,s5i,s5n,s5y,s5q,s5j,s5r,s6c,s6e,s6a,s6k,s6i,s6n,s7e,s7c,s8,b1c,b1e,b2c,b2e,b2a,b2k,b2i,b2n,b4c,b4e,b4a,b4k,b4i,b4n,b4y,b4q,b4j,b4r,b4w,b4z,b5c,b5e,b5a,b5k,b5n,b5q,b5j,b5r,b6e,b6a,b6k,b6i,b6n,b7c,b8,b3q,b3y,s2n,s3k,s3y}
var off1 = off
var off2 = off
var off3 = off
var off4 = off
var off5 = off
var off6 = off
var off7 = off
var off8 = off

on,off1,on1,off2,on2,off3,off4,off5,off6,1
on,on1,off1,on2,off2,off3,off4,off5,off6,1
on,on1,on2,off1,off2,off3,off4,off5,off6,1
on,on1,off1,off2,on2,off3,off4,off5,off6,1
on,on1,off1,off2,off3,on2,off4,off5,off6,1

on,off1,on1,off2,on2,off3,on3,off4,off5,1
on,on1,off1,on2,off2,on3,off3,off4,off5,1
on,on1,on2,on3,off1,off2,off3,off4,off5,1
on,off1,on1,on2,on3,off2,off3,off4,off5,1
on,on1,on2,off1,on3,off2,off3,off4,off5,1
on,on1,on2,off1,off2,off3,on3,off4,off5,1
on,on1,off1,on2,on3,off2,off3,off4,off5,1
on,on1,on2,off1,off2,on3,off3,off4,off5,1

on,on1,on2,on3,on4,on5,off1,off2,off3,1
on,on1,off1,on2,on3,off2,on4,on5,off3,1

off,off1,on1,off2,on2,off3,on3,off4,off5,1
off,on1,off1,on2,off2,on3,off3,off4,off5,1
off,on1,on2,on3,off1,off2,off3,off4,off5,1
off,on1,off1,on2,off2,off3,on3,off4,off5,1
off,off1,on1,on2,on3,off2,off3,off4,off5,1
off,on1,on2,off1,on3,off2,off3,off4,off5,1
off,on1,off1,off2,on2,off3,on3,off4,off5,1
off,on1,on2,off1,off2,off3,on3,off4,off5,1
off,on1,off1,on2,on3,off2,off3,off4,off5,1
off,on1,on2,off1,off2,on3,off3,off4,off5,1

#defaults
all,a,b,c,d,e,f,g,h,0

b-engine · Post by **b-engine** » December 22nd, 2024, 10:51 am

Life, but a condition[1] is added to support the alien p62 from Conway++:

Code: Select all

x = 40, y = 40, rule = LifePlus
22bo$22bo$23bo8$20bo$19b3o$22bo$17bobo2b2o$16b2obo2b3o$14bob2obo3bo$2b
o10b13o$2o10b3ob2o3b6o$11bo4b2o5bo$10b2o4bo6b4obo$11bob4o6bo4b2o$16bo
5b2o4bo$13b6o3b2ob3o10b2o$14b13o10bo$16bo3bob2obo$15b3o2bob2o$16b2o2b
obo$17bo$18b3o$19bo8$16bo$17bo$17bo!
[[ STEP 2 ]]
@RULE LifePlus
@COLORS
0 255 255 0 0 255
1 255 255 255
@NAMES
0 dead
1 alive
@TABLE
n_states:13
neighborhood:Moore
symmetries:rotate4reflect
var a={0,1,2,3,4,5,6,7,8,9,10,11,12}
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 b1 = {0,2,3,4,5,6}
var b2 = b1
var b3 = b2
var b4 = b3
var b5 = b4
var b6 = b5
var c1 = {7,8,9,10,11,12}
var c2 = c1
var c3 = c2
var c4 = c3
var c5 = c4
var c6 = c5
# transition setup
0 a1,1,a2,0,a3,0,a4,0 2
0 a1,1,a2,1,a3,0,a4,0 3
0 a1,1,a2,0,a3,1,a4,0 4
0 a1,1,a2,1,a3,1,a4,0 5
0 a1,1,a2,1,a3,1,a4,1 6
1 a1,0,a2,0,a3,0,a4,0 7
1 a1,1,a2,0,a3,0,a4,0 8
1 a1,1,a2,1,a3,0,a4,0 9
1 a1,1,a2,0,a3,1,a4,0 10
1 a1,1,a2,1,a3,1,a4,0 11
1 a1,1,a2,1,a3,1,a4,1 12
# transitions
# cgol
b1 b2,c1,b3,c2,b4,c3,b5,b6 1
b1 c1,b2,c2,b3,c3,b4,b5,b6 1
b1 c1,b2,c2,b3,b4,c3,b5,b6 1
b1 c1,c2,c3,b2,b3,b4,b5,b6 1
b1 b2,c1,c2,c3,b3,b4,b5,b6 1
b1 c1,c2,b2,c3,b3,b4,b5,b6 1
b1 c1,b2,c2,c3,b3,b4,b5,b6 1
b1 c1,c2,b2,b3,b4,c3,b5,b6 1
b1 c1,c2,b2,b3,c3,b4,b5,b6 1
b1 c1,b2,b3,c2,b4,c3,b5,b6 1
c1 b1,c2,b2,c3,b3,b4,b5,b6 1
c1 c2,b1,c3,b2,b3,b4,b5,b6 1
c1 c2,b1,b2,c3,b3,b4,b5,b6 1
c1 c2,c3,b1,b2,b3,b4,b5,b6 1
c1 c2,b1,b2,b3,c3,b4,b5,b6 1
c1 b1,c2,b2,b3,b4,c3,b5,b6 1
c4 b2,c1,b3,c2,b4,c3,b5,b6 1
c4 c1,b2,c2,b3,c3,b4,b5,b6 1
c4 c1,b2,c2,b3,b4,c3,b5,b6 1
c4 c1,c2,c3,b2,b3,b4,b5,b6 1
c4 b2,c1,c2,c3,b3,b4,b5,b6 1
c4 c1,c2,b2,c3,b3,b4,b5,b6 1
c4 c1,b2,c2,c3,b3,b4,b5,b6 1
c4 c1,c2,b2,b3,b4,c3,b5,b6 1
c4 c1,c2,b2,b3,c3,b4,b5,b6 1
c4 c1,b2,b3,c2,b4,c3,b5,b6 1
# added transitions
12,2,8,0,11,2,9,0,8,1


a, a1, a2, a3, a4, a5, a6, a7, a8, 0

[1] Condition, in some sense, is a line that defines the rule of the CA itself in a 2-state range 1 ruletable. (I don't know how to explain that in any other way.)

confocaloid · Post by **confocaloid** » December 22nd, 2024, 11:07 am

b-engine wrote: December 22nd, 2024, 10:51 am Life, but a condition[1] is added to support the alien p62 from Conway++: [...]

Without any additional explanations of the idea, it is non-obvious why would one want to use a separate .rule file emulating a range-2 CA for that. The same can be done with just range-1 CA in several different ways.

Also, the condition is just the "IF" part of the rule that tells current states of a cell and/or its neighbours. It doesn't include the "THEN" part of the rule that tells what will happen with the cell.

b-engine · Post by **b-engine** » January 12th, 2025, 5:13 am

This is the closest rule to Life with the HighLife replicator:

Code: Select all

# [[ STEP 2 ]]
x = 5, y = 5, rule = Rep-CGoL
2.3A$.A2.A$A3.A$A2.A$3A!

@RULE Rep-CGoL
@COLORS
0 255 255 0 0 255
1 255 255 255
@NAMES
0 dead
1 alive
@TABLE
n_states:13
neighborhood:Moore
symmetries:rotate4reflect
var a={0,1,2,3,4,5,6,7,8,9,10,11,12}
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 b1 = {0,2,3,4,5,6}
var b2 = b1
var b3 = b2
var b4 = b3
var b5 = b4
var b6 = b5
var c1 = {7,8,9,10,11,12}
var c2 = c1
var c3 = c2
var c4 = c3
var c5 = c4
var c6 = c5
# transition setup
0 a1,1,a2,0,a3,0,a4,0 2
0 a1,1,a2,1,a3,0,a4,0 3
0 a1,1,a2,0,a3,1,a4,0 4
0 a1,1,a2,1,a3,1,a4,0 5
0 a1,1,a2,1,a3,1,a4,1 6
1 a1,0,a2,0,a3,0,a4,0 7
1 a1,1,a2,0,a3,0,a4,0 8
1 a1,1,a2,1,a3,0,a4,0 9
1 a1,1,a2,0,a3,1,a4,0 10
1 a1,1,a2,1,a3,1,a4,0 11
1 a1,1,a2,1,a3,1,a4,1 12
# transitions
# cgol
b1 b2,c1,b3,c2,b4,c3,b5,b6 1
b1 c1,b2,c2,b3,c3,b4,b5,b6 1
b1 c1,b2,c2,b3,b4,c3,b5,b6 1
b1 c1,c2,c3,b2,b3,b4,b5,b6 1
b1 b2,c1,c2,c3,b3,b4,b5,b6 1
b1 c1,c2,b2,c3,b3,b4,b5,b6 1
b1 c1,b2,c2,c3,b3,b4,b5,b6 1
b1 c1,c2,b2,b3,b4,c3,b5,b6 1
b1 c1,c2,b2,b3,c3,b4,b5,b6 1
b1 c1,b2,b3,c2,b4,c3,b5,b6 1
c1 b1,c2,b2,c3,b3,b4,b5,b6 1
c1 c2,b1,c3,b2,b3,b4,b5,b6 1
c1 c2,b1,b2,c3,b3,b4,b5,b6 1
c1 c2,c3,b1,b2,b3,b4,b5,b6 1
c1 c2,b1,b2,b3,c3,b4,b5,b6 1
c1 b1,c2,b2,b3,b4,c3,b5,b6 1
c4 b2,c1,b3,c2,b4,c3,b5,b6 1
c4 c1,b2,c2,b3,c3,b4,b5,b6 1
c4 c1,b2,c2,b3,b4,c3,b5,b6 1
c4 c1,c2,c3,b2,b3,b4,b5,b6 1
c4 b2,c1,c2,c3,b3,b4,b5,b6 1
c4 c1,c2,b2,c3,b3,b4,b5,b6 1
c4 c1,b2,c2,c3,b3,b4,b5,b6 1
c4 c1,c2,b2,b3,b4,c3,b5,b6 1
c4 c1,c2,b2,b3,c3,b4,b5,b6 1
c4 c1,b2,b3,c2,b4,c3,b5,b6 1

4,11,5,11,10,11,5,11,10,1
4,11,8,11,4,11,8,11,0,1
4,11,0,11,7,9,0,9,7,1
4,11,8,12,4,12,8,11,0,1
4,11,4,11,10,12,4,12,10,1
4,11,10,11,4,11,10,11,4,1

a, a1, a2, a3, a4, a5, a6, a7, a8, 0

Corder engine stabilize into the block-laying orbit of it:

Code: Select all

# [[ STEP 2 ]]
x = 6, y = 4, rule = Rep-CGoL
2.A.A$5.A$.A2.A$3A!
@RULE Rep-CGoL
@COLORS
0 255 255 0 0 255
1 255 255 255
@NAMES
0 dead
1 alive
@TABLE
n_states:13
neighborhood:Moore
symmetries:rotate4reflect
var a={0,1,2,3,4,5,6,7,8,9,10,11,12}
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 b1 = {0,2,3,4,5,6}
var b2 = b1
var b3 = b2
var b4 = b3
var b5 = b4
var b6 = b5
var c1 = {7,8,9,10,11,12}
var c2 = c1
var c3 = c2
var c4 = c3
var c5 = c4
var c6 = c5
# transition setup
0 a1,1,a2,0,a3,0,a4,0 2
0 a1,1,a2,1,a3,0,a4,0 3
0 a1,1,a2,0,a3,1,a4,0 4
0 a1,1,a2,1,a3,1,a4,0 5
0 a1,1,a2,1,a3,1,a4,1 6
1 a1,0,a2,0,a3,0,a4,0 7
1 a1,1,a2,0,a3,0,a4,0 8
1 a1,1,a2,1,a3,0,a4,0 9
1 a1,1,a2,0,a3,1,a4,0 10
1 a1,1,a2,1,a3,1,a4,0 11
1 a1,1,a2,1,a3,1,a4,1 12
# transitions
# cgol
b1 b2,c1,b3,c2,b4,c3,b5,b6 1
b1 c1,b2,c2,b3,c3,b4,b5,b6 1
b1 c1,b2,c2,b3,b4,c3,b5,b6 1
b1 c1,c2,c3,b2,b3,b4,b5,b6 1
b1 b2,c1,c2,c3,b3,b4,b5,b6 1
b1 c1,c2,b2,c3,b3,b4,b5,b6 1
b1 c1,b2,c2,c3,b3,b4,b5,b6 1
b1 c1,c2,b2,b3,b4,c3,b5,b6 1
b1 c1,c2,b2,b3,c3,b4,b5,b6 1
b1 c1,b2,b3,c2,b4,c3,b5,b6 1
c1 b1,c2,b2,c3,b3,b4,b5,b6 1
c1 c2,b1,c3,b2,b3,b4,b5,b6 1
c1 c2,b1,b2,c3,b3,b4,b5,b6 1
c1 c2,c3,b1,b2,b3,b4,b5,b6 1
c1 c2,b1,b2,b3,c3,b4,b5,b6 1
c1 b1,c2,b2,b3,b4,c3,b5,b6 1
c4 b2,c1,b3,c2,b4,c3,b5,b6 1
c4 c1,b2,c2,b3,c3,b4,b5,b6 1
c4 c1,b2,c2,b3,b4,c3,b5,b6 1
c4 c1,c2,c3,b2,b3,b4,b5,b6 1
c4 b2,c1,c2,c3,b3,b4,b5,b6 1
c4 c1,c2,b2,c3,b3,b4,b5,b6 1
c4 c1,b2,c2,c3,b3,b4,b5,b6 1
c4 c1,c2,b2,b3,b4,c3,b5,b6 1
c4 c1,c2,b2,b3,c3,b4,b5,b6 1
c4 c1,b2,b3,c2,b4,c3,b5,b6 1
4,11,5,11,10,11,5,11,10,1
4,11,8,11,4,11,8,11,0,1
4,11,0,11,7,9,0,9,7,1
4,11,8,12,4,12,8,11,0,1
4,11,4,11,10,12,4,12,10,1
4,11,10,11,4,11,10,11,4,1
a, a1, a2, a3, a4, a5, a6, a7, a8, 0

R2INT · Post by **R2INT** » March 13th, 2025, 9:07 pm

Because there are multiple Range-2 INT rules under investigation, I feel the need to create software that natively supports R2INT rules. Because I am new to CA programming, the set of features I will add is somewhat limited:

Limited grid size, about 200x200
Painting will be implemented after the first test build
Importing *.r2int files will be implemented later
The test rule once the first alpha build is released will be one of the R2OT rules from my rule collection.

This program will be written in C++ using Microsoft Visual Studio.

confocaloid · Post by **confocaloid** » March 14th, 2025, 12:25 pm

Strobing background is unnecessary:

Code: Select all

x = 44, y = 19, rule = R2,C0,S18-35,54-71,90-107,135-143,B18,27-35,63-71,99-107,135-143,NW010001000100092D0900012D002D0100092D09000100010001
5b2o14bo$3bo4bo10bo3bo11bo2bo$9bo14bo14bo$3bo5bo9bo4bo10bo3bo$4b6o10b
5o11b4o11$2bo28bo10b2o$2bo9bo7b3o7bo2bo8b2o$2o8b2o18bo2bo6b2o$b2o8b2o
19bo7b2o!

pifricted wrote: March 14th, 2025, 8:08 am GlIder and glider:
Code: Select all
x = 10, y = 4, rule = B0124rw5nr6ae/S14k5inr6c
2bo$2bo6bo$2o5b2o$b2o5b2o!
Code: Select all
x = 36, y = 4, rule = B0124rw5nr6aei/S14kq5ainr6ci
2bo23bo7b2o$2bo6bo15bo2bo5b2o$2o5b2o9b3o4bo2bo3b2o$b2o5b2o17bo4b2o!

R2INT · Post by **R2INT** » April 12th, 2025, 6:40 pm

R2INT wrote: March 13th, 2025, 9:07 pm Because there are multiple Range-2 INT rules under investigation, I feel the need to create software that natively supports R2INT rules.
[...]

I have created the new software, named R2INT. More details are at this forum thread.

Here is a potentially interesting Range-2 INT rule that I made entirely in the new software(note that saving in .r2int is not fully developed; a script will have to be written to recover from the format)

Code: Select all

15: True
17: True
23: True
39: True
99: True
128: True
165: True
169: True
199: True
200: True
231: True
255: True
324: True
329: True
363: True
452: True
458: True
463: True
483: True
492: True
758: True
1032: True
1063: True
1135: True
1185: True
1250: True
2065: True
2176: True
2178: True
2179: True
2180: True
2212: True
2274: True
2368: True
2885: True
3360: True
4096: True
4162: True
4172: True
4226: True
4260: True
4416: True
4548: True
4640: True
4768: True
5317: True
6272: True
6370: True
6596: True
8169: True
10240: True
10304: True
11618: True
13440: True
14340: True
14670: True
14825: True
15457: True
17536: True
37120: True
41024: True
46337: True
49280: True
57920: True
65552: True
75840: True
131093: True
141444: True
152580: True
152896: True
261408: True
361030: True
469440: True
557600: True
1049092: True
1200257: True
1332481: True
4211729: True
4357252: True
4769316: True

The preceding numbers to the left of the True statements represent the conditions in which the cell in the center of the following weighted neighborhood (and all of the 8 rotations and reflections of it) is alive in the next generation (ignoring the center cell):

Code: Select all

#C Neighborhood weights are in decimal
16777216 .8388608 .4194304 .2097152 .1048576
..524288 ..262144 ..131072 ...65536 ...32768
...16384 ....8192 ....4096 ....2048 ....1024
.....512 .....256 .....128 ......64 ......32
......16 .......8 .......4 .......2 .......1

Here is the pattern collection of the rule (I think):

Code: Select all

#C From left to right: cd, 3c/2, c, c/3, (2,1)c/3,
#C predecessor of a large still life, OMOS
#C (The correct rule isn't loaded here)
x = 84, y = 3, rule = B3/S23
2o8bob4o4bo9bo7b2o36bo6bo$3o7bob2o15bobo8bo17bo18bo4bo$bo10bo7b2o54bo
6bo!

A 1-cell growth per generation pattern, and an adjustable photon:

Code: Select all

x = 13, y = 13, rule = B3/S23
3bobo11$obobobobobobo$12bo!

This is an incomplete rulegolf. More-developed variants of it will be posted in R2INT's InDev Rules.

Citation needed · Post by **Citation needed** » April 12th, 2025, 6:57 pm

ColorfulGabrielsp138 wrote: June 19th, 2021, 12:16 am Isotropic Range-2 von Neumann rule with c/2 orthogonal gliders.
This is found by hand. Please check if I made any mistakes.

Code: Select all

x = 85, y = 11, rule = 12ColorMarkedLife
7.C22.B46.B$3C3.C6.3B2.3B2.3B3.3B3.3B2.3B2.2BA2.3B2.3B2.3B2.A2B2.BAB3.
3B3.3B$C.C2.5C3.3B2.3B2.3B2.5B2.3B2.A2B2.3B2.A2B2.BAB2.BAB2.BAB2.BAB2.
ABA2B2.B2A$3C3.C6.3B2.BAB2.2BA3.2AB3.ABA2.BAB2.B2A2.B2A2.BAB2.2BA2.2A
B2.B2A3.2AB3.2AB$7.C22.B46.B2$7.C6.B26.B14.B$3C3.C6.3B3.3B2.3B2.BAB2.
BAB3.BAB3.A2B6.3B$CAC2.5C2.5B2.A2B2.3B2.A2B2.A2B2.3A2B2.B2A5.2BA2B$3C
3.C6.2AB3.2AB2.3A2.2AB2.3A3.3B3.2AB6.2AB$7.C6.A26.B14.B!

Does this count as an "R2INT" rule? If so, does the glider work?

R2INT · Post by **R2INT** » April 12th, 2025, 7:23 pm

Citation needed wrote: April 12th, 2025, 6:57 pm
ColorfulGabrielsp138 wrote: June 19th, 2021, 12:16 am Isotropic Range-2 von Neumann rule with c/2 orthogonal gliders.
This is found by hand. Please check if I made any mistakes.
Code: Select all
x = 85, y = 11, rule = 12ColorMarkedLife
7.C22.B46.B$3C3.C6.3B2.3B2.3B3.3B3.3B2.3B2.2BA2.3B2.3B2.3B2.A2B2.BAB3.
3B3.3B$C.C2.5C3.3B2.3B2.3B2.5B2.3B2.A2B2.3B2.A2B2.BAB2.BAB2.BAB2.BAB2.
ABA2B2.B2A$3C3.C6.3B2.BAB2.2BA3.2AB3.ABA2.BAB2.B2A2.B2A2.BAB2.2BA2.2A
B2.B2A3.2AB3.2AB$7.C22.B46.B2$7.C6.B26.B14.B$3C3.C6.3B3.3B2.3B2.BAB2.
BAB3.BAB3.A2B6.3B$CAC2.5C2.5B2.A2B2.3B2.A2B2.A2B2.3A2B2.B2A5.2BA2B$3C
3.C6.2AB3.2AB2.3A2.2AB2.3A3.3B3.2AB6.2AB$7.C6.A26.B14.B!
Does this count as an "R2INT" rule? If so, does the glider work?

I do not see anything in the forum thread saying this is only for R2INT rules with the Moore Neighborhood, so I think this counts.

confocaloid · Post by **confocaloid** » April 12th, 2025, 10:57 pm

R2INT wrote: April 12th, 2025, 6:40 pm [...] Here is a potentially interesting Range-2 INT rule that I made entirely in the new software(note that saving in .r2int is not fully developed; a script will have to be written to recover from the format)
Code: Select all
15: True
[...]
4096: True
[...]
The preceding numbers to the left of the True statements represent the conditions in which the cell in the center of the following weighted neighborhood (and all of the 8 rotations and reflections of it) is alive in the next generation (ignoring the center cell):
Code: Select all
#C Neighborhood weights are in decimal
16777216 .8388608 .4194304 .2097152 .1048576
..524288 ..262144 ..131072 ...65536 ...32768
...16384 ....8192 ....4096 ....2048 ....1024
.....512 .....256 .....128 ......64 ......32
......16 .......8 .......4 .......2 .......1
[...] This is an incomplete rulegolf. More-developed variants of it will be posted in R2INT's InDev Rules.

If I understand the idea correctly, then the part "(ignoring the center cell)" is a bit of a misnomer. Looks like the system does take the middle cell's state into account: "a cell counts as its own neighbour" with weight 4096. Since all weights are distinct powers of two, one can map different sums-of-weights into different neighbourhood configurations (which is of course the main idea behind choosing those weights).

On the other hand, the system doesn't explicitly keep two separate sets of birth conditions and survival conditions, and instead merges them into a single set that might be described as "living conditions" (to keep the same intuition: a "living condition" is either a birth condition or a survival condition, depending on what it tells about the middle cell's current state). This looks like a simplification without losing or ignoring any information.

As an example, the CA definition posted above has "4096: True" but doesn't have "0: True". That means [4096] ("the cell is currently alive and has no alive neighbours") is a survival condition, while [0] ("the cell is currently dead and has no alive neighbours") isn't a birth condition. The system can tell those two cell conditions apart.

The line "15: True" means (I think) that the following cell condition:

Code: Select all

[15] = {15, 30, 33825, 541200, 1082400, 15728640, 17318400, 31457280}

- is a "living condition" (this one is a birth condition), rotations/reflections of the following:

Code: Select all

Instead of an int-to-bool mapping, one could give the "living conditions" more concisely as a set:

{15, 17, 23, 39, 99, 128, 165, 169, 199, 200, 231, 255, 324, 329, 363, 452, 458, 463, 483, 492, 758, 1032, 1063, 1135, 1185, 1250, 2065, 2176, 2178, 2179, 2180, 2212, 2274, 2368, 2885, 3360, 4096, 4162, 4172, 4226, 4260, 4416, 4548, 4640, 4768, 5317, 6272, 6370, 6596, 8169, 10240, 10304, 11618, 13440, 14340, 14670, 14825, 15457, 17536, 37120, 41024, 46337, 49280, 57920, 65552, 75840, 131093, 141444, 152580, 152896, 261408, 361030, 469440, 557600, 1049092, 1200257, 1332481, 4211729, 4357252, 4769316}

where each number is a representative of an equivalence class of neighbourhood configurations (up to rotations and reflections).

CARuler · Post by **CARuler** » April 20th, 2025, 3:19 pm

finish a script that makes a .r2int table from a rulestring (knightwise neighborhood)

Code: Select all

import golly as g

# defining the transitions (in the same list)

T = ["0","xxxxxxxxx0x0x0x0x0x0x0x0","1","xxxxxxxxx1x0x0x0x0x0x0x0","2o","xxxxxxxxx1x1x0x0x0x0x0x0","2c","xxxxxxxxx1x0x1x0x0x0x0x0","2d","xxxxxxxxx1x0x0x0x1x0x0x0","2h","xxxxxxxxx1x0x0x1x0x0x0x0","2i","xxxxxxxxx1x0x0x0x0x0x0x1","2w","xxxxxxxxx1x0x0x0x0x1x0x0","3o","xxxxxxxxx1x1x1x0x0x0x0x0","3c","xxxxxxxxx1x0x1x0x1x0x0x0","3d","xxxxxxxxx1x1x0x0x1x0x0x0","3h","xxxxxxxxx1x1x0x1x0x0x0x0","3i","xxxxxxxxx1x0x0x1x0x0x0x1","3w","xxxxxxxxx1x0x0x1x0x0x1x0","3q","xxxxxxxxx1x0x1x0x0x0x0x1","4o","xxxxxxxxx1x1x0x0x0x0x1x1","4c","xxxxxxxxx1x0x1x0x1x0x1x0","4d","xxxxxxxxx1x1x0x0x1x1x0x0","4h","xxxxxxxxx1x0x1x0x0x1x0x1","4i","xxxxxxxxx1x0x0x1x1x0x0x1","4w","xxxxxxxxx1x1x1x0x0x0x0x1","4q","xxxxxxxxx1x0x1x0x1x0x0x1","4y","xxxxxxxxx1x1x0x1x0x0x1x0","4k","xxxxxxxxx1x1x0x1x1x0x0x0","4x","xxxxxxxxx1x1x0x1x0x1x0x0","4t","xxxxxxxxx1x1x1x0x1x0x0x0","4j","xxxxxxxxx1x1x1x0x0x1x0x0","4r","xxxxxxxxx1x1x1x0x0x0x1x0","5o","xxxxxxxxx1x1x1x1x1x0x0x0","5c","xxxxxxxxx1x1x1x0x1x0x1x0","5d","xxxxxxxxx1x1x0x1x1x1x0x0","5h","xxxxxxxxx1x1x1x1x0x1x0x0","5i","xxxxxxxxx1x1x1x0x0x1x1x0","5w","xxxxxxxxx1x1x0x1x0x1x1x0","5q","xxxxxxxxx1x1x1x0x0x1x0x1","6o","xxxxxxxxx1x1x1x1x1x1x0x0","6c","xxxxxxxxx1x1x1x1x1x0x1x0","6d","xxxxxxxxx1x1x1x0x1x1x1x0","6h","xxxxxxxxx1x1x1x1x0x1x1x0","6i","xxxxxxxxx1x1x1x1x1x0x0x1","6w","xxxxxxxxx1x1x0x1x1x1x1x0","7","xxxxxxxxx1x1x1x1x1x1x1x0","8","xxxxxxxxx1x1x1x1x1x1x1x1"]

TL2 = ["o","c","d","h","i","w"]
TL6 = TL2
TL3 = ["o","c","d","h","i","w","q"]
TL5 = TL3
TL4 = ["o","c","d","h","i","w","q","y","k","x","t","j","r"]
TL = [TL2,TL3,TL4,TL5,TL6]

#add something in front of the elements of each list
def adderL(n,l):
    a = []
    for b in l:
        a.append(n+b)
    return(a)

# find transition x
def find(x):
    global T
    i1 = 0
        
    while(i1 < len(T)):
        if (x == T[i1]): return(T[i1+1])
        i1 += 2
    else:
        g.error("a transition does not exist")

# letters alowed 
LA = []

# letters so far
Temp = []

#all transitions so far
Trans = []

# the number of alive cells
num = -1

# is this a brith or survival transition; 0=brith, 1=survival
s = "0"

#convert transitions to strings
def convert(l):
    if (l == []): return([])
    global s
    tp = []
    for t in l:
        tp.append(s+find(t))
    return(tp)

#the letter we're at
l = ""

# the rulestring
RS = g.getstring("enter a rulestring in the form of Knight=b[brith condistions]/s[survival conditions]","Knight=b/s","Enter a rulestring")

#subtranact transitions
sub = False

#sutract lists
def subList(l1,l2):
    a = l1
    for x in l2:
        a.remove(x)
    return(a)

#add the transitions
def AddT(t):
    global Trans
    global LA
    global sub
    global num
    a = adderL(str(num),LA)
    if not sub:
        if (t == []): pass
        if (num in [0,1,7,8]): Trans.extend(convert([str(num)]))
        Trans.extend(convert(t))
    else:
        if (num in [0,1,7,8]): Trans.extend(convert([str(num)]))
        elif (t == []): Trans.extend(convert(a))
        else: Trans.extend(convert(subList(a,t)))

#put that all together 
i = 8
while(i < len(RS)):
    l = RS[i]
    if l == "/":
        if RS[i-1] != "b":
            if (RS[i-1] in ["0","1","2","3","4","5","6","7","8"]): sub = True
            AddT(Temp)
            Temp.clear()
        s = "1"
        sub = False
        i += 2
        continue
    if l in ["0","1","2","3","4","5","6","7","8"]:
        if RS[i-1] in ["0","1","2","3","4","5","6","7","8"]: sub = True
        AddT(Temp)
        num = int(l)
        if l not in ["0","1","7","8"]: LA = TL[num-2]
        Temp.clear()
        sub = False
        i += 1
        if ((i == len(RS)) and (l in ["0","1","7","8"])): AddT([l])
        continue
    if l == "-": 
        sub = True
        i += 1
        continue
    if l in LA:
        Temp.append(str(num)+l)
        i += 1
        if (i == len(RS)): AddT(Temp)
        continue

#print transitions
def PT(t):
    a = t[0]
    b = t
    b.pop(0)
    for i in b:
        a = a+"\n"+i
    return(a)

#test
#g.warn(str(len(Trans)))

B = PT(Trans)

g.setclipstr(B)

the transitions:

CARuler wrote: March 11th, 2025, 8:22 pm

something to try:

Code: Select all

x = 2, y = 2, rule = Knight=b2hio/s1
bo$obo$bo!

R2INT · Post by **R2INT** » April 26th, 2025, 12:40 am

Below is a R2 hexagonal INT rule, emulated using a 28-state isotropic non-totalistic hexagonal rule:

Code: Select all

# [[ STEP 2 ]]
x = 20, y = 20, rule = R2INT_Hex
7.2A4.2A$2A7.A$A.A11.A6$9.A7.A.A$9.2A$17.A7$17.2A$17.A.A$18.2A!
@RULE R2INT_Hex
@NAMES
0 dead
1 alive
2 b1
3 b2o
4 b2m
5 b2p
6 b3o
7 b3m
8 b3p
9 b4o
10 b4m
11 b4p
12 b5
13 b6
@COLORS
0 0,0,0
1 255,255,255
2 0,80,0
3 0,96,0
4 0,112,0
5 0,128,0
6 0,144,0
7 0,160,0
8 0,176,0
9 0,192,0
10 0,208,0
11 0,224,0
12 0,240,0
13 0,255,0
14 255,80,0
15 255,96,0
16 255,112,0
17 255,128,0
18 255,144,0
19 255,160,0
20 255,176,0
21 255,192,0
22 255,208,0
23 255,224,0
24 255,240,0
25 255,255,0
26 255,0,0
@NAMES
@TABLE
n_states:27
neighborhood:hexagonal
symmetries:rotate6reflect
var a1 = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26}
var a2 = a1
var a3 = a2
var a4 = a3
var a5 = a4
var a6 = a5
var a7 = a6
# neighborhood communication
0 1,0,0,0,0,0 2
0 1,1,0,0,0,0 3
0 1,0,1,0,0,0 4
0 1,0,0,1,0,0 5
0 1,1,1,0,0,0 6
0 1,1,0,1,0,0 7
0 1,0,1,0,1,0 8
0 1,1,1,1,0,0 9
0 1,1,1,0,1,0 10
0 1,1,0,1,1,0 11
0 1,1,1,1,1,0 12
0 1,1,1,1,1,1 13
1 1,0,0,0,0,0 14
1 1,1,0,0,0,0 15
1 1,0,1,0,0,0 16
1 1,0,0,1,0,0 17
1 1,1,1,0,0,0 18
1 1,1,0,1,0,0 19
1 1,0,1,0,1,0 20
1 1,1,1,1,0,0 21
1 1,1,1,0,1,0 22
1 1,1,0,1,1,0 23
1 1,1,1,1,1,0 24
1 1,1,1,1,1,1 25
1 0,0,0,0,0,0 26
# transitions
# p1 photon
2 3,16,3,0,0,0 1
3 2,16,14,2,0,0 1
# p2 c/2 diagonal
2 2,14,5,2,0,0 1
16 16,9,14,3,2,3 1
# still life
15 15,15,3,2,2,3 1
2 2,9,15,2,0,0 1
15 19,15,3,2,2,9 1
# c/2o
3 2,14,14,2,0,0 1
14 14,7,2,2,2,3 1
4 2,14,7,26,2,0 1
# p2
26 5,2,2,2,2,2 1
0 0,2,2,2,0,0 1
# p3
2 2,14,9,2,0,0 1
16 16,13,16,3,2,3 1
9 14,20,20,14,2,2 1
13 20,20,20,20,20,20 1
8 26,8,15,11,15,8 1
#default
a1 a2,a3,a4,a5,a6,a7 0

EDIT: The 19-cell neighborhood the emulator uses:

Code: Select all

# [[ STEP 2 GRID COLOR GRID 255 0 0 ]]
x = 5, y = 5, rule = R2INT_Hex
3B$4B$2BA2B$.4B$2.3B!
@RULE R2INT_Hex
@COLORS
0 255,255,255
1 32,32,32
2 0,96,255
@NAMES
@TABLE
n_states:3
neighborhood:hexagonal
symmetries:rotate6reflect

confocaloid · Post by **confocaloid** » April 26th, 2025, 12:47 am

R2INT wrote: April 26th, 2025, 12:40 am Below is a R2 hexagonal INT rule, emulated using a 28-state isotropic non-totalistic hexagonal rule: [...]

How it is supposed to work? Can you write down the rules of the "range-2" cellular automaton in a human-readable way (like how the rules of Conway's Life are explained in all introductory texts), or you're expecting readers to decode that information from the low-level implementation?

So far I can guess that it's probably meant to be a way to emulate some particular two-state isotropic cellular automaton on the hexagonal tiling with range-2 (18+1)-cell neighbourhood, but even that isn't stated clearly in your post and there is a room for ambiguity/misinterpretation.

CARuler · Post by **CARuler** » April 26th, 2025, 6:42 pm

R2INT wrote: April 26th, 2025, 12:40 am Below is a R2 hexagonal INT rule, emulated using a 28-state isotropic non-totalistic hexagonal rule:

Code: Select all

# [[ STEP 2 ]]
x = 20, y = 20, rule = R2INT_Hex
7.2A4.2A$2A7.A$A.A11.A6$9.A7.A.A$9.2A$17.A7$17.2A$17.A.A$18.2A!
@RULE R2INT_Hex
@NAMES
0 dead
1 alive
2 b1
3 b2o
4 b2m
5 b2p
6 b3o
7 b3m
8 b3p
9 b4o
10 b4m
11 b4p
12 b5
13 b6
@COLORS
0 0,0,0
1 255,255,255
2 0,80,0
3 0,96,0
4 0,112,0
5 0,128,0
6 0,144,0
7 0,160,0
8 0,176,0
9 0,192,0
10 0,208,0
11 0,224,0
12 0,240,0
13 0,255,0
14 255,80,0
15 255,96,0
16 255,112,0
17 255,128,0
18 255,144,0
19 255,160,0
20 255,176,0
21 255,192,0
22 255,208,0
23 255,224,0
24 255,240,0
25 255,255,0
26 255,0,0
@NAMES
@TABLE
n_states:27
neighborhood:hexagonal
symmetries:rotate6reflect
var a1 = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26}
var a2 = a1
var a3 = a2
var a4 = a3
var a5 = a4
var a6 = a5
var a7 = a6
# neighborhood communication
0 1,0,0,0,0,0 2
0 1,1,0,0,0,0 3
0 1,0,1,0,0,0 4
0 1,0,0,1,0,0 5
0 1,1,1,0,0,0 6
0 1,1,0,1,0,0 7
0 1,0,1,0,1,0 8
0 1,1,1,1,0,0 9
0 1,1,1,0,1,0 10
0 1,1,0,1,1,0 11
0 1,1,1,1,1,0 12
0 1,1,1,1,1,1 13
1 1,0,0,0,0,0 14
1 1,1,0,0,0,0 15
1 1,0,1,0,0,0 16
1 1,0,0,1,0,0 17
1 1,1,1,0,0,0 18
1 1,1,0,1,0,0 19
1 1,0,1,0,1,0 20
1 1,1,1,1,0,0 21
1 1,1,1,0,1,0 22
1 1,1,0,1,1,0 23
1 1,1,1,1,1,0 24
1 1,1,1,1,1,1 25
1 0,0,0,0,0,0 26
# transitions
# p1 photon
2 3,16,3,0,0,0 1
3 2,16,14,2,0,0 1
# p2 c/2 diagonal
2 2,14,5,2,0,0 1
16 16,9,14,3,2,3 1
# still life
15 15,15,3,2,2,3 1
2 2,9,15,2,0,0 1
15 19,15,3,2,2,9 1
# c/2o
3 2,14,14,2,0,0 1
14 14,7,2,2,2,3 1
4 2,14,7,26,2,0 1
# p2
26 5,2,2,2,2,2 1
0 0,2,2,2,0,0 1
# p3
2 2,14,9,2,0,0 1
16 16,13,16,3,2,3 1
9 14,20,20,14,2,2 1
13 20,20,20,20,20,20 1
8 26,8,15,11,15,8 1
#default
a1 a2,a3,a4,a5,a6,a7 0

EDIT: The 19-cell neighborhood the emulator uses:

Code: Select all

# [[ STEP 2 GRID COLOR GRID 255 0 0 ]]
x = 5, y = 5, rule = R2INT_Hex
3B$4B$2BA2B$.4B$2.3B!
@RULE R2INT_Hex
@COLORS
0 255,255,255
1 32,32,32
2 0,96,255
@NAMES
@TABLE
n_states:3
neighborhood:hexagonal
symmetries:rotate6reflect

i found a p2

Code: Select all

# [[ STEP 2 ]]
x = 25, y = 20, rule = R2INT_Hex
12.2A4.2A$5.2A7.A$5.A.A11.A6$14.A7.A.A$14.2A$22.A2$A3$.A2$22.2A$22.A.
A$23.2A!
@RULE R2INT_Hex
@NAMES
0 dead
1 alive
2 b1
3 b2o
4 b2m
5 b2p
6 b3o
7 b3m
8 b3p
9 b4o
10 b4m
11 b4p
12 b5
13 b6
@COLORS
0 0,0,0
1 255,255,255
2 0,80,0
3 0,96,0
4 0,112,0
5 0,128,0
6 0,144,0
7 0,160,0
8 0,176,0
9 0,192,0
10 0,208,0
11 0,224,0
12 0,240,0
13 0,255,0
14 255,80,0
15 255,96,0
16 255,112,0
17 255,128,0
18 255,144,0
19 255,160,0
20 255,176,0
21 255,192,0
22 255,208,0
23 255,224,0
24 255,240,0
25 255,255,0
26 255,0,0
@NAMES
@TABLE
n_states:27
neighborhood:hexagonal
symmetries:rotate6reflect
var a1 = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26}
var a2 = a1
var a3 = a2
var a4 = a3
var a5 = a4
var a6 = a5
var a7 = a6
# neighborhood communication
0 1,0,0,0,0,0 2
0 1,1,0,0,0,0 3
0 1,0,1,0,0,0 4
0 1,0,0,1,0,0 5
0 1,1,1,0,0,0 6
0 1,1,0,1,0,0 7
0 1,0,1,0,1,0 8
0 1,1,1,1,0,0 9
0 1,1,1,0,1,0 10
0 1,1,0,1,1,0 11
0 1,1,1,1,1,0 12
0 1,1,1,1,1,1 13
1 1,0,0,0,0,0 14
1 1,1,0,0,0,0 15
1 1,0,1,0,0,0 16
1 1,0,0,1,0,0 17
1 1,1,1,0,0,0 18
1 1,1,0,1,0,0 19
1 1,0,1,0,1,0 20
1 1,1,1,1,0,0 21
1 1,1,1,0,1,0 22
1 1,1,0,1,1,0 23
1 1,1,1,1,1,0 24
1 1,1,1,1,1,1 25
1 0,0,0,0,0,0 26
# transitions
# p1 photon
2 3,16,3,0,0,0 1
3 2,16,14,2,0,0 1
# p2 c/2 diagonal
2 2,14,5,2,0,0 1
16 16,9,14,3,2,3 1
# still life
15 15,15,3,2,2,3 1
2 2,9,15,2,0,0 1
15 19,15,3,2,2,9 1
# c/2o
3 2,14,14,2,0,0 1
14 14,7,2,2,2,3 1
4 2,14,7,26,2,0 1
# p2
26 5,2,2,2,2,2 1
0 0,2,2,2,0,0 1
# p3
2 2,14,9,2,0,0 1
16 16,13,16,3,2,3 1
9 14,20,20,14,2,2 1
13 20,20,20,20,20,20 1
8 26,8,15,11,15,8 1
#default
a1 a2,a3,a4,a5,a6,a7 0

your ruletable

Code: Select all

@RULE R2INT_Hex
@NAMES
0 dead
1 alive
2 b1
3 b2o
4 b2m
5 b2p
6 b3o
7 b3m
8 b3p
9 b4o
10 b4m
11 b4p
12 b5
13 b6
@COLORS
0 0,0,0
1 255,255,255
2 0,80,0
3 0,96,0
4 0,112,0
5 0,128,0
6 0,144,0
7 0,160,0
8 0,176,0
9 0,192,0
10 0,208,0
11 0,224,0
12 0,240,0
13 0,255,0
14 255,80,0
15 255,96,0
16 255,112,0
17 255,128,0
18 255,144,0
19 255,160,0
20 255,176,0
21 255,192,0
22 255,208,0
23 255,224,0
24 255,240,0
25 255,255,0
26 255,0,0
@NAMES
@TABLE
n_states:27
neighborhood:hexagonal
symmetries:rotate6reflect
var a1 = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26}
var a2 = a1
var a3 = a2
var a4 = a3
var a5 = a4
var a6 = a5
var a7 = a6
# neighborhood communication
0 1,0,0,0,0,0 2
0 1,1,0,0,0,0 3
0 1,0,1,0,0,0 4
0 1,0,0,1,0,0 5
0 1,1,1,0,0,0 6
0 1,1,0,1,0,0 7
0 1,0,1,0,1,0 8
0 1,1,1,1,0,0 9
0 1,1,1,0,1,0 10
0 1,1,0,1,1,0 11
0 1,1,1,1,1,0 12
0 1,1,1,1,1,1 13
1 1,0,0,0,0,0 14
1 1,1,0,0,0,0 15
1 1,0,1,0,0,0 16
1 1,0,0,1,0,0 17
1 1,1,1,0,0,0 18
1 1,1,0,1,0,0 19
1 1,0,1,0,1,0 20
1 1,1,1,1,0,0 21
1 1,1,1,0,1,0 22
1 1,1,0,1,1,0 23
1 1,1,1,1,1,0 24
1 1,1,1,1,1,1 25
1 0,0,0,0,0,0 26
# transitions
# p1 photon
2 3,16,3,0,0,0 1
3 2,16,14,2,0,0 1
# p2 c/2 diagonal
2 2,14,5,2,0,0 1
16 16,9,14,3,2,3 1
# still life
15 15,15,3,2,2,3 1
2 2,9,15,2,0,0 1
15 19,15,3,2,2,9 1
# c/2o
3 2,14,14,2,0,0 1
14 14,7,2,2,2,3 1
4 2,14,7,26,2,0 1
# p2
26 5,2,2,2,2,2 1
0 0,2,2,2,0,0 1
# p3
2 2,14,9,2,0,0 1
16 16,13,16,3,2,3 1
9 14,20,20,14,2,2 1
13 20,20,20,20,20,20 1
8 26,8,15,11,15,8 1
#default
a1 a2,a3,a4,a5,a6,a7 0

breaker's glider gun · April 27th, 2025, 7:39 pm

p12... looks like we've got the margulos family here...

Code: Select all

# [[ STEP 2 ]]
x = 7, y = 10, rule = R2INT_Hex
A3$2.A3$4.A3$6.A!

@RULE R2INT_Hex
@NAMES
0 dead
1 alive
2 b1
3 b2o
4 b2m
5 b2p
6 b3o
7 b3m
8 b3p
9 b4o
10 b4m
11 b4p
12 b5
13 b6
@COLORS
0 0,0,0
1 255,255,255
2 0,80,0
3 0,96,0
4 0,112,0
5 0,128,0
6 0,144,0
7 0,160,0
8 0,176,0
9 0,192,0
10 0,208,0
11 0,224,0
12 0,240,0
13 0,255,0
14 255,80,0
15 255,96,0
16 255,112,0
17 255,128,0
18 255,144,0
19 255,160,0
20 255,176,0
21 255,192,0
22 255,208,0
23 255,224,0
24 255,240,0
25 255,255,0
26 255,0,0
@NAMES
@TABLE
n_states:27
neighborhood:hexagonal
symmetries:rotate6reflect
var a1 = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26}
var a2 = a1
var a3 = a2
var a4 = a3
var a5 = a4
var a6 = a5
var a7 = a6
# neighborhood communication
0 1,0,0,0,0,0 2
0 1,1,0,0,0,0 3
0 1,0,1,0,0,0 4
0 1,0,0,1,0,0 5
0 1,1,1,0,0,0 6
0 1,1,0,1,0,0 7
0 1,0,1,0,1,0 8
0 1,1,1,1,0,0 9
0 1,1,1,0,1,0 10
0 1,1,0,1,1,0 11
0 1,1,1,1,1,0 12
0 1,1,1,1,1,1 13
1 1,0,0,0,0,0 14
1 1,1,0,0,0,0 15
1 1,0,1,0,0,0 16
1 1,0,0,1,0,0 17
1 1,1,1,0,0,0 18
1 1,1,0,1,0,0 19
1 1,0,1,0,1,0 20
1 1,1,1,1,0,0 21
1 1,1,1,0,1,0 22
1 1,1,0,1,1,0 23
1 1,1,1,1,1,0 24
1 1,1,1,1,1,1 25
1 0,0,0,0,0,0 26
# transitions
# p1 photon
2 3,16,3,0,0,0 1
3 2,16,14,2,0,0 1
# p2 c/2 diagonal
2 2,14,5,2,0,0 1
16 16,9,14,3,2,3 1
# still life
15 15,15,3,2,2,3 1
2 2,9,15,2,0,0 1
15 19,15,3,2,2,9 1
# c/2o
3 2,14,14,2,0,0 1
14 14,7,2,2,2,3 1
4 2,14,7,26,2,0 1
# p2
26 5,2,2,2,2,2 1
0 0,2,2,2,0,0 1
# p3
2 2,14,9,2,0,0 1
16 16,13,16,3,2,3 1
9 14,20,20,14,2,2 1
13 20,20,20,20,20,20 1
8 26,8,15,11,15,8 1
#default
a1 a2,a3,a4,a5,a6,a7 0

Code: Select all

# [[ STEP 2 ]]
x = 49, y = 73, rule = R2INT_Hex
A3$2.A3$4.A3$6.A3$8.A3$10.A3$12.A3$14.A3$16.A3$18.A3$20.A3$22.A3$24.A
3$26.A3$28.A3$30.A3$32.A3$34.A3$36.A3$38.A3$40.A3$42.A3$44.A3$46.A3$48.
A!

@RULE R2INT_Hex
@NAMES
0 dead
1 alive
2 b1
3 b2o
4 b2m
5 b2p
6 b3o
7 b3m
8 b3p
9 b4o
10 b4m
11 b4p
12 b5
13 b6
@COLORS
0 0,0,0
1 255,255,255
2 0,80,0
3 0,96,0
4 0,112,0
5 0,128,0
6 0,144,0
7 0,160,0
8 0,176,0
9 0,192,0
10 0,208,0
11 0,224,0
12 0,240,0
13 0,255,0
14 255,80,0
15 255,96,0
16 255,112,0
17 255,128,0
18 255,144,0
19 255,160,0
20 255,176,0
21 255,192,0
22 255,208,0
23 255,224,0
24 255,240,0
25 255,255,0
26 255,0,0
@NAMES
@TABLE
n_states:27
neighborhood:hexagonal
symmetries:rotate6reflect
var a1 = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26}
var a2 = a1
var a3 = a2
var a4 = a3
var a5 = a4
var a6 = a5
var a7 = a6
# neighborhood communication
0 1,0,0,0,0,0 2
0 1,1,0,0,0,0 3
0 1,0,1,0,0,0 4
0 1,0,0,1,0,0 5
0 1,1,1,0,0,0 6
0 1,1,0,1,0,0 7
0 1,0,1,0,1,0 8
0 1,1,1,1,0,0 9
0 1,1,1,0,1,0 10
0 1,1,0,1,1,0 11
0 1,1,1,1,1,0 12
0 1,1,1,1,1,1 13
1 1,0,0,0,0,0 14
1 1,1,0,0,0,0 15
1 1,0,1,0,0,0 16
1 1,0,0,1,0,0 17
1 1,1,1,0,0,0 18
1 1,1,0,1,0,0 19
1 1,0,1,0,1,0 20
1 1,1,1,1,0,0 21
1 1,1,1,0,1,0 22
1 1,1,0,1,1,0 23
1 1,1,1,1,1,0 24
1 1,1,1,1,1,1 25
1 0,0,0,0,0,0 26
# transitions
# p1 photon
2 3,16,3,0,0,0 1
3 2,16,14,2,0,0 1
# p2 c/2 diagonal
2 2,14,5,2,0,0 1
16 16,9,14,3,2,3 1
# still life
15 15,15,3,2,2,3 1
2 2,9,15,2,0,0 1
15 19,15,3,2,2,9 1
# c/2o
3 2,14,14,2,0,0 1
14 14,7,2,2,2,3 1
4 2,14,7,26,2,0 1
# p2
26 5,2,2,2,2,2 1
0 0,2,2,2,0,0 1
# p3
2 2,14,9,2,0,0 1
16 16,13,16,3,2,3 1
9 14,20,20,14,2,2 1
13 20,20,20,20,20,20 1
8 26,8,15,11,15,8 1
#default
a1 a2,a3,a4,a5,a6,a7 0

b-engine · Post by **b-engine** » April 29th, 2025, 6:48 pm

Code: Select all

# [[ STEP 2 ]]
x = 3, y = 3, rule = CGoL-test
.A$A.A$A.A!
@RULE CGoL-test
@COLORS
0 255 255 0 0 255
1 255 255 255
@NAMES
0 dead
1 alive
@TABLE
n_states:13
neighborhood:Moore
symmetries:rotate4reflect
var a={0,1,2,3,4,5,6,7,8,9,10,11,12}
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 b1 = {0,2,3,4,5,6}
var b2 = b1
var b3 = b2
var b4 = b3
var b5 = b4
var b6 = b5
var c1 = {7,8,9,10,11,12}
var c2 = c1
var c3 = c2
var c4 = c3
var c5 = c4
var c6 = c5
# transition setup
0 a1,1,a2,0,a3,0,a4,0 2
0 a1,1,a2,1,a3,0,a4,0 3
0 a1,1,a2,0,a3,1,a4,0 4
0 a1,1,a2,1,a3,1,a4,0 5
0 a1,1,a2,1,a3,1,a4,1 6
1 a1,0,a2,0,a3,0,a4,0 7
1 a1,1,a2,0,a3,0,a4,0 8
1 a1,1,a2,1,a3,0,a4,0 9
1 a1,1,a2,0,a3,1,a4,0 10
1 a1,1,a2,1,a3,1,a4,0 11
1 a1,1,a2,1,a3,1,a4,1 12
# transitions
# cgol
b1 b2,c1,b3,c2,b4,c3,b5,b6 1
b1 c1,b2,c2,b3,c3,b4,b5,b6 1
b1 c1,b2,c2,b3,b4,c3,b5,b6 1
b1 c1,c2,c3,b2,b3,b4,b5,b6 1
b1 b2,c1,c2,c3,b3,b4,b5,b6 1
b1 c1,c2,b2,c3,b3,b4,b5,b6 1
b1 c1,b2,c2,c3,b3,b4,b5,b6 1
b1 c1,c2,b2,b3,b4,c3,b5,b6 1
b1 c1,c2,b2,b3,c3,b4,b5,b6 1
b1 c1,b2,b3,c2,b4,c3,b5,b6 1
c1 b1,c2,b2,c3,b3,b4,b5,b6 1
c1 c2,b1,c3,b2,b3,b4,b5,b6 1
c1 c2,b1,b2,c3,b3,b4,b5,b6 1
c1 c2,c3,b1,b2,b3,b4,b5,b6 1
c1 c2,b1,b2,b3,c3,b4,b5,b6 1
c1 b1,c2,b2,b3,b4,c3,b5,b6 1
c4 b2,c1,b3,c2,b4,c3,b5,b6 1
c4 c1,b2,c2,b3,c3,b4,b5,b6 1
c4 c1,b2,c2,b3,b4,c3,b5,b6 1
c4 c1,c2,c3,b2,b3,b4,b5,b6 1
c4 b2,c1,c2,c3,b3,b4,b5,b6 1
c4 c1,c2,b2,c3,b3,b4,b5,b6 1
c4 c1,b2,c2,c3,b3,b4,b5,b6 1
c4 c1,c2,b2,b3,b4,c3,b5,b6 1
c4 c1,c2,b2,b3,c3,b4,b5,b6 1
c4 c1,b2,b3,c2,b4,c3,b5,b6 1
0,9,3,8,2,2,0,2,0,1
a, a1, a2, a3, a4, a5, a6, a7, a8, 0

CARuler · Post by **CARuler** » June 24th, 2025, 8:35 pm

OMOS

Code: Select all

# [[ STEP 2 ]]
x = 10, y = 11, rule = R2INT-cgol-test
.A$3A7$8.A$7.3A$8.A!

@RULE R2INT-cgol-test
@COLORS
0 255 255 0 0 255
1 255 255 255
@NAMES
0 dead
1 alive
@TABLE
n_states:13
neighborhood:Moore
symmetries:rotate4reflect
var a={0,1,2,3,4,5,6,7,8,9,10,11,12}
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 b1 = {0,2,3,4,5,6}
var b2 = b1
var b3 = b2
var b4 = b3
var b5 = b4
var b6 = b5
var c1 = {7,8,9,10,11,12}
var c2 = c1
var c3 = c2
var c4 = c3
var c5 = c4
var c6 = c5
# transition setup
0 a1,1,a2,0,a3,0,a4,0 2
0 a1,1,a2,1,a3,0,a4,0 3
0 a1,1,a2,0,a3,1,a4,0 4
0 a1,1,a2,1,a3,1,a4,0 5
0 a1,1,a2,1,a3,1,a4,1 6
1 a1,0,a2,0,a3,0,a4,0 7
1 a1,1,a2,0,a3,0,a4,0 8
1 a1,1,a2,1,a3,0,a4,0 9
1 a1,1,a2,0,a3,1,a4,0 10
1 a1,1,a2,1,a3,1,a4,0 11
1 a1,1,a2,1,a3,1,a4,1 12
# transitions
7,7,2,6,2,7,2,3,2,0
7,9,2,11,4,12,4,11,2,1
9,9,2,9,10,9,10,9,2,1
9,0,3,0,3,0,9,0,9,0

# cgol
b1 b2,c1,b3,c2,b4,c3,b5,b6 1
b1 c1,b2,c2,b3,c3,b4,b5,b6 1
b1 c1,b2,c2,b3,b4,c3,b5,b6 1
b1 c1,c2,c3,b2,b3,b4,b5,b6 1
b1 b2,c1,c2,c3,b3,b4,b5,b6 1
b1 c1,c2,b2,c3,b3,b4,b5,b6 1
b1 c1,b2,c2,c3,b3,b4,b5,b6 1
b1 c1,c2,b2,b3,b4,c3,b5,b6 1
b1 c1,c2,b2,b3,c3,b4,b5,b6 1
b1 c1,b2,b3,c2,b4,c3,b5,b6 1
c1 b1,c2,b2,c3,b3,b4,b5,b6 1
c1 c2,b1,c3,b2,b3,b4,b5,b6 1
c1 c2,b1,b2,c3,b3,b4,b5,b6 1
c1 c2,c3,b1,b2,b3,b4,b5,b6 1
c1 c2,b1,b2,b3,c3,b4,b5,b6 1
c1 b1,c2,b2,b3,b4,c3,b5,b6 1
c4 b2,c1,b3,c2,b4,c3,b5,b6 1
c4 c1,b2,c2,b3,c3,b4,b5,b6 1
c4 c1,b2,c2,b3,b4,c3,b5,b6 1
c4 c1,c2,c3,b2,b3,b4,b5,b6 1
c4 b2,c1,c2,c3,b3,b4,b5,b6 1
c4 c1,c2,b2,c3,b3,b4,b5,b6 1
c4 c1,b2,c2,c3,b3,b4,b5,b6 1
c4 c1,c2,b2,b3,b4,c3,b5,b6 1
c4 c1,c2,b2,b3,c3,b4,b5,b6 1
c4 c1,b2,b3,c2,b4,c3,b5,b6 1
a, a1, a2, a3, a4, a5, a6, a7, a8, 0

R2INT · Post by **R2INT** » August 17th, 2025, 10:25 pm

Here is an interesting R2INT rule I made with my R2INT program:

Code: Select all

000000000000000111110000
000010000000000000100000
000010000000001011000000
000001000000000000000000
000001000000000110110000
000011000000000001100000
000011000000001000100000
000011100000000010100000
000011100000000011100000
000010000000001010001000
000010100000001000001000
000011100000001000001000
000000000000010001000000
000010000000010101000000
000001000000010100000000
000001000000010001000000
000010100000011000000000
000001000000011000001000
000100000000000110100000
000100000000000000010000
000101000000000001000000
000101000000001010000000
000101000000001100100000
000101000000001010100000
000111000000000010000000
000111000000001000010000
000101100000001010000000
000111100000000000000000
000100000000000000001000
000101000000000000001000
000111000000000010001000
000111000000001000001000
000101100000000000101000
000111000000010101000000
100000000000000010100000
100010000000001001000000
100001000000000010000000
100001000000000010100000
100011000000000001000000
100010100000000001000000
100010100000000100100000
100010100000000010100000
100010100000000101010000
100011100000000000000000
100011100000000100010000
100010100000001001001000
100001000000011010100000
100000100000010000000000
100000100000010000010000
100000100000010010110000
100001100000011101000000
100101000000000011000000
100100100000001011000000
100110000000011110100000
100101000000011000010000
100111000000011111000000
100100100000010000000000
100100100000010111000000
100101000000011000001000
000011110000011100100000
000100010000000000000000
000100010000001000001000
000100010000011000000000
100101010000000001000000
100110110000000000000000
100000000000011000000100
000100010000010110110100
100100010000010000000100
000001000000110000010000
100000000000101111010000
000000110000100000100000
100111110000100011100000
000100100000111000011100
100000110000100000000100
001000100000000000110000
001010100000001010000000
001001100000000000000000
001010000000000000001000
001010000000000000011000
101001100000001001000000
101001100000001100110000
101000100000011011000000
101010100000010101000000
101001100000011010000000
101100000000010000010000
101001010000011010000000
001010000000000000000100
101100000000010111010100
001010000000111000001000
001010000000111000000100
010000000000001000001000
010000110000010100100000
010101010000000000000000
010101010000001010101000
010110110000010001000000
110001010000010000000000
110100010000001000001000
110100010000001001001000
010001000000010111110100
111010110000000000000000
110011111000100000000000
111111111000000000000000
011011101000010000000100
000000110000111000010010
001110000000101000001110
001010101000101000001010
111100011000110100010110
100000000001000000010000
100000000001000100010000
100010000001000110100100
101101100001000010110000
001000100001010000010100
101000000001101001010100
010110101001000001000100
101000000001101001000010
101000000001101001010110
101011011001000010000010
000000000010100000101000
100000000010100000101000
110000110010011101011000
011111111010101010101000
100010000011000110100100
101000100011100000111000
000000000100010001000100
100101000100111111100100
101010101100010001000100
100011100100101101011010
110111110100101011101010
101010101100101001001010
111011101100111101011110
111110101111110010010010
100001000010110101010110
100000000010111010101110
100100010011000110101110
100010001101111111110110
100000000001000100010001
110101010001011111111101
101110010101111101010101
111111111101010101010101
110101010111111111111111
111111111111111111111111

islptng · Post by **islptng** » August 25th, 2025, 8:59 pm

R2INT wrote: August 17th, 2025, 10:25 pm Here is an interesting R2INT rule I made with my R2INT program:

Code: Select all

000000000000000111110000
000010000000000000100000
000010000000001011000000
000001000000000000000000
000001000000000110110000
000011000000000001100000
000011000000001000100000
000011100000000010100000
000011100000000011100000
000010000000001010001000
000010100000001000001000
000011100000001000001000
000000000000010001000000
000010000000010101000000
000001000000010100000000
000001000000010001000000
000010100000011000000000
000001000000011000001000
000100000000000110100000
000100000000000000010000
000101000000000001000000
000101000000001010000000
000101000000001100100000
000101000000001010100000
000111000000000010000000
000111000000001000010000
000101100000001010000000
000111100000000000000000
000100000000000000001000
000101000000000000001000
000111000000000010001000
000111000000001000001000
000101100000000000101000
000111000000010101000000
100000000000000010100000
100010000000001001000000
100001000000000010000000
100001000000000010100000
100011000000000001000000
100010100000000001000000
100010100000000100100000
100010100000000010100000
100010100000000101010000
100011100000000000000000
100011100000000100010000
100010100000001001001000
100001000000011010100000
100000100000010000000000
100000100000010000010000
100000100000010010110000
100001100000011101000000
100101000000000011000000
100100100000001011000000
100110000000011110100000
100101000000011000010000
100111000000011111000000
100100100000010000000000
100100100000010111000000
100101000000011000001000
000011110000011100100000
000100010000000000000000
000100010000001000001000
000100010000011000000000
100101010000000001000000
100110110000000000000000
100000000000011000000100
000100010000010110110100
100100010000010000000100
000001000000110000010000
100000000000101111010000
000000110000100000100000
100111110000100011100000
000100100000111000011100
100000110000100000000100
001000100000000000110000
001010100000001010000000
001001100000000000000000
001010000000000000001000
001010000000000000011000
101001100000001001000000
101001100000001100110000
101000100000011011000000
101010100000010101000000
101001100000011010000000
101100000000010000010000
101001010000011010000000
001010000000000000000100
101100000000010111010100
001010000000111000001000
001010000000111000000100
010000000000001000001000
010000110000010100100000
010101010000000000000000
010101010000001010101000
010110110000010001000000
110001010000010000000000
110100010000001000001000
110100010000001001001000
010001000000010111110100
111010110000000000000000
110011111000100000000000
111111111000000000000000
011011101000010000000100
000000110000111000010010
001110000000101000001110
001010101000101000001010
111100011000110100010110
100000000001000000010000
100000000001000100010000
100010000001000110100100
101101100001000010110000
001000100001010000010100
101000000001101001010100
010110101001000001000100
101000000001101001000010
101000000001101001010110
101011011001000010000010
000000000010100000101000
100000000010100000101000
110000110010011101011000
011111111010101010101000
100010000011000110100100
101000100011100000111000
000000000100010001000100
100101000100111111100100
101010101100010001000100
100011100100101101011010
110111110100101011101010
101010101100101001001010
111011101100111101011110
111110101111110010010010
100001000010110101010110
100000000010111010101110
100100010011000110101110
100010001101111111110110
100000000001000100010001
110101010001011111111101
101110010101111101010101
111111111101010101010101
110101010111111111111111
111111111111111111111111

I failed to load this rule in Golly. Is my program not working, or is your rule in wrong format?
EDIT: The length of each line is 24!? It should be 25! Which neighbor is missing?

R2INT · Post by **R2INT** » August 26th, 2025, 6:12 pm

Whoops, seems like my program had a bug in saving rules. . . After some minor code changes, here is a test rule with only one transition:

Code: Select all

0001101110011100111000100

If all is well, then this configuration should cause the center cell to turn on:

Code: Select all

x = 5, y = 5, rule = B5r/S
bo$b4o$4bo$2b3o$3o!

hotcrystal0 · Post by **hotcrystal0** » May 23rd, 2026, 8:53 pm

Can someone make a range 2 INT rule which is B3/S23-a5 but a transition is added so that this almost P9 is a working P9?

Code: Select all

x = 37, y = 12, rule = B3/S23-a5History
30.A$5.3A21.3A$2.A.A.A.A.A15.A.A3.A.A$3A.A.A.A.3A5.A5.3A.A.A.A.3A$A.A
.CDCDC.A.A6.A4.A.A.A3.A.A.A$4.5C7.5A7.2A.2A$3.A2DE2DA9.A7.A2.A2.A$4.5A
9.A9.5A$4.5D$6.A23.A$5.A.A21.A.A$6.A23.A!

ConwayLife.com

Radius 2 INT rules

Re: Radius 2INT rules

Re: Range 2 INT rules

Re: two-state isotropic CA with range-2 Moore neighbourhood

Re: Radius 2 INT rules

Re: Range-2 INT rules

Re: Radius 2 INT rules

Re: Range-2 INT rules

Re: Radius 2 INT rules

Re: Radius 2 INT rules

Re: Range-2 INT rules

Re: Radius 2 INT rules

Re: Radius 2 INT rules

Re: Radius 2 INT rules

Re: Radius 2 INT rules

Re: Radius 2 INT rules

Re: Radius 2 INT rules

Re: Radius 2 INT rules

Re: Radius 2 INT rules

Re: Radius 2 INT rules

Re: Radius 2 INT rules

Re: Radius 2 INT rules