Ejemplo n.º 1
0
def PrepareList(cells):
	g.new("")
	g.putcells(cells)
	cells = g.getcells(g.getrect())
	g.new("")
	g.putcells(cells, -cells[0], -cells[1])
	c = g.getcells(g.getrect())
	
	result = []
	
	for i in xrange(0, len(c), 2):
		x = c[i]
		y = c[i + 1]
		
		for dx in xrange(-1,2):
			for dy in xrange(-1, 2):
				val = g.getcell(x + dx, y + dy)
				
				if (x + dx, y + dy, val) in result:
					continue
					
				result.append((x + dx, y + dy, val))

	random.shuffle(result)
	
	return result
Ejemplo n.º 2
0
def randtopo(num, low, high):
    hashlist = []
    topolist = []
    arealist = []
    i = 0
    while i < num:
        size = random.choice(range(low, high + 1))
        area = size * size
        sel = [size, size, size, size]
        g.new('')
        randfill(sel, (1 + random.randrange(area)) * int(100 / area))
        if g.empty():
            continue
        h = g.hash(g.getrect())
        if h in hashlist:
            continue
        else:
            hashlist.append(h)
            pbox = g.getrect()
            actarea = pbox[2] * pbox[3]
            clist = g.getcells(g.getrect())
            g.store(clist, dir + 'topo_area%i_hash%i' % (actarea, h))

            clist.insert(0, pbox[2])  #prepare for tiling
            clist.insert(1, pbox[3])
            topolist.append(clist)
            arealist.append(actarea)
            i = i + 1
            continue
            return [topolist, hashlist, arealist]
Ejemplo n.º 3
0
def GunArea(cells, curGunPeriod):

	maxBox = [10000, 10000, -1000, -1000]
	
	for i in xrange(0, curGunPeriod, 4):
		
		g.new(str(i))
		g.putcells(g.evolve(cells, i))
		
		g.setbase(8)
		g.setstep(3)
		g.step()
		g.step()
		g.step()
		g.step()
		
		
		edgeGlider = EdgeGlider()

		while PerformDelete(edgeGlider, curGunPeriod):
			edgeGlider = DevolveGlider(edgeGlider, curGunPeriod)
		
		for j in xrange(0, 4):
			maxBox = AppendBox(maxBox, g.getrect())
			g.run(1)
		
		if i == 0:
			somegun = g.getcells(g.getrect())
		
	return [BoxValue(maxBox), somegun, maxBox]
Ejemplo n.º 4
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.º 5
0
def SaveForwardSalvoData(dir):
    g.new("")
    MakeBackwardSalvo(step, 0, 0, 0, True, True)
    rectB = g.getrect()

    g.new("")
    MakeForwardSalvo(step, 0, 0, 0, True, True)
    rectF = g.getrect()

    g.run(3)

    forwardRecipe = FindWssByDirection(True, distForward)
    forwardRecipe.reverse()
    fRecipe = []

    dx = rectB[0] - (rectF[0] + rectF[2]) - 100
    dx = int(dx / 8) * 8

    for i in xrange(0, len(forwardRecipe)):
        x, y, d = forwardRecipe[i]
        fRecipe.append((x + dx, y + 1, d))

    pickle.dump(
        fRecipe, open(path.join(dir,
                                str(step) + "_ForwardSalvoAuto.pkl"), "wb"))
Ejemplo n.º 6
0
def PrepareList(cells):
    g.new("")
    g.putcells(cells)
    cells = g.getcells(g.getrect())
    g.new("")
    g.putcells(cells, -cells[0], -cells[1])
    c = g.getcells(g.getrect())

    result = []

    for i in xrange(0, len(c), 2):
        x = c[i]
        y = c[i + 1]

        for dx in xrange(-1, 2):
            for dy in xrange(-1, 2):
                val = g.getcell(x + dx, y + dy)

                if (x + dx, y + dy, val) in result:
                    continue

                result.append((x + dx, y + dy, val))

    random.shuffle(result)

    return result
Ejemplo n.º 7
0
def bijoscar(maxsteps):
    initpop = int(g.getpop())
    initrect = g.getrect()
    if (len(initrect) == 0):
        return 0, None
    inithash = g.hash(initrect)

    for i in range(maxsteps):
        g.run(1)

        if (int(g.getpop()) == initpop):
            prect = g.getrect()
            phash = g.hash(prect)

            if (phash == inithash):
                period = i + 1

                if (prect == initrect):
                    return period, (0, 0)
                else:
                    dx = prect[0] - initrect[0]
                    dy = prect[1] - initrect[1]
                    return period, (dx, dy)

    return -1, None
