Ejemplo n.º 1
0
	def draw(self, addstr = ""):
		
		xy = [] 
		xz = [] 
		yz = [] 
		proj = []
		
		for (k, v) in self.cur_state.items():
			x, y, z = k
			
			xy.append(x)
			xy.append(y)
			
			xz.append(x + 128)
			xz.append(z)
			
			yz.append(y)
			yz.append(z + 128)
		
			proj.append(x + y + z + 128)
			proj.append(- x + y + z + 128)
			
		if len(g.getrect()) > 0:
			g.select(g.getrect())
			g.clear(0)
			g.select([])
		
		g.putcells(xy)
		g.putcells(xz)
		g.putcells(yz)
		g.putcells(proj)
		g.setpos("64", "64")
		g.setmag(1)
		g.show("Size: {0}, (w, d, h): {1}".format(self.get_pop(), str(self.get_wdh())) + addstr)
		g.update()
Ejemplo n.º 2
0
    def draw(self):

        xy = []
        xz = []
        yz = []
        proj = []

        for (k, v) in self.cur_state.items():
            x, y, z = k

            xy.append(x)
            xy.append(y)

            xz.append(x + 128)
            xz.append(z)

            yz.append(y)
            yz.append(z + 128)

            proj.append(x + y + z + 128)
            proj.append(-x + y + z + 128)

        if len(g.getrect()) > 0:
            g.select(g.getrect())
            g.clear(0)
            g.select([])

        g.putcells(xy)
        g.putcells(xz)
        g.putcells(yz)
        g.putcells(proj)
        g.setpos("64", "64")
        g.setmag(1)
        g.update()
Ejemplo n.º 3
0
def clearlayer():
    r = g.getrect()
    if r:
        g.select(r)
        g.clear(0)
    if withB0:
        # Needed with B0 rules to ensure pattern runs correctly
        g.setgen('0')
Ejemplo n.º 4
0
def testRule(rulestr):
    r = g.getrect()
    if r:
        g.select(r)
        g.clear(0)
    g.putcells(origPatt)
    g.setrule(rulestr)
    g.run(stabGen)
    if g.empty():
        return ()
    pop = int(g.getpop())
    if (pop < minPop or pop > maxPop):
        return ()
    r = g.getrect()
    testPatt = g.transform(g.getcells(r), -r[0], -r[1])
    testPop = int(g.getpop())
    testRect = g.getrect()
    stabPatt = list(testPatt)
    stabPop = testPop
    for ii in xrange(maxGen):
        g.run(1)
        pop = int(g.getpop())
        if (pop < minPop or pop > maxPop):
            break
        if (pop == testPop):
            # Test for periodicity
            r = g.getrect()
            if testPatt == g.transform(g.getcells(r), -r[0], -r[1]):
                period = ii + 1
                dy, dx = sss.minmaxofabs(
                    (r[0] - testRect[0], r[1] - testRect[1]))
                if (dx == 0):
                    # Oscillator (reject if low period or bOsc is False)
                    if bOsc and period >= minOscP:
                        return (0, 0, period)
                elif (period >= minShipP):
                    # Spaceship
                    return (dx, dy, period)
                elif ((dx + dy / 1.9) / (period * 1.0) > minSpeed
                      and period >= fastShipP):
                    # Fast spaceship
                    return (dx, dy, period)
                break  # Pattern is a low period oscillator or spaceship
        # Stability check
        if (ii % stabCheckP == 0):
            r = g.getrect()
            # First check for BBox expansion
            if maxDim > 0 and max(r[2:4]) > maxDim:
                # Pattern is expanding
                # XXX Attempt to separate components expanding in different directions
                break
            currPatt = g.transform(g.getcells(r), -r[0], -r[1])
            if (pop == stabPop and currPatt == stabPatt):
                # Pattern has stabilised to low period oscillator / spaceship
                break
            stabPop = pop
            stabPatt = list(currPatt)
    return ()
Ejemplo n.º 5
0
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))
Ejemplo n.º 6
0
def GunsReader():
	
	result = [] 
	
	for i in xrange(0, 10000):
		cells = g.getcells([0, i * 650, 500, 550])
		
		if len(cells) == 0:
			return result 
		
		g.select([-200, i * 650 - 10, 800, 550])
		g.clear(0)
		
		result.append(cells)
Ejemplo n.º 7
0
def AdaptiveGoto(hwssRecipe, enablePrinting=True):

    #g.setrule("LifeHistory")
    fense50 = g.parse(
        "F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F!"
    )

    helixD = CalcHelix(hwssRecipe)

    curgen = -helixD * 2
    curgen += 2 * distForward

    goto(curgen)
    g.setbase(8)
    g.setstep(3)

    delta = 10
    lastmaxi = delta
    idx = 0

    for i in hwssRecipe:

        if enablePrinting and (100 * (idx + 1)) / len(hwssRecipe) != (
                100 * idx) / len(hwssRecipe):
            percent = (100 * (idx + 1)) / len(hwssRecipe)
            g.update()

            g.show("Iterating forward progress " + str(percent) + "%")

        curgen += 2 * distForward
        idx += 1

        while int(g.getgen()) < curgen:
            g.step()

        if i == 'SKIP':
            continue

        if i > lastmaxi:

            g.select([fenseX, helixD + fenseY + lastmaxi - delta, 1, delta])
            g.clear(0)
            lastmaxi += delta
            #g.update()

        if i < lastmaxi - delta:
            g.putcells(fense50, fenseX, helixD + fenseY + lastmaxi - 2 * delta)
            lastmaxi -= delta
Ejemplo n.º 8
0
def AdaptiveGoto(hwssRecipe, enablePrinting = True):

	#g.setrule("LifeHistory")
	fense50 = g.parse("F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F!")

	helixD = CalcHelix(hwssRecipe)
		
	curgen = -helixD * 2
	curgen += 2 * distForward
	
	goto(curgen)
	g.setbase(8)
	g.setstep(3)
	
	delta = 10
	lastmaxi = delta
	idx = 0
	
	for i in hwssRecipe:
		
		if enablePrinting and (100 * (idx + 1)) / len(hwssRecipe) != (100 * idx) / len(hwssRecipe):
			percent = (100 * (idx + 1)) / len(hwssRecipe)
			g.update()
			
			g.show("Iterating forward progress " + str(percent) + "%")
			
		curgen += 2 * distForward
		idx += 1
		
		while int(g.getgen()) < curgen:
			g.step()
			
		if i == 'SKIP':
			continue 
			
		if i > lastmaxi:
			
			g.select([fenseX, helixD + fenseY + lastmaxi - delta, 1, delta])
			g.clear(0)
			lastmaxi += delta
			#g.update()
			
		if i < lastmaxi - delta:
			g.putcells(fense50, fenseX, helixD + fenseY + lastmaxi - 2 * delta)
			lastmaxi -= delta
Ejemplo n.º 9
0
def write(asm):
	binary = translateAll(asm)
	g.open("computer.mc")
	g.duplicate()
	g.setname("programmed", 0)
	g.movelayer(1, 0)
	g.dellayer()
	
	g.select([-25950, 1890, 450, 240])
	g.cut()

	for i in range(len(binary)):
		for j in range(21):
		
			if int(binary[i][j]):
				g.select([-23639+i*600+j*300, 2159+i*600-j*300, 450, 240])
				g.clear(0)
				g.paste(-23639+i*600+j*300, 2159+i*600-j*300, "or")
