コード例 #1
0
def envelope():
    # draw stacked layers using same location and scale
    g.setoption("stacklayers", 1)

    g.show("Hit escape key to stop script...")
    while True:
        g.run(1)
        if g.empty():
            g.show("Pattern died out.")
            break

        # copy current pattern to envelope layer;
        # we temporarily disable event checking so thumb scrolling
        # and other mouse events won't cause confusing changes
        currpatt = g.getcells(g.getrect())
        g.check(0)
        g.setlayer(envindex)
        g.putcells(currpatt)
        g.setlayer(currindex)
        g.check(1)

        step = 1
        exp = g.getstep()
        if exp > 0:
            step = g.getbase()**exp
        if int(g.getgen()) % step == 0:
            # display all 3 layers (envelope, start, current)
            g.update()
コード例 #2
0
ファイル: envelope.py プロジェクト: bahusvel/ConwayLife
def envelope ():
    # draw stacked layers using same location and scale
    g.setoption("stacklayers", 1)

    g.show("Hit escape key to stop script...")
    while True:
        g.run(1)
        if g.empty():
            g.show("Pattern died out.")
            break

        # copy current pattern to envelope layer;
        # we temporarily disable event checking so thumb scrolling
        # and other mouse events won't cause confusing changes
        currpatt = g.getcells(g.getrect())
        g.check(0)
        g.setlayer(envindex)
        g.putcells(currpatt)
        g.setlayer(currindex)
        g.check(1)

        step = 1
        exp = g.getstep()
        if exp > 0:
            step = g.getbase()**exp
        if int(g.getgen()) % step == 0:
            # display all 3 layers (envelope, start, current)
            g.update()
コード例 #3
0
ファイル: heisenburp.py プロジェクト: re-curse/golly
# -----------------------------------------------------

def show_status_text(s, d, t):
    if d==-1:
        if t==1:
            g.show(s + "Speed is " + str(t) + " tick per step.")
        else:
            g.show(s + "Speed is " + str(t) + " ticks per step.")
    else:
        g.show(s + "Delay between ticks is " + str(d) + " seconds.")

# -----------------------------------------------------

# if there are multiple layers, get permission to remove them
if g.numlayers() > 1:
    answer = g.getstring("All existing layers will be removed. OK?")
    if lower(answer[:1]) == "n":
        g.exit()
oldswitch = g.setoption("switchlayers", True) # allow user to switch layers
oldtile = g.setoption("tilelayers", True)
rule()
try:
    burp()
finally:
    # remove the cloned layers added by the script
    while g.numlayers() > 1: g.dellayer()
    g.setname("Stable Pseudo-Heisenburp Device")
    g.setoption("tilelayers", oldtile)
    g.setoption("switchlayers", oldswitch)
    g.show("")
コード例 #4
0
def export_icons(iconsection, rulename):
    global multi_color_icons

    if multi_color_icons:
        # prepend a new @COLORS section with the average colors in each icon
        iconsection = create_average_colors(iconsection) + iconsection

    # replace any illegal filename chars with underscores
    filename = rulename.replace("/", "_").replace("\\", "_")

    # we will only create/update a .rule file in the user's rules folder
    # (ie. we don't modify the supplied Rules folder)
    rulepath = g.getdir("rules") + filename + ".rule"
    fileexists = os.path.isfile(rulepath)
    if fileexists:
        # .rule file already exists so replace or add @ICONS section
        rulefile = open(rulepath, "rU")

        # create a temporary file for writing new rule info
        temphdl, temppath = mkstemp()
        tempfile = open(temppath, "w")

        wroteicons = False
        skiplines = False
        for line in rulefile:
            if line.startswith("@ICONS"):
                # replace the existing @ICONS section
                tempfile.write(iconsection)
                wroteicons = True
                skiplines = True
            elif line.startswith("@COLORS") and multi_color_icons:
                # skip the existing @COLORS section
                # (iconsection contains a new @COLORS section)
                skiplines = True
            elif skiplines and line.startswith("@"):
                if wroteicons: tempfile.write("\n")
                skiplines = False
            if not skiplines:
                tempfile.write(line)

        if not wroteicons:
            # .rule file had no @ICONS section
            tempfile.write("\n")
            tempfile.write(iconsection)

        # close files
        rulefile.close()
        tempfile.flush()
        tempfile.close()
        os.close(temphdl)

        # remove original .rule file and rename temporary file
        os.remove(rulepath)
        move(temppath, rulepath)

    else:
        # .rule file doesn't exist so create it
        rulefile = open(rulepath, "w")
        rulefile.write("@RULE " + filename + "\n\n")

        if not multi_color_icons:
            # grayscale icons, so check if Rules/filename.rule exists
            # and if so copy any existing @COLORS section
            suppliedrule = g.getdir("app") + "Rules/" + filename + ".rule"
            if os.path.isfile(suppliedrule):
                colordata = get_color_section(suppliedrule)
                if len(colordata) > 0:
                    rulefile.write(colordata)

        rulefile.write(iconsection)
        rulefile.flush()
        rulefile.close()

    # create another layer for displaying the new icons
    if g.numlayers() < g.maxlayers():
        g.addlayer()
        g.new("icon test")
        g.setrule(rulename)
        for i in range(g.numstates() - 1):
            g.setcell(i, 0, i + 1)
        g.fit()
        g.setoption("showicons", True)
        g.update()

    if fileexists:
        g.note("Updated the icon data in " + rulepath)
    else:
        g.note("Created " + rulepath)
