def Remove(self, phisSig):
for i in xrange(0, len(phisSig.signal), 2):
xs = phisSig.signal[i]
ys = phisSig.signal[i + 1]
g.setcell(phisSig.x + xs, phisSig.y + ys, 0)
def rp_plot(input, fill=3):
m = len(input)
for i in range(m):
for j in range(m):
d = norm(input[i], input[j])
if d <= dmax:
g.setcell(i, -j, fill)
def Remove(self, phisSig): for i in xrange(0, len(phisSig.signal), 2): xs = phisSig.signal[i] ys = phisSig.signal[i + 1] g.setcell(phisSig.x + xs, phisSig.y + ys, 0)
def draw_icons(iconinfo, transparent):
global colorstate
if len(iconinfo) == 0: return
width = iconinfo[0]
height = iconinfo[1]
num_colors = iconinfo[2]
chars_per_pixel = iconinfo[3]
colordict = iconinfo[4]
pos = 5
numicons = height/width
for i in xrange(numicons):
x = i*32
y = 0
if width == 15: y = 32
if width == 7: y = 48
for row in xrange(width):
pxls = iconinfo[pos]
pos += 1
for col in xrange(width):
offset = col*chars_per_pixel
key = pxls[offset : offset + chars_per_pixel]
if not key in colordict:
g.exit("Unexpected key in icon data: " + key)
rgb = colordict[key]
if rgb != transparent:
g.setcell(x+col, y+row, colorstate[rgb])
def create_smaller_icons(big, small):
# scale down the big x big bitmaps into small x small bitmaps
# using a simple sampling algorithm
global iconinfo15, iconinfo31
if big == 15:
numicons = iconinfo15[1] / 15
ybig = 32
else:
# big = 31
numicons = iconinfo31[1] / 31
ybig = 0
if small == 7:
y = 48
else:
# small = 15
y = 32
sample = big / small
offset = sample / 2
for i in xrange(numicons):
x = i*32
for row in xrange(small):
for col in xrange(small):
state = g.getcell(x + offset + col*sample, ybig + offset + row*sample)
if state > 0:
g.setcell(x+col, y+row, state)
def GetObjectByClick(event):
x = int(event.split()[1])
y = int(event.split()[2])
found = False
for i in [0, -1, 1, -2, 2]:
for j in [0, -1, 1]:
if found:
break
o = IsObjectExists(objectArray, x + i, y + j)
if o != None:
g.show("found!")
for k in xrange(0, len(o[0]), 2):
dx = o[0][k]
dy = o[0][k + 1]
g.setcell(x + i + dx, y + j + dy, 0)
found = True
g.update()
if found:
return o
else :
return None
def update_golly(self):
invgcells = {v: k for (k, v) in self.gcells.iteritems()}
for (v, c) in self.known_states.iteritems():
if v in invgcells:
(x, y) = invgcells[v]
g.setcell(x, y, c)
g.update()
def create_smaller_icons(big, small):
# scale down the big x big bitmaps into small x small bitmaps
# using a simple sampling algorithm
global iconinfo15, iconinfo31
if big == 15:
numicons = iconinfo15[1] // 15
ybig = 32
else:
# big = 31
numicons = iconinfo31[1] // 31
ybig = 0
if small == 7:
y = 48
else:
# small = 15
y = 32
sample = big // small
offset = sample // 2
for i in range(numicons):
x = i * 32
for row in range(small):
for col in range(small):
state = g.getcell(x + offset + col * sample,
ybig + offset + row * sample)
if state > 0:
g.setcell(x + col, y + row, state)
def draw_icons(iconinfo, transparent):
global colorstate
if len(iconinfo) == 0: return
width = iconinfo[0]
height = iconinfo[1]
num_colors = iconinfo[2]
chars_per_pixel = iconinfo[3]
colordict = iconinfo[4]
pos = 5
numicons = height // width
for i in range(numicons):
x = i * 32
y = 0
if width == 15: y = 32
if width == 7: y = 48
for row in range(width):
pxls = iconinfo[pos]
pos += 1
for col in range(width):
offset = col * chars_per_pixel
key = pxls[offset:offset + chars_per_pixel]
if not key in colordict:
g.exit("Unexpected key in icon data: " + key)
rgb = colordict[key]
if rgb != transparent:
g.setcell(x + col, y + row, colorstate[rgb])
def cellchange(self, x, y, state):
"""
Sets the color of the specific cell
:param x: the x location of the cell
:param y: the y location of the cell
:param state: the color state that the cell is in
"""
g.setcell(x, y, state)
def checkneighbor(x, y): # first check if x,y is outside bounded grid if g.getwidth() > 0 and (x < gridl or x > gridr): return if g.getheight() > 0 and (y < gridt or y > gridb): return if g.getcell(x, y) == 0: return # no need for next test because we kill cell after adding it to ncells # if (x, y) in ncells: return False ncells.append( (x, y, g.getcell(x,y)) ) g.setcell(x, y, 0)
def checkneighbor(x, y):
# first check if x,y is outside bounded grid
if g.getwidth() > 0 and (x < gridl or x > gridr): return
if g.getheight() > 0 and (y < gridt or y > gridb): return
if g.getcell(x, y) == 0: return
# no need for next test because we kill cell after adding it to ncells
# if (x, y) in ncells: return False
ncells.append( (x, y, g.getcell(x,y)) )
g.setcell(x, y, 0)
def randfill_mash(rectcoords, amt):
newstate = g.getoption("drawingstate")
for i in range(rectcoords[0], rectcoords[0] + rectcoords[2]):
for j in range(rectcoords[1], rectcoords[1] + rectcoords[3]):
if (100 * random.random() < amt):
g.setcell(i, j, dict_fill[rule][g.getcell(i, j)])
else:
# g.setcell(i, j, 0)
continue
def write_data_bits(s):
x = data_tape_x
for c in s:
if c == '1':
bit = 1
else:
bit = 0
g.setcell(x, data_tape_y, bit)
x += 1
def randfill(rectcoords, amt, amt2=100, secondary_state=1):
statelist = [g.getoption("drawingstate"), secondary_state]
for i in range(rectcoords[0], rectcoords[0] + rectcoords[2]):
for j in range(rectcoords[1], rectcoords[1] + rectcoords[3]):
if (100 * random.random() < amt):
newstate = (100 * random.random() > amt2)
g.setcell(i, j, statelist[newstate])
else:
# g.setcell(i, j, 0)
continue
def write_byte_at(addr, write_byte):
if addr <= QFTASM_REGAREA_MAX_ADDRESS:
addr = addr
elif addr >= RAM_SIZE - RAM_NEGATIVE_BUFFER_SIZE:
addr = RAM_SIZE - addr + QFTASM_REGAREA_MAX_ADDRESS
elif addr > QFTASM_REGAREA_MAX_ADDRESS:
addr = addr + RAM_NEGATIVE_BUFFER_SIZE
b_binary = "{:016b}".format(write_byte)
for i_bit, bit in enumerate(b_binary):
for x_offset in range(2):
g.setcell(p_init[0] + i_bit * delta_x + x_offset, p_init[1] + addr * delta_y, d_bit2state[int(bit)])
def main(step=1, start=0):
img = Image.open(srcPath)
size = img.size
for y in xrange(0, size[1]):
for x in xrange(0, size[0]):
c = img.getpixel((x, y))
state = 1 if c[0] > 128 else 0
g.setcell(x, y, state)
def main( step = 1, start = 0 ): img = Image.open( srcPath ) size = img.size for y in xrange( 0, size[1] ): for x in xrange( 0, size[0] ): c = img.getpixel( (x, y) ) state = 1 if c[0] > 128 else 0 g.setcell( x, y, state )
def ClearCellDictionary(self, curdict, obejctIdx):
before = len(curdict)
removeList = [key for key in curdict if curdict[key] == obejctIdx]
for key in removeList:
x, y = key.split(":")
g.setcell(int(x), int(y), 0)
del curdict[key]
after = len(curdict)
g.show("size change: " + str(before) + "," + str(after) + "," + str(obejctIdx))
def rp_plot(a,b,fill=fill):
ma=max(a)
mb=max(b)
l=range(min(len(a),min(b)))
# g.note('%i'%min(8,8))
for i in range(min(len(a),len(b))):
# for i in range(ma+1):
# for j in range(mb+1):
# if i==a[i] and j==b[j]:
g.setcell(a[i],-b[i],fill)
def write_program_bits(s):
stripe_offset = 6 # the y offset in bits to offset our various striped sections of the program tape
for (i, c) in enumerate(s):
if c == '1':
bit = 1
else:
bit = 0
# The program tape we've been given is one long string of binary, but we want to stripe it into 4 different strings.
# we'll handle that logic via modular arithmetic here
x = program_tape_x + i // 4
y = program_tape_y - (i % 4) * stripe_offset
g.setcell(x, y, bit)
def ClearCellDictionary(self, curdict, obejctIdx):
before = len(curdict)
removeList = [key for key in curdict if curdict[key] == obejctIdx]
for key in removeList:
x, y = key.split(":")
g.setcell(int(x), int(y), 0)
del curdict[key]
after = len(curdict)
g.show("size change: " + str(before) + "," + str(after) + "," +
str(obejctIdx))
def draw_line(x1, y1, x2, y2, state=1):
# draw a line of cells in given state from x1,y1 to x2,y2
# using Bresenham's algorithm
g.setcell(x1, y1, state)
if x1 == x2 and y1 == y2: return
dx = x2 - x1
ax = abs(dx) * 2
sx = 1
if dx < 0: sx = -1
dy = y2 - y1
ay = abs(dy) * 2
sy = 1
if dy < 0: sy = -1
if ax > ay:
d = ay - (ax / 2)
while x1 != x2:
g.setcell(x1, y1, state)
if d >= 0:
y1 += sy
d -= ax
x1 += sx
d += ay
else:
d = ax - (ay / 2)
while y1 != y2:
g.setcell(x1, y1, state)
if d >= 0:
x1 += sx
d -= ay
y1 += sy
d += ax
g.setcell(x2, y2, state)
def is_there(x, y, gl):
l = len(gl)
for i in range(1, l, 2):
xg = gl[i - 1]
yg = gl[i]
if g.getcell(x + xg, y + yg) == 0:
return False
for i in range(1, l, 2):
xg = gl[i - 1]
yg = gl[i]
g.setcell(x + xg, y + yg, 0)
return True
def write_byte_at(addr, write_byte):
if addr < 11:
addr = addr
# elif addr > 32768:
# addr = 32768 - addr + 11
elif addr >= RAM_SIZE - RAM_NEGATIVE_BUFFER_SIZE:
addr = RAM_SIZE - addr + 10
elif addr >= 11:
addr = addr + RAM_NEGATIVE_BUFFER_SIZE
b_binary = "{:016b}".format(write_byte)
for i_bit, bit in enumerate(b_binary):
for x_offset in range(2):
g.setcell(p_init[0] + i_bit * delta_x + x_offset,
p_init[1] + addr * delta_y, d_bit2state[int(bit)])
def draw_line(x1, y1, x2, y2, state = 1):
# draw a line of cells in given state from x1,y1 to x2,y2
g.setcell(x1, y1, state)
if x1 == x2 and y1 == y2: return
dx = x2 - x1
ax = abs(dx) * 2
sx = 1
if dx < 0: sx = -1
dy = y2 - y1
ay = abs(dy) * 2
sy = 1
if dy < 0: sy = -1
if ax > ay:
d = ay - (ax / 2)
while x1 != x2:
g.setcell(x1, y1, state)
if d >= 0:
y1 += sy
d -= ax
x1 += sx
d += ay
else:
d = ax - (ay / 2)
while y1 != y2:
g.setcell(x1, y1, state)
if d >= 0:
x1 += sx
d -= ay
y1 += sy
d += ax
g.setcell(x2, y2, state)
def draw_line(x1, y1, x2, y2):
g.setcell(x1, y1, 1)
if x1 == x2 and y1 == y2: return
dx = x2 - x1
ax = abs(dx) * 2
sx = 1
if dx < 0: sx = -1
dy = y2 - y1
ay = abs(dy) * 2
sy = 1
if dy < 0: sy = -1
if ax > ay:
d = ay - (ax / 2)
while x1 != x2:
g.setcell(x1, y1, 1)
if d >= 0:
y1 += sy
d -= ax
x1 += sx
d += ay
else:
d = ax - (ay / 2)
while y1 != y2:
g.setcell(x1, y1, 1)
if d >= 0:
x1 += sx
d -= ay
y1 += sy
d += ax
g.setcell(x2, y2, 1)
def convbellman (text, stx, sty):
textln = text.split ('\n')
gen = -1
glcnt = -1
y = sty;
for ln in textln:
if not ln:
break
if ln [0] == '#':
if ln [0:35] == "#C Solution accepted at generation ":
gen = int (ln [35:])
elif ln [0:26] == "#C Glider count at accept ":
glcnt = int (ln [26:])
else:
x = stx;
for c in ln:
if c == '.':
g.setcell (x, y, 0)
x += 1;
elif c == '?':
g.setcell (x, y, 5)
x += 1;
elif c == '*':
g.setcell (x, y, 3)
x += 1;
elif c == '@':
g.setcell (x, y, 1)
x += 1;
y += 1
return (gen, glcnt)
def draw_line(x1, y1, x2, y2):
g.setcell(x1, y1, 1)
if x1 == x2 and y1 == y2: return
dx = x2 - x1
ax = abs(dx) * 2
sx = 1
if dx < 0: sx = -1
dy = y2 - y1
ay = abs(dy) * 2
sy = 1
if dy < 0: sy = -1
if ax > ay:
d = ay - (ax / 2)
while x1 != x2:
g.setcell(x1, y1, 1)
if d >= 0:
y1 += sy
d -= ax
x1 += sx
d += ay
else:
d = ax - (ay / 2)
while y1 != y2:
g.setcell(x1, y1, 1)
if d >= 0:
x1 += sx
d -= ay
y1 += sy
d += ax
g.setcell(x2, y2, 1)
def loadImage( path ): img = Image.open( path ) size = img.size c = None state = None for y in xrange( 0, size[1] ): for x in xrange( 0, size[0] ): c = img.getpixel( (x, y) ) if c[0] > 128: g.setcell( x, y, 1 )
def UpdateState(self, newPat, dx, dy): self.under = [] self.curPat = newPat self.dx = dx self.dy = dy for i in xrange(0, len(self.curPat), 2): if g.getcell(self.curPat[i] + self.dx, self.curPat[i + 1] + self.dy) == 1: self.under.append(self.curPat[i] + self.dx) self.under.append(self.curPat[i + 1] + self.dy) g.setcell(self.curPat[i] + self.dx, self.curPat[i + 1] + self.dy, 1) g.update()
def insert(self, g, g_xmin, g_xmax, g_ymin, g_ymax):
"""
Write the seed into the Golly grid at a random location
within the given bounds.
g = the Golly universe
s = a seed
"""
step = 1
g_xstart = rand.randrange(g_xmin, g_xmax - self.xspan, step)
g_ystart = rand.randrange(g_ymin, g_ymax - self.yspan, step)
for s_x in range(self.xspan):
for s_y in range(self.yspan):
g_x = g_xstart + s_x
g_y = g_ystart + s_y
s_state = self.cells[s_x][s_y]
g.setcell(g_x, g_y, s_state)
def draw_dna():
logging.debug('loading cell pallate')
pallate = cellPallate()
pallate.load()
logging.debug('getting default pallate selection')
chosenCell = pallate.getUserChoice()
chosenName = pallate.getSelectedCellName()
g.show('now drawing with DNA from '+chosenName)
logging.debug('now drawing with DNA from '+chosenName+'='+str(chosenCell))
# prepare environment
env = environment()
logging.debug('turning on golly even script access')
event = g.getevent(True) # turn on golly event script access
# === let user draw
g.setcursor("Draw")
try: #this try statement is just to ensure the 'finally' block is run
while True: # loop until stop button is pressed
event = g.getevent() # event is a string like "click 10 20 left none"
if len(event) < 1: # do not try to split empty string
continue
else:
logging.debug('event recieved: "'+event+'"')
evt, xstr, ystr, butt, mods = event.split()
if evt=="click" and butt=="left" and mods=="none": # left click
# logging.debug('left click detected at '+xstr+','+ystr)
x = int(xstr)
y = int(ystr)
env.cellList.setCell(x,y,cell=cell(x,y,chosenCell.DNA)) #add cell to list
g.setcell(x,y,1) #fill in functional cell
env.drawColor() #update color layer to match
g.update() #update golly display
logging.info('cell ('+xstr+','+ystr+') painted with "'+chosenName+'"')
g.show('cell painted. press "Esc" to stop drawing')
else:
logging.info('event "'+event+'" not recognized')
except: # re-raise any errors encountered
logging.error('unexpected error: '+sys.exc_info()[0])
raise
finally:
g.getevent(False) # return event handling to golly
g.show('done drawing '+chosenName+' cells.')
logging.debug('done drawing '+chosenName+' cells.')
# === teardown
env.teardown()
return
def UpdateState(self, newPat, dx, dy):
self.under = []
self.curPat = newPat
self.dx = dx
self.dy = dy
for i in xrange(0, len(self.curPat), 2):
if g.getcell(self.curPat[i] + self.dx,
self.curPat[i + 1] + self.dy) == 1:
self.under.append(self.curPat[i] + self.dx)
self.under.append(self.curPat[i + 1] + self.dy)
g.setcell(self.curPat[i] + self.dx, self.curPat[i + 1] + self.dy,
1)
g.update()
def getinp(s):
###########################
temp = g.getcell(x, y)
g.setcell(x, y, 5)
g.show(s + "Ptr:" + str(ptr) + " x:" + str(x) + " y:" + str(y))
g.fit()
g.update()
g.setcell(x, y, temp)
# return
k = g.getevent()
count = 0
while k == "":
sleep(.01)
k = g.getevent()
count += 1
if k == "key q none": g.exit()
return
def randfill_mash(rectcoords, amt, statemap):
newstate = g.getoption("drawingstate")
# g.note('%s'%statemap)
for i in range(rectcoords[0], rectcoords[0] + rectcoords[2]):
for j in range(rectcoords[1], rectcoords[1] + rectcoords[3]):
if (100 * random.random() < amt):
try:
g.show('processing %i,%i' % (i, j))
g.setcell(i, j, statemap[g.getcell(i, j)])
except:
dict_lc = [1] * g.numstates()
dict_lc[0] = 0
dict_lc[1:3] = [2, 2]
g.setcell(i, j, dict_lc[g.getcell(i, j)])
else:
# g.setcell(i, j, 0)
continue
def drawlines():
global oldline, firstcell
started = False
oldmouse = ""
while True:
event = g.getevent()
if event.startswith("click"):
# event is a string like "click 10 20 left altctrlshift"
evt, x, y, butt, mods = event.split()
oldmouse = x + ' ' + y
if started:
# draw permanent line from start pos to end pos
endx = int(x)
endy = int(y)
drawline(startx, starty, endx, endy)
# this is also the start of another line
startx = endx
starty = endy
oldline = []
firstcell = []
else:
# start first line
startx = int(x)
starty = int(y)
firstcell = [startx, starty, g.getcell(startx, starty)]
g.setcell(startx, starty, drawstate)
g.update()
started = True
g.show(
"Click where to end this line (and start another line)...")
else:
# event might be "" or "key m none"
if len(event) > 0: g.doevent(event)
mousepos = g.getxy()
if started and len(mousepos) == 0:
# erase old line if mouse is not over grid
if len(oldline) > 0:
eraseline(oldline)
oldline = []
g.update()
elif started and len(mousepos) > 0 and mousepos != oldmouse:
# mouse has moved, so erase old line (if any) and draw new line
if len(oldline) > 0: eraseline(oldline)
x, y = mousepos.split()
oldline = drawline(startx, starty, int(x), int(y))
oldmouse = mousepos
def drawlines():
global oldline, firstcell
started = False
oldmouse = ""
while True:
event = g.getevent()
if event.startswith("click"):
# event is a string like "click 10 20 left altctrlshift"
evt, x, y, butt, mods = event.split()
oldmouse = x + ' ' + y
if started:
# draw permanent line from start pos to end pos
endx = int(x)
endy = int(y)
drawline(startx, starty, endx, endy)
# this is also the start of another line
startx = endx
starty = endy
oldline = []
firstcell = []
else:
# start first line
startx = int(x)
starty = int(y)
firstcell = [ startx, starty, g.getcell(startx, starty) ]
g.setcell(startx, starty, drawstate)
g.update()
started = True
g.show("Click where to end this line (and start another line)...")
else:
# event might be "" or "key m none"
if len(event) > 0: g.doevent(event)
mousepos = g.getxy()
if started and len(mousepos) == 0:
# erase old line if mouse is not over grid
if len(oldline) > 0:
eraseline(oldline)
oldline = []
g.update()
elif started and len(mousepos) > 0 and mousepos != oldmouse:
# mouse has moved, so erase old line (if any) and draw new line
if len(oldline) > 0: eraseline(oldline)
x, y = mousepos.split()
oldline = drawline(startx, starty, int(x), int(y))
oldmouse = mousepos
def main(): # get selection and set to boundary bound = g.getselrect() if len( bound ) == 0: g.note( "No selection." ) g.exit() # get current Golly states left = bound[ 0 ] top = bound[ 1 ] width = bound[ 2 ] height = bound[ 3 ] for y in xrange( 0, height ): for x in xrange( 0, width ): state = g.getcell( left + x, top + y ) g.setcell( height - y - 600, x - 600, state )
def main(width, height, update):
w = width
h = height
x = 0
i = 0
while x < w:
y = 0
while y < h:
update = rules(x, y, update)
y += 1
x += 1
while i < w:
j = 0
while j < h:
g.setcell(i, j, update[i][j])
j += 1
i += 1
g.update()
return update
def write_program(program):
global program_tape_x, program_tape_y
# find all the labels
labels = [c[:-1] for c in program if c[-1] == ':']
iCurrentLabel = 0
for i, c in enumerate(program):
if 'jump_if_one:' in c:
write_string(jump_if_one)
jump = labels.index(c[c.index(':') + 1:]) + 1 - iCurrentLabel
if jump < 1:
jump -= 1
if jump > 1 and program[i + 1][-1] == ':':
jump -= 1
# (if next command is a label we don't need to jump so far)
if jump < 0:
write_string('0')
else:
write_string('1')
write_string('1' * abs(jump) + '0')
elif 'goto:' in c:
write_string(goto)
jump = labels.index(c[c.index(':') + 1:]) + 1 - iCurrentLabel
if jump < 1:
jump -= 1
if jump > 1 and program[i + 1][-1] == ':':
jump -= 1
# (if next command is a label we don't need to jump so far)
if jump < 0:
write_string('0')
else:
write_string('1')
write_string('1' * abs(jump) + '0')
elif c[-1] == ':':
# a label, make a mark on the marker tape
g.setcell(program_tape_x - 1, program_tape_y - 6, 1)
iCurrentLabel += 1
else:
# a normal command
write_string(c)
def write_program(program):
global program_tape_x, program_tape_y
# find all the labels
labels = [c[:-1] for c in program if c[-1]==':']
iCurrentLabel=0
for i,c in enumerate(program):
if 'jump_if_one:' in c:
write_string(jump_if_one)
jump = labels.index(c[c.index(':')+1:])+1-iCurrentLabel
if jump<1:
jump-=1
if jump>1 and program[i+1][-1]==':':
jump -= 1
# (if next command is a label we don't need to jump so far)
if jump<0:
write_string('0')
else:
write_string('1')
write_string('1'*abs(jump)+'0')
elif 'goto:' in c:
write_string(goto)
jump = labels.index(c[c.index(':')+1:])+1-iCurrentLabel
if jump<1:
jump-=1
if jump>1 and program[i+1][-1]==':':
jump -= 1
# (if next command is a label we don't need to jump so far)
if jump<0:
write_string('0')
else:
write_string('1')
write_string('1'*abs(jump)+'0')
elif c[-1]==':':
# a label, make a mark on the marker tape
g.setcell(program_tape_x-1,program_tape_y-6,1)
iCurrentLabel+=1
else:
# a normal command
write_string(c)
def write_byte_at(addr, write_byte):
if addr <= QFTASM_REGAREA_MAX_ADDRESS:
addr = addr
elif addr >= RAM_SIZE - RAM_NEGATIVE_BUFFER_SIZE:
addr = RAM_SIZE - addr + QFTASM_REGAREA_MAX_ADDRESS
elif addr > QFTASM_REGAREA_MAX_ADDRESS:
addr = addr + RAM_NEGATIVE_BUFFER_SIZE
b_binary = "{:016b}".format(write_byte)
for i_bit, bit in enumerate(b_binary):
for x_offset in range(2):
x_offset *= OTCAMP_SIZE
for x_p, y_p in write_offsets:
write_x = p_init[0] + i_bit * delta_x + x_offset + x_p
write_y = p_init[1] + addr * delta_y + y_p
write_value = int(bit)
g.setcell(write_x, write_y, write_value)
for x_p, y_p in write_offsets_inv:
write_x = p_init[0] + i_bit * delta_x + x_offset + x_p
write_y = p_init[1] + addr * delta_y + y_p
write_value = 1 - int(bit)
g.setcell(write_x, write_y, write_value)
def tile_rom_demultiplexer_body(
l_binstring,
d_pattern=d_patterns_rom_demultiplexer["d_pattern_mpx_body"],
xoffset=0,
h_repeats=N_BITS_ROM):
p_init = d_pattern["init"]
p_init = (p_init[0] + xoffset, p_init[1])
delta_x, delta_y = d_pattern["delta"]
# h_repeats, v_repeats = d_pattern["repeats"]
v_repeats = d_pattern["repeats"][1]
reverse_bitarray = d_pattern["reverse_bitarray"]
method = d_pattern["method"] if "method" in d_pattern.keys() else "copy"
for i_addr, (lineno, _) in enumerate(l_binstring):
if type(lineno) == int:
bitarray = ("{:0" + str(h_repeats) + "b}").format(lineno)
else:
bitarray = lineno
if reverse_bitarray:
bitarray = list(reversed(bitarray))
for i_bit, bit in enumerate(bitarray):
if bit == " ":
continue
d_pattern[bit].put(p_init[0] + delta_x * i_bit,
p_init[1] + i_addr * delta_y,
A=(1, 0, 0, 1, method))
if bit == "-":
g.setcell(p_init[0] + delta_x * i_bit + 3,
p_init[1] + i_addr * delta_y + 8, 0)
if "footer" in d_pattern.keys():
d_footer = d_pattern["footer"]
# Get the offset stored in "init" first, and then overwrite it
x_offset_footer, y_offset_footer = d_footer["init_init"]
d_footer["init"] = (p_init[0] + x_offset_footer,
p_init[1] + i_addr * delta_y + y_offset_footer)
tile_pattern(d_footer, h_repeats=h_repeats)
def getobject(x, y):
object = []
ncells.append( (x, y, g.getcell(x,y)) )
g.setcell(x, y, 0)
while len(ncells) > 0:
# remove cell from end of ncells and append to object
x, y, s = ncells.pop()
object.append(x)
object.append(y)
object.append(s)
# add any live neighbors to ncells
checkneighbor(x , y+1)
checkneighbor(x , y-1)
checkneighbor(x+1, y )
checkneighbor(x-1, y )
checkneighbor(x+1, y+1)
checkneighbor(x+1, y-1)
checkneighbor(x-1, y+1)
checkneighbor(x-1, y-1)
# append padding int if necessary
if len(object) > 0 and (len(object) & 1) == 0: object.append(0)
g.putcells(object)
return object
def drawline(x1, y1, x2, y2):
# draw a line of cells from x1,y1 to x2,y2 using Bresenham's algorithm;
# we also return the old cells in the line so we can erase line later
oldcells = []
# note that x1,y1 has already been drawn
# oldcells.append( (x1, y1, g.getcell(x1, y1)) )
# g.setcell(x1, y1, drawstate)
if x1 == x2 and y1 == y2:
g.update()
return oldcells
dx = x2 - x1
ax = abs(dx) * 2
sx = 1
if dx < 0: sx = -1
dy = y2 - y1
ay = abs(dy) * 2
sy = 1
if dy < 0: sy = -1
if ax > ay:
d = ay - (ax / 2)
while x1 != x2:
oldcells.append( (x1, y1, g.getcell(x1, y1)) )
g.setcell(x1, y1, drawstate)
if d >= 0:
y1 += sy
d -= ax
x1 += sx
d += ay
else:
d = ax - (ay / 2)
while y1 != y2:
oldcells.append( (x1, y1, g.getcell(x1, y1)) )
g.setcell(x1, y1, drawstate)
if d >= 0:
x1 += sx
d -= ay
y1 += sy
d += ax
oldcells.append( (x2, y2, g.getcell(x2, y2)) )
g.setcell(x2, y2, drawstate)
g.update()
return oldcells
def putcells(outfile, dxy):
dx, dy = dxy
tileCount = -1
maxTileX = -1
maxTileY = -1
with open(outfile, "r") as data:
for line in data:
if tileCount >= 0:
chars = list(line)
for x in xrange(0, len(chars)):
ch = chars[x]
if ch == '@':
g.setcell(dx + tileDX + x, dy + tileCount + tileDY, 1)
if ch == '*':
g.setcell(dx + tileDX + x, dy + tileCount + tileDY, 3)
if ch == '?':
g.setcell(dx + tileDX + x, dy + tileCount + tileDY, 5)
tileCount += 1
if line.startswith("#S"):
continue
if line.startswith("#P"):
vals = line.split()
tileDX = int(vals[1])
tileDY = int(vals[2])
tileCount = 0
if tileDX > maxTileX:
maxTileX = tileDX
if tileDY > maxTileY:
maxTileY = tileDY
return (maxTileX, maxTileY)
# lower triangle
pixels[row][(encode(color,state,dir)-1)*15+column] = \
[palette[0],bg_color,fg_color][lower[dir][row][column]]
# upper triangle
pixels[row][(encode(color,state,dir)+total_states-2)*15+column] = \
[palette[0],bg_color,fg_color][lower[2-dir][13-row][column]]
# draw the 7x7 icon
for row in range(7):
for column in range(7):
# lower triangle
pixels[15+row][(encode(color,state,dir)-1)*15+column] = \
[palette[0],bg_color,fg_color][lower7x7[dir][row][column]]
# upper triangle
pixels[15+row][(encode(color,state,dir)+total_states-2)*15+column] = \
[palette[0],bg_color,fg_color][lower7x7[2-dir][6-row][column]]
ConvertTreeToRule(rule_name, total_states, pixels)
else:
golly.warn('Too many states!')
golly.exit()
# -- select the rule --
golly.new(rule_name+'-demo.rle')
golly.setalgo('RuleLoader')
golly.setrule(rule_name)
golly.setcell(0,0,encode(0,0,0)) # start with a single turmite
golly.show('Created '+rule_name+'.rule and selected that rule.')
bg_col = palette[color]
fg_col = palette[state+n_colors]
mid = [(f+b)/2 for f,b in zip(fg_col,bg_col)]
for x in range(15):
for y in range(15):
column = (encode(color,state,dir)-1)*15 + rotate4[dir][0][0]*x + \
rotate4[dir][0][1]*y + offset4[dir][0]*14
row = rotate4[dir][1][0]*x + rotate4[dir][1][1]*y + offset4[dir][1]*14
pixels[row][column] = [bg_col,fg_col,eyes,mid][ant15x15[y][x]]
for x in range(7):
for y in range(7):
column = (encode(color,state,dir)-1)*15 + rotate4[dir][0][0]*x + \
rotate4[dir][0][1]*y + offset4[dir][0]*6
row = 15 + rotate4[dir][1][0]*x + rotate4[dir][1][1]*y + offset4[dir][1]*6
pixels[row][column] = [bg_col,fg_col,eyes,mid][ant7x7[y][x]]
for color in range(n_colors):
bg_col = palette[color]
for row in range(15):
for column in range(15):
pixels[row][(color-1)*15+column] = bg_col
for row in range(7):
for column in range(7):
pixels[15+row][(color-1)*15+column] = bg_col
WriteBMP(pixels,golly.getdir('rules')+rule_name+'.icons')
# now we can switch to the new rule
golly.setrule(rule_name)
golly.new(rule_name+' demo')
golly.setcell(0,0,n_colors+3) # start with an ant facing west
golly.show('Created '+rule_name+'.tree, and selected this rule.')
def eraseline(oldcells):
for t in oldcells:
x, y, s = t
g.setcell(x, y, s)
if started and len(mousepos) == 0:
# erase old line if mouse is not over grid
if len(oldline) > 0:
eraseline(oldline)
oldline = []
g.update()
elif started and len(mousepos) > 0 and mousepos != oldmouse:
# mouse has moved, so erase old line (if any) and draw new line
if len(oldline) > 0: eraseline(oldline)
x, y = mousepos.split()
oldline = drawline(startx, starty, int(x), int(y))
oldmouse = mousepos
# ------------------------------------------------------------------------------
g.show("Click where to start line...")
oldcursor = g.getcursor()
g.setcursor("Draw")
drawstate = g.getoption("drawingstate")
oldline = []
firstcell = [] # pos and state of the 1st cell clicked
try:
drawlines()
finally:
g.setcursor(oldcursor)
if len(oldline) > 0: eraseline(oldline)
if len(firstcell) > 0:
x, y, s = firstcell
g.setcell(x, y, s)
g.update()
# also allow keyboard interaction
g.dokey( g.getkey() )
for col in xrange(r.left, r.left + r.width):
if g.getcell(col, row)==1:
tape += extend*(4+col-r.left) + extend_left + extend*(r.top+r.height-row)
tape += mark
tape += retract*(r.top+r.height-row) + retract_left + retract*(4+col-r.left)
elif g.getcell(col,row)!=0:
g.exit('Cells in the selected area must be in states 0 or 1 only.')
# finally we sheath and trigger and retract
tape += extend_left + extend*4 + extend_right + extend
tape += inject_sheath + '1'*50 + inject_trigger
tape += retract*2 + retract_right + retract*4 + retract_left
# now write the tape out
x = r.left+r.width+10
y = r.top+r.height+10
g.setcell(x+1,y,2)
for i in tape:
g.setcell(x,y-1,2)
g.setcell(x,y,int(i))
g.setcell(x,y+1,2)
x-=1
g.exit("Percentage must be from 0 to 100.")
if minlive < 1 or minlive > maxlive:
g.exit("Minimum state must be from 1 to " + str(maxlive) + ".")
if len(pmm) > 2:
if not validint(pmm[2]):
g.exit("Bad maxstate value: " + pmm[2])
i = int(pmm[2])
if i < minlive:
g.exit("Maximum state must be >= minimum state.")
if i > maxlive:
g.exit("Maximum state must be <= " + str(maxlive) + ".")
maxlive = i
else:
maxlive = minlive
oldsecs = time()
for row in xrange(r.top, r.top + r.height):
for col in xrange(r.left, r.left + r.width):
if randint(0, 99) < perc:
if minlive == maxlive:
g.setcell(col, row, minlive)
else:
g.setcell(col, row, randint(minlive, maxlive))
else:
g.setcell(col, row, 0)
# if large selection then give some indication of progress
newsecs = time()
if newsecs - oldsecs >= 1.0:
oldsecs = newsecs
g.update()
# 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)
def RemoveList(listXY):
for xy in listXY:
x = xy[0]
y = xy[1]
g.setcell(x, y, 0)
# Invert all cell states in the current selection. # Author: Andrew Trevorrow ([email protected]), Jun 2006. # Updated to use exit command, Nov 2006. # Updated to use numstates command, Jun 2008. from glife import rect from time import time import golly as g r = rect( g.getselrect() ) if r.empty: g.exit("There is no selection.") oldsecs = time() maxstate = g.numstates() - 1 for row in xrange(r.top, r.top + r.height): # if large selection then give some indication of progress newsecs = time() if newsecs - oldsecs >= 1.0: oldsecs = newsecs g.update() # also allow keyboard interaction g.dokey( g.getkey() ) for col in xrange(r.left, r.left + r.width): g.setcell(col, row, maxstate - g.getcell(col, row)) if not r.visible(): g.fitsel()