Ejemplo n.º 10
0
Archivo: sss.py Proyecto: apaap/sssss
def canon5Sship(ship, maxgen=2000):
    minpop, rulestr, dx, dy, period, shiprle = ship
    shipPatt = g.parse(shiprle)
    # Transform ship to canonical direction
    if abs(dx) >= abs(dy):
        a, b, c, d = sign(dx), 0, 0, sign(dy)
    else:
        a, b, c, d = 0, sign(dy), sign(dx), 0
    dy, dx = minmaxofabs((dx, dy))
    shipPatt = g.transform(shipPatt, 0, 0, a, b, c, d)
    # Clear the layer and place the ship
    r = g.getrect()
    if r:
        g.select(r)
        g.clear(0)
    g.putcells(shipPatt)
    shiprle = giveRLE(g.getcells(g.getrect()))
    g.setrule(rulestr)
    # Determine the minimal isotropic rule
    setminisorule(period)
    return minpop, g.getrule(), dx, dy, period, shiprle
Ejemplo n.º 11
0
def tileit(clist,tilewd):
	global inc,pbox
	cliplist=clist

	# g.select([boxsel[0]-20,boxsel[1]-20,20,20])
	# g.clear(0)	
	# make_text(str(posi)).put(boxsel[0]-20,boxsel[1])
	
	pbox = rect( [0, 0] + cliplist[0 : 2] )
	
	wd=tilewd*pbox.wd
	ht=tilewd*pbox.ht
	boxsel=[-int(wd/2),-int(wd/2),wd,ht]
	g.select(boxsel)
	selrect = rect( g.getselrect() )
	inc=2
	cliplist[0 : 2] = []                      # remove wd,ht
	p = pattern( cliplist )

	if len(cliplist) & 1 == 1: inc = 3        # multi-state?
	g.clear(inside)

	
	if len(cliplist) > 0:
		# tile selrect with p, clipping right & bottom edges if necessary
		y = selrect.top
		while y <= selrect.bottom:
			bottom = y + pbox.height - 1
			x = selrect.left
			while x <= selrect.right:
				right = x + pbox.width - 1
				if (right <= selrect.right) and (bottom <= selrect.bottom):
					p.put(x, y)
				else:
					clip_rb( p(x, y), selrect.right, selrect.bottom ).put()
				x += pbox.width
			y += pbox.height

	if not selrect.visible(): g.fitsel()				
Ejemplo n.º 12
0
def setupT(dhead, binaryStr, dx, dy):
    setupR(dhead, dx, dy)
    setupR(len(binaryStr) - 1 - dhead, dx + 310, dy - 506)
    setupR(dhead * 16, dx + 130, dy - 3286)
    setupR(dhead * 16, dx - 1113, dy - 2062)

    if len(binaryStr) == 0:
        return

    x = dx + 142
    y = dy - 3305
    g.select([x, y, 3, 3])
    g.clear(0)

    for i in range(len(binaryStr)):
        if binaryStr[i] == '0':
            g.putcells(boat, x, y)
        else:
            g.putcells(boat, x - 3, y - 3)

        x -= 16
        y -= 16
Ejemplo n.º 13
0
def AdaptiveGoto(hwssRecipe):

	#g.setrule("LifeHistory")
	fense50 = g.parse("F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F!")

	helixD = -step * len(hwssRecipe) - 1000
		
	while helixD % 7500 != 0:
		helixD -= 1
	
	curgen = -helixD * 2
	curgen += 2 * distForward
	goto(curgen)
	g.setstep(3)
	
	delta = 10
	lastmaxi = delta
	
	for i in hwssRecipe:
		curgen += 2 * distForward
		
		while int(g.getgen()) < curgen:
			g.step()
		
	
		if i == 'SKIP':
			continue 
			
		if i > lastmaxi:
			
			g.select([240, helixD + fenseY + lastmaxi - delta, 1, delta])
			g.clear(0)
			lastmaxi += delta
			#g.update()
			
		if i < lastmaxi - delta:
			g.putcells(fense50, 240, helixD + fenseY + lastmaxi - 2 * delta)
			lastmaxi -= delta
def AdaptiveGoto(hwssRecipe):

	#g.setrule("LifeHistory")
	fense50 = g.parse("F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F$F!")

	helixD = -step * len(hwssRecipe) - 1000
		
	while helixD % 7500 != 0:
		helixD -= 1
	
	curgen = -helixD * 2
	curgen += 2 * distForward
	goto(curgen)
	g.setstep(3)
	
	delta = 10
	lastmaxi = delta
	
	for i in hwssRecipe:
		curgen += 2 * distForward
		
		while int(g.getgen()) < curgen:
			g.step()
		
	
		if i == 'SKIP':
			continue 
			
		if i > lastmaxi:
			
			g.select([240, helixD + fenseY + lastmaxi - delta, 1, delta])
			g.clear(0)
			lastmaxi += delta
			#g.update()
			
		if i < lastmaxi - delta:
			g.putcells(fense50, 240, helixD + fenseY + lastmaxi - 2 * delta)
			lastmaxi -= delta
Ejemplo n.º 15
0
	def CanApplyRecipe(self, recipe, expected):
		g.new("")
		g.setstep(3)
		
		g.putcells(blck)
		g.putcells(self.init)
		
		for r in self.recipe:
			g.putcells(gld, 80, 80 + r)
			g.step()
		
		g.select([self.block0[0], self.block0[1], 2, 2])
		g.clear(0)
		cells = g.getcells(g.getrect())
		g.putcells(blck, self.block0[0], self.block0[1])
		delta = self.block0[1] - self.block0[0]
		
		for r in recipe:
			g.putcells(gld, 80, 80 + r + delta)
			g.step()
		
		for i in xrange(0, len(cells), 2):
			x = cells[i]
			y = cells[i + 1]
			
			if g.getcell(x, y) == 0:
				return False
				
		for i in xrange(0, len(expected), 2):
		
			x = expected[i] + self.block0[0]
			y = expected[i + 1] + self.block0[1]
			
			if g.getcell(x, y) == 0:
				return False
				
		return True
Ejemplo n.º 16
0
    mode = "or"

# abort shift if the new selection would be outside a bounded grid
if g.getwidth() > 0:
    gridl = -int(g.getwidth()/2)
    gridr = gridl + g.getwidth() - 1
    newl = selrect[0] + x
    newr = newl + selrect[2] - 1
    if newl < gridl or newr > gridr:
        g.exit("New selection would be outside grid.")
if g.getheight() > 0:
    gridt = -int(g.getheight()/2)
    gridb = gridt + g.getheight() - 1
    newt = selrect[1] + y
    newb = newt + selrect[3] - 1
    if newt < gridt or newb > gridb:
        g.exit("New selection would be outside grid.")

# do the shift by cutting the current selection and pasting it into
# the new position without changing the current clipboard pattern
selcells = g.getcells(selrect)
g.clear(inside)
selrect[0] += x
selrect[1] += y
g.select(selrect)
if mode == "copy":
    g.clear(inside)
g.putcells(selcells, x, y, 1, 0, 0, 1, mode)

if not g.visrect(selrect): g.fitsel()
Ejemplo n.º 17
0
   
   return pattern(clist)

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

selrect = rect( g.getselrect() )
if selrect.empty: g.exit("There is no selection.")

