For discussion of other cellular automata.

How about a rule that simulates a 3D rule which is two cells thick on the Z axis?
Bored of using the Moore neighbourhood for everything? Introducing the Range-2 von Neumann isotropic non-totalistic rulespace!
muzik

Posts: 3404
Joined: January 28th, 2016, 2:47 pm
Location: Scotland

gameoflifemaniac wrote:Three Life universes at once?

I wouldn't mind seeing the rules with three and four independent universes, but the DoubleB3S23 rule is as far as my patience goes for building these rules manually. If we write a script to generate the lines of the rule table, we might as well make it work also for four and five independent universes, and just see how Golly handles a rule table with 1.3 million lines in it, and how many are needed for five independent states.

Maybe it will be somewhat less than 1.3 million rule lines for four states, if we can come up with a workable way to use variables. DoubleB3S23 manages with fewer than 55 rule lines, after all.

So... if someone would build colored icons for the sixteen states, showing different colored squares in each of the four quadrants, then we could use the first eight of the icons for TripleB3S23. Or 32 states, with a fifth state in the center? The automated script could use whatever icons anyone wants to make.

It still seems as if six or more independent universes is going to be too many for Golly to be happy with, though it might be able to handle five if it had to. Every time you add an independent bit to the pile, you double the number of groups of rule lines you need, and also the size of each group increases exponentially. Best to have a script generate all the possibilities.

Here's what the TripleB3S23 rule could look like, minus the auto-generated rule lines:

`@RULE TripleB3S23-INCOMPLETE@TABLEn_states:8neighborhood:Mooresymmetries:permute# The three universes will be state 1, state 2, and state 4.# Summing these independent universes gives the composite state.# 0x001 bit ON (+1)var a={1,3,5,7}var aa=avar ab=avar ac=avar ad=avar ae=avar af=avar ag=a# 0x001 bit OFFvar b={0,2,4,6}var ba=bvar bb=bvar bc=bvar bd=bvar be=bvar bf=bvar bg=b# 0x010 bit ON (+2)var c={2,3,6,7}var ca=cvar cb=cvar cc=cvar cd=cvar ce=cvar cf=cvar cg=c# 0x010 bit OFFvar d={0,1,4,5}var da=dvar db=dvar dc=dvar dd=dvar de=dvar df=dvar dg=d# 0x100 bit ON (+4)var e={4,5,6,7}var ea=evar eb=evar ec=evar ed=evar ee=evar ef=evar eg=e# 0x100 bit OFFvar f={0,1,2,3}var fa=fvar fb=fvar fc=fvar fd=fvar fe=fvar ff=fvar fg=f# don't-care cellsvar x={0,1,2,3,4,5,6,7}var xa=xvar xb=xvar xc=xvar xd=xvar xe=xvar xf=xvar xg=xvar xh=x# # the following are the rules for DoubleB3S23 --# # can be used as a template for completing TripleB3S23## # birth for both 0x01 and 0x10 bits# x,1,1,1,2,2,2,0,0,3# x,1,1,3,2,2,0,0,0,3# x,1,3,3,2,0,0,0,0,3# x,3,3,3,0,0,0,0,0,3# # # survival for 0x01 bit, birth for 0x10 bit# 1,2,2,2,1,1,0,0,0,3# 1,2,2,3,1,0,0,0,0,3# 1,2,3,3,0,0,0,0,0,3# # # birth for 0x01 bit, survival for 0x10 bit# 2,1,1,1,2,2,0,0,0,3# 2,1,1,3,2,0,0,0,0,3# 2,1,3,3,0,0,0,0,0,3# # # 2-neighbor survival for 0x01 bit, 3-neighbor survival for 0x10 bit# 3,1,1,2,2,2,0,0,0,3# 3,1,3,2,2,0,0,0,0,3# 3,3,3,2,0,0,0,0,0,3# # # 3-neighbor survival for 0x01 bit, 2-neighbor survival for 0x10 bit# 3,1,1,1,2,2,0,0,0,3# 3,1,1,3,2,0,0,0,0,3# 3,1,3,3,0,0,0,0,0,3# # # 2-neighbor survival for both 0x01 and 0x10 bits# 3,1,1,2,2,0,0,0,0,3# 3,1,3,2,0,0,0,0,0,3# 3,3,3,0,0,0,0,0,0,3# # # birth for 0x01 bit, death for 0x10 bit# x,a,aa,ab,ba,bb,bc,bd,be,1# x,a,aa,ab,ba,bb,bc,bd,be,1# 1,a,aa,ba,bb,bc,bd,be,bf,1# 3,a,aa,ba,bb,bc,bd,be,bf,1# # # death for 0x01 bit, birth for 0x10 bit# x,c,ca,cb,da,db,dc,dd,de,2# x,c,ca,cb,da,db,dc,dd,de,2# 2,c,ca,da,db,dc,dd,de,df,2# 3,c,ca,da,db,dc,dd,de,df,2# # # death for both bits# x,xa,xb,xc,xd,xe,xf,xg,xh,0@COLORS0 0 0 01 255 0 02 0 255 03 255 255 04 0 0 2555 255 0 2556 255 255 07 255 255 255@ICONS# ????`

dvgrn
Moderator

Posts: 5739
Joined: May 17th, 2009, 11:00 pm

dvgrn wrote:
gameoflifemaniac wrote:Three Life universes at once?

I wouldn't mind seeing the rules with three and four independent universes, but the DoubleB3S23 rule is as far as my patience goes for building these rules manually. If we write a script to generate the lines of the rule table, we might as well make it work also for four and five independent universes, and just see how Golly handles a rule table with 1.3 million lines in it, and how many are needed for five independent states.

Maybe it will be somewhat less than 1.3 million rule lines for four states, if we can come up with a workable way to use variables. DoubleB3S23 manages with fewer than 55 rule lines, after all.

So... if someone would build colored icons for the sixteen states, showing different colored squares in each of the four quadrants, then we could use the first eight of the icons for TripleB3S23. Or 32 states, with a fifth state in the center? The automated script could use whatever icons anyone wants to make.

It still seems as if six or more independent universes is going to be too many for Golly to be happy with, though it might be able to handle five if it had to. Every time you add an independent bit to the pile, you double the number of groups of rule lines you need, and also the size of each group increases exponentially. Best to have a script generate all the possibilities.

Here's what the TripleB3S23 rule could look like, minus the auto-generated rule lines:

