User:Danf/TurtleGraphics

# turtlife.py - Artistic License w/ Attribution -> "(evil) Dan of MOISEBRIDGE"
# note: press 'n' to advance frame, 'r' to run, 'p' to pause

from turtle import Screen, Turtle, mainloop
from itertools import count, islice, product, repeat, starmap
from collections import deque
from random import choice, randint
from time import sleep

class Logic(object):
  def __init__(self, rules=None):
    self.rules = rules
  def evaluate(self, o=None):
    ret = None
    if self.rules == 'life':
      ret = self.evaluate_life(o)
    elif self.rules == 'prime':
      ret = self.evaluate_prime(o)
    else:  # random  
      ret = (choice((0, 1)), choice(range(0, 9))) 
    return ret
  def evaluate_life(self, o):
    n = o.neighborsum()
    if n == 2:
      destiny = o.binary_val
    elif n == 3:
      destiny = 1
    else:
      destiny = 0
    return (destiny, n)
  def evaluate_prime(self, o):
    n = o.neighborsum()
    if n in (2, 3):
      destiny = 1
    elif n in (5, 7):
      destiny = o.binary_val
    else:
      destiny = 0
    return (destiny, n)
  def toggle(self):
    if self.rules == 'life':
      self.rules = 'prime'
    elif self.rules == 'prime':
      self.rules = 'life'
    else:
      self.rules = choice(('prime', 'life')) 

class Cell(object):
  def __init__(self, colony, row, col):
    self.colony = colony
    self.row = row
    self.col = col
    self.binary_val = 0
    self.cause = 0
    self.logic = colony.logic
    self._neighbors = None
  def neighbors(self):
    if self._neighbors is None:
      self._neighbors = list(starmap(
        lambda x, y: self.colony.cells[x * self.colony.cols + y],
        self.colony.neighborhood(self.row, self.col) ))
    return self._neighbors
  def neighborsum(self):
    return sum(o.binary_val for o in self.neighbors())
  def destiny(self):
    effect, cause = self.logic.evaluate(self)
    return (effect, cause)
  def update(self, effect=None, cause=None):
    if effect is not None:
      self.binary_val = 1 if effect else 0
    if cause is not None:
      self.cause = cause
    return self.binary_val

class Colony(object):
  def __init__(self, rules, displaymode, rows, cols):
    self.logic = Logic(rules)
    self.rows = rows
    self.cols = cols
    self.cells = list(starmap(
      lambda x, y: Cell(self, x, y),
      product(range(rows), range(cols)) ))
    self.state = State(self)
    self.display = ColonyDisplay(self, displaymode)
  def neighborhood(self, row, col):
    up = row - 1 if row else self.rows - 1
    down = row + 1 if row < self.rows - 1 else 0
    left = col - 1 if col else self.cols - 1
    right = col + 1 if col < self.cols - 1 else 0
    return ( (up, left), (up, col), (up, right),
             (row, left),             (row, right),
             (down, left), (down, col), (down, right) )
  def randomize(self):
    orig_rules = self.logic.rules
    self.logic.rules = 'random'
    self.update() 
    self.logic.rules = orig_rules
  def update(self, sync=True):
    self.state.update()
    self.display.update()

class ColonyDisplay(object):
  def __init__(self, colony, displaymode):
    self.displaymode = displaymode
    self.cells = colony.cells
    self.textdisplay = lambda: colony.state.displaystring()
    self.turtles = list(starmap(
      lambda x, y: ColonialTurtle(colony, x, y),
      product(range(colony.rows), range(colony.cols)) ))
  def update(self):
    print(self.textdisplay()) 
    self.turtledisplay() 
  def turtledisplay(self):
    for c, t in zip(self.cells, self.turtles):
      if c.binary_val:
        if c.cause == 2:
          t.set_rgb('blue')
        elif c.cause == 3:
          t.set_rgb('green')
        elif c.cause == 5:
          t.set_rgb('yellow')
        elif c.cause == 7:
          t.set_rgb('red')
      else:
        if self.displaymode == 'ambient':
          t.set_rgb(t.ambience())
        elif self.displaymode == 'fade':
          t.set_rgb(0.618)
        else:
          t.set_rgb('black')