cliplist = g.getclip()                    # 1st 2 items are wd,ht
pbox = rect( [0, 0] + cliplist[0 : 2] )
cliplist[0 : 2] = []                      # remove wd,ht
p = pattern( cliplist )

if len(cliplist) & 1 == 1: inc = 3        # multi-state?

g.clear(inside)
if len(cliplist) > 0:
   # tile selrect with p, clipping right & bottom edges if necessary
   y = selrect.top
   while y <= selrect.bottom:
      bottom = y + pbox.height - 1
      x = selrect.left
      while x <= selrect.right:
         right = x + pbox.width - 1
         if (right <= selrect.right) and (bottom <= selrect.bottom):
            p.put(x, y)
         else:
            clip_rb( p(x, y), selrect.right, selrect.bottom ).put()
         x += pbox.width
      y += pbox.height
Ejemplo n.º 18
0
# Use the current selection to create a toroidal universe.
# Author: Andrew Trevorrow ([email protected]), Sept 2010.

from glife import inside, outside
import golly as g

selrect = g.getselrect()
if len(selrect) == 0: g.exit("There is no selection.")
x = selrect[0]
y = selrect[1]
wd = selrect[2]
ht = selrect[3]

selcells = g.getcells(selrect)
if not g.empty():
    g.clear(inside)
    g.clear(outside)

# get current rule, remove any existing suffix, then add new suffix
rule = g.getrule().split(":")[0]
g.setrule(rule + ":T" + str(wd) + "," + str(ht))

newx = -int(wd / 2)
newy = -int(ht / 2)
selrect[0] = newx
selrect[1] = newy
g.select(selrect)
if len(selcells) > 0: g.putcells(selcells, newx - x, newy - y)
g.fitsel()
Ejemplo n.º 19
0
def moveselection():
    global oldcells, selrect, selpatt

    # wait for 1st click in selection
    while True:
        event = g.getevent()
        if event.startswith("click"):
            # event is a string like "click 10 20 left none"
            evt, xstr, ystr, butt, mods = event.split()
            x = int(xstr)
            y = int(ystr)
            if cellinrect(x, y, selrect):
                oldmouse = xstr + ' ' + ystr
                firstx = x
                firsty = y
                xoffset = firstx - selrect[0]
                yoffset = firsty - selrect[1]
                if mods == "alt":
                    # don't delete pattern in selection
                    oldcells = g.getcells(selrect)
                break
        elif event == "key h none":
            showhelp1()
        else:
            g.doevent(event)

    # wait for 2nd click while moving selection
    g.show("Move mouse and click again..." + helpmsg)
    gotclick = False
    while not gotclick:
        event = g.getevent()
        if event.startswith("click"):
            evt, x, y, butt, mods = event.split()
            mousepos = x+' '+y
            gotclick = True
        else:
            if len(event) > 0:
                lookforkeys(event, x - firstx, y - firsty)
                # update xoffset,yoffset in case selection was rotated
                xoffset = x - selrect[0]
                yoffset = y - selrect[1]
            mousepos = g.getxy()
        if len(mousepos) > 0 and mousepos != oldmouse:
            # mouse has moved, so move selection rect and pattern
            g.clear(0)
            if len(oldcells) > 0: g.putcells(oldcells)
            xstr, ystr = mousepos.split()
            x = int(xstr)
            y = int(ystr)
            selrect[0] = x - xoffset
            selrect[1] = y - yoffset

            if g.getwidth() > 0:
                # ensure selrect doesn't move beyond left/right edge of grid
                if selrect[0] < gridl:
                    selrect[0] = gridl
                    x = selrect[0] + xoffset
                elif selrect[0] + selrect[2] - 1 > gridr:
                    selrect[0] = gridr + 1 - selrect[2]
                    x = selrect[0] + xoffset
            if g.getheight() > 0:
                # ensure selrect doesn't move beyond top/bottom edge of grid
                if selrect[1] < gridt:
                    selrect[1] = gridt
                    y = selrect[1] + yoffset
                elif selrect[1] + selrect[3] - 1 > gridb:
                    selrect[1] = gridb + 1 - selrect[3]
                    y = selrect[1] + yoffset

            g.select(selrect)
            oldcells = g.getcells(selrect)
            g.putcells(selpatt, x - firstx, y - firsty)
            oldmouse = mousepos
            g.update()
Ejemplo n.º 20
0
Archivo: sss.py Proyecto: apaap/sssss
def getRuleRangeElems(period, ruleRange='minmax'):
    if g.empty():
        return
    if period < 1:
        return

    rule = g.getrule().split(':')[0]

    if not (rule[0] == 'B' and '/S' in rule):
        g.exit('Please set Golly to an isotropic 2-state rule.')

    # Parse rule string to list of transitions for Birth and Survival
    oldrule = rule
    Bstr, Sstr = rule.split('/')
    Bstr = Bstr.lstrip('B')
    Sstr = Sstr.lstrip('S')
    b_need = parseTransitions(Bstr)
    b_OK = list(b_need)
    s_need = parseTransitions(Sstr)
    s_OK = list(s_need)

    patt = g.getcells(g.getrect())

    # Record behavior of pattern in current rule
    clist = []
    poplist = []
    for i in range(0, period):
        g.run(1)
        clist.append(g.getcells(g.getrect()))
        poplist.append(g.getpop())
    finalpop = g.getpop()

    if 'min' in ruleRange:
        # Test all rule transitions to determine if they are required
        for t in b_OK:
            b_need.remove(t)
            g.setrule('B' + ''.join(b_need) + '/S' + Sstr)
            r = g.getrect()
            if r:
                g.select(r)
                g.clear(0)
            g.putcells(patt)
            for j in range(0, period):
                g.run(1)
                try:
                    if not (clist[j] == g.getcells(g.getrect())):
                        b_need.append(t)
                        break
                except:
                    b_need.append(t)
                    break
        b_need.sort()

        for t in s_OK:
            s_need.remove(t)
            g.setrule('B' + Bstr + '/S' + ''.join(s_need))
            r = g.getrect()
            if r:
                g.select(r)
                g.clear(0)
            g.putcells(patt)
            for j in range(0, period):
                g.run(1)
                try:
                    if not (clist[j] == g.getcells(g.getrect())):
                        s_need.append(t)
                        break
                except:
                    s_need.append(t)
                    break
        s_need.sort()

    if 'max' in ruleRange:
        # Test unused rule transitions to determine if they are allowed
        allRuleElem = [t for l in Hensel for t in l]

        for t in allRuleElem:
            if t in b_OK:
                continue
            b_OK.append(t)
            g.setrule('B' + ''.join(b_OK) + '/S' + Sstr)
            r = g.getrect()
            if r:
                g.select(r)
                g.clear(0)
            g.putcells(patt)
            for j in range(0, period):
                g.run(1)
                try:
                    if not (clist[j] == g.getcells(g.getrect())):
                        b_OK.remove(t)
                        break
                except:
                    b_OK.remove(t)
                    break
        b_OK.sort()

        for t in allRuleElem:
            if t in s_OK:
                continue
            s_OK.append(t)
            g.setrule('B' + Bstr + '/S' + ''.join(s_OK))
            r = g.getrect()
            if r:
                g.select(r)
                g.clear(0)
            g.putcells(patt)
            for j in range(0, period):
                g.run(1)
                try:
                    if not (clist[j] == g.getcells(g.getrect())):
                        s_OK.remove(t)
                        break
                except:
                    s_OK.remove(t)
                    break
        s_OK.sort()

    r = g.getrect()
    if r:
        g.select(r)
        g.clear(0)
    g.putcells(patt)
    g.setrule(oldrule)

    return b_need, s_need, b_OK, s_OK
