The idea was to use the basic Gemini block movement recipes, which doesn't require special timing, and use blockic setup to build the Geminoid. It looks pretty naive to me today, but it could be useful for other rules, or to someone who just wants to prove p30 is not such a bad technology for Geminoids after all:
And here a script that generates the initial parts (the pattern itself is too big for the post)
Code: Select all
import golly as g
from glife import *
from random import randint
class Glider:
def __init__(self, x, y, dx, dy, gen, state):
self.x = x
self.y = y
self.gen = gen
self.state = state
self.dx = dx
self.dy = dy
def Place(self):
gld = g.parse("3o$2bo$bo!", 0, 0, self.dx, 0, 0, self.dy)
gld = g.evolve(gld, self.state)
g.putcells(gld, self.x, self.y)
def PlaceD(self, deltax, deltay):
gld = g.parse("3o$2bo$bo!", 0, 0, self.dx, 0, 0, self.dy)
gld = g.evolve(gld, self.state)
g.putcells(gld, self.x + deltax, self.y + deltay)
def Description(self):
return " x {0} , y {1} , gen {2} , state {3}, dx {4}, dy {5} ".format(self.x, self.y, self.gen, self.state, self.dx, self.dy)
def NextIter(self):
if(self.state < 3):
self.state += 1
else:
self.x += self.dx
self.y -= self.dy
self.state = 0
self.gen += 1
def NextIters(self, n):
if n <= 0:
return
for x in xrange(0, n):
self.NextIter()
def BringToGeneration(self, n):
self.NextIters(n - self.gen)
class RelativeGlider:
def __init__(self, first, second):
maxGen = max(first.gen, second.gen)
first.BringToGeneration(maxGen)
second.BringToGeneration(maxGen)
while first.state != 0:
first.NextIter()
second.NextIter()
self.state = second.state
self.x = second.x - first.x
self.y = second.y - first.y
def Description(self):
return " x {0} , y {1} , state {2} ".format(self.x, self.y, self.state)
class Mirror:
def __init__(self, glider, dist, isRight):
self.glider = glider
self.dist = dist
self.isRight = isRight ^ (glider.dx == 1) ^ (glider.dy == 1)
self.x = glider.x + dist * glider.dx
self.y = glider.y - dist * glider.dy
self.state = (((((-4 * (dist - 1)) % 30) - (4 - self.glider.state)) - (self.glider.gen) % 30) + 90) % 30 + 30
if self.isRight:
self.outputGlider = Glider(self.x + 3 * self.glider.dx, self.y, self.glider.dx, -self.glider.dy, 7 + self.glider.gen + 4 * (dist - 1) + (4 - self.glider.state), 0)
else:
self.outputGlider = Glider(self.x + 3 * self.glider.dx, self.y - 2 * self.glider.dy, -self.glider.dx, self.glider.dy, 5 + self.glider.gen + 4 * (dist - 1) + (4 - self.glider.state), 2)
def Place(self):
if self.isRight:
mir = g.parse("2o$bo$bobo6b2o$2b3o5bobo$4b3o6bo7b2o$4bo2bo2bo2bo7b2o$5b2o6bo$10bobo$10b2o!", -1, -8, 1, 0, 0, 1)
else:
mir = g.parse("3b2o$3b2o7$2b3o$bo3bo2$o5bo$2o3b2o3$3bo$2bo$2bo2$5b2o$5bo$6b3o$8bo!", 1, -19, 1, 0, 0, 1)
mir = g.transform(mir, 0, 0, self.glider.dx, 0, 0, self.glider.dy)
mir = g.evolve(mir, self.state)
g.putcells(mir, self.x, self.y)
def PlaceD(self, deltax, deltay):
if self.isRight:
mir = g.parse("2o$bo$bobo6b2o$2b3o5bobo$4b3o6bo7b2o$4bo2bo2bo2bo7b2o$5b2o6bo$10bobo$10b2o!", -1, -8, 1, 0, 0, 1)
else:
mir = g.parse("3b2o$3b2o7$2b3o$bo3bo2$o5bo$2o3b2o3$3bo$2bo$2bo2$5b2o$5bo$6b3o$8bo!", 1, -19, 1, 0, 0, 1)
mir = g.transform(mir, 0, 0, self.glider.dx, 0, 0, self.glider.dy)
mir = g.evolve(mir, self.state)
g.putcells(mir, self.x + deltax, self.y + deltay)
class Splitter:
def __init__(self, glider, dist, isRight):
self.glider = glider
self.dist = dist
self.isRight = isRight ^ (glider.dx == 1) ^ (glider.dy == 1)
self.x = glider.x + dist * glider.dx
self.y = glider.y - dist * glider.dy
self.state = (((((-4 * (dist - 1)) % 60) - (4 - self.glider.state)) - (self.glider.gen) % 60) + 180) % 60 + 60
if self.isRight:
self.forwardGlider = Glider(self.x + 28 * self.glider.dx, self.y - 23 * self.glider.dy, self.glider.dx, self.glider.dy, 97 + self.glider.gen + 4 * (dist - 1) + (4 - self.glider.state), 0)
self.refGlider = Glider(self.x + 37 * self.glider.dx, self.y + 9 * self.glider.dy, self.glider.dx, -self.glider.dy, 112 + self.glider.gen + 4 * (dist - 1) + (4 - self.glider.state), 0)
else:
self.forwardGlider = Glider(self.x + 23 * self.glider.dx, self.y - 28 * self.glider.dy, self.glider.dx, self.glider.dy, 97 + self.glider.gen + 4 * (dist - 1) + (4 - self.glider.state), 0)
self.refGlider = Glider(self.x + -7 * self.glider.dx, self.y + - 37 * self.glider.dy, -self.glider.dx, self.glider.dy, 112 + self.glider.gen + 4 * (dist - 1) + (4 - self.glider.state), 0)
def Place(self):
if self.isRight:
mir = g.parse("34b2o$34bo$23bobo6bobo$21bo3bo6b2o$13bo7bo$12b4o4bo4bo$2o9b2obobo4bo$2o8b3obo2bo3bo3bo$11b2obobo6bobo$12b4o$13bo$24bo21b2o$22bobo21b2o$23b2o5$31bo$24b2o6bo$24b2o4b3o$46bo$45b3o$44b5o$43b2o3b2o$44b5o$39bo4bo3bo$37bobo5bobo$38b2o6bo3$44bo$42b2ob2o2$41bo5bo2$41b2obob2o9$44b2o$44b2o!", -11, -24, 1, 0, 0, 1)
else:
mir = g.parse("23bo$23b2o$12bo5b2o4b2o8b2o$12bobo3b2o4b3o7b2o$2o11bobo2b2o4b2o$2o11bo2bo6b2o$13bobo7bo$12bobo$12bo$18b2o$18bobo$18bo3$46bo$44b3o$43bo$25b3o15b2o$25bo$26bo5$26b2o5b2o$26b2o5bobo$33bo4b2o3b2o$40b3o$39bo3bo$40bobo$41bo2$38b3o$38b3o4$36b2o3b2o$37b5o$38b3o$39bo8$39b2o$39b2o!", -21, -36, 1, 0, 0, 1)
mir = g.transform(mir, 0, 0, self.glider.dx, 0, 0, self.glider.dy)
mir = g.evolve(mir, self.state)
g.putcells(mir, self.x, self.y)
def PlaceD(self, deltax, deltay):
if self.isRight:
mir = g.parse("34b2o$34bo$23bobo6bobo$21bo3bo6b2o$13bo7bo$12b4o4bo4bo$2o9b2obobo4bo$2o8b3obo2bo3bo3bo$11b2obobo6bobo$12b4o$13bo$24bo21b2o$22bobo21b2o$23b2o5$31bo$24b2o6bo$24b2o4b3o$46bo$45b3o$44b5o$43b2o3b2o$44b5o$39bo4bo3bo$37bobo5bobo$38b2o6bo3$44bo$42b2ob2o2$41bo5bo2$41b2obob2o9$44b2o$44b2o!", -11, -24, 1, 0, 0, 1)
else:
mir = g.parse("23bo$23b2o$12bo5b2o4b2o8b2o$12bobo3b2o4b3o7b2o$2o11bobo2b2o4b2o$2o11bo2bo6b2o$13bobo7bo$12bobo$12bo$18b2o$18bobo$18bo3$46bo$44b3o$43bo$25b3o15b2o$25bo$26bo5$26b2o5b2o$26b2o5bobo$33bo4b2o3b2o$40b3o$39bo3bo$40bobo$41bo2$38b3o$38b3o4$36b2o3b2o$37b5o$38b3o$39bo8$39b2o$39b2o!", -21, -36, 1, 0, 0, 1)
mir = g.transform(mir, 0, 0, self.glider.dx, 0, 0, self.glider.dy)
mir = g.evolve(mir, self.state)
g.putcells(mir, self.x + deltax, self.y + deltay)
class GliderBlock:
def __init__(self, glider, dist):
self.glider = glider
self.x = glider.x + dist * glider.dx
self.y = glider.y - dist * glider.dy
def Place(self):
mir = g.parse("6b2o$6bo$4bobo$4b2o!", 1, -6, 1, 0, 0, 1)
mir = g.transform(mir, 0, 0, self.glider.dx, 0, 0, self.glider.dy)
g.putcells(mir, self.x, self.y)
class FixerSmallStep:
def __init__(self, glider, dist, isRight):
self.glider = glider
self.dist = dist
self.isRight = isRight ^ (glider.dx == 1) ^ (glider.dy == 1)
self.x = glider.x + dist * glider.dx
self.y = glider.y - dist * glider.dy
self.state = (((((-4 * (dist - 1)) % 30) - (4 - self.glider.state)) - (self.glider.gen) % 30) + 90) % 30 + 30
if self.isRight:
self.outputGlider = Glider(self.x + 2 * self.glider.dx , self.y - 3 * self.glider.dy, self.glider.dx, self.glider.dy, 13 + self.glider.gen + 4 * (dist - 1) + (4 - self.glider.state), 0)
else:
self.outputGlider = Glider(self.x + 2 * self.glider.dx, self.y - 1 * self.glider.dy, self.glider.dx, self.glider.dy, 9 + self.glider.gen + 4 * (dist - 1) + (4 - self.glider.state), 0)
def Place(self):
if self.isRight:
mir = g.parse("9b8o$3bo5bob4obo$2bo6b8o$2b2o$3bo3$2o3b2o$obobobo$b5o$2b3o$3bo7$3b2o$3b2o!", 3, -1, 1, 0, 0, 1)
else:
mir = g.parse("19bo$18b3o$17b2ob2o$16b3ob3o$16b3ob3o$16b3ob3o$16b3ob3o$17b2ob2o$18b3o$19bo2$12b2o$12b2o$b2o6b2o$b2o5b3o5bobo$9b2o5bobo$12b2o3bo$12b2o!", -18, -18, 1, 0, 0, 1)
mir = g.transform(mir, 0, 0, self.glider.dx, 0, 0, self.glider.dy)
mir = g.evolve(mir, self.state)
g.putcells(mir, self.x, self.y)
def PlaceD(self, deltax, deltay):
if self.isRight:
mir = g.parse("9b8o$3bo5bob4obo$2bo6b8o$2b2o$3bo3$2o3b2o$obobobo$b5o$2b3o$3bo7$3b2o$3b2o!", 3, -1, 1, 0, 0, 1)
else:
mir = g.parse("19bo$18b3o$17b2ob2o$16b3ob3o$16b3ob3o$16b3ob3o$16b3ob3o$17b2ob2o$18b3o$19bo2$12b2o$12b2o$b2o6b2o$b2o5b3o5bobo$9b2o5bobo$12b2o3bo$12b2o!", -18, -18, 1, 0, 0, 1)
mir = g.transform(mir, 0, 0, self.glider.dx, 0, 0, self.glider.dy)
mir = g.evolve(mir, self.state)
g.putcells(mir, self.x + deltax, self.y + deltay)
class BlockicSplitter:
def __init__(self, glider, dist, isRight):
self.glider = glider
self.dist = dist
self.isRight = isRight ^ (glider.dx == 1) ^ (glider.dy == 1)
self.x = glider.x + dist * glider.dx
self.y = glider.y - dist * glider.dy
if self.isRight:
self.forwardGlider = Glider(self.x + 8 * self.glider.dx , self.y + 4 * self.glider.dy, self.glider.dx, self.glider.dy, 45 + self.glider.gen + 4 * (dist - 1) + (4 - self.glider.state), 0)
self.refGlider = Glider(self.x - 3 * self.glider.dx, self.y + 10 * self.glider.dy, self.glider.dx, -self.glider.dy, 53 + self.glider.gen + 4 * (dist - 1) + (4 - self.glider.state), 0)
else:
self.forwardGlider = Glider(self.x - 4 * self.glider.dx , self.y - 8 * self.glider.dy, self.glider.dx, self.glider.dy, 45 + self.glider.gen + 4 * (dist - 1) + (4 - self.glider.state), 0)
self.refGlider = Glider(self.x - 6 * self.glider.dx, self.y + 3 * self.glider.dy, -self.glider.dx, self.glider.dy, 53 + self.glider.gen + 4 * (dist - 1) + (4 - self.glider.state), 0)
def Place(self):
if self.isRight:
mir = g.parse("9b2o$9b2o$16b2o$2o14b2o$2o!", -8, -4, 1, 0, 0, 1)
else:
mir = g.parse("b2o$b2o6$3b2o$3b2o8$2o$2o!", 2, -8, 1, 0, 0, 1)
mir = g.transform(mir, 0, 0, self.glider.dx, 0, 0, self.glider.dy)
g.putcells(mir, self.x, self.y)
class BlockicMirror1:
def __init__(self, glider, dist, isRight):
self.glider = glider
self.dist = dist
self.isRight = isRight ^ (glider.dx == 1) ^ (glider.dy == 1)
self.x = glider.x + dist * glider.dx
self.y = glider.y - dist * glider.dy
if self.isRight:
self.outputGlider = Glider(self.x + 4 * self.glider.dx , self.y + 1 * self.glider.dy, self.glider.dx, -self.glider.dy, 31 + self.glider.gen + 4 * (dist - 1) + (4 - self.glider.state), 0)
else:
self.outputGlider = Glider(self.x + 2 * self.glider.dx , self.y - 5 * self.glider.dy, -self.glider.dx, self.glider.dy, 35 + self.glider.gen + 4 * (dist - 1) + (4 - self.glider.state), 0)
def Place(self):
if self.isRight:
mir = g.parse("2o$2o3$5b2o$5b2o!", 2, -4, 1, 0, 0, 1)
else:
mir = g.parse("2o$2o4$4b2o$4b2o!", 1, -7, 1, 0, 0, 1)
mir = g.transform(mir, 0, 0, self.glider.dx, 0, 0, self.glider.dy)
g.putcells(mir, self.x, self.y)
class BlockicMirror2:
def __init__(self, glider, dist, isRight):
self.glider = glider
self.dist = dist
self.isRight = isRight ^ (glider.dx == 1) ^ (glider.dy == 1)
self.x = glider.x + dist * glider.dx
self.y = glider.y - dist * glider.dy
if self.isRight:
self.outputGlider = Glider(self.x + 6 * self.glider.dx , self.y + 0 * self.glider.dy, self.glider.dx, -self.glider.dy, 26 + self.glider.gen + 4 * (dist - 1) + (4 - self.glider.state), 0)
else:
self.outputGlider = Glider(self.x + 3 * self.glider.dx , self.y - 7 * self.glider.dy, -self.glider.dx, self.glider.dy, 30 + self.glider.gen + 4 * (dist - 1) + (4 - self.glider.state), 0)
def Place(self):
if self.isRight:
mir = g.parse("2o$2o4$9b2o$9b2o4$8b2o$8b2o!", -4, -5, 1, 0, 0, 1)
else:
mir = g.parse("5b2o$2o3b2o$2o7$10b2o$10b2o!", -4, -5, 1, 0, 0, 1)
mir = g.transform(mir, 0, 0, self.glider.dx, 0, 0, self.glider.dy)
g.putcells(mir, self.x, self.y)
class BlockicMirror3:
def __init__(self, glider, dist, isRight):
self.glider = glider
self.dist = dist
self.isRight = isRight ^ (glider.dx == 1) ^ (glider.dy == 1)
self.x = glider.x + dist * glider.dx
self.y = glider.y - dist * glider.dy
if self.isRight:
self.outputGlider = Glider(self.x + 6 * self.glider.dx , self.y -1 * self.glider.dy, self.glider.dx, -self.glider.dy, 28 + self.glider.gen + 4 * (dist - 1) + (4 - self.glider.state), 0)
else:
self.outputGlider = Glider(self.x + 3 * self.glider.dx , self.y - 6 * self.glider.dy, -self.glider.dx, self.glider.dy, 28 + self.glider.gen + 4 * (dist - 1) + (4 - self.glider.state), 0)
def Place(self):
if self.isRight:
mir = g.parse("2o4b2o$2o4b2o8$9b2o$9b2o!", -5, -5, 1, 0, 0, 1)
else:
mir = g.parse("2o$2o2$9b2o$9b2o5$9b2o$9b2o!", -4, -3, 1, 0, 0, 1)
mir = g.transform(mir, 0, 0, self.glider.dx, 0, 0, self.glider.dy)
g.putcells(mir, self.x, self.y)
class BlockicMirror4:
def __init__(self, glider, dist, isRight):
self.glider = glider
self.dist = dist
self.isRight = isRight ^ (glider.dx == 1) ^ (glider.dy == 1)
self.x = glider.x + dist * glider.dx
self.y = glider.y - dist * glider.dy
if self.isRight:
self.outputGlider = Glider(self.x + 3 * self.glider.dx , self.y + 5 * self.glider.dy, self.glider.dx, -self.glider.dy, 44 + self.glider.gen + 4 * (dist - 1) + (4 - self.glider.state), 0)
else:
self.outputGlider = Glider(self.x - 3 * self.glider.dx , self.y - 3 * self.glider.dy, -self.glider.dx, self.glider.dy, 44 + self.glider.gen + 4 * (dist - 1) + (4 - self.glider.state), 0)
def Place(self):
if self.isRight:
mir = g.parse("2b2o$2b2o5$b2o$b2o6$7b2o$7b2o!", 2, -13, 1, 0, 0, 1)
else:
mir = g.parse("2o$2o4$13b2o$7b2o4b2o$7b2o!", 0, -8, 1, 0, 0, 1)
mir = g.transform(mir, 0, 0, self.glider.dx, 0, 0, self.glider.dy)
g.putcells(mir, self.x, self.y)
class BlockicMirror5:
def __init__(self, glider, dist, isRight):
self.glider = glider
self.dist = dist
self.isRight = isRight ^ (glider.dx == 1) ^ (glider.dy == 1)
self.x = glider.x + dist * glider.dx
self.y = glider.y - dist * glider.dy
if self.isRight:
self.outputGlider = Glider(self.x + 6 * self.glider.dx , self.y + -1 * self.glider.dy, self.glider.dx, -self.glider.dy, 38 + self.glider.gen + 4 * (dist - 1) + (4 - self.glider.state), 0)
else:
self.outputGlider = Glider(self.x + 3 * self.glider.dx , self.y - 6 * self.glider.dy, -self.glider.dx, self.glider.dy, 38 + self.glider.gen + 4 * (dist - 1) + (4 - self.glider.state), 0)
def Place(self):
if self.isRight:
mir = g.parse("2o$2o3$2b2o$2b2o3$3b2o$3b2o!", 3, -5, 1, 0, 0, 1)
else:
mir = g.parse("2o$2o2b2o$4b2o$8b2o$8b2o!", -3, -5, 1, 0, 0, 1)
mir = g.transform(mir, 0, 0, self.glider.dx, 0, 0, self.glider.dy)
g.putcells(mir, self.x, self.y)
class BlockicMirror6:
def __init__(self, glider, dist, isRight):
self.glider = glider
self.dist = dist
self.isRight = isRight ^ (glider.dx == 1) ^ (glider.dy == 1)
self.x = glider.x + dist * glider.dx
self.y = glider.y - dist * glider.dy
if self.isRight:
self.outputGlider = Glider(self.x + 9 * self.glider.dx , self.y + 1 * self.glider.dy, self.glider.dx, -self.glider.dy, 36 + self.glider.gen + 4 * (dist - 1) + (4 - self.glider.state), 0)
else:
self.outputGlider = Glider(self.x + 1 * self.glider.dx , self.y - 9 * self.glider.dy, -self.glider.dx, self.glider.dy, 36 + self.glider.gen + 4 * (dist - 1) + (4 - self.glider.state), 0)
def Place(self):
if self.isRight:
mir = g.parse("12b2o$2o10b2o$2o3$12b2o$12b2o!", -7, 0, 1, 0, 0, 1)
else:
mir = g.parse("2o3b2o$2o3b2o11$4b2o$4b2o!", -5, -4, 1, 0, 0, 1)
mir = g.transform(mir, 0, 0, self.glider.dx, 0, 0, self.glider.dy)
g.putcells(mir, self.x, self.y)
def MirrorTiming(gliderStart, gliderEnd, y, r, deltax, deltay, numFixers):
rx = gliderEnd.x - gliderStart.x
ry = gliderEnd.y - gliderStart.y
dx = int((rx - ry) / 2)
dy = int((-ry - rx) / 2)
dGen = gliderEnd.gen - gliderStart.gen
x = int((int(dGen / 4) - (dx + dy)) / 2) - y
golly.show("First dx - {0} dy - {1} dGen - {2} x - {3}".format(dx, dy, dGen, x))
mir = Mirror(gliderStart, r + x, True)
mir.PlaceD(deltax, deltay)
mir = Mirror(mir.outputGlider, y, True)
mir.PlaceD(deltax, deltay)
mir = Mirror(mir.outputGlider, x, True)
mir.PlaceD(deltax, deltay)
mir = Mirror(mir.outputGlider, y + dy, True)
mir.PlaceD(deltax, deltay)
gld = mir.outputGlider
for x in xrange(0, numFixers):
fix = FixerSmallStep(gld, 20, False)
fix.PlaceD(deltax, deltay)
gld = fix.outputGlider
def TwoMirrorNoTiming(gliderStart, r1, r2, r3, deltax, deltay, numFixers, direction):
if r3 > 0:
mir = Mirror(gliderStart, r1, direction)
mir.PlaceD(deltax, deltay)
mir = Mirror(mir.outputGlider, r3, not direction)
mir.PlaceD(deltax, deltay)
mir = Mirror(mir.outputGlider, 15, not direction)
mir.PlaceD(deltax, deltay)
else:
mir = Mirror(gliderStart, r1, not direction)
mir.PlaceD(deltax, deltay)
mir = Mirror(mir.outputGlider, r2 + r3, direction)
mir.PlaceD(deltax, deltay)
gld = mir.outputGlider
for x in xrange(0, numFixers):
fix = FixerSmallStep(gld, 20, False)
fix.PlaceD(deltax, deltay)
gld = fix.outputGlider
def BlockicMirrorByIndex(idx, gld, dist, isRight):
if idx == 1:
return BlockicMirror1(gld, dist, isRight)
if idx == 2:
return BlockicMirror2(gld, dist, isRight)
if idx == 3:
return BlockicMirror3(gld, dist, isRight)
if idx == 4:
return BlockicMirror4(gld, dist, isRight)
if idx == 5:
return BlockicMirror5(gld, dist, isRight)
if idx == 6:
return BlockicMirror6(gld, dist, isRight)
def FindBlockicConfig(x, y, dirX, dirY, N, isRight):
gld = Glider(0, 0, dirX, dirY, 0, 0)
for dx in xrange(0, 2):
for dy in xrange(0, 2):
for i in xrange(1, 7):
for j in xrange(1, 7):
miri = BlockicMirrorByIndex(i, gld, dx, isRight)
mirj = BlockicMirrorByIndex(j, miri.outputGlider, dy, isRight)
if N % 4 == mirj.outputGlider.gen % 4:
k = (N - mirj.outputGlider.gen) / 4
if mirj.outputGlider.x % 2 == (k + x) % 2 and mirj.outputGlider.y % 2 == (k + y) % 2:
return [i, j, dx, dy]
def BlockicMirrorTiming(gliderStart, gliderEnd, isRight):
gliderEnd.BringToGeneration(gliderEnd.gen + 4 - gliderEnd.state)
dx = gliderStart.dx * (gliderEnd.x - gliderStart.x)
dy = -(gliderEnd.y - gliderStart.y) * gliderStart.dy
dGen = gliderEnd.gen - gliderStart.gen
blockicConfig = FindBlockicConfig(dx, dy, gliderStart.dx, gliderStart.dy, dGen, isRight)
gld = Glider(0, 0, gliderStart.dx, gliderStart.dy, 0, 0)
miri = BlockicMirrorByIndex(blockicConfig[0], gld, blockicConfig[2], isRight)
mirj = BlockicMirrorByIndex(blockicConfig[1], miri.outputGlider, blockicConfig[3], isRight)
N0 = mirj.outputGlider.gen
x0 = mirj.outputGlider.x
y0 = mirj.outputGlider.y
k = (dGen - N0) / 4
a = (dx + k - gliderStart.dx * x0) / 2
b = ((dy + k + gliderStart.dy * y0) / 2) - a
miri = BlockicMirrorByIndex(blockicConfig[0], gliderStart, blockicConfig[2] + a, isRight)
mirj = BlockicMirrorByIndex(blockicConfig[1], miri.outputGlider, blockicConfig[3] + b, isRight)
miri.Place()
mirj.Place()
gliderStart.Place();
golly.select( [-50000,-50000,100000,100000] )
golly.clear(0)
golly.select([])
'''
gldStart = Glider(-10, -10, -1, -1, 0, 0)
gldEnd = Glider(30, 70, 1, 1, 1000, 0)
BlockicMirrorTiming(gldStart, gldEnd, False)
'''
'''
split = BlockicMirror6(gld, 0, False)
gld.Place()
split.Place()
split = BlockicMirror6(split.outputGlider, 10, True)
split.Place()
split = BlockicMirror6(split.outputGlider, 20, False)
split.Place()
split = BlockicMirror6(split.outputGlider, 30, False)
split.Place()
split = BlockicMirror6(split.outputGlider, 40, False)
split.Place()
split = BlockicMirror6(split.outputGlider, 50, False)
split.Place()
split = BlockicMirror6(split.outputGlider,50, True)
split.Place()
'''
#Here is the interpreter
#g.putcells(g.parse("2o$2o!"), 1730,-1570)
def GlideStrem(numRefs, dist, f1s, r1s, r2s, ds, nums):
for x in xrange(0, numRefs * 2):
gld = Glider(x * dist, 0, 1, 1, 0, 0)
if x < 6:
gld = Glider(x * dist, 0, 1, 1, 0, ds[5 - x])
if x < 13 and x > 6:
gld = Glider(x * dist, 0, 1, 1, 0, ds[12 - x])
split = Splitter(gld, 0, True)
split.Place()
if x < 6 :
mir = Mirror(split.forwardGlider, f1s[5 - x], False)
mir.Place()
gl = mir.outputGlider
mir = Mirror(gl, r1s[5 - x], True)
mir.Place()
gl = mir.outputGlider
mir = Mirror(gl, 15, True)
mir.Place()
gl = mir.outputGlider
mir = Mirror(gl, r2s[5 - x] + r1s[5 - x], False)
mir.Place()
gl = mir.outputGlider
for i in xrange(0, nums[5 - x]):
fix = FixerSmallStep(gl, 20, True)
fix.Place()
gl = fix.outputGlider
if x >= numRefs:
mir = Splitter(split.forwardGlider, (dist / 2) * (numRefs + 1), True)
mir.Place()
blck = GliderBlock(mir.forwardGlider, 10)
blck.Place()
if x < 13 and x > 6:
mir = Mirror(mir.refGlider, f1s[12 - x], True)
mir.Place()
gl = mir.outputGlider
mir = Mirror(gl, r1s[12 - x], False)
mir.Place()
gl = mir.outputGlider
mir = Mirror(gl, 15, False)
mir.Place()
gl = mir.outputGlider
mir = Mirror(gl, r2s[12 - x] + r1s[12 - x], True)
mir.Place()
gl = mir.outputGlider
for i in xrange(0, nums[12 - x]):
fix = FixerSmallStep(gl, 20, False)
fix.Place()
gl = fix.outputGlider
gld1 = split.refGlider
mir = Splitter(gld1, dist * (2 * numRefs - x), True)
mir.Place()
blck = GliderBlock(mir.forwardGlider, 10)
blck.Place()
g.putcells(g.parse("2o$2o!"), 2586,-2129)
g.putcells(g.parse("2o$2o!"), 3444,1795)
def CalcPos(numRefs, dist, x, d, gen):
if x < 6:
gld = Glider(x * dist - d, d, 1, 1, 0, ds[5 - x])
split = Splitter(gld, d, True)
if x < 6:
mir = Mirror(split.forwardGlider, f1s[5 - x], False)
gl = mir.outputGlider
mir = Mirror(gl, r1s[5 - x], True)
gl = mir.outputGlider
mir = Mirror(gl, 15, True)
gl = mir.outputGlider
mir = Mirror(gl, r2s[5 - x] + r1s[5 - x], False)
gl = mir.outputGlider
for i in xrange(0, nums[5 - x]):
fix = FixerSmallStep(gl, 20, True)
gl = fix.outputGlider
gl.BringToGeneration(gen)
golly.show("{0}, {1}".format(gl.x, gl.y))
return gl
def SetInterpreter():
f1s = [60, 250, 620, 1050, 1830, 2140]
r1s = [12, 11, 15, 16, 14, 14]
r2s = [42, 84, 125, 172, 200, 236]
ds = [1, 3, 0, 0, 0, 0]
nums = [5, 14, 16, 32, 11, 7]
GlideStrem(7, 75, f1s, r1s, r2s, ds, nums)
def SetStream(placement):
deltas = [0,5,8,15,20,26,33,0,5,8,15,20,26,33]
ds = [1, 3, 0, 0, 0, 0]
dist = 75
for x in xrange(0, 14):
gld = Glider(x * dist, 0, 1, 1, 0, 0)
if x < 6:
gld = Glider(x * dist, 0, 1, 1, 0, ds[5 - x])
if x < 13 and x > 6:
gld = Glider(x * dist, 0, 1, 1, 0, ds[12 - x])
for i in xrange(0, len(placement)):
if placement[i][x] > 0:
gld.PlaceD(-(i + deltas[x]) * 15, (i + deltas[x]) * 15)
SetInterpreter()
placement = [[0,0,0,0,1,1,1,0,0,0,0,1,1,1], [0,0,0,0,1,1,1,0,0,0,0,1,1,1], [0,0,0,0,1,1,1,0,0,0,0,1,1,1], [0,0,0,0,1,1,1,0,0,0,0,1,1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,1,1,0,1,0,0,1,1,1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,1,0,0,1,0,1,1,1,0,0,1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0]]
placement.extend(placement)
placement.extend(placement)
placement.extend(placement)
placement.extend(placement)
placement.extend(placement)
placement.extend(placement)
SetStream(placement)
#posx += 4000
'''
for j in xrange(0, 60):
for i in xrange(-80, 80):
for k in xrange(10,17):
f1s = [60, 250, 620, 1050, 1850, 2300]
r1s = [12, 11, 15, 16, 14, k]
r2s = [42, 84, 125, 172, 200, 240 + i]
ds = [1, 3, 0, 0, 0, (j + 1)%4]
nums = [5, 14, 16, 32, 11, j]
minDef = 0
deltas = [0,1,0,7,12,18,25,0,0,0,0,0,0,0]
placement = [[1,1,0,0,1,0,1,1,1,1,1,1,1,1], [0,0,0,0,0,0,0,1,1,1,1,1,1,1]]
placement.extend(placement)
placement.extend(placement)
placement.extend(placement)
placement.extend(placement)
placement.extend(placement)
placement.extend(placement)
placement.extend(placement)
placement.extend(placement)
placement.extend(placement)
gl = CalcPos(7, 75, 0, 0, 14584)
if gl.x == 3614 and gl.y == -3142:
golly.show("i = {0}, j = {1}, k = {2}".format(i, j, k))
GlideStrem(7, 75)
golly.exit("")
#End of interpreter
'''