Ejemplo n.º 8
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()
def GunArea(cells, curGunPeriod):

	maxBox = []
	minpop = -100000
	
	for i in xrange(0, curGunPeriod, 4):
		
		g.new(str(i))
		g.putcells(g.evolve(cells, i))
		
		g.setbase(8)
		g.setstep(3)
		g.step()
		g.step()
		
		edgeGlider = EdgeGlider()

		while PerformDelete(edgeGlider, curGunPeriod):
			edgeGlider = DevolveGlider(edgeGlider, curGunPeriod)
		
		for j in xrange(0, 4):
		
			if g.getpop() > minpop:
				maxpop = g.getpop()
				maxpopgun = g.getcells(g.getrect())
				
			maxBox = AppendBox(maxBox, g.getrect())
			g.run(1)
		
	return [BoxValue(maxBox), maxpopgun, maxBox]
Ejemplo n.º 10
0
def bijoscar(maxsteps):

    initpop = int(g.getpop())
    initrect = g.getrect()
    if (len(initrect) == 0):
        return 0
    inithash = g.hash(initrect)

    for i in xrange(maxsteps):

        g.run(1)

        if (int(g.getpop()) == initpop): 

            prect = g.getrect()
            phash = g.hash(prect)

            if (phash == inithash):

                period = i + 1

                if (prect == initrect):
                    return period
                else:
                    return -period 
    return -1
Ejemplo n.º 11
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.º 12
0
def HasEdgeShooter(minx):
	rect = g.getrect()
	
	if len(rect) == 0:
		return -1
		
	y = rect[1] + rect[3]
	
	if y < 100: 
		return -1
	
	if rect[2] > 120:
		return -1
		
	g.run(4)
	
	rect = g.getrect()
	
	if y + 2 == rect[1] + rect[3]:
	
		maxX = -10000
		minL = 10000
		minY = 10000
		for i in xrange(0, 4):
		
			g.run(1)
			rect = g.getrect()
			curCells = g.getcells([rect[0], rect[1] + rect[3] - 10, rect[2], 11])
			curx, cury = FindRightMost(curCells)
			curL = len(curCells)
			
			if curL <= minL:
				minL = curL
				
				if curx > maxX or (curx == maxX and cury < minY):
					maxX = curx
					minY = cury
					
					parity = (int(g.getgen()) % 4) + ((cury - curx + 1000000)% 2) * 4
					
					if curL == 22:
						parity += 8
					if curL == 26: 
						parity += 16
						
		if minx - 2 > maxX:
			
			cells = g.getcells([-100, -100, 200, 200])
			
			for i in xrange(1, len(cells), 2):
				if  cells[i - 1] - 2 < maxX:
					return -1
			
			return parity
		
	return -1
Ejemplo n.º 13
0
def trygliders(ginfo):
    gdistance = ginfo / 4
    phase = ginfo % 4
    bstatus = boxstatus
    pstatus = popstatus
    for num in xrange(8):
        tlist = form(celllist, num)
        rect = boxform(fullrect, num)
        g.new('')
        g.putcells(tlist)
        gx = rect[0] - 3 - gdistance
        gy = rect[1] - 3 - gdistance
        for w in xrange(rect[2] + 5):
            g.new('')
            g.putcells(tlist)
            g.putcells(glider[phase], gx + w, gy)
            g.fit()
            g.update()
            for gen in xrange(1000):
                g.run(1)
                if int(g.getpop()) <= 2:
                    g.new('')
                    g.show("Found clean glider destruction.")
                    status = 0, num, phase, [gx + w, gy]
                    putcells_and_fit(result(celllist, status))
                    g.exit()
            box = g.getrect()[2:]
            # Checking the bounding box size and population against the current lowest found.
            if reduce(mul, box) < reduce(mul, bstatus[0]):
                bstatus = (box, num, phase, [gx + w, gy])
            pop = int(g.getpop())
            if pop < pstatus[0]:
                pstatus = (pop, num, phase, [gx + w, gy])
            # Show results if the user presses certain keys
            event = g.getevent()
            if event.startswith("key x"):
                g.new('')
                put_result_pair(celllist, bstatus, pstatus)
                g.select(g.getrect())
                g.copy()
                g.select([])
                g.note(
                    "Minimum bounding box and population collisions copied to clipboard."
                )
            if event.startswith("key q"):
                g.new('')
                g.show("Search stopped.")
                put_result_pair(celllist, bstatus, pstatus)
                g.fit()
                g.exit()
            g.show(
                "Searching for a 1-glider destruction... press <x> to copy minimum bounding box and population results to clipboard; press <q> to quit. Stats: minimum bounding box %dx%d, minimum population %d"
                % (bstatus[0][0], bstatus[0][1], pstatus[0]))
    return bstatus, pstatus
Ejemplo n.º 14
0
def is_static():
    global prev_world

    bbox = rect(g.getrect())
    if bbox.empty:
        return False

    cur_world = g.hash(g.getrect())
    if prev_world and prev_world == cur_world:
        return True
    else:
        prev_world = cur_world