`@RULE TripleB3S23-INCOMPLETE@TABLEn_states:8neighborhood:Mooresymmetries:permute# The three universes will be state 1, state 2, and state 4.# Summing these independent universes gives the composite state.# 0x001 bit ON (+1)var a={1,3,5,7}var aa=avar ab=avar ac=avar ad=avar ae=avar af=avar ag=a# 0x001 bit OFFvar b={0,2,4,6}var ba=bvar bb=bvar bc=bvar bd=bvar be=bvar bf=bvar bg=b# 0x010 bit ON (+2)var c={2,3,6,7}var ca=cvar cb=cvar cc=cvar cd=cvar ce=cvar cf=cvar cg=c# 0x010 bit OFFvar d={0,1,4,5}var da=dvar db=dvar dc=dvar dd=dvar de=dvar df=dvar dg=d# 0x100 bit ON (+4)var e={4,5,6,7}var ea=evar eb=evar ec=evar ed=evar ee=evar ef=evar eg=e# 0x100 bit OFFvar f={0,1,2,3}var fa=fvar fb=fvar fc=fvar fd=fvar fe=fvar ff=fvar fg=f# don't-care cellsvar x={0,1,2,3,4,5,6,7}var xa=xvar xb=xvar xc=xvar xd=xvar xe=xvar xf=xvar xg=xvar xh=x# # the following are the rules for DoubleB3S23 --# # can be used as a template for completing TripleB3S23## # birth for both 0x01 and 0x10 bits# x,1,1,1,2,2,2,0,0,3# x,1,1,3,2,2,0,0,0,3# x,1,3,3,2,0,0,0,0,3# x,3,3,3,0,0,0,0,0,3# # # survival for 0x01 bit, birth for 0x10 bit# 1,2,2,2,1,1,0,0,0,3# 1,2,2,3,1,0,0,0,0,3# 1,2,3,3,0,0,0,0,0,3# # # birth for 0x01 bit, survival for 0x10 bit# 2,1,1,1,2,2,0,0,0,3# 2,1,1,3,2,0,0,0,0,3# 2,1,3,3,0,0,0,0,0,3# # # 2-neighbor survival for 0x01 bit, 3-neighbor survival for 0x10 bit# 3,1,1,2,2,2,0,0,0,3# 3,1,3,2,2,0,0,0,0,3# 3,3,3,2,0,0,0,0,0,3# # # 3-neighbor survival for 0x01 bit, 2-neighbor survival for 0x10 bit# 3,1,1,1,2,2,0,0,0,3# 3,1,1,3,2,0,0,0,0,3# 3,1,3,3,0,0,0,0,0,3# # # 2-neighbor survival for both 0x01 and 0x10 bits# 3,1,1,2,2,0,0,0,0,3# 3,1,3,2,0,0,0,0,0,3# 3,3,3,0,0,0,0,0,0,3# # # birth for 0x01 bit, death for 0x10 bit# x,a,aa,ab,ba,bb,bc,bd,be,1# x,a,aa,ab,ba,bb,bc,bd,be,1# 1,a,aa,ba,bb,bc,bd,be,bf,1# 3,a,aa,ba,bb,bc,bd,be,bf,1# # # death for 0x01 bit, birth for 0x10 bit# x,c,ca,cb,da,db,dc,dd,de,2# x,c,ca,cb,da,db,dc,dd,de,2# 2,c,ca,da,db,dc,dd,de,df,2# 3,c,ca,da,db,dc,dd,de,df,2# # # death for both bits# x,xa,xb,xc,xd,xe,xf,xg,xh,0@COLORS0 0 0 01 255 0 02 0 255 03 255 255 04 0 0 2555 255 0 2556 255 255 07 255 255 255@ICONS# ????`

The rule doesn't move at all. Is this why the rule is incomplete?
One big dirty Oro. Yeeeeeeeeee...

gameoflifemaniac

Posts: 762
Joined: January 22nd, 2017, 11:17 am
Location: There too

gameoflifemaniac wrote:
dvgrn wrote:...Here's what the TripleB3S23 rule could look like, minus the auto-generated rule lines:

`...# # the following are the rules for DoubleB3S23 --# # can be used as a template for completing TripleB3S23...@ICONS# ????`

The rule doesn't move at all. Is this why the rule is incomplete?

Yes. Must you really quote entire previous posts including patterns and rule tables and everything? It's not as if anyone really needs to see another exact copy quite so soon.

Start at the top of the rule table and look at every line. The whole thing really is human-readable. It seems mysterious at first, because the

`1,2,2,2,1,1,0,0,0,3`

lines aren't labeled. But that's really the biggest item that you have to learn, and it's not complicated at all. The above line translates to

[ implied IF ]

CellStartState=1,
NorthNeighborState=2,
NortheastNeighborState=2,
EastNeighborState=2,
SoutheastNeighborState=1,
SouthNeighborState=1,
SouthwestNeighborState=0,
WestNeighborState=0,
and
NorthwestNeighborState=0
{or any permutation of the above, because the permute symmetry is set}

[ implied THEN ]

set the cell state to 3, and stop reading the rule list -- a matching rule has been found.

A rule table is just made up of a series of statements like this, in abbreviated form. If you read the whole rule file, and notice the comments along the way that provide the answer to your question, then you should be able to follow the logic and see why the commented-out lines would produce a working DoubleB3S23 universe.

It's not too horribly difficult to complete a TripleB3S23 rule manually, but it would be tedious and very easy to miss a few cases, so I'd advise writing a script to generate all the right rule lines.

dvgrn
Moderator

Posts: 5739
Joined: May 17th, 2009, 11:00 pm

The double life might allow tricks in computation for scripts. For instance, it is trivial to find, say, one glider in a specific orientation that destroys either of two different patterns, regardless of which it is (shown, how this glider destroys both a B and a century):
`x = 9, y = 8, rule = DoubleB3S237.C\$6.3C\$5.2C.A3\$3C\$2.C\$.C!`
As you might be able to tell, performing this trick without DoubleB3S23 takes longer because you have to check for every possibility whether the combination of the bounding boxes of the results is smaller or not. I'm using glider-destruction.py, which minimises results based on bounding box. So the idea of simulating two diffrent patterns at once and studying the relative position of the outcome could potentially be very useful. Slow salvos, how to synthesise specific objects for cleaner syntheses. I don't know, it will take some creativity but there is something.
SoL : FreeElectronics : DeadlyEnemies : 6a-ite : Rule X3VI
what is “sesame oil”?

Rhombic

Posts: 1056
Joined: June 1st, 2013, 5:41 pm