Ejemplo n.º 21
0
def randfill(x, y):
    g.select([-int(x / 2), -int(y / 2), x, y])
    g.clear(0)
    g.randfill(50)
    g.select([])
Ejemplo n.º 22
0
def moveselection():
   global oldcells, selrect, selpatt
   
   # wait for 1st click in selection
   while True:
      event = g.getevent()
      if event.startswith("click"):
         # event is a string like "click 10 20 left none"
         evt, xstr, ystr, butt, mods = event.split()
         x = int(xstr)
         y = int(ystr)
         if cellinrect(x, y, selrect):
            oldmouse = xstr + ' ' + ystr
            firstx = x
            firsty = y
            xoffset = firstx - selrect[0]
            yoffset = firsty - selrect[1]
            if mods == "alt":
               # don't delete pattern in selection
               oldcells = g.getcells(selrect)
            break
      elif event == "key h none":
         showhelp1()
      else:
         g.doevent(event)
   
   # wait for 2nd click while moving selection
   g.show("Move mouse and click again..." + helpmsg)
   gotclick = False
   while not gotclick:
      event = g.getevent()
      if event.startswith("click"):
         evt, x, y, butt, mods = event.split()
         mousepos = x+' '+y
         gotclick = True
      else:
         if len(event) > 0:
            lookforkeys(event, x - firstx, y - firsty)
            # update xoffset,yoffset in case selection was rotated
            xoffset = x - selrect[0]
            yoffset = y - selrect[1]
         mousepos = g.getxy()
      if len(mousepos) > 0 and mousepos != oldmouse:
         # mouse has moved, so move selection rect and pattern
         g.clear(0)
         if len(oldcells) > 0: g.putcells(oldcells)
         xstr, ystr = mousepos.split()
         x = int(xstr)
         y = int(ystr)
         selrect[0] = x - xoffset
         selrect[1] = y - yoffset
         
         if g.getwidth() > 0:
            # ensure selrect doesn't move beyond left/right edge of grid
            if selrect[0] < gridl:
               selrect[0] = gridl
               x = selrect[0] + xoffset
            elif selrect[0] + selrect[2] - 1 > gridr:
               selrect[0] = gridr + 1 - selrect[2]
               x = selrect[0] + xoffset
         if g.getheight() > 0:
            # ensure selrect doesn't move beyond top/bottom edge of grid
            if selrect[1] < gridt:
               selrect[1] = gridt
               y = selrect[1] + yoffset
            elif selrect[1] + selrect[3] - 1 > gridb:
               selrect[1] = gridb + 1 - selrect[3]
               y = selrect[1] + yoffset
         
         g.select(selrect)
         oldcells = g.getcells(selrect)
         g.putcells(selpatt, x - firstx, y - firsty)
         oldmouse = mousepos
         g.update()
Ejemplo n.º 23
0
                if g.getcell(signal[0], signal[1]) == 1: done = 1
            g.run(finaladjustment)
            g.run(100 * iperiod / subperiod)
            if subperiod > 1 and outputmatch(output) != 1:
                countdown = subperiod
                g.setgen("0")
                while countdown >= 0:
                    countdown -= 1
                    g.run(iperiod / subperiod)
                    if outputmatch(output) == 1:
                        break
            if outputmatch(output) != 1:
                g.exit("Looks like something went wrong at period " + period \
                     + ".  Output is not showing up after any reasonable number of subperiod cycles.")
            g.select(r)
            g.clear(1)
            g.select([])
            g.setgen("0")
            g.show("Done!  " + os.path.join(outfolder, str(period)))
            g.putcells(fixedbb)
            g.putcells(movablebb, iadjustment * dx, iadjustment * dy)
            g.save(
                os.path.join(
                    outfolder,
                    "p" + str(iperiod + 100000)[1:] + "_" + basegun + ".rle"),
                "rle")
            countbuilt += 1

    #check we get the expected size
    if usebb == 1:
        r = bb  # guns not built from template should use their LifeHistory bounds
Ejemplo n.º 24
0
def setupR(val, dx, dy):
    g.select([dx, dy, 2, 2])
    g.clear(0)
    g.putcells(blck, dx - val, dy - val)
	def Main(self):
		
		g.show("left click on a pattern to change, 'h' for help")
		gollyMode = False
		
		while True:
		
			event = g.getevent()
			
			if ("key" in event and "return" in event) or (gollyMode and " a " in event):
				gollyMode = not gollyMode
				
				if gollyMode:
					g.show("In golly mode")
					g.update()

				else: 
					g.show("left click on a pattern, right click to finish")
					g.setrule("B3/S23")
					g.setalgo("HashLife")
					g.reset()
				
					g.update()
				
				continue 
				
			if gollyMode:
				
				if " delete " in event: 
					g.clear(0)
					
				if "click" in event and "ctrl" in event and g.getxy() != "":
					
					x, y = g.getxy().split()
					
					cell = g.getcell(int(x), int(y))
					
					if cell >= 0 and cell <= 1:
						g.setcell(int(x), int(y), 1 - cell)
					
					g.update()
				
				if " c " in event and "ctrl" in event and g.getselrect() != []:	
					g.copy()
				
				if " v " in event and "ctrl" in event and g.getxy() != "":
				
					x, y = g.getxy().split()
					
					g.paste(int(x), int(y), "or")
				
				if " space " in event:	
					if "ctrl" in event:
						g.run(10)
					else:
						g.run(1)
						
				g.doevent(event)
				continue 
				
			
			if "click" in event:
				
				if "left" in event:
					
					if self.ExistinCircuitHandler() == None:
						if self.SignalClickHandler(event) == None:
							g.show("left click on a pattern, h for help")
		
		
			elif "key" in event:
				if " space " in event:
					for i in xrange(0, 30):
						g.run(60)
						g.update()
						
					g.reset()
					g.update()		
					
				if " a " in event:
					
					if g.getrule() == "Perrier":
						g.setrule("B3/S23")
						g.setalgo("HashLife")
						g.update()
						
						
					else:
						g.setrule("Perrier")
						
						for key in self.smarCells:
							x, y = key.split(":")
							g.setcell(int(x), int(y),  self.smarCells[key] + 2)
						
						gollyMode = True
						g.show("In golly mode")
						g.update()
				
				if " s " in event:
					fname = os.path.join(g.getdir("data"), "MetadataManager.json")
					#self.Save(fname)
				
				if " h " in event:
					noteMessage = "Viewing and Selecting\n\n"
					noteMessage += "'left click' to chose gun or glider\n"
					noteMessage += "'a' to see in colors, a to go back \n"
					noteMessage += "'space' see ahead 1800 generations \n"
					noteMessage += "'enter' gollyMode, stays in the script \n"
					
					noteMessage += "\n Editing Gun \n\n"
					noteMessage += "'left click' to place\n"
					noteMessage += "'right click' to switch gun/orientation \n"
					noteMessage += "'delete' to delete the gun \n"
					noteMessage += "'left-right arrow' - one step adjustment\n"
					
					noteMessage += "\n In Golly Mode \n\n"
					noteMessage += "'delete' to clear selection\n"
					noteMessage += "'ctrl' + 'click' to draw \n"
					noteMessage += "'ctrl' + 'c' to copy selection \n"
					noteMessage += "'ctrl' + 'v' to paste in mouse location \n"
					noteMessage += "'space' + to run 1 generation \n"
					noteMessage += "'ctrl' +'space' to run 10 generations \n"
				
					g.note(noteMessage)