Ejemplo n.º 15
0
def PlaceReadingHeads(hwssRecipe):
    global fenseX

    g.new("")
    g.setrule("LifeHistoryNoMark")

    if directionType == "B":
        dist = int(1.5 * len(hwssRecipe) / speed)
        for y in xrange(-dist, 1):

            MakeBackwardSalvo(step, 0, distBack * y,
                              step * len(hwssRecipe) + 100, y == 0, y == 0)

        MakeBackwardRecipe(step, 0, 0, hwssRecipe)

        rect = g.getrect()

        cells = []

        for i in xrange(1200, step * len(hwssRecipe) + 1501):

            cells.append(rect[0] - 50)
            cells.append(i)
            cells.append(6)

        g.putcells(cells)
        g.putcells(cells, rect[0] - 1000, 0)

    else:

        helixD = CalcHelix(hwssRecipe)
        dist = int(1.5 * len(hwssRecipe) / speed)
        for y in xrange(0, dist + 1):
            MakeForwardSalvo(step, 0, distForward * y, helixD, y == 0, y == 0)

        MakeForwardRecipe(helixD, step, 0, 0, hwssRecipe)
        rect = g.getrect()

        cells = []

        fenseX = rect[0] + rect[2] + 50

        for i in xrange(fenseY, -helixD + 201):

            cells.append(rect[0] + rect[2] + 50)
            cells.append(i + helixD)
            cells.append(6)

        g.putcells(cells)
Ejemplo n.º 16
0
def PlaceReadingHeads(hwssRecipe):
	global fenseX
	
	g.new("")
	g.setrule("LifeHistoryNoMark")
	
	if directionType == "B":
		dist = int(1.5 * len(hwssRecipe) / speed)
		for y in xrange(-dist, 1):
		
			MakeBackwardSalvo(step, 0, distBack * y, step * len(hwssRecipe) + 100, y == 0, y == 0)
		
		MakeBackwardRecipe(step, 0, 0, hwssRecipe)
		
		rect = g.getrect()
		
		cells = []

		for i in xrange(1200, step * len(hwssRecipe) + 1501):
			
			cells.append(rect[0]-50)
			cells.append(i)
			cells.append(6)
		
		g.putcells(cells)
		g.putcells(cells, rect[0]-1000, 0)
		
	else:
	
		helixD = CalcHelix(hwssRecipe)
		dist = int(1.5 * len(hwssRecipe) / speed)
		for y in xrange(0, dist + 1):
		   MakeForwardSalvo(step, 0, distForward * y, helixD, y == 0, y == 0)
		
		MakeForwardRecipe(helixD, step, 0, 0, hwssRecipe)
		rect = g.getrect()
		
		cells = []
		
		fenseX = rect[0] + rect[2] + 50
		
		for i in xrange(fenseY, -helixD + 201):
			
			cells.append(rect[0] + rect[2] + 50)
			cells.append(i + helixD)
			cells.append(6)
		
		g.putcells(cells)
Ejemplo n.º 17
0
def EvolveRecipes(recipes):
	newrecipes = []

	cnt = 0 
	
	for recipe in recipes:
		cnt += 1
		
		if cnt % 100 == 0:
			g.show(str(cnt) + "/" + str(len(recipes)))
		
		minx = EvolveRecipe(recipe)
		cells = g.getcells(g.getrect())
		
		answer = FindAllHs(cells, minx)
		
		for h in answer[0]:
			i = h[0]
			x1 = h[1]
			y1 = h[2]
			xySL = h[3]

			res = copy(recipe)
			res.append(i)
			result.append([res, x1, y1, xySL])
			
		for h in answer[1]:
			res = copy(recipe)
			res.append(h)
			newrecipes.append(res)
	
	return newrecipes
Ejemplo n.º 18
0
def main():

    g.setstep(0)
    g.setalgo('QuickLife')

    velocity = g.getstring('Please specify velocity', '(2,1)c/6')
    a, b, p = parse_velocity(velocity)
    params = partial_derivatives(a, b, p)

    dvdx = params['dvdx']
    dudx = params['dudx']
    dvdy = params['dvdy']
    dudy = params['dudy']
    dvdt = params['dvdt']
    dudt = params['dudt']

    cells = []

    for t in xrange(p):

        things = g.getcells(g.getrect())
        things = zip(things[::2], things[1::2])
        cells += [(dudx * x + dudy * y + dudt * t,
                   dvdx * x + dvdy * y + dvdt * t) for (x, y) in things]
        g.step()

    g.setlayer(g.addlayer())
    g.putcells([x for y in cells for x in y])
Ejemplo n.º 19
0
def canonise():
    
    p = bijoscar(4)
    
    representation = "#"
    for i in range(abs(p)):
        rect = g.getrect()
        representation = compare_representations(representation, canonise_orientation(rect[2], rect[3], rect[0], rect[1], 1, 0, 0, 1))
        representation = compare_representations(representation, canonise_orientation(rect[2], rect[3], rect[0]+rect[2]-1, rect[1], -1, 0, 0, 1))
        representation = compare_representations(representation, canonise_orientation(rect[2], rect[3], rect[0], rect[1]+rect[3]-1, 1, 0, 0, -1))
        representation = compare_representations(representation, canonise_orientation(rect[2], rect[3], rect[0]+rect[2]-1, rect[1]+rect[3]-1, -1, 0, 0, -1))
        representation = compare_representations(representation, canonise_orientation(rect[3], rect[2], rect[0], rect[1], 0, 1, 1, 0))
        representation = compare_representations(representation, canonise_orientation(rect[3], rect[2], rect[0]+rect[2]-1, rect[1], 0, -1, 1, 0))
        representation = compare_representations(representation, canonise_orientation(rect[3], rect[2], rect[0], rect[1]+rect[3]-1, 0, 1, -1, 0))
        representation = compare_representations(representation, canonise_orientation(rect[3], rect[2], rect[0]+rect[2]-1, rect[1]+rect[3]-1, 0, -1, -1, 0))
        g.run(1)
    
    if (p<0):
        prefix = "q"+str(abs(p))
    elif (p==1):
        prefix = "s"+str(g.getpop())
    else:
        prefix = "p"+str(p)

    return "x"+prefix+"_"+representation
