# -*- coding: utf-8 -*-
from turtle import *

# Génération de plante par grammaire L-system

def initialisation():
    # Définition des variables indépendantes de la grammaire
    global nbiteration, longueur
    # Pour le flocon de Koch
    nbiteration = 3
    longueur = 2
    
    # Pour le flocon de Koch Island
    #nbiteration = 3
    #longueur = 2
    
    # Pour la plante
    #nbiteration = 5
    #longueur = 5
    
    # Pour la plante 2
    #nbiteration = 5
    #longueur = 5
    
    # Pour la plante 3
    #nbiteration = 5
    #longueur = 3

def grammaire():
    # Définition de la grammaire
    # Pour le flocon de  Koch
    angle = 90
    axiom = 'F-F-F-F'
    regle = 'F+F-F-F+F'
    
    # Pour le flocon de Koch Island
    #angle = 90
    #axiom = 'F-F-F-F'
    #regle = 'F-F+F+FF-F-F+F'
    
    # Pour la plante
    #angle = 25.7
    #axiom = 'F'
    #regle = 'F[+F]F[-F]F'
    
    # Pour la plante 2
    #angle = 20
    #axiom = 'F'
    #regle = 'F[+F]F[-F][F]'
    
    # Pour la plante 3
    #angle = 22.5
    #axiom = 'F'
    #regle = 'FF-[-F+F+F]+[+F-F-F]'
    return angle, axiom, regle
    
def production(axiom, regle):
    # Génération de la chaine de caractères
    i = 0
    while i < nbiteration:
        j = 0
        axiom2 = ''
        while j < len(axiom):
            pointeur1 = axiom[j]
            
            # Symboles non terminaux
            if pointeur1 == 'F':
                # remplacement de la règle dans l'axiome
                axiom2 = axiom2 + regle
                
            # Symboles terminaux
            if pointeur1 == '+':
                axiom2 = axiom2 + '+'
            if pointeur1 == '-':
                axiom2 = axiom2 + '-'
            if pointeur1 == '[':
                axiom2 = axiom2 + '['
            if pointeur1 == ']':
                axiom2 = axiom2 + ']'
            
            j = j + 1
        axiom = axiom2
        i = i + 1
    print axiom
    return axiom
    
def interpretation(angle, axiom):
    # Interprétation de la chaine par turtle
    k = 0
    laposition = []
    langle = []
    while k < len(axiom):
        pointeur2 = axiom[k]
        
        # Interpréation
        if pointeur2 == 'F':
            forward(longueur)
        elif pointeur2 == '+':
            left(angle)
        elif pointeur2 == '-':
            right(angle)
        elif pointeur2 == '[':
            # mémorisation de la position courante
            laposition.append(position())
            langle.append(heading())
        elif pointeur2 == ']':
            # retour à la dernière position et suppression de celle-ci
            up()
            goto(laposition[len(laposition)-1][0], laposition[len(laposition)-1][1])
            del laposition[len(laposition)-1]
            setheading(langle[len(langle)-1])
            del langle[len(langle)-1]
            down()
            
        k = k + 1

# Placement initial de la tortue
up()
backward(400)
down()

# Programme principal
## gram[0] retourne l'angle
## gram[1] retourne l'axiome
## gram[2] retourne la règle

initialisation()
gram = grammaire()
axio = production(gram[1], gram[2])
interpretation(gram[0], axio)

#quit()