P30 technology Geminoid design

For discussion of specific patterns or specific families of patterns, both newly-discovered and well-known.
Post Reply
User avatar
simsim314
Posts: 1823
Joined: February 10th, 2014, 1:27 pm

P30 technology Geminoid design

Post by simsim314 » 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)

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
'''

User avatar
triller
Posts: 114
Joined: September 3rd, 2009, 2:41 pm

Re: P30 technology Geminoid design

Post by triller » July 14th, 2015, 8:46 pm

P30 being my bent, I'd like to look at this. I've really done no script work, though.

Can I copy this and paste it somewhere directly for immediate execution?
Perl or Python? (release?)

triller
The most exciting phrase to hear in science, the one that heralds new
discoveries, is not "Eureka!" (I found it!) but "That's funny ..."
-- Isaac Asimov

User avatar
gmc_nxtman
Posts: 1150
Joined: May 26th, 2015, 7:20 pm

Re: P30 technology Geminoid design

Post by gmc_nxtman » July 14th, 2015, 9:36 pm

Copy the code > Go into golly > File > Run clipboard.

User avatar
triller
Posts: 114
Joined: September 3rd, 2009, 2:41 pm

Re: P30 technology Geminoid design

Post by triller » July 14th, 2015, 9:51 pm

gmc_nxtman wrote:Copy the code > Go into golly > File > Run clipboard.
thanks.
triller
The most exciting phrase to hear in science, the one that heralds new
discoveries, is not "Eureka!" (I found it!) but "That's funny ..."
-- Isaac Asimov

User avatar
triller
Posts: 114
Joined: September 3rd, 2009, 2:41 pm

Re: P30 technology Geminoid design

Post by triller » July 14th, 2015, 11:13 pm

simsim314 wrote: ... 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:
A reasonably demonstrated blockic recipe for either the queenbee or pentadecathlon would definitely bolster this thread of study.
I did a single arm p30 constructor (see p30 thread). Eaters only. My thought is that it is certainly doable. I haven't studied the geminoid possibilities for periodic construction/synchronization. Bigger fish to fry for now. Good luck!

triller
The most exciting phrase to hear in science, the one that heralds new
discoveries, is not "Eureka!" (I found it!) but "That's funny ..."
-- Isaac Asimov

Post Reply