Ejemplo n.º 20
0
def fit_if_not_visible():
    try:
        r = rect(g.getrect())
        if (not r.empty) and (not r.visible()): g.fit()
    except:
        # getrect failed because pattern is too big
        g.fit()
Ejemplo n.º 21
0
def FindActive():

   rect = g.getrect()
   
   cells = g.getcells([rect[0], rect[1], rect[2], 1])
   
   return [cells[0], cells[1]]
Ejemplo n.º 22
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()
Ejemplo n.º 23
0
def testkey():
    if results and g.getevent().startswith("key x"):
        g.setlayer(results_layer)
        g.select(g.getrect())
        g.copy()
        g.select([])
        g.setlayer(work_layer)
Ejemplo n.º 24
0
def getwhp():
    bbox = g.getrect()

    if len(bbox) == 0:
        return 0, 0, 0

    return bbox[2], bbox[3], int(g.getpop())
Ejemplo n.º 25
0
def rule_boring():
    explode = 0
    die = 0
    num_trial = 8

    for i in range(num_trial):
        g.new("")
        g.select([0, 0, 32, 32])
        g.randfill(50)

        g.run(16)

        if int(g.getpop()) == 0:
            die += 1
            continue

        r = g.getrect()

        if r[2] > 60 and r[3] > 60:
            explode += 1
            continue

        return -1

    if explode == num_trial:
        return 0

    if die == num_trial:
        return 1

    return -1
Ejemplo n.º 26
0
def canonise():

    p = bijoscar(1000)

    representation = "#"
    for i in range(abs(p)):
        rect = g.getrect()
        representation = compare_representations(representation, canonise_orientation(rect[2], rect[3], rect[0], rect[1], 1, 0, 0, 1))
        representation = compare_representations(representation, canonise_orientation(rect[2], rect[3], rect[0]+rect[2]-1, rect[1], -1, 0, 0, 1))
        representation = compare_representations(representation, canonise_orientation(rect[2], rect[3], rect[0], rect[1]+rect[3]-1, 1, 0, 0, -1))
        representation = compare_representations(representation, canonise_orientation(rect[2], rect[3], rect[0]+rect[2]-1, rect[1]+rect[3]-1, -1, 0, 0, -1))
        representation = compare_representations(representation, canonise_orientation(rect[3], rect[2], rect[0], rect[1], 0, 1, 1, 0))
        representation = compare_representations(representation, canonise_orientation(rect[3], rect[2], rect[0]+rect[2]-1, rect[1], 0, -1, 1, 0))
        representation = compare_representations(representation, canonise_orientation(rect[3], rect[2], rect[0], rect[1]+rect[3]-1, 0, 1, -1, 0))
        representation = compare_representations(representation, canonise_orientation(rect[3], rect[2], rect[0]+rect[2]-1, rect[1]+rect[3]-1, 0, -1, -1, 0))
        g.run(1)
    
    if (p<0):
        prefix = "q"+str(abs(p))
    elif (p==1):
        prefix = "s"+str(g.getpop())
    else:
        prefix = "p"+str(p)

    rule = str.replace(g.getrule(),"/","").lower()
    
    webbrowser.open_new("http://catagolue.appspot.com/object?apgcode=x"+prefix+"_"+representation+"&rule="+rule)
Ejemplo n.º 27
0
def calculate_density():
    bbox = gl.rect(g.getrect())
    if bbox.empty:
        d = 0
    else:
        d = float(g.getpop()) / float(bbox.wd*bbox.ht)
    return d
Ejemplo n.º 28
0
def FindActive():

   rect = g.getrect()
   
   cells = g.getcells([rect[0], rect[1], rect[2], 1])
   
   return [cells[0], cells[1]]