コード例 #5
0
ファイル: slide-show.py プロジェクト: re-curse/golly
                while True:
                    event = g.getevent()
                    if event == "key space none": break
                    g.doevent(event)        # allow keyboard/mouse interaction
                    sleep(0.01)             # avoid hogging cpu

    # if all patterns have been displayed then restore original algo and rule
    # (don't do this if user hits escape in case they want to explore pattern)
    g.new("untitled")
    g.setalgo(oldalgo)
    g.setrule(oldrule)

# ------------------------------------------------------------------------------

# show status bar but hide other info to maximize viewport
oldstatus = g.setoption("showstatusbar", True)
oldtoolbar = g.setoption("showtoolbar", False)
oldlayerbar = g.setoption("showlayerbar", False)
oldeditbar = g.setoption("showeditbar", False)
oldfiles = g.setoption("showfiles", False)

try:
    slideshow()
finally:
    # this code is always executed, even after escape/error;
    # clear message line in case there was no escape/error
    g.show("")
    # restore original state
    g.setoption("showstatusbar", oldstatus)
    g.setoption("showtoolbar", oldtoolbar)
    g.setoption("showlayerbar", oldlayerbar)
コード例 #6
0
if grayscale_icons: deadrgb = (0, 0, 0)

draw_icon_boxes(livestates, graystate)
draw_icons(iconinfo31, deadrgb)
draw_icons(iconinfo15, deadrgb)
draw_icons(iconinfo7, deadrgb)

# create missing icons by scaling up/down the existing icons
if len(iconinfo31) == 0 and len(iconinfo15) > 0:
    create31x31icons()
    iconnote += "The 31x31 icons were created by scaling up the 15x15 icons.\n\n"

if len(iconinfo15) == 0 and len(iconinfo31) > 0:
    create_smaller_icons(31, 15)
    iconnote += "The 15x15 icons were created by scaling down the 31x31 icons.\n\n"

if len(iconinfo7) == 0:
    if len(iconinfo15) > 0:
        create_smaller_icons(15, 7)
        iconnote += "The 7x7 icons were created by scaling down the 15x15 icons.\n\n"
    elif len(iconinfo31) > 0:
        create_smaller_icons(31, 7)
        iconnote += "The 7x7 icons were created by scaling down the 31x31 icons.\n\n"

g.setoption("showlayerbar", True)
g.setoption("showallstates", True)
g.setoption("showicons", False)
g.fit()
g.update()
g.note(iconnote + "Edit the icons and then run icon-exporter.py.")
コード例 #7
0
g.new(layername)   
g.setalgo("QuickLife")              # qlife's setcell is faster