Ejemplo n.º 26
0
    def __init__(self):
        try:
            g.show('setting up test')


            testSize = 100 #this is the size of one side of the square testing area
            g.select([-testSize/2,-testSize/2,testSize,testSize])
            #clear the canvas
            g.clear(1)
            g.clear(0)
            g.randfill(50)
            g.update()

            g.show('stressTest started')

            startTime = time()
            lg_envmt = lifegenes_environment()
            endTime = time()
            logging.debug('\tsetup t\t=\t\t'+str(endTime-startTime))
            g.update()

            startTime = time()
            lg_envmt.drawColor()
            endTime = time()
            logging.debug('\tcolorDraw t\t=\t' + str( endTime - startTime))
            g.update()
            
            startTime = time()
            lg_envmt.cellMotions()
            endTime = time()
            logging.debug('\tmovement t\t=\t' + str( endTime - startTime))
            g.update()

            startTime = time()
            lg_envmt.drawColor()
            endTime = time()
            logging.debug('\tcolor update t \t= ' + str( endTime - startTime))
            g.update()

            g.step()

            startTime = time()
            lg_envmt.update()
            endTime = time()
            logging.debug('\tevolve update t\t= ' + str( endTime - startTime))

            startTime = time()
            lg_envmt.cellMotions()
            endTime = time()
            logging.debug('\tmovement t\t=\t' + str( endTime - startTime))
            g.update()

            startTime = time()
            lg_envmt.drawColor()
            endTime = time()
            logging.debug('\tcolor update t\t= ' + str( endTime - startTime))
            g.update()



            g.update()
            g.show('test complete')
        finally:
                logging.info('cycling halted from external source (probably golly)')
Ejemplo n.º 27
0
# Use the current selection to create a toroidal universe.
# Author: Andrew Trevorrow ([email protected]), Sept 2010.

from glife import inside, outside
import golly as g

selrect = g.getselrect()
if len(selrect) == 0: g.exit("There is no selection.")
x =  selrect[0]
y =  selrect[1]
wd = selrect[2]
ht = selrect[3]

selcells = g.getcells(selrect)
if not g.empty():
    g.clear(inside)
    g.clear(outside)

# get current rule, remove any existing suffix, then add new suffix
rule = g.getrule().split(":")[0]
g.setrule(rule + ":T" + str(wd) + "," + str(ht))

newx = -int(wd/2)
newy = -int(ht/2)
selrect[0] = newx
selrect[1] = newy
g.select(selrect)
if len(selcells) > 0: g.putcells(selcells, newx - x, newy - y)
g.fitsel()
Ejemplo n.º 28
0
iters = int(l / speed + l * 2 + l * (1 + 2 * speed) / (0.5 - speed))
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)
Ejemplo n.º 29
0
Archivo: sss.py Proyecto: apaap/sssss
def testShip(rlepatt, rule, maxgen=2000):
    # Clear the layer and place the ship
    r = g.getrect()
    if rlepatt:
        patt = g.parse(rlepatt)
        # If rlepatt is in a multistate representation then patt will be
        # a multistate cell list. testShip() only works for ships in two
        # state rules, so convert to two state cell list.
        if (len(patt) % 2):
            # This assumes all cells have non-zero state - which is reasonable
            # for the results of g.parse()
            patt = [patt[i] for j, i in enumerate(patt[:-1]) if (j + 1) % 3]
    else:
        # Use the current pattern
        if not r:
            return (0, tuple())
        patt = g.getcells(r)
        patt = g.transform(patt, -r[0], -r[1])
    # g.note(str((rlepatt, rule)))
    if r:
        g.select(r)
        g.clear(0)
    g.putcells(patt)
    # g.note(str(len(patt)) + ", " + str(patt))
    # rlepatt might be different to the rle representation determined by
    # giveRLE(), so ensure we have the correct representation
    testrle = giveRLE(patt)
    if rule:
        g.setrule(rule)
    speed = ()
    startpop = int(g.getpop())
    bbox = g.getrect()
    minpop = startpop
    minbboxarea = bbox[2] * bbox[3]
    mingen = 0
    # Keep track of the total bbox
    maxx = bbox[2]
    maxy = bbox[3]
    maxpop = startpop
    # Ignore ship if rule is not a 2-state rule
    if not g.numstates() == 2:
        return (minpop, speed)
    for ii in xrange(maxgen):
        g.run(1)
        r = g.getrect()
        if not r:
            # Pattern has died out and is therefore not a ship
            mingen = 0
            break
        pop = int(g.getpop())
        bboxarea = r[2] * r[3]
        if pop < minpop:
            # Find phase with minimimum population
            minpop = pop
            minbboxarea = r[2] * r[3]
            mingen = ii + 1
        elif pop == minpop:
            # Amongst phases with min pop, find one with minimum bbox area
            # bboxarea = r[2]*r[3]
            if bboxarea < minbboxarea:
                minbboxarea = bboxarea
                mingen = ii + 1
        # Track the bounding box of the pattern's evolution
        maxx = max(maxx, r[2])
        maxy = max(maxy, r[3])
        maxpop = max(maxpop, pop)
        if (pop == startpop and r[2:4] == bbox[2:4]):
            if (giveRLE(g.getcells(r)) == testrle):
                # Starting ship has reappeared
                speed = (r[0] - bbox[0], r[1] - bbox[1], ii + 1
                         )  # displacement and period
                break
        # Check for rotated pattern
        elif (pop == startpop and r[2:4] == bbox[3:1:-1]):
            # For 2-cell oscillators this is sufficient
            if minpop == 2:
                speed = (0, 0, 2 * (ii + 1))
                mingen = ii + 1
                break
    g.run(mingen)  # Evolve ship to generation with minimum population
    # return (minpop, speed)
    # return (minpop, speed, maxpop)
    return (minpop, speed, maxx * maxy)
Ejemplo n.º 30
0
def CreateWssMovementData(recipes, dir, isUp = True):

	result = [] 
	
	for i in xrange(0, len(recipes.WssCreator)):
		
		recipes.Reset()
		
		if isUp:
			recipes.Goto(-23, 1)
			
		recipes.AddWss(i)

		PlaceReadingHeads(recipes.recipe)
		
		if isUp:
			
			gen = period * (len(recipes.recipe) + 10)
			
			while gen % (2 * distForward) != 0:
				gen += 1
			
			goto(gen)
			g.fit()
			g.update()
			rect = g.getrect()
			
			g.select([rect[0], -6 * distBack, rect[2], 7 * distBack])
			g.clear(1)
			
			x, y, res = FindWssByDirection(isUp, distForward)[0]
		
			x += 23
			y += -21
			y = y % distForward
		else:
			
			gen = period * (len(recipes.recipe) + 10)
			
			while gen % (2 * distBack) != 0:
				gen += 1
			
			goto(gen)
			g.fit()
			g.update()
			
			rect = g.getrect()
			helixy = CalcHelix(recipes.recipe)
			
			g.select([rect[0], helixy - distBack, rect[2], 7 * distBack])
			g.clear(1)
			
			x, y, res = FindWssByDirection(isUp, distBack)[0]
			y = y % distBack
			
		result.append((x, y, res))
	if isUp:	
		pickle.dump(result, open(path.join(dir, str(step) + "_" + str(period) + "_ForwardWssBaseAuto.pkl"), "wb"))
	else:
		pickle.dump(result, open(path.join(dir, str(step) + "_" + str(period) + "_BackwardWssBaseAuto.pkl"), "wb"))
	
	recipes.Reset()