Ejemplo n.º 29
0
def canonise():
    p = bijoscar(MAXPERIOD)
    if p == -1:
        # In rules with photons the pattern may be periodic, but not in CGoL
        return ""
    
    representation = "#"
    for i in range(abs(p)):
        rect = g.getrect()
        representation = compare_representations(representation, canonise_orientation(rect[2], rect[3], rect[0], rect[1], 1, 0, 0, 1))
        representation = compare_representations(representation, canonise_orientation(rect[2], rect[3], rect[0]+rect[2]-1, rect[1], -1, 0, 0, 1))
        representation = compare_representations(representation, canonise_orientation(rect[2], rect[3], rect[0], rect[1]+rect[3]-1, 1, 0, 0, -1))
        representation = compare_representations(representation, canonise_orientation(rect[2], rect[3], rect[0]+rect[2]-1, rect[1]+rect[3]-1, -1, 0, 0, -1))
        representation = compare_representations(representation, canonise_orientation(rect[3], rect[2], rect[0], rect[1], 0, 1, 1, 0))
        representation = compare_representations(representation, canonise_orientation(rect[3], rect[2], rect[0]+rect[2]-1, rect[1], 0, -1, 1, 0))
        representation = compare_representations(representation, canonise_orientation(rect[3], rect[2], rect[0], rect[1]+rect[3]-1, 0, 1, -1, 0))
        representation = compare_representations(representation, canonise_orientation(rect[3], rect[2], rect[0]+rect[2]-1, rect[1]+rect[3]-1, 0, -1, -1, 0))
        g.run(1)
    
    if (p<0):
        prefix = "xq" + str(abs(p))
    elif (p==1):
        prefix = "xs" + str(g.getpop())
    else:
        prefix = "xp" + str(p)
    
    return prefix + "_" + representation
Ejemplo n.º 30
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()
Ejemplo n.º 31
0
def fit_if_not_visible():
    try:
        r = rect(g.getrect())
        if (not r.empty) and (not r.visible()): g.fit()
    except:
        # getrect failed because pattern is too big
        g.fit()
Ejemplo n.º 32
0
def SnakeReader(let):
	g.new("")
	g.setrule("LifeHistory")
	cl = let2cells[let][0]
	g.putcells(cl)

	emptyline = True
	dir = 1
	
	rect = g.getrect()
	
	y0 = 0
	h = rect[1]  + rect[3] + 2
	l = rect[0] + rect[2] + 3
	x0 = rect[0] - 1
	y = y0
	x = x0 
	code = "" 
	
	while True: 
		y += dir 
		
		if y < y0:
			
			if emptyline == True:
				code += "Y+;"
				break 
				
			dir = 1
			y += dir
			code += "Y+;"
			x += 1
			emptyline = True 
			
		elif y >= y0 + h:
			dir = -1
			y += dir 
			code += "Y+;"
			x += 1
			emptyline = True
		else: 
			if dir == -1:
				code += "X-;"
			else: 
				code += "X+;"

		if g.getcell(x, y) != 0:
			code += "SET;"
			emptyline = False
			
		if x >= x0 + l:
			break 
		
		
	for i in range(h):		
		code = code.replace("X+;Y+;X-;", "Y+;")
		code = code.replace("X-;Y+;X+;", "Y+;")
	
	return code 
Ejemplo n.º 33
0
def popcount(sel=0):
    dict_lc = {'BDRainbow': [2, 4], 'BGRainbowR2': [2, 4]}
    live_cells = dict_lc[g.getrule().split(':')[0]]
    if not sel:
        clist = g.getcells(g.getrect())
    else:
        clist = g.getcells(g.getselrect())
    return sum(clist[2::3].count(x) for x in live_cells)
Ejemplo n.º 34
0
def checkFit():
    r = g.getrect()
    if not r:
        return
    if not g.visrect(r):
        g.setpos(str(r[0] + r[2] / 2), str(r[1] + r[3] / 2))
        if not g.visrect(r):
            g.setmag(g.getmag() - 1)
Ejemplo n.º 35
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.º 36
0
def EvolveRecipe(recipe):
	g.new("")
	g.setstep(3)
	
	g.putcells(blck)
	
	minx = g.getrect()[0]
	
	for r in recipe:
		g.putcells(gld, 40, 40 + r)
		g.step()
		g.step()
		
		if minx > g.getrect()[0]:
			minx > g.getrect()[0]
	
	return minx
Ejemplo n.º 37
0
def analyse (gogen, glcnt, minpop, maxpop, mingl):
  if glcnt < mingl:
    return (False, 0)
  
  g.run (gogen)
  inrect = g.getrect ()
  clean (inrect)

  endpop = int (g.getpop ())
  if endpop < minpop or endpop > maxpop:
    return (False, 0)

  rect = g.getrect ()
  if rect == []:
    return (True, 0)
  else:
    addmarkers (inrect)
    return (True, g.hash (inrect))
Ejemplo n.º 38
0
def CalculateLane(cells):
	g.new("")
	g.putcells(cells)
	cells = g.getcells(g.getrect())
	g.new("")
	g.putcells(cells, -cells[0], -cells[1])
	
	minx = 1000
	maxx = -1000
	
	for i in xrange(0, 4):
		rect = g.getrect()
		
		minx = min(minx, rect[0])
		maxx = max(maxx, rect[0] + rect[2])
		g.run(1)
		
	return (minx, maxx)
