P30 technology Geminoid design
Posted: July 14th, 2015, 6:51 pm
A while back I was working on P30 technology Geminoid. It wasn't such a great idea but I got pretty far with it.
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)
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
'''