def make(blocks): g.new("circuit") for block in blocks: fname = "blocks/{}.mc".format(block[0]) paste(g, fname, *transfo(block[1], block[2])) g.fit() g.save("circuit.mc", "mc")
def add_data(PATTERN_FN): g.select([-2753, 891, 1092, 1397]) g.clear(0) g.select([]) input_str = open(PATTERN_FN, "r").read() firstbreak = input_str.find("\n") if firstbreak == -1: g.show("Error, no newlines found, invalid format") g.exit() info_line = input_str[0:firstbreak] input_str = input_str[firstbreak:] #x = 1581, y = 1396, rule = Varlife dataptrn = re.compile( br'x = (?P<xval>[0-9]{1,4}), y = (?P<yval>[0-9]{1,4}), rule = .*') match = dataptrn.match(info_line) xval = 0 yval = 0 if (match): xval = int(match.group("xval"), 10) yval = int(match.group("yval"), 10) else: g.show("ERROR invalid format {}".format(info_line)) g.exit() ipat = pattern(input_str) minbox = getminbox(ipat) if max(xval, minbox.x) > 1200: g.show("ERROR inserted cell area too wide, max width is 1090") g.exit() if max(yval, minbox.y) > 1397: g.show("ERROR inserted cell area too tall, max height is 1397") g.exit() startx = -1661 - xval starty = 891 #blankptrn.put(startx, starty) g.show( "width={}, height={} startx={}, starty={}, xval={}, yval={}, bytes={}". format(minbox.wd, minbox.height, startx, starty, xval, yval, len(input_str))) ipat.put(startx, starty) g.save("/tmp/output.mc", "rle", False) return "Pattern load data: width={}, height={} startx={}, starty={}, xval={}, yval={}, bytes={}".format( minbox.wd, minbox.height, startx, starty, xval, yval, len(input_str))
def run_patt(known_cells): global patt_count, meth_count g.new("PlutoniumSearch") g.reset() g.update() patt_count += 1 #patt = g.parse(known_cells + "!") patt = g.parse(known_cells[1:] + "!") #g.note(known_cells[1:] + "!") g.putcells(patt) g.update() hashlist = {} for gene in range(999): if g.empty(): break if g.hash(g.getrect()) in hashlist: p = int(g.getgen()) - hashlist[g.hash(g.getrect())] if not p in boring_periods: g.reset() g.save("p" + str(p) + "_" + str(cnt[p]) + ".rle", "rle") cnt[p] += 1 break else: hashlist[g.hash(g.getrect())] = int(g.getgen()) g.run(1) """ except: # Pattern dies if int(g.getgen()) > min_lifespan: meth_count += 1 newlifespan = int(g.getgen()) g.new("Saving methuselah") g.putcells(patt) try: g.save("diehard-" + str(newlifespan) + ".rle", "rle") except: pass g.update() #max_final_pop = newpop break""" #g.warn(str(hashlist)) g.show(str(patt_count) + "/" + str(2**(bx * by)))
if ("outfilename" in os.environ): pattern_fp = os.environ["outfilename"] g.open(os.environ["outfilename"]) if pattern_fp: fpath = pattern_fp else: fpath = g.getpath() dirpath = os.path.dirname(fpath) basename = os.path.basename(fpath) timestr = time.strftime("%Y%m%d-%H%M%S") backuppath = os.path.join(dirpath, "backups", basename[:-3] + "_" + timestr + ".mc") g.show(backuppath) g.save(backuppath,"mc") bitOff = pattern('4.DBD$5.B$4.2B$5.D$D.B2.F2.3D$3BD2FD4B$D4.D2.3D$5.B$4.DBD$4.DBD$4.DBD!') bitOn = pattern('4.DBD$5.B.B$4.2B.2B$5.D.2D$D.B2.F.D2.D$3BD2FDF.2B$D4.D2.B.D$5.B2.B$4.DBD$4.DBD$4.DBD!') bitOffRedLin = pattern('4.DBD$5.B$4.2B$5.D$D.B2.F2.3D$3BD2FD4B$D4.D2.3D$5.B$4.DBD$4.DBD$3F.DBD.3F!') bitOnRedLine = pattern('4.DBD$5.B.B$4.2B.2B$5.D.2D$D.B2.F.D2.D$3BD2FDF.2B$D4.D2.B.D$5.B2.B$4.DBD$4.DBD$3F.DBD.3F!') bitOffHorzLine = pattern('4.DBD$.F3.B$.F2.2B$5.D$D.B2.F2.3D$3BD2FD4B$D4.D2.3D$5.B$.F2.DBD$.F2.DBD$4.DBD!') bitOnHorzLine = pattern('4.DBD$.F3.B.B$.F2.2B.2B$5.D.2D$D.B2.F.D2.D$3BD2FDF.2B$D4.D2.B.D$5.B2.B$.F2.DBD$.F2.DBD$4.DBD!') """ x = 11, y = 11, rule = Varlife 4.DBD$.F3.B.B$.F2.2B.2B$5.D.2D$D.B2.F.D2.D$3BD2FDF.2B$D4.D2.B.D$5.B2.B$.F2.DBD$.F2.DBD$4.DBD! """
d1 = delta * 15 + 9 d2 = 0 d3 = 9 g.open("reflecteur.mc") # 2eme reflecteur g.select(ref2) g.cut() g.run(29 + 4 * d1) g.paste(-19 - d1, 16 + d1, "or") # 3eme reflecteur g.select(ref3) g.cut() g.run(4 * d1) g.run(4 + 4 * d2) g.paste(d2 + 1 - d1, 34 + d2 + d1, "or") # 4eme reflecteur g.select(ref4) g.cut() g.run(4 * (d1 + d2)) g.run(3 + 4 * d3) g.paste(d2 + 17 - d1 + d3, 15 + d2 + d1 - d3, "or") g.select([-80, -80, 10, 10]) g.clear(0) g.save("deca_" + str(decalage) + ".mc", "mc")
iters = (1 + int(iters / distForward)) * distForward g.show("Iterating Tail to reach " + str(iters) + " iter") g.fit() g.update() #The speed is negative Head = -speed * iters + 576 Tail = -speed * (iters - l * 2) + l + 576 GotoLimited(iters, 5) rect = g.getrect() g.select([rect[0], Head - 3 * distBack, rect[2], Tail - Head + 3 * distBack + 1500]) g.clear(1) g.save(path.join(dir, str(step) + "_" + str(period) + "_Back.rle"), "rle", False) #''' #This code synchronize the backward recipes to fit with forward created at 0,0 g.show("synchronize the backward recipes to fit with forward") g.new("") MakeForwardSalvo(step, 0, 0, 0, True, True) forwardRecipe = FindWssByDirection(True, distForward) x0, y0, id = forwardRecipe[0] ConvertToRelative(forwardRecipe, distForward) g.open(path.join(dir, str(step) + "_" + str(period) + "_Back.rle"), False) rect = g.getrect()
import os import golly as g #g.select(g.getrect()) oldrule=g.getrule() i=0 g.autoupdate(0) while i==0: g.run(1) g.save('temp','rle') g.setrule('S_input') g.run(1) cellindex=g.getlayer() execfile("histogram_2002_r75.py") histindex=g.getlayer() g.setlayer(cellindex) g.open('temp') g.setlayer(histindex) g.fit() g.update() g.setlayer(cellindex) i=+1
# Set Directory Back to Parent Folder fileLoc = g.getdir("rules") + generationDir # Creates Subfolder specific to Rule Set to hold Generation Patterns fileLoc += rule.replace("/", "_") + "/" if (os.path.isdir(fileLoc) is not True): os.mkdir(fileLoc) # Prepare File Names for each Genereration's Pattern File fileNamePrefix = fileLoc + rule.replace("/", "_") + "_" # Loop and Save Patterns for i in range(int(timeElapsed) + 1): # Stop Loop if Universe is Empty if (g.empty()): break # Determine File Names fileNameRLE = fileNamePrefix + str(i) + ".rle" # Determine Previous File Names fileNamePrevRLE = fileNamePrefix + str(i - 1) + ".rle" g.save(fileNameRLE, "rle") # Compare Previous Generation to Determine Class I Systems if (i > 0 and compare_rle(fileNameRLE, fileNamePrevRLE)): break g.run(1) # Close g.doevent("key q cmd")
''' toimage2.py Saves the current configuration to a mc, then loads the mc, and converts it to an image. Assumes two virtual cells inside every physical (golly) cell. ''' import parameters reload(parameters) from parameters import mcfn, bmpfn2, nstates from gollytools.macrocell import Macrocell from gollytools.bmp import display from golly import save save(mcfn, 'mc') Macrocell().from_file(mcfn).setnstates2(nstates).bmp2().save(bmpfn2) display(bmpfn2)
boxsel = [-int(tilewd / 2), -int(tilewd / 2), tilewd, tilewd] # output a buffer line and an index if rand: myfile.write('\n \n hash%i arealist%i \n' % (topohash[pos], topoarea[pos])) else: myfile.write('\n \n index%i \n' % posi) # tile the universe 100*100 tileit(i, tilewd) g.select(boxsel) tempfile = g.getdir('rules') + 'topoS_temptile' g.putcells(i, 0, 0) g.save(tempfile, 'rle') list_reset() # An I/O race # tile_clist=g.getcells(boxsel) # g.new('') # t1=time() # tile_clist=g.putcells(tile_clist,0,0) # t2=time() # tempfile=g.getdir('rules')+'topoS_temptile' # g.save(tempfile,'rle') # t3=time() # g.open(tempfile) # t4=time()
except ValueError: 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)
import golly as g import os.path # default base path as the Desktop, change it if needed default_path = os.path.expanduser('~/Desktop') # default name is the current pattern name without extension pattern_name = g.getname().split('.')[0] # getting an output path export_path = g.savedialog('Choose the directory and name', 'All files (*)|*', default_path, pattern_name) if export_path == "": export_path = default_path # number of generations num_generations = 10 # has a selection been made? selected = 1 if len(g.getselrect()) > 0 else 0 for i in range(num_generations): # advance by one generation (checking if something is selected) if selected == 1: g.advance(0, 1) else: g.run(1) # export to a new file file_path = '%s-%d.rle' % (export_path, i) g.show(file_path) g.save(file_path, 'rle')
import os.path # default base path as the Desktop, change it if needed default_path = os.path.expanduser('~/Desktop') # default name is the current pattern name without extension pattern_name = g.getname().split('.')[0] # getting an output path export_path = g.savedialog('Choose the directory and name', 'All files (*)|*', default_path, pattern_name) if export_path == "": export_path = default_path # number of generations num_generations = 10 # has a selection been made? selected = 1 if len(g.getselrect()) > 0 else 0 for i in range(num_generations): # advance by one generation (checking if something is selected) if selected == 1: g.advance(0, 1) else: g.run(1) # export to a new file file_path = '%s-%d.rle' % (export_path, i) g.show(file_path) g.save(file_path, 'rle')
return True return False #g.show(str(calc_p_boring(0.83))) found = 0 fail_reasons = [0, 0, 0, 0, 0, 0, 0] for i in range(10000000): p_rule = 0.6 rand_rule(p_rule) bor = rule_boring() if bor != -1: fail_reasons[bor] += 1 else: if explode_dense(): fail_reasons[2] += 1 continue status = fail_cd() if status == -1: found += 1 g.show(str([fail_reasons, found, i])) g.reset() g.save("../../rule_gen/CA{0}.rle".format(found), "rle", True) else: fail_reasons[3 + status] += 1
g.show("Iterating Tail to reach " + str(iters) + " iter") g.fit() g.update() #The speed is negative Head = -speed * iters + 576 Tail = -speed * (iters - l * 2) + l + 576 GotoLimited(iters, 5) rect = g.getrect() g.select( [rect[0], Head - 3 * distBack, rect[2], Tail - Head + 3 * distBack + 1500]) g.clear(1) g.save(path.join(dir, str(step) + "_" + str(period) + "_Back.rle"), "rle", False) #''' #This code synchronize the backward recipes to fit with forward created at 0,0 g.show("synchronize the backward recipes to fit with forward") g.new("") MakeForwardSalvo(step, 0, 0, 0, True, True) forwardRecipe = FindWssByDirection(True, distForward) x0, y0, id = forwardRecipe[0] ConvertToRelative(forwardRecipe, distForward) g.open(path.join(dir, str(step) + "_" + str(period) + "_Back.rle"), False) rect = g.getrect()
''' todensimage.py Saves the current configuration to a mc, then loads the mc, and converts it to a density image. ''' import parameters reload(parameters) from parameters import mcfn, densbmpfn, nstates, lbsl from gollytools.macrocell import Macrocell from gollytools.bmp import display from golly import save save(mcfn,'mc') Macrocell().from_file(mcfn).setnstates2(nstates).precount_live_cells().bmpd(lbsl).save(densbmpfn) display(densbmpfn)
Brle = Brle[:ind] + "o" + Brle[ind + 1:] for ch in Svalues: ind = 32 - int(ch) * 4 Srle = Srle[:ind] + "o" + Srle[ind + 1:] RuleBits = pattern(Brle, 148, 1404) + pattern(Srle, 162, 1406) # apply the rule to the appropriate version of the metapixel metacell = (ONcell if alive else OFFcell) + RuleBits # place the metapixel on the board metacell.put(2048 * i - 5, 2048 * j - 5) g.fit() g.update() if varlife and j > 0 and j % 10 == 0: # every 10 lines, flush the board to a compressed RLE file # otherwise all your memory will be gone g.save(g.getdir("app") + "{}.rle.gz".format(file_num), "rle.gz") g.new(layername) file_num += 1 g.save(g.getdir("app") + "{}.rle.gz".format(file_num), "rle.gz") g.show("") g.setalgo("HashLife") # no point running a metapattern without hashing g.setoption("hyperspeed", False) # avoid going too fast g.setbase(8) g.setstep(4) g.step() # save start and populate hash tables # g.run(35328) # run one full cycle (can lock up Golly if construction has failed) # # Note that the first cycle is abnormal, since it does not advance the metapattern by # one metageneration: the first set of communication signals to adjacent cells is
if basegun == "fixed": fixedname = "p" + ("0000" + period)[-5:] folder = fixedfolder else: # g.note(basegun) ################# fixedname = basegun + "_special_p" + ("0000" + period)[-5:] + ",0,0,0" folder = specialfolder g.open(os.path.join(folder, fixedname + ".rle")) bb = g.getrect() usebb = 1 g.setrule("LifeHistoryToLife") g.run(1) g.setrule("Life") if basegun == "fixed": g.save(os.path.join(outfolder, fixedname) + "_fixed.rle", "rle") g.show("[fixed]") countfixed += 1 else: g.save( os.path.join(outfolder, "p" + ("0000" + period)[-5:] + "_custom") + ".rle", "rle") countspecial += 1 r = g.getrect() else: datalist = basegun.split("_") if len(datalist) == 2: baseperiod, adjustment = datalist else: baseperiod, adjustment, finalperiod = datalist
g.run(29+4*d1) g.paste(-19-d1,16+d1, "or") # 3eme reflecteur g.select(ref3) g.cut() g.run(4*d1) g.run(4+4*d2) g.paste(d2+1-d1,34+d2+d1, "or") # 4eme reflecteur g.select(ref4) g.cut() g.run(4*(d1+d2)) g.run(3+4*d3) g.paste(d2+17-d1+d3,15+d2+d1-d3, "or") # envoyer les planeurs g.select([-82,-80, 10, 10]) g.clear(0) g.run(1000) g.save("delay.mc", "mc")