Ejemplo n.º 39
0
def CalculateLane(cells):
    g.new("")
    g.putcells(cells)
    cells = g.getcells(g.getrect())
    g.new("")
    g.putcells(cells, -cells[0], -cells[1])

    minx = 1000
    maxx = -1000

    for i in xrange(0, 4):
        rect = g.getrect()

        minx = min(minx, rect[0])
        maxx = max(maxx, rect[0] + rect[2])
        g.run(1)

    return (minx, maxx)
Ejemplo n.º 40
0
def threes_and_fours(i):

    bounding_box = g.getrect()
    celllist = g.getcells(bounding_box)

    while (len(celllist) % 3):
        celllist = celllist[:-1]
    celllist = map(tuple, zip(celllist[0::3], celllist[1::3], celllist[2::3]))

    return {(x, y, i): c for (x, y, c) in celllist if c in [3, 4]}
Ejemplo n.º 41
0
def run_patt(known_cells):
    global patt_count, meth_count
    g.new("PlutoniumSearch")
    g.reset()
    g.update()
    patt_count += 1
    #patt = g.parse(known_cells + "!")
    patt = g.parse(known_cells[1:] + "!")
    #g.note(known_cells[1:] + "!")
    g.putcells(patt)
    g.update()
    hashlist = {}
    for gene in range(999):
        if g.empty():
            break
        if g.hash(g.getrect()) in hashlist:
            p = int(g.getgen()) - hashlist[g.hash(g.getrect())]
            if not p in boring_periods:
                g.reset()
                g.save("p" + str(p) + "_" + str(cnt[p]) + ".rle", "rle")
                cnt[p] += 1
            break
        else:
            hashlist[g.hash(g.getrect())] = int(g.getgen())
            g.run(1)
        """
		except:
			# Pattern dies
			if int(g.getgen()) > min_lifespan:
				meth_count += 1
				newlifespan = int(g.getgen())
				g.new("Saving methuselah")
				g.putcells(patt)
				try:
					g.save("diehard-" + str(newlifespan) + ".rle", "rle")
				except:
					pass
				g.update()
				#max_final_pop = newpop
			break"""
    #g.warn(str(hashlist))
    g.show(str(patt_count) + "/" + str(2**(bx * by)))
Ejemplo n.º 42
0
def PeriodCalculator():
	
	g.setbase(8)
	g.setstep(3)
	g.step()
	g.step()

	cells = g.getrect()
	
	rect = g.getrect()
	cells = g.getcells(rect)
	
	for i in xrange(0, 10000):
		g.run(1)
		if str(g.getcells(rect)) == str(cells):
			#g.show(str(i + 1))
			#g.reset
			return i + 1
	
	return -1
Ejemplo n.º 43
0
def popcount(sel=0):
    dict_lc = {'BDRainbow': [2, 4], 'BGRainbowR2': [2, 4]}
    rule = g.getrule().split(':')[0]
    try:
        live_cells = dict_lc[rule]
    except:
        live_cells = range(1, g.numstates())
    if not sel:
        clist = g.getcells(g.getrect())
    else:
        clist = g.getcells(g.getselrect())
        return sum(clist[2::3].count(x) for x in live_cells)
Ejemplo n.º 44
0
def PerformDelete(glider, gunPeriod):

	initCells = g.getcells(g.getrect())
	
	for j in xrange(0, len(glider), 2):
		if g.getcell(glider[j], glider[j + 1]) != 1:
			return False
	
	Erase(glider)
	rect = g.getrect()
	cells = g.getcells(rect)
	g.run(gunPeriod)
	
	if str(g.getcells(rect)) == str(cells):
		g.new("")
		g.putcells(cells)
		return True
	else:
		g.new("")
		g.putcells(initCells)
		return False
Ejemplo n.º 45
0
def LeftMost(recipe):

	g.putcells(block_cells)
	
	idx = 1
	for r in recipe:
		#g.putcells(glider_cells, 80, 80 + r )
		g.putcells(glider_cells, 160 * idx, 160 * idx + int(r))
		idx += 1
		#g.step()
		
	rect = g.getrect()
	
	return rect[0]
Ejemplo n.º 46
0
def SaveForwardSalvoData(dir):
	g.new("")
	MakeBackwardSalvo(step, 0, 0, 0, True, True)
	rectB = g.getrect()
	
	g.new("")
	MakeForwardSalvo(step, 0, 0, 0, True, True)
	rectF = g.getrect()
	
	g.run(3)

	forwardRecipe = FindWssByDirection(True, distForward)
	forwardRecipe.reverse()
	fRecipe = [] 
	
	dx = rectB[0] - (rectF[0] + rectF[2]) - 100
	dx = int(dx / 8) * 8
	
	for i in xrange(0, len(forwardRecipe)):
		x, y, d = forwardRecipe[i]
		fRecipe.append((x + dx, y + 1, d))
		
	pickle.dump(fRecipe, open(path.join(dir, str(step) + "_ForwardSalvoAuto.pkl"), "wb"))
