import turtle
import sys
sys.setrecursionlimit(1000000)

def draw_square(t, size):
    
    t.forward(size / 2)
    t.left(90)
    t.forward(size)
    t.left(90)
    t.forward(size)
    t.left(90)
    t.forward(size)
    t.left(90)
    t.forward(size / 2)

# draw_square(turtle, 100)

def draw_recursive_stairs(t, size, steps):
    if steps == 0:
        return
    t.left(90)
    t.forward(size)
    t.right(90)
    t.forward(size)
    draw_recursive_stairs(t, size, steps - 1)

# draw_recursive_stairs(turtle, 20, 5)

def draw_recursive_tree(t, size, größe):
    if größe == 0:
        return
    t.forward(size)
    t.left(30)
    draw_recursive_tree(t, size * 0.7, größe - 1)
    t.right(60)
    draw_recursive_tree(t, size * 0.7, größe - 1)
    t.left(30)
    t.backward(size)
#turtle.left(90)
#draw_recursive_tree(turtle, 100, 5)


# Ich möchte einen Code schreiben der erst ein 64 Quadrat zeichnet 
# und dann rekursiv immer zwei halb so große Quadrate oben links und rechts über das ursprüngliche Quadrat zeichnet. 
# Bis die Seitenlänge = 1 ist.
# Es soll nur eine Turtle geben, die wiederverwendet wird.


def draw_recursive_squares(t, length, x, y):
    if length < 1:
        draw_recursive_squares(t, length / 2, x - length * 2.5, y + length * 2.5)
        return
    x = t.xcor()
    y = t.ycor()

        
    t.penup()
    t.goto(x + length * 1.5 , y + length * 2.5)
    t.pendown()
    
    
    draw_square(t, length)
    
    

    draw_recursive_squares(t, length / 2, x - length * 2.5, y + length * 2.5)
#square = draw_square(turtle, 64)    
#turtle.speed(10)
#draw_recursive_squares(turtle, 32, 0,0)


t = turtle.Turtle()
t.speed(2000)
#t.speed(0)

def square_recursion(t, length, x, y):
    if length < 8:
        return
    print(length)
    t.penup()
    t.goto(x, y)
    t.pendown()
    draw_square(t, length)
    square_recursion(t, length / 2, x - length * 1.5, y + length * 1.5)
    square_recursion(t, length / 2, x + length * 1.5, y + length * 1.5)


#square_recursion(t, 64, 0, 0) 
#turtle.done()

# Jetzt möchte ich eine Kochkurve zeichnen, die rekursiv immer kleinere Dreiecke zeichnet.
def draw_koch_Kurve(t, length, depth):
    if depth == 0:
        t.forward(length)
        return
    t.forward(length / 3)
    t.left(60)
    draw_koch_Kurve(t, length / 3, depth - 1)
    t.right(120)
    draw_koch_Kurve(t, length / 3, depth - 1)
    t.left(60)
    draw_koch_Kurve(t, length / 3, depth - 1)

draw_koch_Kurve(t, 300, 10)