L-Systems 0.0.5

from turtle import *

#Version 0.0.5 by J.B. Wincek
#The next version will be 0.1.0 which will be code clean up and comments
#Changes from version 0.0.4: added in fractal Plant based grammar


axiomA='A'
rulesA = {}
rulesA['A'] = 'AB'
rulesA['B'] = 'A'

axiomB='B'
rulesB = {}
rulesB['B'] = 'BA'
rulesB['A'] = 'B'

axiomF='F'
rulesF = {}
rulesF['F'] = 'F+F-F-F+F'
turtleRulesF = {}
turtleRulesF['F'] = 'forward(10)'
turtleRulesF['+'] = 'left(90)'
turtleRulesF['-'] = 'right(90)'

axiomS='A'
rulesS = {}
rulesS['A'] = 'B-A-B'
rulesS['B'] = 'A+B+A'
turtleRulesS = {}
turtleRulesS['A'] = 'forward(3)'
turtleRulesS['B'] = 'forward(3)'
turtleRulesS['+'] = 'left(60)'
turtleRulesS['-'] = 'right(60)'

axiomD='FX'
rulesD={}
rulesD['X']='X+YF'
rulesD['Y']='FX-Y'
turtleRulesD={}
turtleRulesD['F'] = 'forward(3)'
turtleRulesD['-'] = 'left(90)'
turtleRulesD['+'] = 'right(90)'
turtleRulesD['X'] = 'nul'
turtleRulesD['Y'] = 'nul'

axiomP='X'
positionHash = ()
positionHeap = []
rulesP={}
rulesP['X']='F-[[X]+X]+F[+FX]-X'
rulesP['F']='FF'
turtleRulesP={}
turtleRulesP['F'] = 'forward(3)'
turtleRulesP['-'] = 'left(25)'
turtleRulesP['+'] = 'right(25)'
turtleRulesP['X'] = 'nul'
turtleRulesP['['] = """positionHeap.append(hashPosition())"""
turtleRulesP[']'] = 'restorePosition(positionHeap.pop())'

def hashPosition():
    output = ()
    output = output + pos()
    output = (output, heading())
    return output

def restorePosition(hashed):
    pu()
    setx(int(hashed[0][0]))
    sety(int(hashed[0][1]))
    setheading(hashed[1])
    pd()
    return hashed

def compose(axiom, rules):
        output = ""
        for i in axiom:
            output = output + rules.get(i,i)
        return output

def iterate(axiom,rules, times):
    output = ''
    if times == 0:
        output = axiom
    else:
        return iterate(compose(axiom, rules), rules, times -1)
    return output

# format for evaluate ( <which axiom to use>,
#                       <which rule set to use> ,
#                       < which ruleset for turtle navigation> ,
#                       <how many iterations>)
def evaluate(axiom,rules,turtleRules,times):
    for words in iterate(axiom,rules,times):
        if turtleRules[words] != 'nul':
            exec(turtleRules[words])

#print iterate(axiomA,rulesB,6)
#print iterate(axiomB,rulesA,6)
#directions = iterate(axiomF,rulesF,3)
#print directions

screensize(210,210)

speed(0)
pu()
setx(200)
sety(-200)
left(90)
pd()
color('red','yellow')
#begin_fill()
#evaluate(axiomS,rulesS,turtleRulesS,6)
#evaluate(axiomD,rulesD,turtleRulesD,14)
#testString = "newHash = hashPosition()"
#exec(testString)
#print newHash

evaluate(axiomP,rulesP,turtleRulesP,6)

#end_fill()
done()

#special thanks to http://www.4dsolutions.net/ocn/lsystems.html