Ejemplo n.º 47
0
def HasEdgeShooter(minx):
	rect = g.getrect()
	
	y = rect[1] + rect[3]
	
	if y < 100: 
		return False
		
	g.run(4)
	
	rect = g.getrect()
	
	if y + 2 == rect[1] + rect[3]:
	
		maxX = -10000
		maxL = -10000
		
		for i in xrange(0, 4):
		
			g.run(1)
			rect = g.getrect()
			curCells = g.getcells([rect[0], rect[1] + rect[3] - 10, rect[2], 11])
			curx = FindRightMost(curCells)
			curL = len(curCells)
			
			if curx > maxX:
				maxX = curx
				
			if curL > maxL:
				maxL = curL
		
		if minx - 2 > maxL:
			return 100 * maxL
			
		return maxL
	
	return False
Ejemplo n.º 48
0
def LeftMost(recipe):

	g.new("")
	g.setstep(3)
	
	g.putcells(block_cells)
	
	for r in recipe:
		#g.putcells(glider_cells, 80, 80 + r )
		g.putcells(glider_cells, 80, 80 + 2 - r )
		g.step()
		g.step()
		
	rect = g.getrect()
	
	return rect[0]
Ejemplo n.º 49
0
def Validate(recipe):

	g.new("")
	g.setstep(3)
	
	g.putcells(block_cells)
	
	for r in recipe:
		g.putcells(glider_cells, 120, 120 + r)
		#g.putcells(glider_cells, 80, 80 + 2 - r )
		g.step()
		g.step()
		
	rect = g.getrect()
	
	return rect
Ejemplo n.º 50
0
def EdgeGlider():
	
	for i in xrange(0, 4):
		rect = g.getrect()
		
		x0 = rect[0] + rect[2] - 3
		y0 = rect[1] + rect[3] - 3
		
		gldFound = True
		
		for j in xrange(0, len(gld), 2):
			if g.getcell(x0 + gld[j], y0 + gld[j + 1]) == 0:
				gldFound = False
				break
		
		if gldFound:
			return g.getcells([x0, y0, 3, 3])
			
		g.run(1)
	
	return -1
Ejemplo n.º 51
0
	def __init__(self, path = None, SLpaths = None, SLExpected = None):
		self.blockX = 0
		self.blockY = 0
		self.sequence = []
		self.recipe = []
		self.block0 = [0,0]
		self.block1 = [0,0]
		self.splitterData1 = [[-4, -14],[-8,7],[12,5],  g.parse("5$22b2o$22b2o$2b2o$2b2o!", -10, 0)]
		self.splitterData2 = [[5, 15],[7,-8],[5,12], g.parse("2$7b2o$7b2o19$5b2o$5b2o!", 0, -10)]
		self.recipeIdxList = []
		self.lastGotoIdx = -1 
		self.SLsMoveTable = []
		self.SLsExpected = SLExpected
		self.init = g.getcells(g.getrect())
		
		if path != None:
			self.moveTable = self.LoadMoveTable(path, True)
		
		if SLpaths != None:
			for pt in SLpaths:
				self.SLsMoveTable.append(self.LoadMoveTable(pt, False))
Ejemplo n.º 52
0
def FindObj(objData, idx):
	c = g.getcells(g.getrect())
	
	result = []
	
	for i in xrange(2, len(c), 3):
		#g.show(str(i) + "/" + str(len(c)))
		x = c[i - 2]
		y = c[i - 1]
		
		found = True
		
		for r in objData:
			dx, dy, v = r
			
			if g.getcell(x + dx, y + dy) != v:
				found = False
				break
		
		if found:
			result.append((x, y, idx))
	
	return result 
Ejemplo n.º 53
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.º 54
0
def FindAllHs(cells, minx):
	g.new("")
	g.putcells(cells)
	rect = g.getrect()
	
	min = 10000
	max = -10000
	
	for i in xrange(1, len(cells), 2):
		cx = cells[i - 1]
		cy = cells[i]
		
		dx = 40 - cx
		cy += dx
		
		if cy < min:
			min = cy
		
		if cy > max:
			max = cy
		
	answer = [[],[]] 
	
	if (min - 9) % 2 != 0:
		min += 1
		
	for i in xrange(min - 9 - 40, max + 6 - 40, 2):
		g.new("")
		g.putcells(cells)
		g.putcells(gld, 40, 40 + i)
		g.setstep(3)
		g.step()
		g.step()
		
		if int(g.getpop()) > 60:
			continue 
			
		if int(g.getpop()) == 0:
			continue 
		
		if g.getrect()[0] < -120:
			continue 
		
		edgeType = HasEdgeShooter(minx)
		
		if edgeType != False:
			answer[0].append([i, 0, 0, [edgeType]])
			
		rect = g.getrect()
		
		if rect[2] > 12 or rect[3] > 12:
			continue
		
		s = str(g.getcells(g.getrect()))
		g.run(2)
		
		if s == str(g.getcells(g.getrect())):
			
			key = str(rect) + ":" + str(g.getpop())
			
			if not (key in existingKeys):
				existingDic[key] = []
				existingKeys.append(key)
				
			if s in existingDic[key]:
				continue 
			else:
				existingDic[key].append(s)
		
			answer[1].append(i)
			
	return answer 