Ejemplo n.º 31
0
def CreateWssMovementData(recipes, dir, isUp=True):

    result = []

    for i in xrange(0, len(recipes.WssCreator)):

        recipes.Reset()

        if isUp:
            recipes.Goto(-23, 1)

        recipes.AddWss(i)

        PlaceReadingHeads(recipes.recipe)

        if isUp:

            gen = period * (len(recipes.recipe) + 10)

            while gen % (2 * distForward) != 0:
                gen += 1

            goto(gen)
            g.fit()
            g.update()
            rect = g.getrect()

            g.select([rect[0], -6 * distBack, rect[2], 7 * distBack])
            g.clear(1)

            x, y, res = FindWssByDirection(isUp, distForward)[0]

            x += 23
            y += -21
            y = y % distForward
        else:

            gen = period * (len(recipes.recipe) + 10)

            while gen % (2 * distBack) != 0:
                gen += 1

            goto(gen)
            g.fit()
            g.update()

            rect = g.getrect()
            helixy = CalcHelix(recipes.recipe)

            g.select([rect[0], helixy - distBack, rect[2], 7 * distBack])
            g.clear(1)

            x, y, res = FindWssByDirection(isUp, distBack)[0]
            y = y % distBack

        result.append((x, y, res))
    if isUp:
        pickle.dump(
            result,
            open(
                path.join(
                    dir,
                    str(step) + "_" + str(period) + "_ForwardWssBaseAuto.pkl"),
                "wb"))
    else:
        pickle.dump(
            result,
            open(
                path.join(
                    dir,
                    str(step) + "_" + str(period) +
                    "_BackwardWssBaseAuto.pkl"), "wb"))

    recipes.Reset()
Ejemplo n.º 32
0
    def Main(self):

        g.show("left click on a pattern to change, 'h' for help")
        gollyMode = False

        while True:

            event = g.getevent()

            if ("key" in event and "return" in event) or (gollyMode
                                                          and " a " in event):
                gollyMode = not gollyMode

                if gollyMode:
                    g.show("In golly mode")
                    g.update()

                else:
                    g.show("left click on a pattern, right click to finish")
                    g.setrule("B3/S23")
                    g.setalgo("HashLife")
                    g.reset()

                    g.update()

                continue

            if gollyMode:

                if " delete " in event:
                    g.clear(0)

                if "click" in event and "ctrl" in event and g.getxy() != "":

                    x, y = g.getxy().split()

                    cell = g.getcell(int(x), int(y))

                    if cell >= 0 and cell <= 1:
                        g.setcell(int(x), int(y), 1 - cell)

                    g.update()

                if " c " in event and "ctrl" in event and g.getselrect() != []:
                    g.copy()

                if " v " in event and "ctrl" in event and g.getxy() != "":

                    x, y = g.getxy().split()

                    g.paste(int(x), int(y), "or")

                if " space " in event:
                    if "ctrl" in event:
                        g.run(10)
                    else:
                        g.run(1)

                g.doevent(event)
                continue

            if "click" in event:

                if "left" in event:

                    if self.ExistinCircuitHandler() == None:
                        if self.SignalClickHandler(event) == None:
                            g.show("left click on a pattern, h for help")

            elif "key" in event:
                if " space " in event:
                    for i in xrange(0, 30):
                        g.run(60)
                        g.update()

                    g.reset()
                    g.update()

                if " a " in event:

                    if g.getrule() == "Perrier":
                        g.setrule("B3/S23")
                        g.setalgo("HashLife")
                        g.update()

                    else:
                        g.setrule("Perrier")

                        for key in self.smarCells:
                            x, y = key.split(":")
                            g.setcell(int(x), int(y), self.smarCells[key] + 2)

                        gollyMode = True
                        g.show("In golly mode")
                        g.update()

                if " s " in event:
                    fname = os.path.join(g.getdir("data"),
                                         "MetadataManager.json")
                    #self.Save(fname)

                if " h " in event:
                    noteMessage = "Viewing and Selecting\n\n"
                    noteMessage += "'left click' to chose gun or glider\n"
                    noteMessage += "'a' to see in colors, a to go back \n"
                    noteMessage += "'space' see ahead 1800 generations \n"
                    noteMessage += "'enter' gollyMode, stays in the script \n"

                    noteMessage += "\n Editing Gun \n\n"
                    noteMessage += "'left click' to place\n"
                    noteMessage += "'right click' to switch gun/orientation \n"
                    noteMessage += "'delete' to delete the gun \n"
                    noteMessage += "'left-right arrow' - one step adjustment\n"

                    noteMessage += "\n In Golly Mode \n\n"
                    noteMessage += "'delete' to clear selection\n"
                    noteMessage += "'ctrl' + 'click' to draw \n"
                    noteMessage += "'ctrl' + 'c' to copy selection \n"
                    noteMessage += "'ctrl' + 'v' to paste in mouse location \n"
                    noteMessage += "'space' + to run 1 generation \n"
                    noteMessage += "'ctrl' +'space' to run 10 generations \n"

                    g.note(noteMessage)
Ejemplo n.º 33
0
            g.update()

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

selrect = g.getselrect()
if len(selrect) == 0: g.exit("There is no selection.")
selpatt = g.getcells(selrect)

# remember initial selection in case user aborts script
firstrect = g.getselrect()
firstpatt = g.getcells(selrect)

g.show("Click anywhere in selection, move mouse and click again..." + helpmsg)
oldcursor = g.getcursor()
g.setcursor("Move")
oldcells = []

try:
    aborted = True
    moveselection()
    aborted = False
finally:
    g.setcursor(oldcursor)
    if aborted:
        g.clear(0)
        if len(oldcells) > 0: g.putcells(oldcells)
        g.putcells(firstpatt)
        g.select(firstrect)
    else:
        g.show(" ")