class State(object):
  def __init__(self, colony):
    self.colony = colony
    self.context = None
    self.lookback = 1000
    self.gen = 0
    self.history = deque(maxlen=self.lookback)
    self.cycle_detector = None
  def bitvals(self):
    bits = 0
    for o in self.colony.cells:
      bits <<= 1
      bits += o.binary_val
    return bits
  def update_context(self):
    prev_context = self.context
    self.context = (self.colony.logic.rules, self.colony.rows, self.colony.cols)
    return (self.context, prev_context)
  def memorialize(self):
    current, prev = self.update_context()
    if current != prev:
      self.history.append((self.gen, (current, prev)))
    self.history.append((self.gen, self.bitvals()))
  def update(self, sync=True):
    dst = (x.destiny() for x in self.colony.cells)
    for c, d in zip(self.colony.cells, list(dst) if sync else dst):
      effect, cause = d
      c.update(effect, cause)
    self.memorialize()
    self.gen += 1
  def smash(self):
    self.history.clear()
    self.gen = 0
  def dump(self):
    cur, prev = None, None
    print('history:')
    for gen, entry in self.history:
      if type(entry) == tuple:  # context
        cur, prev = entry
      else:
        print(cur, gen)
        print(self.bitstring(entry))  
  def cycler(self):
    if self.cycle_detector:  # toggle
      self.cycle_detector = None
      ret = None
    else:
      self.cycle_detector = dict()
      ret = self.cycler_check_history()
    return ret
  def cycler_check_history(self):
    cycle_found = None
    for gen, entry in self.history:
      if type(entry) == tuple:  # context
        continue
      regen = self.cycler_check_entry(gen, entry)
      if gen != regen:
        cycle_found = regen
        break
    return cycle_found
  def cycler_check_entry(self, gen, entry):
    if entry in self.cycle_detector:  # key via history <- self.bitvals()
      ret = self.cycle_detector[entry]
    else:
      self.cycle_detector[entry] = gen
      ret = gen
    return ret
  def bitstring(self, bits=None, wrapped=True):
    if bits is None:
      bits = self.bitvals()
    s = '{0:0{n}b}'.format(bits, n=len(self.colony.cells))
    if wrapped:
      s = '\n'.join(map(
        lambda x: s[x:x+self.colony.cols],
        range(0, len(s), self.colony.cols) ))
    return s
  def displaystring(self, which=-1):
    gen, entry = self.history[which]
    if which == -1:
      cur = self.context
    while type(entry) == tuple:  # context
      cur, prev = entry
      which -= 1
      if which + len(d) < 0:
        return ""
      gen, entry = self.history[which]
    s = ' '.join((str(cur), str(gen)))
    return '\n'.join((s, self.bitstring(entry).replace('1','o').replace('0',' ')))

class ColonialTurtle(Turtle):
  def __init__(self, colony, row, col):
    Turtle.__init__(self)
    self.colony = colony
    self.row = row
    self.col = col
    self.speed(0)
    self.shape("turtle")
    self.settiltangle(45)
    self.resizemode("user")
    self.shapesize(1, 1, 0)
    self.penup()
    self.setx(col)
    self.sety(row)
    self.colors = dict( (
      ( 'black', (0.0, 0.0, 0.0) ),
      ( 'grey50', (0.5, 0.5, 0.5) ),
      ( 'white', (1.0, 1.0, 1.0) ),
      ( 'red', (0.7, 0.0, 0.0) ),
      ( 'yellow', (0.7, 0.7, 0.0) ),
      ( 'green', (0.0, 0.7, 0.0) ),
      ( 'blue', (0.0, 0.0, 0.7) ) ) )
    self.set_rgb('black')
    self._neighbors = None
  def neighbors(self):
    if self._neighbors is None:
      self._neighbors = list(starmap(
        lambda x, y: self.colony.display.turtles[x * self.colony.cols + y],
        self.colony.neighborhood(self.row, self.col) ))
    return self._neighbors
  def set_rgb(self, c):
    otype = type(c)
    if otype is float:
      for i in range(3):
        self.rgb[i] *= c
    else:
      if otype is str:
        c = self.colors[c]
      self.rgb = list(c)
    self.color(self.rgb)
  def avg_rgb(self, turtles):
    rgb = [0.0, 0.0, 0.0]
    n = len(turtles)
    for t in turtles:
      for i in range(3):
        rgb[i] += t.rgb[i]
    return map(lambda x: x/n, rgb)
  def ambience(self):
    return self.avg_rgb(self.neighbors())

class ScreenRunner(object):
  def __init__(self, rules='prime', displaymode='ambient', delay=0, rows=16, cols=32):
    self.delay_milliseconds = delay
    self.screen = self.initscreen(rows, cols)
    self.colony = Colony(rules, displaymode, rows, cols) 
    self.randomize()
    self.run()
  def initscreen(self, rows, cols):
    screen = Screen()
    screen.delay(0)
    offset = map(lambda x: x - 0.3, (0, rows, cols, 0))
    screen.setworldcoordinates(*offset)
    screen.bgcolor(0.0, 0.0, 0.0)
    screen.tracer(n=rows*cols)
    self.bindkeys(screen)
    return screen
  def bindkeys(self, screen):
    screen.onkey(self.cycle_detection, 'c')
    screen.onkey(self.dump, 'd')
    screen.onkey(self.mode, 'm')
    screen.onkey(self.next, 'n')
    screen.onkey(self.pause, 'p')
    screen.onkey(self.run, 'r')
    screen.onkey(self.smash, 's')
    screen.onkey(self.randomize, 'x')
    screen.onkey(self.quit, 'q')
    screen.listen()
  def cycle_detection(self):
    detected = self.colony.state.cycler()
    if detected is not None:
      print('cycle detected - gen ', detected)
  def dump(self):
    self.colony.state.dump()
  def mode(self):
    self.colony.logic.toggle()
    self.colony.update()
  def next(self):
    self.colony.update()
  def pause(self):
    self.running = False
  def run(self):
    self.running = True
    self.timer()
  def randomize(self):
    self.colony.randomize()
  def smash(self):
    self.colony.state.smash()
  def quit(self):
    exit()
  def timer(self, delay=None):
    if delay is None:
      delay = self.delay_milliseconds
    if self.running:
      self.next()
      self.screen.ontimer(lambda: self.timer(delay), delay)

def main():
  ScreenRunner(rules='prime', displaymode='ambient', delay=0, rows=17, cols=23)   # delay in milliseconds 
  return "EVENTLOOP"

if __name__ == "__main__":
  msg = main()
  print(msg)
  mainloop()