Ejemplo n.º 55
0
def oscillating():
   # return True if the pattern is empty, stable or oscillating
   
   # first get current pattern's bounding box
   prect = g.getrect()
   pbox = rect(prect)
   if pbox.empty:
      g.show("The pattern is empty.")
      return True
   
   # get current pattern and create hash of "normalized" version -- ie. shift
   # its top left corner to 0,0 -- so we can detect spaceships and knightships
   ## currpatt = pattern( g.getcells(prect) )
   ## h = hash( tuple( currpatt(-pbox.left, -pbox.top) ) )

   # use Golly's hash command (3 times faster than above code)
   h = g.hash(prect)

   # check if outer-totalistic rule has B0 but not S8
   rule = g.getrule().split(":")[0]
   hasB0notS8 = rule.startswith("B0") and (rule.find("/") > 1) and not rule.endswith("8")
   
   # determine where to insert h into hashlist
   pos = 0
   listlen = len(hashlist)
   while pos < listlen:
      if h > hashlist[pos]:
         pos += 1
      elif h < hashlist[pos]:
         # shorten lists and append info below
         del hashlist[pos : listlen]
         del genlist[pos : listlen]
         del poplist[pos : listlen]
         del boxlist[pos : listlen]
         break
      else:
         # h == hashlist[pos] so pattern is probably oscillating, but just in
         # case this is a hash collision we also compare pop count and box size
         if (int(g.getpop()) == poplist[pos]) and \
            (pbox.wd == boxlist[pos].wd) and \
            (pbox.ht == boxlist[pos].ht):
            period = int(g.getgen()) - genlist[pos]
            
            if hasB0notS8 and (period % 2 > 0) and (pbox == boxlist[pos]):
               # ignore this hash value because B0-and-not-S8 rules are
               # emulated by using different rules for odd and even gens,
               # so it's possible to have identical patterns at gen G and
               # gen G+p if p is odd
               return False
            
            if period == 1:
               if pbox == boxlist[pos]:
                  g.show("The pattern is stable.")
               else:
                  show_spaceship_speed(1, 0, 0)
            elif pbox == boxlist[pos]:
               g.show("Oscillator detected (period = " + str(period) + ")")
            else:
               deltax = abs(boxlist[pos].x - pbox.x)
               deltay = abs(boxlist[pos].y - pbox.y)
               show_spaceship_speed(period, deltax, deltay)
            return True
         else:
            # look at next matching hash value or insert if no more
            pos += 1
   
   # 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
Ejemplo n.º 56
0
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()
Ejemplo n.º 57
0
                 and g.getname(currindex - 1) == envname :
    # switch from starting layer to current layer and continue
    currindex += 1
    g.setlayer(currindex)
    startindex = currindex - 1
    envindex = currindex - 2

else:
    # start a new envelope using pattern in current layer
    if g.numlayers() + 1 > g.maxlayers():
        g.exit("You need to delete a couple of layers.")
    if g.numlayers() + 2 > g.maxlayers():
        g.exit("You need to delete a layer.")

    # get current layer's starting pattern
    startpatt = g.getcells(g.getrect())

    envindex = g.addlayer()       # create layer for remembering all live cells
    g.setcolors([-1,100,100,100]) # set all states to darkish gray
    g.putcells(startpatt)         # copy starting pattern into this layer

    startindex = g.addlayer()     # create layer for starting pattern
    g.setcolors([-1,0,255,0])     # set all states to green
    g.putcells(startpatt)         # copy starting pattern into this layer

    # move currindex to above the envelope and starting pattern
    g.movelayer(currindex, envindex)
    g.movelayer(envindex, startindex)
    currindex = startindex
    startindex = currindex - 1
    envindex = currindex - 2
Ejemplo n.º 58
0
# Change the entire pattern from emulated-Margolus states to N-state:

from glife import rect
import golly as g

r = rect( g.getrect() )
if r.empty: g.exit("There is no pattern.")

for row in xrange(r.top, r.top + r.height):
    for col in xrange(r.left, r.left + r.width):
        s = g.getcell(col,row)
        g.setcell(col, row, (s+s%2)/2-1)
Ejemplo n.º 59
0
            if obox.top < gridt:
               y += gridt - obox.top
            elif obox.bottom > gridb:
               y -= obox.bottom - gridb

         object = g.transform(object, x - prevx, y - prevy)
         oldcells = underneath(object)
         g.putcells(object)
         prevx = x
         prevy = y
         oldmouse = mousepos
         g.update()

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

if len(g.getrect()) == 0: g.exit("There are no objects.")

g.show("Click on or near live cell in object, move mouse and click again..." + helpmsg)
oldcursor = g.getcursor()
g.setcursor("Move")
oldcells = []        # cells under moved object
object = []          # cells in moving object
object1 = []         # cells in initial object

try:
   aborted = True
   moveobject()
   aborted = False
finally:
   g.setcursor(oldcursor)
   if aborted: