Python integra el módulo turtle, una herramienta clásica para dibujar gráficos vectoriales mediante instrucciones simples. Combinado con conceptos como recursividad, números aleatorios y funcionse trigonométricas, permite ganerar escenas naturales como un árbol cuyas hojas se desprenden con el viento. A continuación se explica paso a paso cómo lograrlo.

Fundamentos de Turtle

El módulo turtle emula una tortuga que se desplaza sobre un lienzo dejando un rastro. Con comandos como forward(), right(), pencolor() y pensize() se controla su movimiento y apariencia. Al ser parte de la biblioteca estándar, no requiere instalación adicional.

Estructura del programa

El proyecto se basa en una función recursiva que dibuja las ramas y, al llegar al nivel máximo, genera hojas. Además, con cierta probabilidad, algunas hojas se dibujan en posiciones aleatorias simulando una caída.

Las importaciones necesarias:

from turtle import *
from random import *
from math import *

Función recursiva para el árbol

Se define arbol(nivel, largo) donde nivel controla la profundidad de la recursión y largo la longitud de la rama actual.

def arbol(nivel, largo):
    pd()
    factor_color = cos(radians(heading() + 45)) / 8 + 0.25
    pencolor(factor_color, factor_color, factor_color)
    pensize(nivel / 3)
    forward(largo)
    
    if nivel > 0:
        ang_der = random() * 15 + 10
        ang_izq = random() * 15 + 10
        nuevo_largo = largo * (random() * 0.25 + 0.7)
        right(ang_der)
        arbol(nivel - 1, nuevo_largo)
        left(ang_der + ang_izq)
        arbol(nivel - 1, nuevo_largo)
        right(ang_izq)
    else:
        # Dibujar hoja en la punta
        right(90)
        tinte = cos(radians(heading() - 45)) / 4 + 0.5
        pencolor(tinte, tinte * 0.8, tinte * 0.8)
        circle(3)
        left(90)
        # Probabilidad de hoja cayendo
        if random() > 0.7:
            pu()
            direccion_original = heading()
            angulo_caida = -40 + random() * 40
            setheading(angulo_caida)
            distancia = int(800 * random() * 0.5 + 400 * random() * 0.3 + 200 * random() * 0.2)
            forward(distancia)
            setheading(direccion_original)
            pd()
            right(90)
            color_hoja = cos(radians(heading() - 45)) / 4 + 0.5
            pencolor(color_hoja * 0.5 + 0.5, 0.4 + color_hoja * 0.4, 0.4 + color_hoja * 0.4)
            circle(2)
            left(90)
            pu()
            setheading(angulo_caida)
            backward(distancia)
            setheading(direccion_original)
    pu()
    backward(largo)

El cálculo del color aprovecha el coseno del ángulo de la tortuga para crear un degradado gris en las ramas y tonos rosados en las hojas. La recursión genera bifurcaciones con ángulos y longitudes variables gracias a random().

Configuración inicial y ejecución

bgcolor(0.5, 0.5, 0.5)
ht()
speed(0)
pu()
backward(100)
left(90)
pu()
backward(300)
arbol(12, 100)
done()

Se define un fondo gris, se oculta la tortuga, se coloca en la posición inicial y se invoca la función con 12 niveles de profundidad y una longitud inicial de 100 píxeles.

Código completo

from turtle import *
from random import *
from math import *

def arbol(nivel, largo):
    pd()
    factor_color = cos(radians(heading() + 45)) / 8 + 0.25
    pencolor(factor_color, factor_color, factor_color)
    pensize(nivel / 3)
    forward(largo)
    
    if nivel > 0:
        ang_der = random() * 15 + 10
        ang_izq = random() * 15 + 10
        nuevo_largo = largo * (random() * 0.25 + 0.7)
        right(ang_der)
        arbol(nivel - 1, nuevo_largo)
        left(ang_der + ang_izq)
        arbol(nivel - 1, nuevo_largo)
        right(ang_izq)
    else:
        right(90)
        tinte = cos(radians(heading() - 45)) / 4 + 0.5
        pencolor(tinte, tinte * 0.8, tinte * 0.8)
        circle(3)
        left(90)
        if random() > 0.7:
            pu()
            direccion_original = heading()
            angulo_caida = -40 + random() * 40
            setheading(angulo_caida)
            distancia = int(800 * random() * 0.5 + 400 * random() * 0.3 + 200 * random() * 0.2)
            forward(distancia)
            setheading(direccion_original)
            pd()
            right(90)
            color_hoja = cos(radians(heading() - 45)) / 4 + 0.5
            pencolor(color_hoja * 0.5 + 0.5, 0.4 + color_hoja * 0.4, 0.4 + color_hoja * 0.4)
            circle(2)
            left(90)
            pu()
            setheading(angulo_caida)
            backward(distancia)
            setheading(direccion_original)
    pu()
    backward(largo)

bgcolor(0.5, 0.5, 0.5)
ht()
speed(0)
pu()
backward(100)
left(90)
pu()
backward(300)
arbol(12, 100)
done()

El resultado es un árbol generatvio con hojas que parecen desprenderse aleatoriamente, mostrando cómo la recursividad y los números aleatorios pueden emular fenómenos naturales.