Golly 2.5 has been released

[Rlo]

You can toggle the grid on and off with the 'L' key. There's also a setting in File > Preferences > View that lets you set how close you have to zoom in before the grid appears.

Sadly, I spoke poorly when I said grid-spacing. I was referring to the spacing between cells at higher magnification. That spacing stops when at magnifications of 1:2 and further, but appears regardless of your grid setting when closer than that. My apologies.

However, thanks for the tip about the min and max delay, I must have overlooked that. It is close to what I am needing and will make it easier for me!

[Andrew]

I was referring to the spacing between cells at higher magnification. That spacing stops when at magnifications of 1:2 and further, but appears regardless of your grid setting when closer than that.

Can you describe in more detail why you don't like the gap between cells? (I'd have to say I'll need a very convincing argument to bother providing an option to disable the gap. Doing so would complicate the rendering code, the click detection code, the icon mode display, etc. I think having a gap between cells is far more aesthetically pleasing than no gap.)

[Rlo]

I would be happy to. From an aesthetic point of view I can't argue against your own preference but merely state mine. I'll try my best to be convincing but ultimately aesthetic is a choice of preference, not a ruleset.

It is important, in my opinion, to remember that a grid--in this case the uniform spacing between cells-- is just a specific type of outline. All things have outlines, where a shape is defined by visual cues that make us perceive differences between one body and another. For eyes it could be a difference in light, or depth. So when we outline an object we are breaking it apart from the things around it and when we don't we are connecting it. Our eyes have had millions of experiences in this cue and know it very well.

In game of life a major aspect (for me at least) is how individual cells interact with one another. Yet there are objects which act as larger bodies than their individual cells. Working collectively, these cells act differently than when alone. Whether that be movement or stasis it is their 'togetherness' that makes them what they are. Therefore, without a grid outlining each individual cell their outline becomes that of the whole organism rather than the individual parts. This, to me, is an important visual cue.

It is a visual cue, to the viewer, of scale or importance. Of interest or disinterest, of attention, of connection or separation. All of which are helpful and powerful for an image to have its desired impact or for attention to be drawn accurately, and it's an important aspect for image makers to have control over.

If you'd like I can make an example to show you what I mean, but I don't want to take up too much of your time. I appreciate your letting me state my case.

[Andrew]