for j in xrange(selheight):
   for i in xrange(selwidth):
      golly.show("Placing (" + str(i+1) + "," + str(j+1) + ") tile" +
                 " in a " + str(selwidth) + " by " + str(selheight) + " rectangle.")
      if livecell[i][j]:
         ONcell.put(2048 * i - 5, 2048 * j - 5)
      else:
         OFFcell.put(2048 * i - 5, 2048 * j - 5)
      g.fit()
   
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 
# generated during this first cycle.  Thus at the end of 35328 ticks, the pattern
# is ready to start its first "normal" metageneration (where cell states may change).
#
# It should be possible to define a version of ONcell that is not fully populated
# with LWSSs and HWSSs until the end of the first full cycle.  This would be much
# quicker to generate from a script definition, and so it wouldn't be necessary to
# save it to a file.  The only disadvantage is that ONcells would be visually
コード例 #8
0
def dmprinter(pdy, copies=1):
    ''' Generate & display a dot matrix printer for named bitmap pattern '''
    #Horizontal pixel separation between LineMakers. minimum = 5
    LMsx = 5

    #Horizontal distance between bitmap pixels. Constant, due to LineMaker period
    pdx = 15

    #Distance between LineMakers
    LMdx, LMdy = -LMsx * pdx, pdy

    #Get bitmap pattern from current selection.
    bm = get_bitmap()

    #Make printer in a new layer
    golly.duplicate()
    golly.setoption("syncviews", False)

    #Build new window title from old
    title = golly.getname().split('.')[0]
    title = '%s_Printer [%d] v0.10' % (title, pdy)
    golly.new(title)

    #Make sure we're using the standard Life generation rule
    golly.setrule("B3/S23")

    #Bitmap dimensions. Width MUST be of form 4m, for m >=1
    bmheight = len(bm)
    bmwidth = len(bm[0])
    mid = (bmheight + 1) // 2

    loopw = (bmwidth - 8) // 4
    loopm = pdx * loopw

    #Gliders, heading north-east
    g0 = pattern('2bo$2o$b2o!')
    g1 = pattern('obo$2o$bo!')
    gliders = [
        g0, g1,
        g1(0, 2, rccw),
        g0(0, 2, rccw),
        g0(2, 2, flip),
        g1(2, 2, flip),
        g1(2, 0, rcw),
        g0(2, 0, rcw)
    ]

    #Create full Glider loop.
    gg = []
    ox, oy = 35, 23
    for j in xrange(loopw + 1):
        dd = pdx * j
        gg += [
            gliders[0](ox + dd, oy - dd), gliders[1](ox + 8 + dd, oy - 7 - dd)
        ]
    dd = loopm
    gg += [gliders[2](45 + dd, 4 - dd), gliders[3](37 + dd, -3 - dd)]

    ox, oy = 26 + loopm, -4 - loopm
    for j in xrange(loopw + 1):
        dd = pdx * j
        gg += [
            gliders[4](ox - dd, oy + dd), gliders[5](ox - 8 - dd, oy + 7 + dd)
        ]
    dd = loopm
    gg += [gliders[6](16, 15), gliders[7](24, 22)]
    parity = 2 * ((loopw + 1) * (0, 0) + (1, 1))

    def buildLM():
        ''' Build a complete LineMaker '''
        #Populate glider loop. (jj, ii) are bitmap coords
        gloop = pattern()
        for j in xrange(bmwidth):
            jj = (j - delta + bmwidth - 1) % bmwidth

            #Is there a pixel at this location?
            if bm[ii][jj] == parity[j]:
                gloop += gg[j]  #Add glider to the loop

        #Only put LineMaker if glider loop isn't empty
        if len(gloop) > 0:
            (LMBlank + gloop).put(Lx, Ly, trans)

    #Assemble blank LineMaker
    LMBlank = linemaker(loopm)

    #Do upper LineMakers
    trans = identity
    for i in xrange(mid):
        ii = mid - (i + 1)
        io = mid + (i + 1)
        Lx, Ly = io * LMdx, ii * LMdy
        delta = LMsx * io
        buildLM()

    #Do lower LineMakers
    trans = flip_y
    for i in xrange(mid, bmheight):
        ii = i
        io = i + 2
        Lx, Ly = io * LMdx + pdx, ii * LMdy + 128
        delta = LMsx * io - 1
        buildLM()

    #Eaters facing south-east & north-east
    eaterSE = pattern('2o$bo$bobo$2b2o!')
    eaterNE = eaterSE(0, 10, flip_y)
    eY = 59
    eaters = (eaterNE(0, eY), eaterSE(0, eY))

    #Eater horizontal displacement. Must be odd
    #bmwidth muliplier determines number of copies visible 'outside' printer.
    eX = (bmheight + 1) * LMdx - (copies * bmwidth - 1) * pdx
    eX = 1 + eX // 2 * 2  #Adjust parity
    all = pattern()
    for i in xrange(bmheight):
        all += eaters[i % (1 + LMsx % 2)](eX, i * LMdy)
    all.put()

    #Centre view over bitmap output area
    golly.setpos(str(-pdx * bmwidth // 2 + (bmheight - 1) * LMdx),
                 str(Ly // 2))
    #golly.setmag(-2)    #Aliasing effects happen at smaller scales than -2 :(
    golly.fit()
コード例 #9
0
ファイル: envelope.py プロジェクト: bahusvel/ConwayLife
        currpatt = g.getcells(g.getrect())
        g.check(0)
        g.setlayer(envindex)
        g.putcells(currpatt)
        g.setlayer(currindex)
        g.check(1)

        step = 1
        exp = g.getstep()
        if exp > 0:
            step = g.getbase()**exp
        if int(g.getgen()) % step == 0:
            # display all 3 layers (envelope, start, current)
            g.update()

# ------------------------------------------------------------------------------

# show status bar but hide layer & edit bars (faster, and avoids flashing)
oldstatus = g.setoption("showstatusbar", True)
oldlayerbar = g.setoption("showlayerbar", False)
oldeditbar = g.setoption("showeditbar", False)

try:
    envelope()
finally:
    # this code is always executed, even after escape/error;
    # restore original state of status/layer/edit bars
    g.setoption("showstatusbar", oldstatus)
    g.setoption("showlayerbar", oldlayerbar)
    g.setoption("showeditbar", oldeditbar)
コード例 #10
0
ファイル: icon-importer.py プロジェクト: Nesk8er/WebLife1
if grayscale_icons: deadrgb = (0,0,0)

draw_icon_boxes(livestates, graystate)
draw_icons(iconinfo31, deadrgb)
draw_icons(iconinfo15, deadrgb)
draw_icons(iconinfo7, deadrgb)

# create missing icons by scaling up/down the existing icons
if len(iconinfo31) == 0 and len(iconinfo15) > 0:
    create31x31icons()
    iconnote += "The 31x31 icons were created by scaling up the 15x15 icons.\n\n"

if len(iconinfo15) == 0 and len(iconinfo31) > 0:
    create_smaller_icons(31, 15)
    iconnote += "The 15x15 icons were created by scaling down the 31x31 icons.\n\n"

if len(iconinfo7) == 0:
    if len(iconinfo15) > 0:
        create_smaller_icons(15, 7)
        iconnote += "The 7x7 icons were created by scaling down the 15x15 icons.\n\n"
    elif len(iconinfo31) > 0:
        create_smaller_icons(31, 7)
        iconnote += "The 7x7 icons were created by scaling down the 31x31 icons.\n\n"

g.setoption("showlayerbar",True)
g.setoption("showallstates",True)
g.setoption("showicons",False)
g.fit()
g.update()
g.note(iconnote + "Edit the icons and then run icon-exporter.py.")
コード例 #11
0
ファイル: pop-plot.py プロジェクト: Nesk8er/WebLife1
    genlist.append( int(g.getgen()) )
    newsecs = time()
    if newsecs - oldsecs >= 1.0:     # show pattern every second
        oldsecs = newsecs
        fit_if_not_visible()
        g.update()
        g.show("Step %i of %i" % (i+1, numsteps))

fit_if_not_visible()

# save some info before we switch layers
stepsize = "%i^%i" % (g.getbase(), g.getstep())
pattname = g.getname()

# create population plot in separate layer
g.setoption("stacklayers", 0)
g.setoption("tilelayers", 0)
g.setoption("showlayerbar", 1)
if poplayer == -1:
    poplayer = g.addlayer()
else:
    g.setlayer(poplayer)
g.new(layername)

# use same rule but without any suffix (we don't want a bounded grid)
g.setrule(g.getrule().split(":")[0])

deadr, deadg, deadb = g.getcolor("deadcells")
if (deadr + deadg + deadb) / 3 > 128:
    # use black if light background
    g.setcolors([1,0,0,0])
コード例 #12
0
ファイル: test2.py プロジェクト: shouldsee/golly_utils
    eX = 1 + eX // 2 * 2
    all = pattern()
    for i in xrange(bmheight):
        all += eaters[i % (1 + LMsx % 2)](eX, i * LMdy)
    all.put()   
    golly.setpos(str(-pdx * bmwidth // 2 + (bmheight - 1) * LMdx), str(Ly//2))
    golly.fit()
    #golly.setcursor(3)
"""

if __name__  ==  '__main__':   
    title = golly.getname().split('.')[0] + '-printer'
    prog = "bits = '%s'\n%s" % (get_bitmap(), prog)
    exec compile(prog, '<string>', 'exec')
    golly.duplicate()
    golly.setoption("syncviews", False)
    main(16, 1, title)   

    #Save pattern as a Python program
    hdr = '#Golly Python script\nimport golly\nfrom glife import *\n'
    ftr = "main(16, 1, '%s')" % title 
    s = """#Golly Python script
import zlib,base64
s=zlib.decompress(base64.decodestring('''
%s'''))
try:import golly
except ImportError:print s
else:   
from glife import *
exec compile(s,'<string>','exec')
main(16, 1, '%s')
コード例 #13
0
        g.check(0)
        g.setlayer(envindex)
        g.putcells(currpatt)
        g.setlayer(currindex)
        g.check(1)

        step = 1
        exp = g.getstep()
        if exp > 0:
            step = g.getbase()**exp
        if int(g.getgen()) % step == 0:
            # display all 3 layers (envelope, start, current)
            g.update()


# ------------------------------------------------------------------------------

# show status bar but hide layer & edit bars (faster, and avoids flashing)
oldstatus = g.setoption("showstatusbar", True)
oldlayerbar = g.setoption("showlayerbar", False)
oldeditbar = g.setoption("showeditbar", False)

try:
    envelope()
finally:
    # this code is always executed, even after escape/error;
    # restore original state of status/layer/edit bars
    g.setoption("showstatusbar", oldstatus)
    g.setoption("showlayerbar", oldlayerbar)
    g.setoption("showeditbar", oldeditbar)
コード例 #14
0
ファイル: register-selection.py プロジェクト: dvgrn/b3s23life
import golly as g
import hashlib
import os

libpath = g.getdir("data") + "recognizer-library/"
if not os.path.isdir(libpath): os.makedirs(libpath)

# for filename in os.listdir(libpath):
#    g.note(filename)
# g.exit

oldsavexrle = g.setoption("savexrle", 1)
xformlist = [[1, 0, 0, 1], [0, -1, 1, 0], [-1, 0, 0, -1], [0, 1, -1, 0],
             [0, 1, 1, 0], [1, 0, 0, -1], [0, -1, -1, 0], [-1, 0, 0, 1]]
xformnames = [
    "identity", "rcw", "flip", "rccw", "swap_xy", "flip_y", "swap_xy_flip",
    "flip_x"
]  # for glife script
g.setrule("B3/S23")


# returns a cell list sorted into TL/BR order
def cellsort(clist):
    return g.evolve(clist, 0)


def findTL(clist):
    return findTLsorted(cellsort(clist))


# version of findTL() for cell lists already known to be in TL/BR order
コード例 #15
0
ファイル: icon-exporter.py プロジェクト: Nesk8er/WebLife1
def export_icons(iconsection, rulename):
    global multi_color_icons
    
    if multi_color_icons:
        # prepend a new @COLORS section with the average colors in each icon
        iconsection = create_average_colors(iconsection) + iconsection
        
    # replace any illegal filename chars with underscores
    filename = rulename.replace("/","_").replace("\\","_")

    # we will only create/update a .rule file in the user's rules folder
    # (ie. we don't modify the supplied Rules folder)
    rulepath = g.getdir("rules") + filename + ".rule"
    fileexists = os.path.isfile(rulepath)
    if fileexists:
        # .rule file already exists so replace or add @ICONS section
        rulefile = open(rulepath,"rU")
    
        # create a temporary file for writing new rule info
        temphdl, temppath = mkstemp()
        tempfile = open(temppath,"w")
        
        wroteicons = False
        skiplines = False
        for line in rulefile:
            if line.startswith("@ICONS"):
                # replace the existing @ICONS section
                tempfile.write(iconsection)
                wroteicons = True
                skiplines = True
            elif line.startswith("@COLORS") and multi_color_icons:
                # skip the existing @COLORS section
                # (iconsection contains a new @COLORS section)
                skiplines = True
            elif skiplines and line.startswith("@"):
                if wroteicons: tempfile.write("\n")
                skiplines = False
            if not skiplines:
                tempfile.write(line)
        
        if not wroteicons:
            # .rule file had no @ICONS section
            tempfile.write("\n")
            tempfile.write(iconsection)
        
        # close files
        rulefile.close()
        tempfile.flush()
        tempfile.close()
        os.close(temphdl)
        
        # remove original .rule file and rename temporary file
        os.remove(rulepath)
        move(temppath, rulepath)
        
    else:
        # .rule file doesn't exist so create it
        rulefile = open(rulepath,"w")
        rulefile.write("@RULE " + filename + "\n\n")
        
        if not multi_color_icons:
            # grayscale icons, so check if Rules/filename.rule exists
            # and if so copy any existing @COLORS section
            suppliedrule = g.getdir("app") + "Rules/" + filename + ".rule"
            if os.path.isfile(suppliedrule):
                colordata = get_color_section(suppliedrule)
                if len(colordata) > 0:
                    rulefile.write(colordata)
        
        rulefile.write(iconsection)
        rulefile.flush()
        rulefile.close()
    
    # create another layer for displaying the new icons
    if g.numlayers() < g.maxlayers():
        g.addlayer()
        g.new("icon test")
        g.setrule(rulename)
        for i in xrange(g.numstates()-1):
            g.setcell(i, 0, i+1)
        g.fit()
        g.setoption("showicons",True)
        g.update()
    
    if fileexists:
        g.note("Updated the icon data in " + rulepath)
    else:
        g.note("Created " + rulepath)
コード例 #16
0
ファイル: heisenburp.py プロジェクト: re-curse/golly
def burp():
    test_signal=pattern("""
    40bo$41bo$39b3o17$40bo4bo4bo4bo4bo$41bo4bo4bo4bo4bo$39b3o2b3o2b3o2b3o
    2b3o3$40bo4bo4bo4bo4bo$41bo4bo4bo4bo4bo$39b3o2b3o2b3o2b3o2b3o3$40bo4bo
    4bo4bo4bo$41bo4bo4bo4bo4bo$39b3o2b3o2b3o2b3o2b3o3$40bo4bo4bo4bo4bo$41b
    o4bo4bo4bo4bo$39b3o2b3o2b3o2b3o2b3o3$bo38bo4bo4bo4bo4bo18bo$2bo38bo4bo
    4bo4bo4bo18bo$3o36b3o2b3o2b3o2b3o2b3o16b3o37$40bo$41bo$39b3o!""")

    prepare_burp()
    ticks=0
    tickstep=5
    last_signal=-99999
    viewport_speed=16
    sel_speed=0.0
    delta_sel=0.0
    delay=-1.0
    run_flag=False
    ch=""
    selx=600.0
    sely=365.0
    place_signal=3
    helpstring="""Use ENTER and SPACE to run or halt the pattern;
 use + and - to change the step size or delay value;
 use arrow keys and mouse tools to pan and zoom in any pane;
 T toggles between a tiled view and a single-pane view;
 S creates another signal fleet near the detection mechanism;
 R resets the Heisenburp device to its initial state;
 Q quits out of the script and restores original settings."""

    instr="Press H for help. "
    g.show(instr + str(tickstep))
    g.select([selx,sely,50,50])

    # keyboard handling
    while ch<>"q":
        if place_signal>0:
            if ticks-last_signal>1846:
                test_signal.put(-150,60)
                last_signal=ticks
                place_signal-=1

        if place_signal>0 and run_flag==True:
            show_status_text("Next signal placement in " \
            + str(1847 - ticks + last_signal) + " ticks. " + instr, delay, tickstep)
        else:
            show_status_text(instr,delay,tickstep)

        event = g.getevent()
        if event.startswith("key"):
            evt, ch, mods = event.split()
        else:
            ch = ""
        if ch=="r":
            prepare_burp()
            ticks=0
            last_signal=-99999
            viewport_speed=16
            sel_speed=0
            run_flag=False
            selx=600.0
            sely=365.0
            place_signal=3
            g.select([selx,sely,50,50])

        elif ch=="h":
            g.note(helpstring)
        elif ch=="t":
            g.setoption("tilelayers",1-g.getoption("tilelayers"))

        elif ch=="=" or ch=="+":
            if delay>.01:
                delay/=2
            elif delay==.01:
                delay=-1
            else:
                if tickstep==1:
                    tickstep=3
                elif tickstep<250:
                    tickstep=(tickstep-1)*2+1
        elif ch=="-" or ch=="_":
            if delay==-1:
                if tickstep==1:
                    delay=.01
                else:
                    if tickstep==3:
                        tickstep=1
                    else:
                        tickstep=(tickstep-1)/2+1
            else:
                if delay<1:
                    delay*=2

        elif ch=="space":
            run_flag=False
        elif ch=="return":
            run_flag=not run_flag
        elif ch=="s":
            place_signal+=1
        else:
            # just pass any other keyboard/mouse event through to Golly
            g.doevent(event)

        # generation and selection speed handling
        if ch=="space" or run_flag==True:
            g.run(tickstep)

            currlayer = g.getlayer()
            if currlayer != 4:
                # user has switched layer so temporarily change it back
                # so we only change location of bottom right layer
                g.check(False)
                g.setlayer(4)

            x, y = getposint()
            oldticks=ticks
            ticks+=tickstep
            delta_view=int(ticks/viewport_speed) - int(oldticks/viewport_speed)
            if delta_view <> 0: # assumes diagonal motion for now
                setposint(x + delta_view, y + delta_view)
            sel = g.getselrect()
            if len(sel)<>0:
                x, y, w, h = sel
                if int(selx)<>x: # user changed selection
                    # prepare to move new selection instead (!?!)
                    # -- use floating-point selx, sely to account for fractional speeds
                    selx=x
                    sely=y
                else:
                    selx+=sel_speed*tickstep
                    sely+=sel_speed*tickstep
                    g.select([selx, sely, w, h])
            else:
                g.select([selx, sely, 50, 50])

            if currlayer != 4:
                g.setlayer(currlayer)
                g.check(True)

            # change viewport speed at appropriate times to follow the action
            if oldticks<4570 and ticks>=4570:
                sel_speed=.666667
                # one-time correction to catch up with the signal at high sim speeds
                g.select([600+(ticks-4570)*1.5, 365+(ticks-4570)*1.5, w, h])
            if selx>2125:
                sel_speed=0
                g.select([2125, sely+2125-selx, w, h])
            if oldticks<4750 and ticks>=4750: viewport_speed=1.5
            if oldticks<6125 and ticks>=6125: viewport_speed=16
            if oldticks>=11995: viewport_speed=99999.9

            # stop automatically after the last signal passes through the device
            if oldticks - last_signal<8705 and ticks - last_signal>=8705:
                run_flag=False
            if run_flag==True and delay>0:
                sleep(delay)

        g.update()
コード例 #17
0
                    event = g.getevent()
                    if event == "key space none": break
                    g.doevent(event)  # allow keyboard/mouse interaction
                    sleep(0.01)  # avoid hogging cpu

    # if all patterns have been displayed then restore original algo and rule
    # (don't do this if user hits escape in case they want to explore pattern)
    g.new("untitled")
    g.setalgo(oldalgo)
    g.setrule(oldrule)


# ------------------------------------------------------------------------------

# show status bar but hide other info to maximize viewport
oldstatus = g.setoption("showstatusbar", True)
oldtoolbar = g.setoption("showtoolbar", False)
oldlayerbar = g.setoption("showlayerbar", False)
oldeditbar = g.setoption("showeditbar", False)
oldfiles = g.setoption("showfiles", False)

try:
    slideshow()
finally:
    # this code is always executed, even after escape/error;
    # clear message line in case there was no escape/error
    g.show("")
    # restore original state
    g.setoption("showstatusbar", oldstatus)
    g.setoption("showtoolbar", oldtoolbar)
    g.setoption("showlayerbar", oldlayerbar)
コード例 #18
0
ファイル: slide-show.py プロジェクト: jamlin416/golly
                    sleep(0.01)  # avoid hogging cpu

        if "CVS" in dirs:
            dirs.remove("CVS")  # don't visit CVS directories

    # if all patterns have been displayed then restore original algo and rule
    # (don't do this if user hits escape in case they want to explore pattern)
    g.new("untitled")
    g.setalgo(oldalgo)
    g.setrule(oldrule)


# ------------------------------------------------------------------------------

# show status bar but hide other info to maximize viewport
oldstatus = g.setoption("showstatusbar", True)
oldtoolbar = g.setoption("showtoolbar", False)
oldlayerbar = g.setoption("showlayerbar", False)
oldeditbar = g.setoption("showeditbar", False)
oldscripts = g.setoption("showscripts", False)
oldpatterns = g.setoption("showpatterns", False)

try:
    slideshow()
finally:
    # this code is always executed, even after escape/error;
    # clear message line in case there was no escape/error
    g.show("")
    # restore original state
    g.setoption("showstatusbar", oldstatus)
    g.setoption("showtoolbar", oldtoolbar)
コード例 #19
0
ファイル: heisenburp.py プロジェクト: bahusvel/ConwayLife
# -----------------------------------------------------

def show_status_text(s, d, t):
    if d==-1:
        if t==1:
            g.show(s + "Speed is " + str(t) + " tick per step.")
        else:
            g.show(s + "Speed is " + str(t) + " ticks per step.")
    else:
        g.show(s + "Delay between ticks is " + str(d) + " seconds.")

# -----------------------------------------------------

# if there are multiple layers, get permission to remove them
if g.numlayers() > 1:
    answer = g.getstring("All existing layers will be removed. OK?")
    if lower(answer[:1]) == "n":
        g.exit()
oldswitch = g.setoption("switchlayers", True) # allow user to switch layers
oldtile = g.setoption("tilelayers", True)
rule()
try:
    burp()
finally:
    # remove the cloned layers added by the script
    while g.numlayers() > 1: g.dellayer()
    g.setname("Stable Pseudo-Heisenburp Device")
    g.setoption("tilelayers", oldtile)
    g.setoption("switchlayers", oldswitch)
    g.show("")
コード例 #20
0
ファイル: heisenburp.py プロジェクト: bahusvel/ConwayLife
def burp():
    test_signal=pattern("""
    40bo$41bo$39b3o17$40bo4bo4bo4bo4bo$41bo4bo4bo4bo4bo$39b3o2b3o2b3o2b3o
    2b3o3$40bo4bo4bo4bo4bo$41bo4bo4bo4bo4bo$39b3o2b3o2b3o2b3o2b3o3$40bo4bo
    4bo4bo4bo$41bo4bo4bo4bo4bo$39b3o2b3o2b3o2b3o2b3o3$40bo4bo4bo4bo4bo$41b
    o4bo4bo4bo4bo$39b3o2b3o2b3o2b3o2b3o3$bo38bo4bo4bo4bo4bo18bo$2bo38bo4bo
    4bo4bo4bo18bo$3o36b3o2b3o2b3o2b3o2b3o16b3o37$40bo$41bo$39b3o!""")

    prepare_burp()
    ticks=0
    tickstep=5
    last_signal=-99999
    viewport_speed=16
    sel_speed=0.0
    delta_sel=0.0
    delay=-1.0
    run_flag=False
    ch=""
    selx=600.0
    sely=365.0
    place_signal=3
    helpstring="""Use ENTER and SPACE to run or halt the pattern;
 use + and - to change the step size or delay value;
 use arrow keys and mouse tools to pan and zoom in any pane;
 T toggles between a tiled view and a single-pane view;
 S creates another signal fleet near the detection mechanism;
 R resets the Heisenburp device to its initial state;
 Q quits out of the script and restores original settings."""

    instr="Press H for help. "
    g.show(instr + str(tickstep))
    g.select([selx,sely,50,50])

    # keyboard handling
    while ch<>"q":
        if place_signal>0:
            if ticks-last_signal>1846:
                test_signal.put(-150,60)
                last_signal=ticks
                place_signal-=1

        if place_signal>0 and run_flag==True:
            show_status_text("Next signal placement in " \
            + str(1847 - ticks + last_signal) + " ticks. " + instr, delay, tickstep)
        else:
            show_status_text(instr,delay,tickstep)

        event = g.getevent()
        if event.startswith("key"):
            evt, ch, mods = event.split()
        else:
            ch = ""
        if ch=="r":
            prepare_burp()
            ticks=0
            last_signal=-99999
            viewport_speed=16
            sel_speed=0
            run_flag=False
            selx=600.0
            sely=365.0
            place_signal=3
            g.select([selx,sely,50,50])

        elif ch=="h":
            g.note(helpstring)
        elif ch=="t":
            g.setoption("tilelayers",1-g.getoption("tilelayers"))

        elif ch=="=" or ch=="+":
            if delay>.01:
                delay/=2
            elif delay==.01:
                delay=-1
            else:
                if tickstep==1:
                    tickstep=3
                elif tickstep<250:
                    tickstep=(tickstep-1)*2+1
        elif ch=="-" or ch=="_":
            if delay==-1:
                if tickstep==1:
                    delay=.01
                else:
                    if tickstep==3:
                        tickstep=1
                    else:
                        tickstep=(tickstep-1)/2+1
            else:
                if delay<1:
                    delay*=2

        elif ch=="space":
            run_flag=False
        elif ch=="return":
            run_flag=not run_flag
        elif ch=="s":
            place_signal+=1
        else:
            # just pass any other keyboard/mouse event through to Golly
            g.doevent(event)

        # generation and selection speed handling
        if ch=="space" or run_flag==True:
            g.run(tickstep)

            currlayer = g.getlayer()
            if currlayer != 4:
                # user has switched layer so temporarily change it back
                # so we only change location of bottom right layer
                g.check(False)
                g.setlayer(4)

            x, y = getposint()
            oldticks=ticks
            ticks+=tickstep
            delta_view=int(ticks/viewport_speed) - int(oldticks/viewport_speed)
            if delta_view <> 0: # assumes diagonal motion for now
                setposint(x + delta_view, y + delta_view)
            sel = g.getselrect()
            if len(sel)<>0:
                x, y, w, h = sel
                if int(selx)<>x: # user changed selection
                    # prepare to move new selection instead (!?!)
                    # -- use floating-point selx, sely to account for fractional speeds
                    selx=x
                    sely=y
                else:
                    selx+=sel_speed*tickstep
                    sely+=sel_speed*tickstep
                    g.select([selx, sely, w, h])
            else:
                g.select([selx, sely, 50, 50])

            if currlayer != 4:
                g.setlayer(currlayer)
                g.check(True)

            # change viewport speed at appropriate times to follow the action
            if oldticks<4570 and ticks>=4570:
                sel_speed=.666667
                # one-time correction to catch up with the signal at high sim speeds
                g.select([600+(ticks-4570)*1.5, 365+(ticks-4570)*1.5, w, h])
            if selx>2125:
                sel_speed=0
                g.select([2125, sely+2125-selx, w, h])
            if oldticks<4750 and ticks>=4750: viewport_speed=1.5
            if oldticks<6125 and ticks>=6125: viewport_speed=16
            if oldticks>=11995: viewport_speed=99999.9

            # stop automatically after the last signal passes through the device
            if oldticks - last_signal<8705 and ticks - last_signal>=8705:
                run_flag=False
            if run_flag==True and delay>0:
                sleep(delay)

        g.update()
コード例 #21
0
               g.doevent(event)           # allow keyboard/mouse interaction
               sleep(0.01)                # avoid hogging cpu
      
      if "CVS" in dirs:
         dirs.remove("CVS")  # don't visit CVS directories
   
   # if all patterns have been displayed then restore original algo and rule
   # (don't do this if user hits escape in case they want to explore pattern)
   g.new("untitled")
   g.setalgo(oldalgo)
   g.setrule(oldrule)

# ------------------------------------------------------------------------------

# show status bar but hide other info to maximize viewport
oldstatus = g.setoption("showstatusbar", True)
oldtoolbar = g.setoption("showtoolbar", False)
oldlayerbar = g.setoption("showlayerbar", False)
oldeditbar = g.setoption("showeditbar", False)
oldscripts = g.setoption("showscripts", False)
oldpatterns = g.setoption("showpatterns", False)

try:
   slideshow()
finally:
   # this code is always executed, even after escape/error;
   # clear message line in case there was no escape/error
   g.show("")
   # restore original state
   g.setoption("showstatusbar", oldstatus)
   g.setoption("showtoolbar", oldtoolbar)
コード例 #22
0
g.setalgo("QuickLife")  # qlife's setcell is faster

for j in xrange(selheight):
    for i in xrange(selwidth):
        golly.show("Placing (" + str(i + 1) + "," + str(j + 1) + ") tile" +
                   " in a " + str(selwidth) + " by " + str(selheight) +
                   " rectangle.")
        if livecell[i][j]:
            ONcell.put(2048 * i - 5, 2048 * j - 5)
        else:
            OFFcell.put(2048 * i - 5, 2048 * j - 5)
        g.fit()

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
# generated during this first cycle.  Thus at the end of 35328 ticks, the pattern
# is ready to start its first "normal" metageneration (where cell states may change).
#
# It should be possible to define a version of ONcell that is not fully populated
# with LWSSs and HWSSs until the end of the first full cycle.  This would be much
# quicker to generate from a script definition, and so it wouldn't be necessary to
# save it to a file.  The only disadvantage is that ONcells would be visually
コード例 #23
0
            g.show("Counting cell states... %.2f%%" % done)
            g.dokey(g.getkey())

statecount = [int(10 * math.log((x + 1), 2)) for x in statecount]
totalcells = sum(statecount)
if statecount[0] == counted: g.exit("Selection is empty.")

# save current layer's info before we switch layers
currname = g.getname()
currcursor = g.getcursor()
currcolors = g.getcolors()
currstates = g.numstates()
deads, deadr, deadg, deadb = g.getcolors(0)

# create histogram in separate layer
g.setoption("stacklayers", 0)
g.setoption("tilelayers", 0)
g.setoption("showlayerbar", 1)
if histlayer == -1:
    histlayer = g.addlayer()
else:
    g.setlayer(histlayer)

g.new(histname)
g.setcursor(currcursor)

# use a Generations rule so we can append extra state for drawing text & lines
g.setrule("//" + str(currstates + 1))
extrastate = currstates
currcolors.append(extrastate)
if (deadr + deadg + deadb) / 3 > 128:
コード例 #24
0
# Slow glider page, for Mozilla CA presentation

import golly as g
from glife.base import glider, flip_x
import time

# Conway's Life
g.setrule("B3/S23")

glider.display("Slow Glider", x=-20, y=20, A = flip_x)
g.setpos('0', '0')
g.setoption('fullscreen', True)
g.setstep(0)

while True:
    time.sleep(.5)
    g.step()
    g.update()