예제 #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.dokey( g.getkey() )
      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
def gofast(newgen, delay):
   ''' Fast goto '''
   #Save current settings
   oldbase = g.getbase()
   # oldhash = g.setoption("hashing", True)
   
   g.show('gofast running, hit escape to abort')
   oldsecs = time()
   
   #Advance by binary powers, to maximize advantage of hashing
   g.setbase(2)
   for i, b in enumerate(intbits(newgen)):
      if b:
         g.setstep(i)
         g.step()
         g.dokey(g.getkey())
         newsecs = time()
         if newsecs - oldsecs >= delay:  # do an update every sec
            oldsecs = newsecs
            g.update()
         if   g.empty():
            break
   
   g.show('')
   
   #Restore settings
   # g.setoption("hashing", oldhash)
   g.setbase(oldbase)
예제 #3
0
def slideshow ():
   oldalgo = g.getalgo()
   oldrule = g.getrule()
   
   message = "Hit space to continue or escape to exit the slide show..."
   g.show(message)
   for root, dirs, files in os.walk(g.getdir("app") + "Patterns"):
      for name in files:
         if name.startswith("."):
            # ignore hidden files (like .DS_Store on Mac)
            pass
         else:
            fullname = join(root, name)
            g.open(fullname, False)       # don't add file to Open/Run Recent submenu
            g.update()
            if name.endswith(".pl") or name.endswith(".py"):
               # reshow message in case it was changed by script
               g.show(message)
            
            while True:
               ch = g.getkey()
               if ch == " ": break
               g.dokey(ch)                # allow keyboard 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)
예제 #4
0
def gofast(newgen, delay):
    ''' Fast goto '''
    #Save current settings
    oldbase = g.getbase()
    # oldhash = g.setoption("hashing", True)

    g.show('gofast running, hit escape to abort')
    oldsecs = time()

    #Advance by binary powers, to maximize advantage of hashing
    g.setbase(2)
    for i, b in enumerate(intbits(newgen)):
        if b:
            g.setstep(i)
            g.step()
            g.dokey(g.getkey())
            newsecs = time()
            if newsecs - oldsecs >= delay:  # do an update every sec
                oldsecs = newsecs
                g.update()
            if g.empty():
                break

    g.show('')

    #Restore settings
    # g.setoption("hashing", oldhash)
    g.setbase(oldbase)
예제 #5
0
# count all cell states in r
g.show("Counting cell states...")
counted = 0
totalcells = r.wd * r.ht
statecount = [0] * g.numstates()
oldsecs = time()
for row in xrange(r.top, r.top + r.height):
    for col in xrange(r.left, r.left + r.width):
        counted += 1
        statecount[g.getcell(col, row)] += 1
        newsecs = time()
        if newsecs - oldsecs >= 1.0:  # show % done every sec
            oldsecs = newsecs
            done = 100.0 * float(counted) / float(totalcells)
            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)
예제 #6
0
# we first write the commands to a string, and then to the grid
# (we start off facing right, at the bottom-left of the construction area)

# write the cells that are in state 1 (can ignore the zeros)
# (still plenty of room for optimisation here)
tape = '11'
for row in xrange(r.top, r.top + r.height):
   # if large selection then give some indication of progress
   newsecs = time()
   if newsecs - oldsecs >= 1.0:
      oldsecs = newsecs
      g.update()

   # also allow keyboard interaction
   g.dokey( g.getkey() )

   for col in xrange(r.left, r.left + r.width):
      if g.getcell(col, row)==1:
         tape += extend*(4+col-r.left) + extend_left + extend*(r.top+r.height-row)
         tape += mark
         tape += retract*(r.top+r.height-row) + retract_left + retract*(4+col-r.left)
      elif g.getcell(col,row)!=0:
	     g.exit('Cells in the selected area must be in states 0 or 1 only.')
	  
# finally we sheath and trigger and retract
tape += extend_left + extend*4 + extend_right + extend
tape += inject_sheath + '1'*50 + inject_trigger
tape += retract*2 + retract_right + retract*4 + retract_left
	
# now write the tape out
예제 #7
0
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 lower(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)

      ch = g.getkey()
      if lower(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 lower(ch)=="h":
         g.note(helpstring)
      elif lower(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==" ":
         run_flag=False
      elif ch==chr(13):
         run_flag=not run_flag
      elif lower(ch)=="s":
         place_signal+=1
      else:
         g.dokey(ch) # just pass any other keypresses through to Golly
      # end of keyboard handling
      
      # generation and selection speed handling
      if ch==" " 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()
예제 #8
0
   # store hash/gen/pop/box info at same position in various lists
   hashlist.insert(pos, h)
   genlist.insert(pos, int(g.getgen()))
   poplist.insert(pos, int(g.getpop()))
   boxlist.insert(pos, pbox)

   return False

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

def fit_if_not_visible():
   # fit pattern in viewport if not empty and not completely visible
   r = rect(g.getrect())
   if (not r.empty) and (not r.visible()): g.fit()

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

g.show("Checking for oscillation... (hit escape to abort)")

oldsecs = time()
while not oscillating():
   g.run(1)
   g.dokey( g.getkey() )            # allow keyboard interaction
   newsecs = time()
   if newsecs - oldsecs >= 1.0:     # show pattern every second
      oldsecs = newsecs
      fit_if_not_visible()
      g.update()

fit_if_not_visible()
예제 #9
0
def goto(gen):
   currgen = int(g.getgen())
   if gen[0] == '+':
      n = int(gen[1:])
      newgen = currgen + n
   elif gen[0] == '-':
      n = int(gen[1:])
      if currgen > n:
         newgen = currgen - n
      else:
         newgen = 0
   else:
      newgen = int(gen)
   
   if newgen < currgen:
      # try to go back to starting gen (not necessarily 0) and
      # then forwards to newgen; note that reset() also restores
      # algorithm and/or rule, so too bad if user changed those
      # after the starting info was saved;
      # first save current location and scale
      midx, midy = g.getpos()
      mag = g.getmag()
      g.reset()
      # restore location and scale
      g.setpos(midx, midy)
      g.setmag(mag)
      # current gen might be > 0 if user loaded a pattern file
      # that set the gen count
      currgen = int(g.getgen())
      if newgen < currgen:
         g.error("Can't go back any further; pattern was saved " +
                 "at generation " + str(currgen) + ".")
         return
   if newgen == currgen: return
   
   g.show("Hit escape to abort...")
   oldsecs = time()
   
   # before stepping we advance by 1 generation, for two reasons:
   # 1. if we're at the starting gen then the *current* step size
   #    will be saved (and restored upon Reset/Undo) rather than a
   #    possibly very large step size
   # 2. it increases the chances the user will see updates and so
   #    get some idea of how long the script will take to finish
   #    (otherwise if the base is 10 and a gen like 1,000,000,000
   #    is given then only a single step() of 10^9 would be done)
   g.run(1)
   currgen += 1
   
   # use fast stepping (thanks to PM 2Ring)
   for i, d in enumerate(intbase(newgen - currgen, g.getbase())):
      if d > 0:
         g.setstep(i)
         for j in xrange(d):
            if g.empty():
               g.show("Pattern is empty.")
               return
            g.step()
            g.dokey( g.getkey() )         # allow keyboard interaction
            newsecs = time()
            if newsecs - oldsecs >= 1.0:  # do an update every sec
               oldsecs = newsecs
               g.update()
   g.show("")