Thanks for expanding on your reasons. I'd argue that you always have the option of using scale 1:1 or 1:2 to view a pattern as a "whole organism". If we were to disable the gaps at larger cell sizes then turning the grid lines on or off would look quite ugly (either the pattern would shift slightly or the cells would appear to change size slightly). Having a grid is absolutely vital for many editing tasks so we certainly don't want to abandon the option of seeing grid lines. Given that requirement, the only way to have a nice transition from grid to no grid is to have a gap between cells (at least I can't think of a nicer solution).

[Extrementhusiast]

Although this is a bit late, I would kinda like to see the odd-numbered Wolfram rules treated like the B0 rules: alternating phase for odd numbers less than 128, and reversed phase for odd numbers greater than 128.

Also, is there a generation-parity-dependent variable for rule tables or trees with this new Golly version? (like the B0 rules)

[Sphenocorona]

Although this is a bit late, I would kinda like to see the odd-numbered Wolfram rules treated like the B0 rules: alternating phase for odd numbers less than 128, and reversed phase for odd numbers greater than 128.

I would have to agree with the above.

I was wondering something my self: will we be able to have variables that can be specified without changing the .rule file, so that we can have a family of rules generated by one .rule file? For example, imagine if I was going to make a family of rules where the state of a cell (we'll call it C) next generation is determined by:

1. taking the states of its neighbors NW-N-NE
2. applying an elementary 1-dimensional rule (e.g. rule 110) to those cells, and returning the value of the center cell (in this case north)
3. repeating step 2 with the sets NE-E-SE, SE-S-SW, and SW-W-NW, and finally
4. taking the four returned values and using them to determine the state of cell C through an outer-totalistic Von-Neumann neighborhood CA such as B1/S23V.

So, I make a rule like that and call it Wolfjvn. Would I be able to make the rule file so that I could type in something like "Wolfjvn:I~W-110,J-23/1" ? (the extensions don't have to be quite like that, but it's just a general idea) I think that would be a really nice addition to the .rule format, as it would be a perfect application of the programming-language style format allowed by the .rule format that RuleTree and RuleTable don't have.

[EricG]

Sphenocorona, The very quick answer is that you'd want to create a rule-generating script for that, and that would most easily be done by adapting code from the extremely useful make-ruletree.py script distributed with Golly. The .rule format merely combines .tree, .table, .colors, and .icons files into one format. Look back to the example of a .rule file that Andrew provided at the beginning of this thread. What looks like code is actually a comment, and is preceded by this note: "The @TREE data was created by copying the following Python code to the clipboard and running Golly's make-ruletree.py script."

(I'm halfway done with a script that does what you're interested in. I'll post it as an example when it is ready.)

[Rlo]

Thanks for expanding on your reasons. I'd argue that you always have the option of using scale 1:1 or 1:2 to view a pattern as a "whole organism". If we were to disable the gaps at larger cell sizes then turning the grid lines on or off would look quite ugly (either the pattern would shift slightly or the cells would appear to change size slightly). Having a grid is absolutely vital for many editing tasks so we certainly don't want to abandon the option of seeing grid lines. Given that requirement, the only way to have a nice transition from grid to no grid is to have a gap between cells (at least I can't think of a nicer solution).

There is another way I think, as it stands (at 1:32 magnification) your cells are 31x31 with a 1px padding along the right and bottom. This makes them 32x32 total.

At 1:16, 15x15 with 1px padding in right and bottom. 1:8, 7x7 with 1px padding. 1:4, 3x3 1px padding.

If you were to extend the color of every cell to the right and down by one pixel that would effectively cover the grid and you wouldn't have any spacing issues. I've attached a gif of what that would look like at 1:32.



As you can probably see the difference in cell size is minimal but the visual effect is not so minimal.

[Andrew]

As you can probably see the difference in cell size is minimal but the visual effect is not so minimal.

I'm not sure whether you mean the not-so-minimal visual effect is a good thing or a bad thing! Personally I find it rather odd and distracting (and would probably be even worse for white cells on a dark background).

Also, what do we do in icon mode? There are some rules with icons that fill all of a cell, so what should happen when grid lines are turned off in that case? I can only think of 3 options:

1. Just have gaps between icons (inconsistent with your non-icon mode).
2. Automatically scale the icons to cover the gaps (ugly!).
3. Tell users to create yet more icon sizes at 8x8, 16x16 and 32x32 (unacceptable!).

Anyway, Golly is open source so if someone wanted to add an option for gapless cells then I've no great objection, but I think it will involve some rather messy changes with very little benefit.

[Andrew]

Although this is a bit late, I would kinda like to see the odd-numbered Wolfram rules treated like the B0 rules: alternating phase for odd numbers less than 128, and reversed phase for odd numbers greater than 128.

I looked at this a couple of years ago but there were some tricky issues (I forget the details) so decided not to bother, especially after people wrote scripts to allow exploration of odd-numbered Wolfram rules (see oddWolfram* at http://www.conwaylife.com/scripts/).

Also, is there a generation-parity-dependent variable for rule tables or trees with this new Golly version? (like the B0 rules)

No, and it would be quite tricky to implement given the way the hashlife algo can skip generations.

(A tip for future reference: the absolutely worst time to make a request or a suggestion is immediately after a new version is released! I'm much more malleable in the beta testing phase. )

[EricG]

Sphenocorona, here you go - a script which asks for a Wolfram Wnnn rule and a semi-totalistic Bnnn/Snnn rule, and puts them together in the manner you proposed. I took the liberty of deleting the "J" from the name - I've gotten used to seeing the letters "VN" and associating it with the von Neumann neighborhood. I hope you don't mind.

We should probably discuss your rule family in the "Other Cellular Automata" forum next door.

Save the code below to WolfVN.py, place it in your personal Scripts folder, and run it in Golly. It'll create .rule files with ruletree data. Notice that the end of the script consists of code copied without modification from make-ruletree.py, and that's the part of the script that does all the hard work generating the ruletrees.

Here's the key point for this thread: Ruletrees (now subsumed in the .rule format) and the make-ruletree code go together like peanut butter and jelly. The make-ruletree code takes a transition function as an input, and, of course, outputs a ruletree (now in .rule format). If you want to express a rule as an algorithm, or if you want to create code for a whole rule family, there are a number of approaches, but you might find it easiest to write a transition function of the type that make-ruletree uses. You can use make-ruletree.py directly, or you can do as I did below, and copy the key part of its code into your own rule-generating script. The Golly download includes the make-ruletree code in Python, Pearl, Java, and C++.

In my opinion, being able to express rules via an algorithm, without concern about the details of how ruletrees (or ruletables) are put together, makes Golly a whole lot more fun. Give it a try!

Code: Select all

# Sphenocorona's WolfVN

# Author:  Eric Goldstein, June 16, 2013, eric at goldstein dot net
# This was thrown together in a hurry from spare parts, 
# as an example of how to use make-ruletree.py

# Sphenocorona's WolfVN rulefamily proposal:
#  1. taking the states of its neighbors NW-N-NE
#  2. applying an elementary 1-dimensional rule (e.g. rule 110) to those cells, 
#     and returning the value of the center cell (in this case north)
#  3. repeating step 2 with the sets NE-E-SE, SE-S-SW, and SW-W-NW, and finally
#  4. taking the four returned values and using them to determine the state of cell C through 
#     an outer-totalistic Von-Neumann neighborhood CA such as B1/S23V.

# The solution below starts with the observation that Stephen Wolfram's "Elementary" CA rules 
# can be expressed in MCell's Weighted Life format.
# For example, Rule 110 can be expressed as 
# NW0,NN0,NE0,WW2,ME0,EE1,SW0,SS0,SE0,HI0,RS0,RS1,RS2,RB1,RB3 
# If you're not familiar with Weighted Life, see the discussion here:
# http://www.conwaylife.com/forums/viewtopic.php?f=11&t=935&start=0&hilit=weighted+life
# and also see the script listed here:
# http://www.conwaylife.com/forums/viewtopic.php?f=9&t=933#p6814 

import golly
from glife.RuleTree import *

rulestring = golly.getstring('''Create one of Sphenocorona's WolfVN rules using this script.
Enter a Wolfram elementary CA rule (even numbered rules only), and a semi-totalistic rule in the Von Neumann neighborhood.
Use the form Wnnn_Bnnn/SnnnnV:''', "W110_B1/S23V")

if "S" not in rulestring:
  golly.exit("The von Neumann neighborhood Bnn/Snnn rule must include the letter S") 

rulestring = rulestring.replace(" ", "")
rulestring = rulestring.upper()
rulestring_parts = rulestring.split("_")
rulestring_wolfram_part = rulestring_parts[0]
rulestring_vn_part = rulestring_parts[1]

VN_B_rulestring = rulestring_vn_part.split("S")[0]
VN_S_rulestring = rulestring_vn_part.split("S")[1]


VN_birth_rule = []
VN_survival_rule = []
VN_birth_canonical = ""
VN_survival_canonical = "" 

valid_neighbors = ["0","1","2","3","4"]

for i in valid_neighbors:
    if i in VN_B_rulestring:
       VN_birth_rule.append(int(i))
       VN_birth_canonical = VN_birth_canonical + i
    if i in VN_S_rulestring:
       VN_survival_rule.append(int(i))
       VN_survival_canonical = VN_survival_canonical + i

name = "WolfVN-" + rulestring_wolfram_part + "_" + "B" + VN_birth_canonical + "_S" + VN_survival_canonical + "V"


# Wolfram rules are converted into Weighted Life rules here.   
# Survival rules in Weighted Life have the RS prefix, and 
# Birth rules in Weighted Life have the RB prefix.

RS = []
RB = []

Wolfnum = int(rulestring_wolfram_part.split("W")[1])

if (Wolfnum >> 7) & 1:
         RS.append(3)
if (Wolfnum >> 6) & 1:
         RS.append(2)
if (Wolfnum >> 5) & 1:
         RB.append(3)
if (Wolfnum >> 4) & 1:
         RB.append(2)
if (Wolfnum >> 3) & 1:
         RS.append(1)
if (Wolfnum >> 2) & 1:
         RS.append(0)
if (Wolfnum >> 1) & 1:
         RB.append(1)
if (Wolfnum >> 0) & 1:
         RB.append(0)


n_states = 2
n_neighbors = 8

def transition_function(a):
    # order for 8 neighbors is NW, NE, SW, SE, N, W, E, S, C
    nw_cell, ne_cell, sw_cell, se_cell, n_cell, w_cell, e_cell, s_cell, me_cell = a

    # Rule 110 for the central cell (unused, but I'm including it for reference)
    # NW0,NN0,NE0,WW2,ME0,EE1,SW0,SS0,SE0,HI0,RS0,RS1,RS2,RB1,RB3 

    # Calculate an elementary CA rule on the North cell
    NW_weight = 2
    NE_weight = 1
    north_sum = NW_weight*(nw_cell == 1) + NE_weight*(ne_cell == 1)  + (n_cell == 1)
    if n_cell == 1 and north_sum in RS:
       north_wolf = 1
    elif n_cell == 0 and north_sum in RB:
       north_wolf = 1
    else:
       north_wolf = 0

    # Calculate an elementary CA rule on the East cell
    NE_weight = 2
    SE_weight = 1
    east_sum = NE_weight*(ne_cell == 1)  + SE_weight*(se_cell == 1)  + (e_cell == 1) 
    if e_cell == 1 and east_sum in RS:
       east_wolf = 1
    elif e_cell == 0 and east_sum in RB:
       east_wolf = 1
    else:
       east_wolf = 0

    # Calculate an elementary CA rule on the South cell
    SE_weight = 2
    SW_weight = 1
    south_sum =   SW_weight*(sw_cell == 1) + SE_weight*(se_cell == 1) +  (s_cell == 1) 
    if s_cell == 1 and south_sum in RS:
       south_wolf = 1
    elif s_cell == 0 and south_sum in RB:
       south_wolf = 1
    else:
       south_wolf = 0

    # Calculate an elementary CA rule on the West cell
    SW_weight = 2
    NW_weight = 1
    west_sum = NW_weight*(nw_cell == 1)  + SW_weight*(sw_cell == 1) + (w_cell == 1) 
    if w_cell == 1 and west_sum in RS:
       west_wolf = 1
    elif w_cell == 0 and west_sum in RB:
       west_wolf = 1
    else:
       west_wolf = 0

    # Now lets calculate the VN rule from the four WolframRule-derived values

    final_sum = north_wolf + east_wolf + south_wolf + west_wolf

    if  me_cell == 1 and final_sum in VN_survival_rule:
        return 1 
    elif me_cell == 0 and final_sum in VN_birth_rule:
        return 1
    else:
        return 0

##########################################################
# The code below this line is copied from make-ruletree.py 
##########################################################

try:

    MakeRuleTreeFromTransitionFunction( n_states, n_neighbors, transition_function,
                                        golly.getdir("rules")+name+".tree" )
    
    # use name.tree to create name.rule (with no icons);
    # note that if name.rule already exists then we only replace the info in
    # the @TREE section to avoid clobbering any other info added by the user
    ConvertTreeToRule(name, n_states, [])
    
    golly.setalgo("RuleLoader")
    golly.setrule(name)
    golly.show("Created "+golly.getdir("rules")+name+".rule and switched to that rule.")

except:
    import sys
    import traceback
    exception, msg, tb = sys.exc_info()
    golly.warn(\
'''A problem was encountered with the supplied rule:'''+ '\n'.join(traceback.format_exception(exception, msg, tb)))
    golly.exit()

Edit: I originally posted a version of the script which violated Golly's naming conventions for rules. I used this format: "W110=>B1_S23V" but "=" isn't allowed (only hyphens and underscores), and ">" might not go over well with unix users. So, I switched it to "W110_B1_S23V" .

Anyway, since the script is for a rule family, and not just a single rule, here's a -shared .rule to invoke von Neumann icons:

Code: Select all

@RULE WolfVN-shared

@ICONS
diamonds

[Extrementhusiast]

Also, what new neighborhoods are supported? I was hoping for the size 2 diamond, to allow for a JVN variant of WWEJ3.

[Sphenocorona]

I found something new in 2.5 that is bugging me alot and have put a post about it here: http://conwaylife.com/forums/viewtopic. ... 8314#p8314

[kiho park]

When I execusting Golly

The warning message says "couldn't create temporary file for clipboard","Can't open 'C:\Users\***\AppData\Roaming/Golly\golly_clipboard'".

So I checked golly_clipboard file. But there is no files.

How fix it???

[bprentice]

I am running OS X 10.6.8 on an IMac and have these two Python scripts in directory "golly-2.5-mac/My Scripts":

make_rule.py

Code: Select all

from random import randint
import golly as g

def f(n):
  line = [0, 0, 0, 0, 0, 0, 0, 0, n]
  i = 0
  while i < 8:
    j = 0
    while j <= i:
      line[j] = 1
      j += 1
    file.write('%d,%d,%d,%d,%d,%d,%d,%d,%d,%d\n' % (line[8], line[7], line[6], line[5], line[4], line[3], line[2], line[1], line[0], r()))
    j = 0
    while j <= i:
      line[j] = 2
      file.write('%d,%d,%d,%d,%d,%d,%d,%d,%d,%d\n' % (line[8], line[7], line[6], line[5], line[4], line[3], line[2], line[1], line[0], r()))
      j += 1
    i += 1

def r():
  return randint(0, 2)

file = open(g.getdir('rules') + 'test.table', 'w')
file.write('n_states:3\n')
file.write('neighborhood:Moore\n')
file.write('symmetries:permute\n')
file.write('\n')
f(0)
file.write('%d,%d,%d,%d,%d,%d,%d,%d,%d,%d\n' % (1, 0, 0, 0, 0, 0, 0, 0, 0, r()))
f(1)
file.write('%d,%d,%d,%d,%d,%d,%d,%d,%d,%d\n' % (2, 0, 0, 0, 0, 0, 0, 0, 0, r()))
f(2)
file.close

run_test.py

Code: Select all

import golly as g

g.new("testing rule")
g.setalgo('RuleLoader')
g.setrule('test')
g.select([0, 0, 100, 100])
g.randfill(33)
g.select([])
g.fit()

If I start Golly and run make_rule.py the rule test.table is written correctly. If I then run run_test.py I get this error:

"Error reading /Users/brian/CA Programs/golly-2.5-mac/My Rules/Forum Rules/test.table: one or more of n_states, neighborhood or symmetries missing"

If I then close Golly, restart it and run run_test.py it works as expected. What am I doing wrong?

I would like to combine these two scripts into this one:

test_rule.py

Code: Select all

from random import randint
import golly as g

def f(n):
  line = [0, 0, 0, 0, 0, 0, 0, 0, n]
  i = 0
  while i < 8:
    j = 0
    while j <= i:
      line[j] = 1
      j += 1
    file.write('%d,%d,%d,%d,%d,%d,%d,%d,%d,%d\n' % (line[8], line[7], line[6], line[5], line[4], line[3], line[2], line[1], line[0], r()))
    j = 0
    while j <= i:
      line[j] = 2
      file.write('%d,%d,%d,%d,%d,%d,%d,%d,%d,%d\n' % (line[8], line[7], line[6], line[5], line[4], line[3], line[2], line[1], line[0], r()))
      j += 1
    i += 1

def r():
  return randint(0, 2)

file = open(g.getdir('rules') + 'test.table', 'w')
file.write('n_states:3\n')
file.write('neighborhood:Moore\n')
file.write('symmetries:permute\n')
file.write('\n')
f(0)
file.write('%d,%d,%d,%d,%d,%d,%d,%d,%d,%d\n' % (1, 0, 0, 0, 0, 0, 0, 0, 0, r()))
f(1)
file.write('%d,%d,%d,%d,%d,%d,%d,%d,%d,%d\n' % (2, 0, 0, 0, 0, 0, 0, 0, 0, r()))
f(2)
file.close
g.new("testing rule")
g.setalgo('RuleLoader')
g.setrule('test')
g.select([0, 0, 100, 100])
g.randfill(33)
g.select([])
g.fit()

Brian Prentice

[EricG]

Try adding file.flush() just before file.close in test_rule.py (There might be other things to fix too, but superficially, this appears to do the trick.) Also, watch out if you have test.rule in your rules directory - I did! I changed your file name in the code to "Brian-randomtable-test" so that the name of the now deprecated .table file wouldn't clash with previous projects of mine that also used the file name "test". This will be cool when you're done.

[bprentice]

Thank you Eric. The real problem was the statement file.close which should have been file.close(). It has been several years since I coded in Python.

[Extrementhusiast]

I really don't like that the zoom centers on the cursor instead of the center of the screen. It really throws me off. (I suppose I will get used to it after some time, though.)

[Sphenocorona]

I really don't like that the zoom centers on the cursor instead of the center of the screen. It really throws me off. (I suppose I will get used to it after some time, though.)

I actually happen to like that method of zooming in, I'm rather used to zooms that do that and I often use that fact to move around quickly without having to leave editing mode (assuming I have a scroll wheel). Maybe there could be an option to switch between zooming on center and zooming on cursor in the next update?