def LoadMoveTable(self, path, report):
ins = open(path, "r" )
array = []
bestdxrecipe = []
for line in ins:
vals = line.split(":")
vals[0] = vals[0].replace("m", "")
vals[0] = vals[0].split(",")
x = int(vals[0][0])
y = int(vals[0][1])
vals[1] = vals[1].replace("E", "").replace("\n", "")
vals[1] = vals[1].split(",")
for i in xrange(0, len(vals[1])):
vals[1][i] = int(vals[1][i])
if x - y == -1 and len(bestdxrecipe) == 0:
bestdxrecipe = vals[1]
array.append([x, y, vals[1]])
if report:
g.show(str(bestdxrecipe))
g.setclipstr(str(bestdxrecipe))
ins.close()
return array
def LoadMoveTable(self, path, report):
ins = open(path, "r" )
array = []
bestdxrecipe = []
bestdx = 1
idx = 0
for line in ins:
vals = line.split(":")
vals[0] = vals[0].replace("m", "")
vals[0] = vals[0].split(",")
x = int(vals[0][0])
y = int(vals[0][1])
vals[1] = vals[1].replace("E", "").replace("\n", "").replace(" ", "")
vals[1] = vals[1].split(",")
for i in xrange(0, len(vals[1])):
vals[1][i] = int(vals[1][i])
if x < 0 and -x * len(bestdxrecipe) > -bestdx * len(vals[1]):
bestdxrecipe = vals[1]
bestdx = x
idx = len(array)
array.append([x, y, vals[1]])
if report:
g.show(str(bestdxrecipe) + ":" + str(idx))
g.setclipstr(str(bestdxrecipe))
ins.close()
return array
def retrieveparam(article, param, s):
if s.find(param) < 0:
g.note("Setting clipboard to current html -- can't find '" + param +
"'.")
g.setclipstr(s)
g.exit()
regexstr = param + r'\s*=\s*(.*)$' #######################
match = re.search(regexstr, s, re.MULTILINE)
if match:
# pval = match.group(1)
# if pval[-1:]=="\n": pval = pval[:-1]
# # handle the case where newlines are not added before each pipe character
# pval += "|"
# g.note(pval + " :: " + pval[:pval.index("|")])
# return pval[:pval.index("|")]
# try to fix problem with multiple EmbedViewers on one line and pname as last parameter, as in Density article
grp = match.group(1)
if grp.find("}") > -1:
pval = grp[:grp.find("}")] + "|"
else:
pval = grp + "|"
return pval[:pval.index("|")].strip()
else:
g.note("Could not find definition of parameter '" + param +
"' in article '" + article + "'.")
g.setclipstr(s)
g.exit()
def HWSS3SLsEdgeShooter(slv): slv.AppendExternalRecipe([-4, -6, -8, -9, -17]) slv.block0[0] += 19 slv.block0[1] += -12 slv.block1[0] += 17 slv.block1[1] += 1 #salvo.GotoAdvanced(12, -20, 10) #'MOVE', 18908, -1, 'MOVE', 297, 10 slv.ApplyRecipeSmart(18908, -1) slv.ApplyRecipeSmart(297, 10) slv.Swap() #'MOVE', 1968, -1, 'MOVE', 25, 5] #salvo.GotoAdvanced(13, -11, 5) slv.ApplyRecipeSmart(1968, -1) slv.ApplyRecipeSmart(25, 5) slv.block0[0] = 0 slv.block0[1] = 0 slv.AppendExternalRecipe([-22, -10, -27]) slv.PlaceRecipe() g.setclipstr(str(slv.recipe))
def PlaceRecipe(self, x = 0, y = 0, makenew = True):
if makenew:
g.new("Results")
g.show(str(self.recipeIdxList))
g.setclipstr(str(self.recipeIdxList))
g.putcells(blck, x, y)
i = 0
for r in self.recipe:
g.putcells(gld, x + 80 + i * 128, y + 80 + i * 128 + r)
i += 1
def retrieveparam(article, param, s):
if s.find(param)<0:
g.note("Setting clipboard to current html -- can't find '"+param+"'.")
g.setclipstr(s)
g.exit()
regexstr = param+r'\s*=\s*(.*)$' #######################
match = re.search(regexstr, s, re.MULTILINE)
if match:
pval = match.group(1)+"|"
return pval[:pval.index("|")] # handle the case where newlines are not added before each pipe character
else:
g.note("Could not find definition of parameter '"+param+"' in article '"+article+"'.")
g.setclipstr(s)
g.exit()
def canonise():
p = bijoscar(1000)
representation = "#"
for i in range(abs(p)):
rect = g.getrect()
representation = compare_representations(
representation,
canonise_orientation(rect[2], rect[3], rect[0], rect[1], 1, 0, 0,
1))
representation = compare_representations(
representation,
canonise_orientation(rect[2], rect[3], rect[0] + rect[2] - 1,
rect[1], -1, 0, 0, 1))
representation = compare_representations(
representation,
canonise_orientation(rect[2], rect[3], rect[0],
rect[1] + rect[3] - 1, 1, 0, 0, -1))
representation = compare_representations(
representation,
canonise_orientation(rect[2], rect[3], rect[0] + rect[2] - 1,
rect[1] + rect[3] - 1, -1, 0, 0, -1))
representation = compare_representations(
representation,
canonise_orientation(rect[3], rect[2], rect[0], rect[1], 0, 1, 1,
0))
representation = compare_representations(
representation,
canonise_orientation(rect[3], rect[2], rect[0] + rect[2] - 1,
rect[1], 0, -1, 1, 0))
representation = compare_representations(
representation,
canonise_orientation(rect[3], rect[2], rect[0],
rect[1] + rect[3] - 1, 0, 1, -1, 0))
representation = compare_representations(
representation,
canonise_orientation(rect[3], rect[2], rect[0] + rect[2] - 1,
rect[1] + rect[3] - 1, 0, -1, -1, 0))
g.run(1)
if (p < 0):
prefix = "q" + str(abs(p))
elif (p == 1):
prefix = "s" + str(g.getpop())
else:
prefix = "p" + str(p)
g.setclipstr("x" + prefix + "_" + representation)
def check_keyboard():
global runflag
while 1:
evt = g.getevent()
if evt != "":
g.show(state + " -- " + nextstate + " :: " + instr + "; regs=" +
str(registers) +
" -- 'r' to toggle run mode, any key to step")
if evt == "key q none":
g.setclipstr(s)
g.exit()
if evt == "key r none":
runflag = 1 - runflag
elif evt == "key g none":
break
else:
g.doevent(evt)
if runflag == 1:
break
g.setmag(0)
g.show("")
# plot the data (do last because it could take a while if numsteps is huge)
x = int(float(genlist[0] - mingen) / genscale)
y = int(float(poplist[0] - minpop) / popscale)
oldsecs = time()
for i in xrange(numsteps):
newx = int(float(genlist[i + 1] - mingen) / genscale)
newy = int(float(poplist[i + 1] - minpop) / popscale)
draw_line(x, -y, newx, -newy)
x = newx
y = newy
newsecs = time()
if newsecs - oldsecs >= 1.0: # update plot every second
oldsecs = newsecs
g.update()
htlist.append(g.getrect()[3])
plotlist.append(g.getcells(g.getrect()))
g.setlayer(plotlayer)
g.new('')
ht = 0
for i in range(len(plotlist)):
ht = ht + htlist[i] + 20
make_text(str(i)).put(-500, ht)
g.putcells(plotlist[i], 0, ht)
g.setclipstr(str(htlist))
g.setname('bk_plot')
# Get catalyst in various positions
if g.getselrect() != []:
g.shrink()
pattern = g.getcells(r)
patrlelist = []
translist =[(1,0,0,1), (1,0,0,-1), (-1,0,0,1), (-1,0,0,-1),
(0,1,1,0), (0,-1,1,0), (0,1,-1,0), (0,-1,-1,0)]
# Get unique transformed patterns
for trans in translist:
g.new('')
g.putcells(g.transform(pattern, 0, 0, *trans))
g.select(g.getrect())
g.copy()
patrle = ''.join(g.getclipstr().split('\n')[1:])
if patrle not in patrlelist:
patrlelist.append(patrle)
patrles = '\n'.join(patrlelist)
# Save data to file
catpath = g.savedialog('Catalyst File', 'all files(*.*)|*', catdir)
try:
with open(catpath, 'w') as catfile:
catfile.write(patrles)
g.exit('Catalyst file successfully generated at {}'.format(catpath))
except:
if catpath == '':
g.setclipstr(patrles)
g.exit('No filename specified, saved it to clipboard instead.')
else:
raise
import golly as g
x,y=0,0
w=110
h=7*8
bits = ""
dump = ""
for row in xrange(y, y+h):
for col in xrange(x, x+w):
if g.getcell(col, row) > 0:
bits += "1"
dump += "%d,%d\n" % (col, row)
else:
bits += "0"
g.setclipstr(dump+"r\n")
data = ""
i = 0
while len(bits) >= 8:
v = int(bits[:8],2)
bits = bits[8:]
if 12 < (i % 0x6e) and i > 0x10 and i != 0x6d:
v = 0xf4
data += chr(v)
i += 1
open("/tmp/life.bin","w").write(data)
os.system("objdump -M intel -b binary -m i386 -D /tmp/life.bin | grep -v hlt > /tmp/life.txt")
x, y = 0, 0
w = 110
h = 7 * 8
bits = ""
dump = ""
for row in xrange(y, y + h):
for col in xrange(x, x + w):
if g.getcell(col, row) > 0:
bits += "1"
dump += "%d,%d\n" % (col, row)
else:
bits += "0"
g.setclipstr(dump + "r\n")
data = ""
i = 0
while len(bits) >= 8:
v = int(bits[:8], 2)
bits = bits[8:]
if 12 < (i % 0x6e) and i > 0x10 and i != 0x6d:
v = 0xf4
data += chr(v)
i += 1
open("/tmp/life.bin", "w").write(data)
os.system(
"objdump -M intel -b binary -m i386 -D /tmp/life.bin | grep -v hlt > /tmp/life.txt"
)
g.run(p) # get rid of bounding-box marker sparks first
g.setrule("LifeHistory")
# there are no pseudo-period template guns, so one cycle should be enough
g.run(p)
originalONcells = g.getcells(r)
g.run(p)
g.clear(1)
g.setgen("0")
g.save(os.path.join(LHoutfolder, item), "rle")
if str(originalONcells) != str(g.getcells(r)):
mismatchreport += "Template gun LifeHistory mismatch found at period " + str(
p) + " after one cycle and two cycles.\n"
missinggunreport = ""
for i in range(14, 1025):
if i not in perioddict:
missinggunreport += "Missing gun with period " + str(i) + "\n"
outmsg = "Done." if warnings == "" else "Done. Errors:\n" + warnings
outmsg += "\nGuns built=" + str(countbuilt) \
+ ", fixed=" + str(countfixed) \
+ ", special=" +str(countspecial) \
+ ", from var folder=" + str(countvar0) \
+ "\n -- total=" + str(countbuilt + countfixed + countspecial + countvar0)
if missinggunreport != "":
outmsg += "\n" + missinggunreport
if mismatchreport != "":
outmsg += "\n" + mismatchreport
g.show("Processing complete.")
g.setclipstr(outmsg)
g.note(outmsg)
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"))
newlist.append(temp[0] + x)
newlist.append(temp[1] + y)
newlist.append(temp[2])
newlist.append(0)
return newlist
input = g.getstring(
'what cell state to screen for/ \n \
treat selection as torus?/ \n \
how many repeating units?',
'%s/%s/%s' % (g.getoption("drawingstate"), '1', '2'))
state = int(input.split('/')[0])
torus = int(input.split('/')[1])
n = int(input.split('/')[2])
pbox = g.getselrect()
clist = getquad(pbox, n=n)
g.setclipstr(str(clist))
parsed_clist = parse_list(clist)
g.show('clist %i %s, parsed_clist %i %s' %
(len(clist), str(clist), len(parsed_clist), str(parsed_clist)))
fclist = full_clist(parsed_clist, pbox)
adjmat = adjacencymatrix(parsed_clist, pbox, torus, n=n)
s = mathematica(str(adjmat))
g.setclipstr(s)
# Use LifeHistory. Indicate the single channel lane by
# drawing a single NE glider in state 4 (red).
# The output cell list will have your pattern roughly
# centered on (0,0)
import golly as g
cells = g.getcells(g.getrect())
sm = smy = cnt = 0
lane = -999
for i in range(0, len(cells)-2, 3):
if cells[i+2] == 4:
lane = max(lane, cells[i] + cells[i+1])
elif cells[i+2] % 2:
cnt += 1
sm += cells[i] - cells[i+1]
sm //= 2 * cnt
dx = lane // 2 + sm - 1
dy = lane - lane // 2 - sm
outstr = "./elbow "
for i in range(0, len(cells)-2, 3):
if cells[i+2] % 2:
outstr += "%d %d " % (cells[i] - dx, cells[i+1] - dy)
g.show(outstr)
g.setclipstr(outstr)
import golly as g
rule = g.getstring(
"Initial MAP rule to modify (default is CGoL) without the MAP prefix. Leave blank to start from scratch (B/S)",
"ARYXfhZofugWaH7oaIDogBZofuhogOiAaIDogIAAgAAWaH7oaIDogGiA6ICAAIAAaIDogIAAgACAAIAAAAAAAA"
)
if rule == "":
rule = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
changes = int(g.getstring("How many changes are you planning?", "1"))
for i in range(changes):
newcase = g.getstring("Binary code to implement:", "000000000")
defect = int(newcase, 2)
base64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
rulepos = (defect - (defect % 6)) // 6
checkcase = int(base64.index(rule[rulepos]))
bcheckcase = "{0:06b}".format(checkcase)
if bcheckcase[defect % 6] == "1":
newdec = int(bin(base64.index(rule[rulepos]))[2:]) - int(
bin(2**(5 - (defect % 6)))[2:])
elif bcheckcase[defect % 6] == "0":
newdec = int(bin(base64.index(rule[rulepos]))[2:]) + int(
bin(2**(5 - (defect % 6)))[2:])
newdecnum = int(str(newdec), 2)
pointdefect = base64[newdecnum]
newrule = rule[0:rulepos] + pointdefect + rule[(rulepos + 1):len(rule)]
g.show("Last transition changed: " + str(pointdefect) + " replaced " +
str(rule[rulepos]) + " at position " + str(rulepos) +
", new rule is MAP" + newrule)
rule = newrule
g.setclipstr("MAP" + newrule)
import golly as g
base64dict = {}
for index, char in enumerate(
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"):
base64dict[char] = "".join(
["1" if index & 2**(5 - j) else "0" for j in range(6)])
mapstr = g.getstring(
"Enter MAP string to convert to a rule: ",
"ARYXfhZofugWaH7oaIDogBZofuhogOiAaIDogIAAgAAWaH7oaIDogGiA6ICAAIAAaIDogIAAgACAAIAAAAAAAA"
)
if mapstr[:3] == "MAP": mapstr = mapstr[3:]
if len(mapstr) != 86:
g.warn("Map string is the wrong length -- should be 86 characters.")
g.exit()
s = "".join([base64dict[char] for char in mapstr])
ruletablestr="@RULE MAPblahblahblah\nRule table for nontotalistic rule MAPblahblahblah" \
+"\n\n@TABLE\nn_states:2\nneighborhood:Moore\nsymmetries:none\n\n"
for i in range(512):
binary = "{0:09b}".format(i)
for j in binary[4] + binary[:4] + binary[5:]:
ruletablestr += j + ","
ruletablestr += s[i] + "\n"
g.setclipstr(ruletablestr.replace("blahblahblah", mapstr))
space_len = len(comments[i])-1
if not began: #if still introduction
comments2 += comments[i] + '\n'
elif i != len(comments)-1 and '#O' in comments[i+1]: #puts pattern discoverer on name line with brackets
comments2 += comments[i] + ' [' + comments[i+1][3:] + ']\n'
elif '#C' in comments[i] and '----' not in comments[i]: #spaces comment lines to match pattern number
comments2 += '#C' + ' '*space_len*began + comments[i][3:] + '\n'
elif '#O' in comments[i]: #discoverers are put on the previous line; this is so that they're not duplicated
pass
else:
comments2 += comments[i] + '\n'
comments2_intro = comments2[:comments2.index('1.0.0')]
comments2_patterns = comments2[comments2.index('1.0.0'):]
comments2_patterns = comments2_patterns.replace("#N ","#C ") #comments file only has one #N, and it's at the very beginning
comments2_patterns = comments2_patterns.replace(' #C', '\n#C')
comments2 = comments2_intro + comments2_patterns
# show_message('Comments size: %s KB' % ((len(comments2)+500)//1000),0.5)
show_message('Comments size: %s KB text, %s KB LifeViewer labels' % ((len(comments2)+500)//1000, (len(lvcomments)+500)//1000),0)
tempname = os.path.join(g.getdir("temp"),"oscillators.rle")
g.save(tempname, "rle")
with open(tempname,"r") as f:
allrle = f.read()
with open(tempname,"w") as f:
f.write(comments2 + "\n" + allrle)
g.open(tempname) # this integrates the comments into the currently open pattern file
# there still seem to be some issues with keeping the comments after re-saving the file,
# but I'll deal with that separately. Meanwhile:
g.note("Click OK to copy pattern to the clipboard, including comments at the beginning and LifeViewer commands at the end.")
g.setclipstr(comments2 + "\n" + allrle + lvcomments)
# Calculates the density of live cells in the current pattern. # Author: Andrew Trevorrow ([email protected]), March 2006. # Updated to use exit command, Nov 2006. import golly as g from glife import * from utils import * def popcount(sel=0): dict_lc = {'BDRainbow': [2, 4], 'BGRainbowR2': [2, 4]} live_cells = dict_lc[g.getrule().split(':')[0]] if not sel: clist = g.getcells(g.getrect()) else: clist = g.getcells(g.getselrect()) return sum(clist[2::3].count(x) for x in live_cells) pop = popcount(sel=1) medium = int(len(g.getcells(g.getselrect())) / 3) density = float(pop) / float(medium) * 100 g.setclipstr(str(density)) g.show('density=%i/100,pop=%i,medium=%i' % (density, pop, medium))
while LONG_ENOUGH < len(deltalist) * 4 * sep + 4000:
LONG_ENOUGH *= 2
ptr = 0
while ptr < len(deltalist):
mindelta, maxdelta = -100, sep
newlist = deltalist[:]
while 1:
midpoint = int(mindelta + (maxdelta - mindelta) / 2)
newlist[ptr] = midpoint
g.show(str([len(deltalist) - ptr, newlist]).replace(" ", ""))
makerecipe(nongliderpat, zip(recipelist, newlist))
g.run(LONG_ENOUGH)
output = g.getrect()
if len(output) == 0: g.exit("Need a hashable output.")
newhash = g.hash(output)
if hash == newhash:
if maxdelta == midpoint: break
maxdelta = midpoint
else:
if mindelta == midpoint: break
mindelta = midpoint
deltalist[ptr] = mindelta + 1 # take the last good one and continue
makerecipe(nongliderpat, zip(recipelist, deltalist))
g.fit()
g.update()
ptr += 1
g.setclipstr(recipe + "\n\n" + str(deltalist))
g.show("Done.")
parity=1 if s[0]=="O" else 0
input+=[[int(s[1:]),parity]]
for i,p in input:
if elbowloc%2==0: # which recipe to use depends on current elbow chirality
targetlane = i
else:
targetlane = -i
if elbowloc<-48: # -32 doesn't work for the end of the recipe
move,recipe,parity = posdict[targetlane]
else:
move,recipe,parity = negdict[targetlane]
elbowloc+=move
adjustedrecipe = recipe[2:] # skip the initial "0"
# g.note(str([targetlane, move, recipe, parity]))
if (total+parity+p)%2==1:
# change the last number in the previous recipe, to flip the parity of the current recipe
output[-1]+=1
total+=1
# now add the current recipe to the total
for s in adjustedrecipe.split(","): total+=int(s)
output+=eval("["+adjustedrecipe+"]")
# build the resulting recipe and display in a new layer
g.setclipstr(str(output).replace("["," ").replace("]","").replace(" ",""))
pat=makerecipe(output[:-1])
g.addlayer()
g.putcells(g.join(elbow,g.transform(pat,5,2)))
g.setalgo("HashLife")
# extract-single-channel-recipe.py
# glider stream should be pointed northwest. First glider should be in 3o$o$bo! phase, point at (0,0).
# no selection needed -- script works on entire pattern in current universe
#
# For very large single-channel streams, a variant of recognizer.py would be enormously more efficient
import golly as g
count = 0
recipe = []
while int(g.getpop())>0:
if g.getcell(0,0)==1 and g.getcell(1,0)==1 and g.getcell(2,0)==1 and g.getcell(0,1)==1 and g.getcell(1,2)==1:
g.setcell(0,0,0)
g.setcell(1,0,0)
g.setcell(2,0,0)
g.setcell(0,1,0)
g.setcell(1,2,0)
recipe+=[count]
count=0
if len(recipe)%10 == 0:
g.show(str(len(recipe)))
g.fit()
g.update()
else:
count+=1
g.run(1)
g.note("Done. Click OK to copy results to clipboard.")
g.setclipstr(str(recipe))
g.show(str(len(recipe)))
state, nextstate, nextoutput, outputtext = "START", "INITIAL", "Z", ""
g.show(state + " -- " + nextstate + " :: " + instr + "; regs=" +
str(registers) + " -- 'r' to toggle run mode, any key to step")
check_keyboard()
while 1:
if nextoutput == "":
g.show(state + " -- " + nextstate + " :: " + instr + "; regs=" +
str(registers) + "; mem=" + str(memory))
g.note(
"Program reached halt state (because no bit value was returned by any instruction)."
)
g.setclipstr(s)
g.exit()
state = nextstate + ";" + nextoutput
# get info from program dictionary, move to next state
nextstate, instr = program[state]
# process instructions for current state
# -- there may be just one instruction,
# or several comma-separated instructions
nextoutput = "" # if some instruction doesn't set this variable, the program will halt
for i in instr.split(","):
# allow stepping or full-speed run from keyboard (toggle "r")
check_keyboard()
if i == "NOP":
import KBs
import random, re, os
# rulestr=golly.getstring('NTCA number',golly.getclipstr()).split('_')[-1];
kb = KBs.kb_2dntca()
# alias = golly.getrule()
prefix, curr, suffix = KBs.interpret(golly.getrule().split(':'))
rulestr = kb.alias2rulestr(curr)
bitstr = KBs.hex2bin(rulestr, 102)
# assert KBs.bin2hex(bitstr)==rulestr
bitlst = list(bitstr)
idx = random.randrange(102)
flip = {'0': '1', '1': '0'}
bitlst[idx] = flip[bitlst[idx]]
rulestr = KBs.bin2hex(''.join(bitlst))
alias = kb.rulestr2alias(rulestr)
if prefix:
DIR = golly.getdir('rules')
fname = os.path.join(DIR, prefix + alias + '.rule')
with open(fname, 'w') as f:
print >> f, kb.rulestr2table(rulestr, reverse=1)
newrule = '%s%s:%s' % (prefix, alias, suffix)
golly.note(newrule)
golly.setclipstr(newrule.split(':')[0])
golly.setrule(newrule)
if i < 3:
g.note(
"No spaces in the first 72 characters of this overlength line: '"
+ line + "'")
t += line + "\n"
line = ""
break
if i < 3:
break
else:
j = i
while j > 0:
j -= 1
if line[j] == "}": break # didn't find an open link marker
if line[j] == "{":
if line[j - 1] == " ":
i = j - 1
break
else:
g.note(
"Found weird formatting: left curly brace just after non-space character\n"
+ line)
g.exit()
t += line[:i] + "\n "
line = line[i + 1:].lstrip()
maxlen = 69
t += line + "\n"
g.note("All done. Lines processed = " + str(count))
g.setclipstr(t)
if not aline:
return b
if not bline:
return a
if (value == 1):
if aline[ii] > bline[ii]:
return a
else:
return b
else:
if aline[ii] > bline[ii]:
return b
else:
return a
# p = int(g.getstring('Enter period of pattern', '1'))
p, dxdy = bijoscar(1000)
if dxdy is None:
if p == 0:
g.exit('Pattern has died out.')
else:
g.exit('Pattern periodicity not detected within 1000 generations.')
canonPatt = sof_canonise(p, dxdy)
g.setclipstr(canonPatt)
g.show('SOF representation of pattern is: ' + canonPatt +
' (copied to clipboard).')
cells = g.getcells([x0, y0, l, h])
allcells.append(cells)
idx = 0
for let in letters:
x0, y0, l, h = let
g.new("")
g.putcells(allcells[idx], -x0)
allcells[idx] = g.getcells([0, y0, l, h])
idx += 1
def Write(dic, L, dx=0, dy=0):
d = 0
for i in range(len(L)):
let, dl = dic[L[i]]
g.putcells(let, dx + d, dy)
d += dl
dic = {}
for i in range(len(textLet)):
dic[textLet[i]] = (allcells[i], letters[i][2])
dic[' '] = ([], 5)
g.new("")
Write(dic, "Hello World!")
g.setclipstr(str(dic))
## This script generate an ECA rule and emulate it on a torus of width 200. ## Written by Feng ([email protected]) Feb 2017. import golly ali = golly.getstring('TCA rulestring', golly.getrule().split(':')[0]) def alias2rnum(ali): rule = ['0'] * 18 ali = ali.replace('/', '').lower().lstrip('b') (b, s) = ali.split('s') lst = list(str(int(i) + 9) for i in s) golly.note(str(lst)) bs = list(b) + (lst) for i in bs: rule[int(i)] = '1' # golly.note(bs) # golly.note(''.join(rule[::-1])) rnum = int(''.join(rule[::-1]), 2) return (rnum) # golly.setalgo("QuickLife") # # golly.note(alias) # golly.setrule(alias); rnum = str(alias2rnum(ali)) golly.setclipstr(rnum) golly.note(rnum)
else:
s += "\n" + url + "\n" + pname + "_synth: found synthesis that has not yet been uploaded."
start = html.index('name="wpTextbox1">')
rle = html[start + 18:html.index('!', start + 17) + 1]
filename = outfolder + pname + "_synth.rle"
data = pnamedict[pname]
discoverer, discoveryear = data[2], data[3]
sourceurl = data[0]
articlename = sourceurl.replace(
"https://conwaylife.com/w/index.php?title=",
"").replace("&action=edit", "")
url = 'https://conwaylife.com/wiki/' + articlename
paturl = 'https://www.conwaylife.com/patterns/' + pname + "_synth.rle"
with open(filename, 'w') as f:
f.write("#N " + pname + "_synth.rle\n")
f.write("#C " + url + "\n")
f.write("#C " + paturl + "\n")
f.write(rle)
g.show("Wrote " + filename)
g.note("Done! Click OK to write exceptions to clipboard.")
g.setclipstr(s + "\nCells files created: " + str(missingcells) + "\nPatterns too big to create cells files, or multistate: " + str(toobigforcells) \
+ "\nIllegal capitalized pnames: " + str(capitalizedpnames) + "\npnames with no RLE header: " + str(noRLEheader) \
+ "\nNo RLE param in infobox: " + str(norleparam) + "\nNo plaintext param in infobox: " + str(noplaintextparam) \
+ "\napgcodes where LifeWiki synth agrees with Catagolue: " + str(apgcodesLWsynthagreeswithC) \
+ "\napgcodes where LifeWiki synth is better than Catagolue: " + str(apgcodesLWsynthbetterthanC) \
+ "\napgcodes where LifeWiki synth is worse than Catagolue: " + str(apgcodesLWsynthworsethanC) \
+ "\napgcodes where LifeWiki synth exists but no Catagolue synth: " +str(apgcodesLWsynthbutnoCsynth) \
+ "\napgcodes where Catagolue synth exists but no LifeWiki synth: " +str(apgcodesnoLWsynthbutCsynth) \
)
letters = getletters(nlist)
bestletters = letters
for affine in affinelist:
altlist = []
for k in nlist:
a, b, c = k
m,n,o,p,q,r,s,t,u = affine
d = m*a + n*b + o*c
e = p*a + q*b + r*c
f = s*a + t*b + u*c
altlist += [(d,e,f)]
altletters = getletters(altlist)
if altletters<bestletters: bestletters = altletters
# g.note(str(i) + ": " + str(nlist)+ " -- " + bestletters + " // " + str(affine) + " = " + str(altlist) + " :: " + altletters)
# if bestletters not in isodict:
# isodict[bestletters]=1
# else:
# isodict[bestletters]+=1
# if i%1024==0:
# g.show(str(i) + ": " + str(len(isodict)) )
# if i>67200000:
# g.setclipstr(str(isodict))
# g.exit()
if bestletters == letters:
isodict[numneighbors]+=1
if i%1024==0:
g.show(str(i) + ": " + str(isodict))
g.setclipstr(str(isodict))
import golly as g def recipe(): res = "" i = 0 prev = 0 while True: i += 1 y = int(128 * i) + 1 cells = g.getcells([-1500+y, y, 2 * 1500, 3]) if len(cells) == 0: break x = cells[0] y = cells[1] cur = x - y if g.getcell(x + 2, y) == 0: res += "O" + str(cur) + " " else: res += "E" + str(cur - 1) + " " prev = cur return res g.setclipstr(recipe())
def add_string():
cells = g.getcells(g.getrect())
n = len(cells)
result = ""
for i in range(0, n, 2):
result += "[%d, %d, %d]" % (cells[i], cells[i + 1], int(g.getgen()))
if i < n - 2:
result += ","
return (result, n / 2)
res = ""
total = 0
for i in range(120):
resn, voln = add_string()
res += resn
total += voln
if i < 119:
res += ","
g.run(1)
g.setclipstr(res)
g.show(str(total))
