ConwayLife.com

Being naturally lazy, I don't really want to have to figure out any of these specification languages, so could someone reply with a template specification that I only have to fill in the S, B, & neighborhood data? Any specification scheme is fine with me as long as I can understand how to do the S, B, and neighborhood specs.

Here are the kind of simple games that I need a template for:

1) Simple S and B specs, such as B3/S23 is all I need for S & B part of the specs.

2) include or exclude any relatively near by neighborhood cells as part of the S & B calculations including 0 to 8 neighbors PLUS, more importantly, other neighbors as well.

I would like individual cell control over its inclusion in S & B calculations, any cell within a few cells of the center for starters, and maybe even further away later.

That is ALL I need. Can anyone help?

Thanks, jks

That's not really how the golly rule table system works. You should look into it; it is intimidating at first, but really incredibly simple.

That's not really how the golly rule table system works. You should look into it; it is intimidating at first, but really incredibly simple.

Gee, thanks for the great example, I'll put it into golly and run it...chuckle

How about an incredibly simple example using a cell beyond 0-8?

I've looked at the rule table stuff a little, but the stuff is so foreign to me I have not been able to recognize any examples or reference to using neighborhood cells beyond 0-8.

If the incredibly simple thing I am asking for is not possible, please help me understand why.

Thanks, jks

The rule table works by defining situations: Is not a very human looking thing, but think of it this way: In the above situation, if a cell that is a 0 has 0's around it except for a one on top, then it becomes 1. Every one of those digits represents one cell, like so: The rest is explained here:
http://golly.sourceforge.net/Help/formats.html#table

Also, none of us appreciate your sarcasm.
I was considering not even doing this for you.

part 2:
When you use symmetries, things get complicated, because just putting in 2 cells will only count for 2 adjacent cells, not a total of 2, so you have to go through all positions like so:

0-
0,0,0,0,0,0,0,0,0,2

1-
0,1,0,0,0,0,0,0,0,2

2-
0,1,1,0,0,0,0,0,0,2
0,1,0,1,0,0,0,0,0,2
0,1,0,0,1,0,0,0,0,2
0,1,0,0,0,1,0,0,0,2

3-
0,1,1,1,0,0,0,0,0,2
0,1,1,0,1,0,0,0,0,2
0,1,1,0,0,1,0,0,0,2
0,1,0,1,0,1,0,0,0,2
0,1,0,1,0,0,1,0,0,2

4-
0,1,1,1,1,0,0,0,0,2
0,1,1,1,0,1,0,0,0,2
0,1,1,1,0,0,1,0,0,2
0,1,1,0,1,1,0,0,0,2
0,1,1,0,1,0,1,0,0,2
0,1,0,1,0,1,0,1,0,2

5-
0,1,1,1,1,1,0,0,0,2
0,1,1,1,1,0,1,0,0,2
0,1,1,1,0,1,1,0,0,2
0,1,1,1,0,1,0,1,0,2
0,1,1,0,1,1,0,1,0,2

6-
0,1,1,1,1,1,1,0,0,2
0,1,1,1,1,1,0,1,0,2
0,1,1,1,1,0,1,1,0,2
0,1,1,1,0,1,1,1,0,2

7-
0,1,1,1,1,1,1,1,0,2

8-
0,1,1,1,1,1,1,1,1,2

Also, you may want to check out this: http://code.google.com/p/ruletablerepos ... /TheFormat

Axaj wrote:Also, you may want to check out this: http://code.google.com/p/ruletablerepos ... /TheFormat

Thanks, I'd skimmed the page before, but took a closer look and found a link to the neighborhood Roadmap, and then I finally discovered what I was after way at the bottom of the page:

...Larger than Life, relies on large neighborhoods; these are not currently supported by Golly.

Also thanks to everybody for the help so far.

So now I am assuming I should pursue Larger than Life. Does that sound right to you? And if this is so, what program would you recommend since golly doesn't support what I need?

Thanks again, jks

PS Axaj - concerning

Also, none of us appreciate your sarcasm.

I'm sorry about that. I meant it in good humor while in the depths of frustration about not finding what I needed.

BTW, times have changed a lot! golly and programs like it are pretty amazing. In the 1970s I wrote a simple version of Game of Life on a mainframe Cyber 6400. It had 60 bit words, which was a big thing in those days. I used parallel word boolean and shift operations to construct the arithmetic and produced results for 60 cells in parallel in about a dozen machine cycles. For those days, it was lightening fast. By todays standards, it was like a snail. But like I say, times have changed. I have sitting on my shelf the manual for my very first IBM PC. It contains instructions for installing an 8K memory board for main memory on a PC.

Also, what I could program in a couple of hours in those days sometimes takes me 2 days now days....the dangers of aging...sigh.

...Larger than Life, relies on large neighborhoods; these are not currently supported by Golly.

I originally wrote that comment, but with the British spelling of "neighbourhoods".

To answer your question, MCell is a good program for experimenting with Larger than Life. The interface isn't as nice as Golly or Life32, though.

It had 60 bit words, which was a big thing in those days.

It's still a big thing nowadays -- my computer has 32-bit registers.


By the way, the algorithm behind Golly is Gosper's HashLife (albeit a very efficient implementation by Tom Rokicki), which dates back to the early 1980s.

Ok, I checked out MCell, and Larger than Life. Still no joy. I looked over the various rules and most of them assume 0-8 and those that consider larger neighborhoods, consider them inclusively. That doesn't do it for me.

I need to find a program that supports something like the following (I hope I am not driven to having to write a dll).

The first time around I want to consider only certain cells in a set of cells like: n, ne, e, se, s, sw, w, nw, n2, nne2, ne2, ene2, e2, ese2, se2, sse2, s2, ssw2, sw2, wsw2, w2, nnw2, nw2, nnw2.

My reasons aren't arbitrary. I have something very specific in mind that I have reasonable hope will work well.

Again, what I am after is an outer totalistic rule like life: M:S23/B3 but extended for additional rows of cells and masked so that only certain cells in the neighborhood effect S & B.

Cheers,
jks

PS Just a thought, but could I do something in Python that would make larger neighborhoods work for at least one of the algorithms in Golly?

jks wrote:Ok, I checked out MCell, and Larger than Life. Still no joy. I looked over the various rules and most of them assume 0-8 and those that consider larger neighborhoods, consider them inclusively. That doesn't do it for me.

I need to find a program that supports something like the following (I hope I am not driven to having to write a dll).

The first time around I want to consider only certain cells in a set of cells like: n, ne, e, se, s, sw, w, nw, n2, nne2, ne2, ene2, e2, ese2, se2, sse2, s2, ssw2, sw2, wsw2, w2, nnw2, nw2, nnw2.

My reasons aren't arbitrary. I have something very specific in mind that I have reasonable hope will work well.

Again, what I am after is an outer totalistic rule like life: M:S23/B3 but extended for additional rows of cells and masked so that only certain cells in the neighborhood effect S & B.

Cheers,
jks

PS Just a thought, but could I do something in Python that would make larger neighborhoods work for at least one of the algorithms in Golly?

Actually, a python scripts for rules with odd neighborhoods have been shown to work. You could definitely try one.