What would the MAP strings for B1/S and B1/S012345678 be, given that the bottom left most cell is never born from the B1 condition?
Bored of using the Moore neighbourhood for everything? Introducing the Range-2 von Neumann isotropic non-totalistic rulespace!
muzik

Posts: 3404
Joined: January 28th, 2016, 2:47 pm
Location: Scotland

muzik wrote:What would the MAP strings for B1/S and B1/S012345678 be, given that the bottom left most cell is never born from the B1 condition?

Still waiting.
Bored of using the Moore neighbourhood for everything? Introducing the Range-2 von Neumann isotropic non-totalistic rulespace!
muzik

Posts: 3404
Joined: January 28th, 2016, 2:47 pm
Location: Scotland

muzik wrote:
muzik wrote:What would the MAP strings for B1/S and B1/S012345678 be, given that the bottom left most cell is never born from the B1 condition?

Still waiting.

I'm very curious, with all due respect, to know why you're still waiting instead of figuring it out yourself.

Given, say, Rhombic's script plus the MAP documentation in the LifeWiki, what exactly stops you from running the script once starting from B1/S or B1/S012345678, and getting the rule you want?

I can certainly add more paragraphs to the documentation if that would be helpful, but I don't know quite what's left that needs explaining.

dvgrn
Moderator

Posts: 5739
Joined: May 17th, 2009, 11:00 pm

Didn't realize those existed until now because i'm stupid. I'll try and get my head around it.
Bored of using the Moore neighbourhood for everything? Introducing the Range-2 von Neumann isotropic non-totalistic rulespace!
muzik

Posts: 3404
Joined: January 28th, 2016, 2:47 pm
Location: Scotland

muzik wrote:Didn't realize those existed until now because i'm stupid. I'll try and get my head around it.

Looking at it again, I see one thing that could make everything much easier.

I thought Rhombic's script defaulted to the current rule set in Golly, but it just defaults to B3/S23 (in MAP format).

EDIT: Just posted a Lua version of MAPper. Seems to work okay for the two cases mentioned above.

The script can double as a Life-like rule to MAP rule converter -- you can copy the MAP string out of the initial dialog, then cancel the script.

`Input=001000000[meaning001000000]-- B1/S-- aIAAAIAAAACAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA-- becomes-- aIAAAIAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA-- B1/S012345678-- aID//4AA//+AAP//AAD//4AA//8AAP//AAD//wAA//+AAP//AAD//wAA//8AAP//AAD//wAA//8AAP//AAD//w-- becomes-- aID//4AA//8AAP//AAD//4AA//8AAP//AAD//wAA//+AAP//AAD//wAA//8AAP//AAD//wAA//8AAP//AAD//w`

dvgrn
Moderator

Posts: 5739
Joined: May 17th, 2009, 11:00 pm

Cant exactly say these results were what I was expecting. I was expecting it to fill out like a heptagon, just like how this does a hexagon:
`x = 1, y = 1, rule = B1/SHo!`

However, the actual result is a Sierpinski triangle:
`x = 1, y = 1, rule = MAPaIAAAIAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAo!`

How could I get a replicator that forms a heptagon?
Bored of using the Moore neighbourhood for everything? Introducing the Range-2 von Neumann isotropic non-totalistic rulespace!
muzik

Posts: 3404
Joined: January 28th, 2016, 2:47 pm
Location: Scotland

muzik wrote:How could I get a replicator that forms a heptagon?

`x = 16, y = 5, rule = MAPaIAAAIAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5o2bo3b5o\$obobo3bo2bo3bo\$o2b2ob4obobobo\$o3bo3bo2bo3bo\$5o2bo3b5o!`

(B2e)
she/they // Please stop using my full name. Refer to me as dani.

"I'm always on duty, even when I'm off duty." -Cody Kolodziejzyk, Ph.D.

danny

Posts: 960
Joined: October 27th, 2017, 3:43 pm
Location: New Jersey, USA

That didn't do it.
`x = 1, y = 1, rule = MAPaIAAAIAAAAAAAAAAAAAAAICAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAo!`
Bored of using the Moore neighbourhood for everything? Introducing the Range-2 von Neumann isotropic non-totalistic rulespace!
muzik

Posts: 3404
Joined: January 28th, 2016, 2:47 pm
Location: Scotland