Ejemplo n.º 34
0
def update5StoSSS(rleFile, collection):
    sssFile = rleFile.replace('.txt', '.sss.txt')
    if sssFile == rleFile:
        g.exit('Error: failed to create new file name.')
    updateFile = sssFile.replace('.sss.txt', '.ss2.txt')
    shipDict = {}
    newSpeeds, updateSpeeds = set(), set()
    global updateShips
    global newShipsList
    header = ''
    status = 'Importing 5S %s collection from file: %s ...' % \
            (collectionNames[collection], rleFile)
    N = 0
    with open(sssFile) as fIn:
        for line in fIn:
            # Trust the data in the sss file, no need to test ships
            ship = sss.parseshipstr(line)
            if not ship:
                # Should only get here if the line was empty, or is a comment
                if (line and (not line[0] == '#')):
                    g.note('Ignoring line:\n\n' + line)
                header += line
                continue
            speed = ship[2:5]
            shipDict[speed] = ship
            N += 1
            if (N % 500 == 0):
                g.show('%s %d ships found.' % (status, N))
    status = '5S %s collection imported, %d ships found. Testing %d new ships ...' % \
            (collectionNames[collection], N, len(newShipsList))
    g.show(status)
    
    N = 0 # New ship counter
    NN = 0 # New ship of current type counter
    for newship in newShipsList:
        minpop, rulestr, dx, dy, period, shiprle = newship
        dy, dx = sss.minmaxofabs((dx, dy))
        if dx == 0: continue # oscillator
        if dy == 0: shiptype = 'o'
        elif dy == dx: shiptype = 'd'
        else: shiptype = 'k'
        # g.note(str((minpop, rulestr, dx, dy, period, shiprle, shiptype, newship)))
        if shiptype == collection:
            bUpdate = True
            speed = (dx, dy, period)
            # Replace current ship in collection if minimum population is reduced
            # or add the smallest (by minpop and bbox) ship for each new speed
            if speed in shipDict:
                if minpop < shipDict[speed][0]:
                    if speed not in newSpeeds:
                        updateSpeeds.add(speed)
                elif minpop == shipDict[speed][0]:
                    # If the speed is not yet in the collection then make sure
                    # to update with the ship that has the smallest bounding box
                    # as well as the lowest minpop
                    if speed in newSpeeds:
                        # Check bounding box areas
                        g.select([-1, -1, 1, 1])
                        g.clear(1)
                        g.putcells(g.parse(shipDict[speed][5]))
                        r = g.getrect()
                        bbox = r[2] * r[3]
                        g.select([-1, -1, 1, 1])
                        g.clear(1)
                        g.putcells(g.parse(shiprle))
                        r = g.getrect()
                        if bbox <= (r[2] * r[3]):
                            bUpdate = False
                    else:
                        bUpdate = False
                else:
                    bUpdate = False
            else:
                # New speed
                newSpeeds.add(speed)
            if bUpdate:
                # Canonise ship and update collection
                shipDict[speed] = sss.canon5Sship(newship)
            NN += 1
        N += 1
        if (N % 100 == 0):
            found = len(newSpeeds) + len(updateSpeeds)
            g.show('%s %d record ships found of %d/%d ships tested.' % (status, found, NN, N))
    
    # Convert to list and sort
    # ship format: (minpop, 'rulestr', dx, dy, period, 'shiprle')
    # For orthogonal and diagonal: sort order is first by period, then decreasing displacement
    # For oblique: sort order is first by slope, then period - specifically first dx, then dy, then period
    # if collection == 'k':
        # shipList = sorted(shipDict.values(), key=lambda x: (x[2], x[3], x[4]))
        # newSpeeds = sorted(newSpeeds, key=lambda x: (x[0], x[1], x[2]))
        # updateSpeeds = sorted(updateSpeeds, key=lambda x: (x[0], x[1], x[2]))
    # else:
        # shipList = sorted(shipDict.values(), key=lambda x: (x[4], -x[2]))
        # newSpeeds = sorted(newSpeeds, key=lambda x: (x[2], -x[0]))
        # updateSpeeds = sorted(updateSpeeds, key=lambda x: (x[2], -x[0]))
    # Sort order now consistent for all three collections:
    # First by period, then decreasing X displacement, then decreasing Y displacement
    shipList = sorted(shipDict.values(), key=lambda x: (x[4], -x[2], -x[3]))
    newSpeeds = sorted(newSpeeds, key=lambda x: (x[2], -x[0], -x[1]))
    updateSpeeds = sorted(updateSpeeds, key=lambda x: (x[2], -x[0], -x[1]))
    
    # Write ships to file
    if (newSpeeds or updateSpeeds):
        g.show('Writing to SSS file: ' + updateFile)
        with open(updateFile, 'w') as fOut:
            fOut.write(header)
            for ship in shipList:
                fOut.write(', '.join(map(str, ship))+'\n')
        if UPDATE:
            try:
                # Update the current project file
                os.remove(sssFile)
                os.rename(updateFile, sssFile)
            except:
                g.exit('Error updating SSS file: ' + sssFile)
    
    # Return list of new and updated speeds and update list of ships added to database
    updateShips += [shipDict[speed] for speed in itertools.chain(newSpeeds, updateSpeeds)]
    return (newSpeeds, updateSpeeds)
Ejemplo n.º 35
0
def lookforkeys(event, deltax, deltay):
    global oldcells, selrect, selpatt

    # look for keys used to flip/rotate selection
    if event == "key x none" or event == "key y none":
        # flip floating selection left-right or top-bottom
        if len(oldcells) > 0:
            g.clear(0)
            g.putcells(selpatt, deltax, deltay)
        if " x " in event:
            g.flip(0)
        else:
            g.flip(1)
        selpatt = g.transform(g.getcells(selrect), -deltax, -deltay)
        if len(oldcells) > 0:
            g.clear(0)
            g.putcells(oldcells)
            g.putcells(selpatt, deltax, deltay)
        g.update()
        return

    if event == "key > none" or event == "key < none":
        # rotate floating selection clockwise or anticlockwise;
        # because we use g.rotate below we have to use the exact same
        # calculation (see Selection::Rotate in wxselect.cpp) for rotrect:
        midx = selrect[0] + int((selrect[2]-1)/2)
        midy = selrect[1] + int((selrect[3]-1)/2)
        newleft = midx + selrect[1] - midy
        newtop = midy + selrect[0] - midx
        rotrect = [ newleft, newtop, selrect[3], selrect[2] ]
        if not rectingrid(rotrect):
            g.warn("Rotation is not allowed if selection would be outside grid.")
            return
        g.clear(0)
        if len(oldcells) > 0: g.putcells(oldcells)
        oldcells = g.join(oldcells, g.getcells(rotrect))
        g.clear(0)
        g.select(rotrect)
        g.clear(0)
        g.select(selrect)
        g.putcells(selpatt, deltax, deltay)
        if " > " in event:
            g.rotate(0)
        else:
            g.rotate(1)
        selrect = g.getselrect()
        if selrect != rotrect: g.warn("Bug: selrect != rotrect")
        selpatt = g.transform(g.getcells(selrect), -deltax, -deltay)
        if len(oldcells) > 0:
            g.clear(0)
            g.putcells(oldcells)
            g.putcells(selpatt, deltax, deltay)
        g.update()
        return

    if event == "key h none":
        showhelp2()
        return

    g.doevent(event)
Ejemplo n.º 36
0
def main ():
  g.update ()
  g.check (False)

  path = g.getstring ("Output directory:")
  files = glob.glob (os.path.join (path, "*.out"))

  mingls = g.getstring ("Min number of gliders at accept:")
  if mingls == "":
    mingl = 0
    minpop = 0
    maxpop = 1024
  else:
    mingl = int (mingls)
    minpops = g.getstring ("Min population except catalyzers:")
    if minpops == "":
      minpop = 0
      maxpop = 1024
    else:
      minpop = int (minpops)
      maxpop = int (g.getstring ("Max population except catalyzers:"))

  if g.getname () != "catbellman_temp":
    g.addlayer ()

  hashdir = {}
  catlist = []
  catix = 0

  g.new ("catbellman_temp")
  g.setrule ("LifeBellman")

  for fix, filename in enumerate (files):
    patt = g.getrect ()
    if patt != []:
      g.select (patt)
      g.clear (0)
  
    g.setgen ("0")
	
    with open(filename, 'r') as f:
      filetext = f.read ()
      if fix % 16 == 0:
        g.show ("Analysing " + str (fix) + "/" + str (len (files)))
		
      (gogen, glcnt) = convbellman (filetext, 0, 0)
      if gogen == -1:
	    gogen = 128
	  
      (use, hash) = analyse (gogen, glcnt, minpop, maxpop, mingl)

      if use:
        if not hash in hashdir:
          catlist.append ([])
          hashdir [hash] = catix
          catix += 1

        cat = hashdir [hash]
        catlist [cat].append (filetext)

  g.new ("catbellman_temp")
  g.setrule ("LifeBellman")

  fix = 0
  y = 0
  for cat in catlist:
    x = 96 * (len (cat) - 1)
    for filetext in cat:
      convbellman (filetext, x, y)
      x -= 96
      fix += 1
      if fix % 32 == 0:
        g.show ("Rendering " + str (fix) + "/" + str (len (files)))
        g.fit ()
        g.check (True)
        g.update ()
        g.check (False)

    y += 96

  g.show ("Done")
  g.fit ()
  g.setstep (-1)
  g.check (True)