I think the limitations of the square grid may just prevent heptagon-shaped replicators entirely (for example, regular replicators don't form octagons either, but squares or diamonds).

77topaz

Posts: 1345
Joined: January 12th, 2018, 9:19 pm

77topaz wrote:I think the limitations of the square grid may just prevent heptagon-shaped replicators entirely (for example, regular replicators don't form octagons either, but squares or diamonds).

The Replicator rule allows for eightfold replication though.
Bored of using the Moore neighbourhood for everything? Introducing the Range-2 von Neumann isotropic non-totalistic rulespace!
muzik

Posts: 3404
Joined: January 28th, 2016, 2:47 pm
Location: Scotland

muzik wrote:The Replicator rule allows for eightfold replication though.

But that occurs in a square shape, not an octagonal shape:
`x = 3, y = 3, rule = B1357/S1357b2o\$2o\$bo!`

77topaz

Posts: 1345
Joined: January 12th, 2018, 9:19 pm

I asked for this before, but it got misunderstood, so I'm gonna try again.

I want a way to take a normal life-like rule, say B3678/S01245 (just an example) and run it so instead of the cells all updating simultaneously, they update in a specific asynchronous fashion.

The way cells should update is as follows:
At time 4n, all cells with even x and even y update.
At time 4n+1, all cells with odd x and even y update.
At time 4n+2, all cells with odd x and odd y update.
At time 4n+3, all cells with even x and odd y update.
In other words, 1/4 of the cells update at any given tick, and the locations of the cells that are updated alternately shift horizontally and vertically.

The motivation behind this is so I can take a rule such as B3678/S01245, where the B's are the complement of the S's, and turn it into a reversible rule.

Hopefully that was clear enough. Please, someone do this, because I'm really intrigued by this rulespace.
0.1485̅
Caenbe

Posts: 51
Joined: September 20th, 2016, 4:24 pm
Location: Nowhere Land, USA

Caenbe wrote:I asked for this before, but it got misunderstood, so I'm gonna try again.

I want a way to take a normal life-like rule, say B3678/S01245 (just an example) and run it so instead of the cells all updating simultaneously, they update in a specific asynchronous fashion.

The way cells should update is as follows:
At time 4n, all cells with even x and even y update.
At time 4n+1, all cells with odd x and even y update.
At time 4n+2, all cells with odd x and odd y update.
At time 4n+3, all cells with even x and odd y update.
In other words, 1/4 of the cells update at any given tick, and the locations of the cells that are updated alternately shift horizontally and vertically.

The motivation behind this is so I can take a rule such as B3678/S01245, where the B's are the complement of the S's, and turn it into a reversible rule.

Hopefully that was clear enough. Please, someone do this, because I'm really intrigued by this rulespace.

This sounds interesting, and I'd certainly be happy to help someone write a Lua or Python script to produce the necessary rule table. But I don't really need the practic -- so somebody else will have to make the initial effort.

To convert an arbitrary pattern to work like this, I think you'll just need an 8-state rule -- four OFF states and four ON states, but states 2 through 7 always just retain their state and cycle 3->5->7>1 and 2->4>6->0. The first part of the script just adds 2, 4, or 6 to the state number according to the location. That's a simple enough script for anyone to write in any language, given sufficient motivation.

Then you need more code to parse "B3678/S01245" into "B3", "B6", "B7", "B8", "S0", "S1", "S2", "S4", "S5". We can get away with permute symmetry as long as you don't need to support isotropic rules -- so you can have a lookup table that converts

"B3" into "0, 1,1,1,0,0,0,0,0, 1",
"B6" into "0, 1,1,1,1,1,1,0,0, 1",
"S5" into "1, 1,1,1,1,1,0,0,0, 1" and so on.

Then the script writes the relevant lines out to a rule table file, but with variables defining all the OFF and ON states replacing all but the first and last 0's and 1's above:

var OFF = {0,2,4,6}
var ON = {1,3,5,7}
var any1 = {0,1,2,3,4,5,6,7}
var any2 = any1
var any3 = any1
var any4 = any1
var any5 = any1
var any6 = any1
var any7 = any1
var any8 = any1

2,any,any,any,any,any,any,any,any,4
4,any,any,any,any,any,any,any,any,6
6,any,any,any,any,any,any,any,any,0
3,any,any,any,any,any,any,any,any,5
5,any,any,any,any,any,any,any,any,7
7,any,any,any,any,any,any,any,any,1

# B3
0,ON,ON,ON,OFF,OFF,OFF,OFF,OFF,1
# etc.

Does anyone have the code for writing two-state Life-like rules as rule tables, lying around somewhere? There seem to be rule tables showing up that look like they're generated by this kind of script, but I don't know where the code is offhand.

dvgrn
Moderator

Posts: 5739
Joined: May 17th, 2009, 11:00 pm

I think you've detailed quite a good scheme to simulate these rules. Just need to make sure that the scheme for translating On and Off cells to the corresponding state matches the spec for when they should transition. I think it's easier if the cell states cycle in the opposite direction, i.e. 7->5->3->1 and 6->4->2->0. Then converting a 2-state pattern to a valid starting pattern should be as simple as:

Cells which update in generations 4n+m have 2*m added to there current state. (Assuming the current generation is 0 (or divisible by 4).

The only other wrinkle is this won't work well with infinite layers in Golly - either run on a plane / torus, or add a ninth state and let 0 remain as vacuum.

dvgrn wrote:# B3
0,ON,ON,ON,OFF,OFF,OFF,OFF,OFF,1
# etc.

I think you need to amend this to include the state transitions. For the scheme I propose (and including survival rules for Life) this becomes:
`0,ON,ON,ON,OFF,OFF,OFF,OFF,OFF,7 # B31,ON,ON,OFF,OFF,OFF,OFF,OFF,OFF,7 # S21,ON,ON,ON,OFF,OFF,OFF,OFF,OFF,7 # S3`

Actually, after testing this I realise that additional variables are required for ON and OFF. Here's a complete test of the idea with B3/S23.
`@RULE AsyncLifeAn Asynchronous version of Conway's Game of Lifehttp://conwaylife.com/forums/viewtopic.php?p=61953#p61953Cells obey the usual rules of Life, but instead of the cells all updatingsimultaneously, they update in a specific asynchronous fashion.Cell states:0:       vacuumodd:    On cellseven:   Off cellsThe way cells update is as follows:At time 4n, all cells with even x and even y update (initialised to states 1 and 2).At time 4n+1, all cells with odd x and even y update (initialised to states 3 and 4).At time 4n+2, all cells with odd x and odd y update (initialised to states 5 and 6).At time 4n+3, all cells with even x and odd y update (initialised to states 7 and 8).@TABLEn_states: 9neighborhood: Mooresymmetries: permutevar OFF1 = {2,4,6,8}var OFF2 = OFF1var OFF3 = OFF1var OFF4 = OFF1var OFF5 = OFF1var OFF6 = OFF1var OFF7 = OFF1var OFF8 = OFF1var ON1 = {1,3,5,7}var ON2 = ON1var ON3 = ON1var ON4 = ON1var ON5 = ON1var ON6 = ON1var ON7 = ON1var ON8 = ON1var any1 = {1,2,3,4,5,6,7,8}var any2 = any1var any3 = any1var any4 = any1var any5 = any1var any6 = any1var any7 = any1var any8 = any1# Active cells2,ON1,ON2,ON3,OFF4,OFF5,OFF6,OFF7,OFF8,7    # B31,ON1,ON2,OFF3,OFF4,OFF5,OFF6,OFF7,OFF8,7    # S21,ON1,ON2,ON3,OFF4,OFF5,OFF6,OFF7,OFF8,7    # S32,any1,any2,any3,any4,any5,any6,any7,any8,81,any1,any2,any3,any4,any5,any6,any7,any8,8 # Death# Inactive cells4,any1,any2,any3,any4,any5,any6,any7,any8,26,any1,any2,any3,any4,any5,any6,any7,any8,48,any1,any2,any3,any4,any5,any6,any7,any8,63,any1,any2,any3,any4,any5,any6,any7,any8,15,any1,any2,any3,any4,any5,any6,any7,any8,37,any1,any2,any3,any4,any5,any6,any7,any8,5@COLORS0    0    0    01  255  255  2552   64   64   643  255    0    04   64    0    05  255  128    06   64   32    07  255  255    08   64   64    0`

And here's a quick and dirty script to initialise an asynchronous universe from a 2-state pattern:
`-- initAsyncUniverse - initialise a part of the universe to run asynchronous CA rules-- see http://conwaylife.com/forums/viewtopic.php?p=61953#p61953-- Author: Arie Paap, July 2018-- Credit: Based on Golly's invert.lua by Andrew Trevorrow-- Usage: Draw a pattern in a 2-state rule at Gen 0 and then run this scriptlocal g = golly()local gp = require "gplus"-- re-assigning inner loop functions results in a 10% speed uplocal setcell = g.setcelllocal getcell = g.getcell-- Determine the area to initialiselocal buffer = 50local r = g.getselrect()if #r == 0 then r = {0, 0, 0, 0} endr[1] = r[1] - bufferr[2] = r[2] - bufferr[3] = r[3] + 2*bufferr[4] = r[4] + 2*bufferr = gp.rect(r)-- Convert cells within this arealocal oldsecs = os.clock()local newsecs = os.clock()local state = 0for row = r.top, r.bottom do    -- if large selection then give some indication of progress    newsecs = os.clock()    if newsecs - oldsecs >= 1.0 then        oldsecs = newsecs        g.update()    end    for col = r.left, r.right do        state = 2 + 2 * ( 2*(row % 2) + (col % 2) )             setcell(col, row, state - getcell(col, row))    endend`

This is significantly more explosive than I was expecting. Here are two nice test patterns:
`x = 8, y = 2, rule = AsyncLife2A3.3A\$2A3.3A!`

`x = 3, y = 1, rule = AsyncLife3A!`

Run the script after opening each of these patterns in Golly.
@Caenbe: Does this match the behaviour you were hoping for?

dvgrn wrote:Does anyone have the code for writing two-state Life-like rules as rule tables, lying around somewhere? There seem to be rule tables showing up that look like they're generated by this kind of script, but I don't know where the code is offhand.

I think many of those rules have been hand written based on a template, though there may be a script. The saveContiguousLife() function from apgsearch should be easily adaptable to this task. It shouldn't be too much work to adapt it using the AsyncLife rule as a template and using the scoline() function to generate the Birth and Survival rules. I'll leave that to someone else though.
The latest version of the 5S Project contains over 196,000 spaceships. Tabulated pages up to period 160 are available on the LifeWiki.
wildmyron

Posts: 1209
Joined: August 9th, 2013, 12:45 am

dvgrn wrote:Does anyone have the code for writing two-state Life-like rules as rule tables, lying around somewhere? There seem to be rule tables showing up that look like they're generated by this kind of script, but I don't know where the code is offhand.

Well I have this one by EricG which works for all isotropic rules, so it should work for two-state Life-like rules:

`# HenselNotation->Ruletable(1.3).py#  by Eric Goldstein, July 20, 2012.import gollydialog_box_message =  '''This script will allow you to enter the non-totalistic rule notation used by Johan Bontes' Life32 program, based on work by Alan Hensel.Please look in the script file to see how the notation works.Newly created rules will be placed in Golly's Rules directory (set in Golly"s preferences).Note:  Alan Hensel's notation for r and y are swapped in Life32.   Life32's rule dialog boxshows the correct arrangements, but they are swapped in the implementation.What should work as 3r, 4r, and 5r, actually work as 3y, 4y, and 5y, and vice versa.This script swaps the definition of r and y just like Life32 does, so that rules willrun the same way using either Golly or Life32.An example rule is given below as a default.  Rules are case-insensitive.B2a/S12, S12/B2a, and 12/2a are valid and equivalent.  Inverse specifications are allowed.  For example, David Bell's Just Friends rule can be expressed B2-a/S12 indicating that all B2 arrangements are included except 2a.There are two ways to use this script.  Both ways will create a new ruletable, and set the active layer of Golly to use the new rule. 1) You can enter a rule below.2) You can copy the contents of a life32 file starting with "#r" and then clickon this script, after which you'll be able to paste the pattern into Golly's active layer.Enter a rule here:   '''# Golly"s ruletable format use the following notation:  #  C,N,NE,E,SE,S,SW,W,NW,C' # where C is the current state, and C' is the new state, and# where the eight neighbors in the Moore neighborhood are as shown below.#     NW  N  NE #     W   C  E  #     SW  S  SE # The lookup table below for Life32"s non-totalistic notation uses the eight neighbor values:#   N,NE,E,SE,S,SW,W,NW# The following code shows how the non-totalistic notation works:notationdict = {                   "1e" : "1,0,0,0,0,0,0,0",  #   N                  "1c" : "0,1,0,0,0,0,0,0",  #   NE                 "2a" : "1,1,0,0,0,0,0,0",  #   N,  NE                 "2e" : "1,0,1,0,0,0,0,0",  #   N,  E                  "2k" : "1,0,0,1,0,0,0,0",  #   N,  SE                 "2i" : "1,0,0,0,1,0,0,0",  #   N,  S                  "2c" : "0,1,0,1,0,0,0,0",  #   NE, SE                 "2v" : "0,1,0,0,0,1,0,0",  #   NE, SW                 "3a" : "1,1,1,0,0,0,0,0",  #   N,  NE, E                 "3v" : "1,1,0,1,0,0,0,0",  #   N,  NE, SE                  "3y" : "1,1,0,0,1,0,0,0",  #   N,  NE, S      (3r in non-swapped notation)                 "3q" : "1,1,0,0,0,1,0,0",  #   N,  NE, SW                 "3j" : "1,1,0,0,0,0,1,0",  #   N,  NE, W                 "3i" : "1,1,0,0,0,0,0,1",  #   N,  NE, NW                 "3e" : "1,0,1,0,1,0,0,0",  #   N,  E,  S                 "3k" : "1,0,1,0,0,1,0,0",  #   N,  E,  SW                 "3r" : "1,0,0,1,0,1,0,0",  #   N,  SE, SW     (3y in non-swapped notation)                 "3c" : "0,1,0,1,0,1,0,0",  #   NE, SE, SW                  "4a" : "1,1,1,1,0,0,0,0",  #   N,  NE, E,  SE                 "4y" : "1,1,1,0,1,0,0,0",  #   N,  NE, E,  S  (4r in non-swapped notation)                 "4q" : "1,1,1,0,0,1,0,0",  #   N,  NE, E,  SW                 "4i" : "1,1,0,1,1,0,0,0",  #   N,  NE, SE, S                 "4r" : "1,1,0,1,0,1,0,0",  #   N,  NE, SE, SW (4y in non-swapped notation)                 "4k" : "1,1,0,1,0,0,1,0",  #   N,  NE, SE, W                 "4v" : "1,1,0,1,0,0,0,1",  #   N,  NE, SE, NW                  "4z" : "1,1,0,0,1,1,0,0",  #   N,  NE, S,  SW                 "4j" : "1,1,0,0,1,0,1,0",  #   N,  NE, S,  W                 "4t" : "1,1,0,0,1,0,0,1",  #   N,  NE, S,  NW                 "4w" : "1,1,0,0,0,1,1,0",  #   N,  NE, SW, W                 "4e" : "1,0,1,0,1,0,1,0",  #   N,  E,  S,  W                 "4c" : "0,1,0,1,0,1,0,1",  #   NE, SE, SW, NW                 "5a" : "0,0,0,1,1,1,1,1",  #   SE, S,  SW, W,  NW                 "5v" : "0,0,1,0,1,1,1,1",  #   E,  S,  SW, W,  NW                 "5y" : "0,0,1,1,0,1,1,1",  #   E,  SE, SW, W,  NW (5r in non-swapped notation)                 "5q" : "0,0,1,1,1,0,1,1",  #   E,  SE, S,  W,  NW                 "5j" : "0,0,1,1,1,1,0,1",  #   E,  SE, S,  SW, NW                  "5i" : "0,0,1,1,1,1,1,0",  #   E,  SE, S,  SW, W                  "5e" : "0,1,0,1,0,1,1,1",  #   NE, SE, SW, W,  NW,                  "5k" : "0,1,0,1,1,0,1,1",  #   NE, SE, S,  W,  NW                 "5r" : "0,1,1,0,1,0,1,1",  #   NE, E,  S,  W, NW  (5y in non-swapped notation)                 "5c" : "1,0,1,0,1,0,1,1",  #   N,  E,  S,  W,  NW                 "6a" : "0,0,1,1,1,1,1,1",  #   E,  SE, S,  SW, W,  NW                 "6e" : "0,1,0,1,1,1,1,1",  #   NE, SE, S,  SW, W,  NW                 "6k" : "0,1,1,0,1,1,1,1",  #   NE, E,  S,  SW, W,  NW                 "6i" : "0,1,1,1,0,1,1,1",  #   NE, E,  SE, SW, W,  NW                 "6c" : "1,0,1,0,1,1,1,1",  #   N,  E,  S,  SW, W,  NW                 "6v" : "1,0,1,1,1,0,1,1",  #   N,  E,  SE, S,  W,  NW                 "7e" : "0,1,1,1,1,1,1,1",  #   NE, E,  SE, S,  SW, W,  NW                  "7c" : "1,0,1,1,1,1,1,1"   #   N,  E,  SE, S,  SW, W,  NW                }#  Here's a graphical depiction of the notation.dummyvariable = '''x = 147, y = 97, rule = B/S01234567821b3o6b5o5bo3bo6b3o6b5o5bo3bo5bo3bo6b3o10bo5b4o6b5o5bobobo5b5o\$20bo3bo5bo9bo2bo6bo3bo7bo7bo3bo5bo3bo5bo3bo9bo5bo3bo7bo7bobobo9bo\$20bo9bo9bobo7bo3bo7bo7bo3bo5bo3bo5bo3bo9bo5bo3bo7bo7bobobo8bo\$20bo9b3o7b2o8b5o7bo7bo3bo6bobo6bo3bo9bo5b4o8bo7bobobo7bo\$20bo9bo9bobo7bo3bo7bo7bo3bo7bo7bobobo5bo3bo5bo3bo7bo7bobobo6bo\$20bo3bo5bo9bo2bo6bo3bo7bo8bobo8bo7bo2bo6bo3bo5bo3bo7bo7bobobo5bo\$21b3o6b5o5bo3bo5bo3bo5b5o7bo9bo8b2obo6b3o6bo3bo7bo8bobo6b5o4\$b3o6b7o\$o3bo5bo5bo\$o2b2o5bo5bo\$obobo5bo2bo2bo\$2o2bo5bo5bo\$o3bo5bo5bo\$b3o6b7o4\$b2o17b7o3b7o\$obo17bo5bo3bo5bo\$2bo17bobo3bo3bo2bo2bo\$2bo17bo2bo2bo3bo2bo2bo\$2bo17bo5bo3bo5bo\$2bo17bo5bo3bo5bo\$5o15b7o3b7o4\$b3o16b7o3b7o3b7o3b7o3b7o3b7o\$o3bo15bo5bo3bo5bo3bo5bo3bo5bo3bo5bo3bo5bo\$4bo15bobobobo3bo2bo2bo3bobo3bo3bobo3bo3bo2bo2bo3bo3bobo\$3bo16bo2bo2bo3bob2o2bo3bo2bo2bo3bob2o2bo3bo2bo2bo3bo2bo2bo\$2bo17bo5bo3bo5bo3bo2bo2bo3bo5bo3bo2bo2bo3bobo3bo\$bo18bo5bo3bo5bo3bo5bo3bo5bo3bo5bo3bo5bo\$5o15b7o3b7o3b7o3b7o3b7o3b7o4\$b3o16b7o3b7o3b7o3b7o3b7o3b7o3b7o3b7o3b7o3b7o\$o3bo15bo5bo3bo5bo3bo5bo3bo5bo3bo5bo3bo5bo3bo5bo3bo5bo3bo5bo3bo5bo\$4bo15bobobobo3bo2bo2bo3bobo3bo3bob2o2bo3bo3bobo3bobobobo3bo2b2obo3bo3bobo3bo3bobo3bobobobo\$2b2o16bo2bo2bo3bob2o2bo3bo2b2obo3bob2o2bo3bo2b2obo3bob2o2bo3bo2bo2bo3bo2bo2bo3bo2b2obo3bo2bo2bo\$4bo15bobo3bo3bo2bo2bo3bo2bo2bo3bo5bo3bo3bobo3bo5bo3bo2bo2bo3bob2o2bo3bo2bo2bo3bo2bo2bo\$o3bo15bo5bo3bo5bo3bo5bo3bo5bo3bo5bo3bo5bo3bo5bo3bo5bo3bo5bo3bo5bo\$b3o16b7o3b7o3b7o3b7o3b7o3b7o3b7o3b7o3b7o3b7o4\$2b2o16b7o3b7o3b7o3b7o3b7o3b7o3b7o3b7o3b7o3b7o3b7o3b7o3b7o\$bobo16bo5bo3bo5bo3bo5bo3bo5bo3bo5bo3bo5bo3bo5bo3bo5bo3bo5bo3bo5bo3bo5bo3bo5bo3bo5bo\$o2bo16bobobobo3bo2bo2bo3bo2b2obo3bob3obo3bob2o2bo3bobobobo3bob2o2bo3bob2o2bo3bo3bobo3bobobobo3bob3obo3bobo3bo3bob2o2bo\$5o15bo2bo2bo3bob3obo3bob2o2bo3bob2o2bo3bo2bo2bo3bob2o2bo3bob2o2bo3bob2o2bo3bob3obo3bo2bo2bo3bo2bo2bo3bob2o2bo3bo2bo2bo\$3bo16bobobobo3bo2bo2bo3bo3bobo3bo5bo3bob2o2bo3bobo3bo3bo2bo2bo3bo3bobo3bo2bo2bo3bob2o2bo3bo2bo2bo3bo2b2obo3bo2b2obo\$3bo16bo5bo3bo5bo3bo5bo3bo5bo3bo5bo3bo5bo3bo5bo3bo5bo3bo5bo3bo5bo3bo5bo3bo5bo3bo5bo\$3bo16b7o3b7o3b7o3b7o3b7o3b7o3b7o3b7o3b7o3b7o3b7o3b7o3b7o4\$5o15b7o3b7o3b7o3b7o3b7o3b7o3b7o3b7o3b7o3b7o\$o19bo5bo3bo5bo3bo5bo3bo5bo3bo5bo3bo5bo3bo5bo3bo5bo3bo5bo3bo5bo\$4o16bo2bo2bo3bobobobo3bo2b2obo3bo3bobo3bob2o2bo3bobo3bo3bobobobo3bob2o2bo3bob2o2bo3bobobobo\$4bo15bob3obo3bo2b2obo3bob2o2bo3bo2b2obo3bob2o2bo3bob3obo3bob3obo3bob2o2bo3bob2o2bo3bob3obo\$4bo15bo2b2obo3bobobobo3bobobobo3bob3obo3bob2o2bo3bob2o2bo3bobo3bo3bo2b2obo3bobobobo3bo2bo2bo\$o3bo15bo5bo3bo5bo3bo5bo3bo5bo3bo5bo3bo5bo3bo5bo3bo5bo3bo5bo3bo5bo\$b3o16b7o3b7o3b7o3b7o3b7o3b7o3b7o3b7o3b7o3b7o4\$b3o16b7o3b7o3b7o3b7o3b7o3b7o\$o3bo15bo5bo3bo5bo3bo5bo3bo5bo3bo5bo3bo5bo\$o19bo2bo2bo3bobobobo3bo2b2obo3bo2b2obo3bobobobo3bob2o2bo\$4o16bob3obo3bo2b2obo3bob3obo3bo2b2obo3bob3obo3bob3obo\$o3bo15bob3obo3bob3obo3bobobobo3bob3obo3bobobobo3bo2b2obo\$o3bo15bo5bo3bo5bo3bo5bo3bo5bo3bo5bo3bo5bo\$b3o16b7o3b7o3b7o3b7o3b7o3b7o4\$5o15b7o3b7o\$4bo15bo5bo3bo5bo\$3bo16bo2b2obo3bob3obo\$3bo16bob3obo3bo2b2obo\$2bo17bob3obo3bob3obo\$2bo17bo5bo3bo5bo\$2bo17b7o3b7o4\$b3o6b7o\$o3bo5bo5bo\$o3bo5bob3obo\$b3o6bob3obo\$o3bo5bob3obo\$o3bo5bo5bo\$b3o6b7o!'''# The following function takes a rule element like B2a or B2-a and creates the appropriate ruletable row.# Parameters:# bs is a string with one of two values "0," to indicate birth, and "1," to indicates survival.# totalistic_num is one character string "0" ... "8"# notation_letter is a one character string indicating Hensel's notation "a", # inverse_list is a list of notation letters for inverse notation def create_table_row(bs,totalistic_num, notation_letter, inverse_list):   result = ""   if totalistic_num == "0":     result = bs + "0,0,0,0,0,0,0,0" + ",1"+"\n"     elif totalistic_num == "8":     result = bs + "1,1,1,1,1,1,1,1" + ",1" +"\n"     elif notation_letter != "none":      result = bs + notationdict[totalistic_num+notation_letter] + ",1" +"\n"   elif inverse_list != []:      for i in notationdict:          if not (i[1] in inverse_list) and i.startswith(totalistic_num):            result = result +  bs + notationdict[i] + ",1" +"\n"   else:       for i in notationdict:         if i.startswith(totalistic_num):            result = result +  bs + notationdict[i] + ",1" + "\n"   return resultCR = chr(13)LF = chr(10)pastepattern = "none"yourclipboard = golly.getclipstr()yourclipboard = yourclipboard.replace(CR+LF,LF)yourclipboard = yourclipboard.replace(CR,LF)if yourclipboard.startswith("#r "):  rulestring = yourclipboard.split(" ")[1].split("\n")[0]  pastepattern = yourclipboard.split("#r "+rulestring)[1] else:  rulestring = golly.getstring(dialog_box_message, "B2a/S12") # The following code cleans up the rulestring# so that it makes a valid and somewhat readable file name - eg "B2-a_S12.table"rulestring = rulestring.replace(" ", "")rulestring = rulestring.lower()rulestring = rulestring.replace("b", "B")rulestring = rulestring.replace("s", "S")# The variable named rulestring will be parsed.  # The variable named rule_name will be the name of the new file.# Valid rules contain a slash character but filenames can not include slashes.rule_name = rulestring.replace("/", "_")  # To do:  Allow the user to specify their own name for a rule.#  The following code cleans up the rule string to #  make life easier for the parser.if rulestring.startswith("B") or rulestring.startswith("S"):    rulestring = rulestring.replace("/", "")else:    rulestring = rulestring.replace("/", "B")rulestring = rulestring + "\n"  # Lets make a new filef = open(golly.getdir("rules")+rule_name+".table", "w")# Now create the header for the rule tableneighborhood = "Moore"  # Incorporate Paul Callahan's hexagonal non-totaistic notation next?f.write("neighborhood:"+neighborhood+"\n")# The next line is where the magic happens! f.write("symmetries:rotate4reflect\n") # Lets stick with 2 states for now, but it would be interesting # to add generations-style decay states, as MCell's Weighted Life does.n_states = 2   f.write("n_states:"+str(n_states)+"\n\n")f.write("""var a={0,1}var b={0,1}var c={0,1}var d={0,1}var e={0,1}var f={0,1}var g={0,1}var h={0,1}""")# Now that the header for the rule table has been created, # parse the rulestring, and add rows to the ruletable as we go.# Lets say rule strings contain "rule elements", such as B2i, or B2-a, which are composed of: # 1) a birth or survival flag # 2) a "totalistic context" consisting of an integer between zero and 8# 3) a "notation_letter".   # 4) a flag for "positive" or "inverse" notationbs = "1,"                        # Use "1," for survival or "0," for birthtotalistic_context = "none"      # "none" will be replaced with "0" through                                 # "8" by the parser.last_totalistic_context = "none" # Lets the parser remember the previous                                   # integer it encountered.notation_letter = "none"         # "none","a", "e", "i", etc.positive_or_inverse = "positive" inverse_list = []for x in rulestring:  if x == "S" or x == "B" or x.isdigit() or x == "\n":     last_totalistic_context = totalistic_context        totalistic_context = x                              if last_totalistic_context != "none"  and notation_letter == "none":         f.write(create_table_row(bs, last_totalistic_context, "none",[]))                  if last_totalistic_context != "none" and  positive_or_inverse == "inverse":         f.write(create_table_row(bs, last_totalistic_context, "none", inverse_list))       # Now lets get ready to move on to the next character.     notation_letter = "none"     inverse_list = []     positive_or_inverse = "positive"     if x == "S" or x == "B":         totalistic_context = "none"     if x == "S":         bs = "1,"     if x == "B":          bs = "0,"  elif x == "-":    positive_or_inverse = "inverse"  elif x in ["c", "a", "e", "k", "i", "v", "j", "y", "q", "r", "w", "t", "z"] and totalistic_context != "none":     if positive_or_inverse == "positive":        notation_letter = x        f.write(create_table_row(bs, totalistic_context, notation_letter, []))         else:        notation_letter = x        inverse_list.append(x) f.write("# Death otherwise"+"\n")f.write("1,a,b,c,d,e,f,g,h,0"+"\n\n")f.flush()f.close()golly.setalgo("RuleTable")golly.setrule(rule_name)if pastepattern != "none":  golly.setclipstr(pastepattern)  golly.show("Paste the pattern when you are ready....")else:  golly.show("Created "+rule_name+".table in "+golly.getdir("rules"))`

Goldtiger997

Posts: 531
Joined: June 21st, 2016, 8:00 am
Location: 11.329903°N 142.199305°E

Goldtiger997 wrote:
dvgrn wrote:Does anyone have the code for writing two-state Life-like rules as rule tables, lying around somewhere? There seem to be rule tables showing up that look like they're generated by this kind of script, but I don't know where the code is offhand.

Well I have this one by EricG which works for all isotropic rules, so it should work for two-state Life-like rules:

<snip script>

That's overkill for asynchronous versions of Life-Like rules, but isotropic versions may well be of interest too.
The latest version of the 5S Project contains over 196,000 spaceships. Tabulated pages up to period 160 are available on the LifeWiki.
wildmyron

Posts: 1209
Joined: August 9th, 2013, 12:45 am

Nice work! So now the only remaining detail is to adapt EricG's script to write out a rule table for an arbitrary rule, using variables instead of 0's and 1's, and then switch to that rule.

Some good code to borrow to get the rule file placed in the right place might be simsim314's LifeHistory2Life.py script.

Sure is hard to see Conway's Life in that rule's behavior, except that still lifes are all the same.

dvgrn
Moderator

Posts: 5739
Joined: May 17th, 2009, 11:00 pm

wildmyron wrote:Does this match the behaviour you were hoping for?

I don't know. The script is giving me errors. The first one was from one of the comments, so I deleted all the comments, and now I'm getting an error from the "local g = golly()" thing.

wildmyron wrote: state = 2 + 2 * ( 2*(row % 2) + (col % 2) )
setcell(col, row, state - getcell(col, row))

It looks it's going to cause the update order to be off. I mentioned earlier
Caenbe wrote:the locations of the cells that are updated alternately shift horizontally and vertically.

This looks like it's going to alternate between shifting horizontally and diagonally. I think it should be:
state = 2 + 2 * ( 2*(row % 2) + ((row + col) % 2) )
setcell(col, row, state - getcell(col, row))
0.1485̅
Caenbe

Posts: 51
Joined: September 20th, 2016, 4:24 pm
Location: Nowhere Land, USA

Caenbe wrote:I don't know. The script is giving me errors. The first one was from one of the comments, so I deleted all the comments, and now I'm getting an error from the "local g = golly()" thing.

How are you trying to run that script, exactly? That one is in Lua, but Golly ordinarily figures out automatically if the script is Lua or Python. So the only way I can think that you'd get an error from "local g = golly()" (or those comments) would be if you're opening a Python command line, or trying to run the script via IDLE, something like that (?).

-- Or if you're running a version of Golly before 3.0. If you're doing that, then please either upgrade to Golly 3.x, or learn how to back-port Lua scripts to Python. Golly 2.x doesn't support Lua scripts.

EDIT: Or possibly if you saved the file with a .py extension... yes, aha, that does fake Golly out. Rename it to something.lua and try it again.

EDIT2: Oh, good -- problem solved.

Really, for the scripts above, or most Golly scripts, the quickest way to try them out is to copy them to the clipboard, then choose File > Run Clipboard.

dvgrn
Moderator

Posts: 5739
Joined: May 17th, 2009, 11:00 pm

dvgrn wrote:
Caenbe wrote:I don't know. The script is giving me errors. The first one was from one of the comments, so I deleted all the comments, and now I'm getting an error from the "local g = golly()" thing.

How are you trying to run that script, exactly? That one is in Lua, but Golly ordinarily figures out automatically if the script is Lua or Python. So the only way I can think that you'd get an error from "local g = golly()" (or those comments) would be if you're opening a Python command line, or trying to run the script via IDLE, something like that (?). Or if you're running a version of Golly before 3.0. If you're doing that, then please either upgrade to Golly 3.x, or learn how to back-port Lua scripts to Python. Golly 2.x doesn't support Lua scripts.

For the scripts above, or most Golly scripts, the quickest way to try them out is to copy them to the clipboard, then choose File > Run Clipboard.

Ohhhh, it's Lua. That explains it. I saved it as a .py file.
EDIT: I guess I should have mentioned, I don't have Lua yet. So, that'll be a blast to get working.
EDIT 2: Yep, thanks, just figured out Lua is already in Golly.
Last edited by Caenbe on July 18th, 2018, 8:56 am, edited 1 time in total.
0.1485̅
Caenbe

Posts: 51
Joined: September 20th, 2016, 4:24 pm
Location: Nowhere Land, USA

PreviousNext