Ejemplo n.º 37
0
         g.update()

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

selrect = g.getselrect()
if len(selrect) == 0: g.exit("There is no selection.")
selpatt = g.getcells(selrect)

# remember initial selection in case user aborts script
firstrect = g.getselrect()
firstpatt = g.getcells(selrect)

g.show("Click anywhere in selection, move mouse and click again..." + helpmsg)
oldcursor = g.getcursor()
g.setcursor("Move")
oldcells = []

try:
   aborted = True
   moveselection()
   aborted = False
finally:
   g.setcursor(oldcursor)
   if aborted:
      g.clear(0)
      if len(oldcells) > 0: g.putcells(oldcells)
      g.putcells(firstpatt)
      g.select(firstrect)
   else:
      g.show(" ")
Ejemplo n.º 38
0
'''
setconf2.py

clears grid and sets just as specified by configuration conf2 in parameters.py
'''
import parameters
reload(parameters)
from parameters import conf2, nstates
from golly import setcell, clear, select, getrect, fit, show
if len(getrect()) > 0:
  select(getrect())
  clear(0)
for i in range(0,len(conf2),2):
  c = conf2[i]
  if i+1 < len(conf2): c += conf2[i+1] * nstates
  setcell(i//2,0,c)
  show(str(i))
select([])
fit()
Ejemplo n.º 39
0
def lookforkeys(event, deltax, deltay):
   global oldcells, selrect, selpatt
   
   # look for keys used to flip/rotate selection
   if event == "key x none" or event == "key y none":
      # flip floating selection left-right or top-bottom
      if len(oldcells) > 0:
         g.clear(0)
         g.putcells(selpatt, deltax, deltay)
      if " x " in event:
         g.flip(0)
      else:
         g.flip(1)
      selpatt = g.transform(g.getcells(selrect), -deltax, -deltay)
      if len(oldcells) > 0:
         g.clear(0)
         g.putcells(oldcells)
         g.putcells(selpatt, deltax, deltay)
      g.update()
      return
   
   if event == "key > none" or event == "key < none":
      # rotate floating selection clockwise or anticlockwise;
      # because we use g.rotate below we have to use the exact same
      # calculation (see Selection::Rotate in wxselect.cpp) for rotrect:
      midx = selrect[0] + int((selrect[2]-1)/2)
      midy = selrect[1] + int((selrect[3]-1)/2)
      newleft = midx + selrect[1] - midy
      newtop = midy + selrect[0] - midx
      rotrect = [ newleft, newtop, selrect[3], selrect[2] ]
      if not rectingrid(rotrect):
         g.warn("Rotation is not allowed if selection would be outside grid.")
         return
      g.clear(0)
      if len(oldcells) > 0: g.putcells(oldcells)
      oldcells = g.join(oldcells, g.getcells(rotrect))
      g.clear(0)
      g.select(rotrect)
      g.clear(0)
      g.select(selrect)
      g.putcells(selpatt, deltax, deltay)
      if " > " in event:
         g.rotate(0)
      else:
         g.rotate(1)
      selrect = g.getselrect()
      if selrect != rotrect: g.warn("Bug: selrect != rotrect")
      selpatt = g.transform(g.getcells(selrect), -deltax, -deltay)
      if len(oldcells) > 0:
         g.clear(0)
         g.putcells(oldcells)
         g.putcells(selpatt, deltax, deltay)
      g.update()
      return

   if event == "key h none":
      showhelp2()
      return
   
   g.doevent(event)
Ejemplo n.º 40
0
def sof_canonise(duration, dxdy):
    sof = ''
    moving = 's'  # Stationary

    # For spaceships the pattern needs to be oriented in the standard direction
    # N, NW, or in between.
    if not dxdy == (0, 0):
        dx, dy = dxdy
        if abs(dx) > abs(dy):
            a, b, c, d = 0, -sign(dy), -sign(dx), 0
        else:
            a, b, c, d = -sign(dx), 0, 0, -sign(dy)
        rect = g.getrect()
        ship = g.getcells(rect)
        g.select(rect)
        g.clear(0)
        g.putcells(ship, 0, 0, a, b, c, d)

        dx, dy = (dx * a + dy * b, dx * c + dy * d)
        if dx == 0:
            moving = 'o'  # Orthogonal
        elif dx == -dy:
            moving = 'd'  # Diagonal
        else:
            moving = 'k'  # Oblique

    # We need to compare each phase to find the one used to determine the
    # pattern's standard form. The standard form is selected from a phase
    # with the minimum population
    minpop = int(g.getpop())
    if (duration > 1):
        for t in range(duration):
            minpop = min(minpop, int(g.getpop()))
            g.run(1)

    if minpop == 0:
        return '0'

    for t in range(duration):
        if int(g.getpop()) == minpop:
            rect = g.getrect()
            ox = rect[0]
            oy = rect[1]
            x_length = rect[2]
            y_breadth = rect[3]

            # Choose the orientation which comes first according to sof comparison rules:
            sof = sof_compare(sof,
                              sof_representation(x_length, y_breadth, ox, oy,
                                                 1, 0, 0, 1))  # Identity
            if moving in ('s', 'o'):
                sof = sof_compare(sof,
                                  sof_representation(x_length, y_breadth,
                                                     ox + x_length - 1, oy, -1,
                                                     0, 0, 1))  # flip_x
            if moving in ('s', 'd'):
                sof = sof_compare(sof,
                                  sof_representation(y_breadth, x_length,
                                                     ox + x_length - 1,
                                                     oy + y_breadth - 1, 0, -1,
                                                     -1, 0))  # swap_xy_flip
            if moving == 's':
                sof = sof_compare(sof,
                                  sof_representation(x_length, y_breadth, ox,
                                                     oy + y_breadth - 1, 1, 0,
                                                     0, -1))  # flip_y
                sof = sof_compare(sof,
                                  sof_representation(x_length, y_breadth,
                                                     ox + x_length - 1,
                                                     oy + y_breadth - 1, -1, 0,
                                                     0, -1))  # 180
                sof = sof_compare(sof,
                                  sof_representation(y_breadth, x_length, ox,
                                                     oy, 0, 1, 1,
                                                     0))  # swap_xy
                sof = sof_compare(sof,
                                  sof_representation(y_breadth, x_length,
                                                     ox + x_length - 1, oy, 0,
                                                     -1, 1, 0))  # cw 90
                sof = sof_compare(sof,
                                  sof_representation(y_breadth, x_length, ox,
                                                     oy + y_breadth - 1, 0, 1,
                                                     -1, 0))  # ccw 90

        if (duration > 1):
            g.run(1)

    return sof