Bachillerato 35 Salas Programación

Objetivos didácticos

Un curso corto de programación creativa con p5.js, la biblioteca de JavaScript para dibujar y animar en un lienzo. El alumno empieza viendo un dibujo animado que son pocas líneas de código y, sala a sala, aprende las piezas con las que se escribe algo así: setup() y draw(), formas, colores, variables, condiciones, bucles, texto, funciones propias y arrays. Termina con dos sketches completos, un sistema de partículas y un árbol fractal recursivo.

El lab tiene 35 salas y casi todas siguen un ritmo de tres tiempos: una sala de observación, una de «Pon a prueba» y, en algunos temas, una de «Escribe tú».

  • Observación. Un panel con el código a un lado y el lienzo en marcha al otro. El alumno mueve controles deslizantes y ve cómo cambian a la vez el dibujo y los números del código. No edita el código: solo cambia valores.
  • Pon a prueba. Una o dos preguntas de opción múltiple y, en la mayoría, un reto de ordenar las líneas de un programa corto.
  • Escribe tú. Una o varias casillas donde el alumno escribe una línea de código (una llamada a una función de p5.js, un operador, una condición, la cabecera de un for, una función) y se comprueba. Si acierta, el resultado aparece en el lienzo cuando la tarea dibuja algo.

No hay apuestas. Las salas de observación solo piden mirar y probar los controles; las de preguntas y las de escribir se dan por resueltas cuando el alumno completa todo lo que piden.

Salas por tema: 1 introducción; 2-3 setup(); 4-5 draw(); 6-7 formas; 8-10 fill, stroke y noStroke; 11-12 colores RGB; 13-15 variables globales y locales; 16-17 variables del sistema; 18-20 if; 21-23 for; 24-25 text(); 26-28 funciones propias; 29-31 arrays; 32-33 forEach, map y filter; 34-35 proyectos.

Qué se aprende

El alumno aprende a leer un programa de p5.js y a escribir fragmentos propios, con la idea de que el código describe lo que pasa en cada fotograma.

  • Saber cuándo se ejecuta cada parte: setup() una sola vez, al principio; draw() unas 60 veces por segundo, con frameCount contando los fotogramas (salas 2-5).
  • Dibujar con ellipse, rect y line en un sistema de coordenadas con origen arriba a la izquierda, y dar color con fill, stroke y noStroke (salas 6-10).
  • Entender el color RGB como tres números de 0 a 255 (salas 11-12).
  • Distinguir variables globales, que persisten entre fotogramas, de las locales, que se reinician en cada llamada, y usar +=, -= y *= (salas 13-15).
  • Usar lo que p5.js ya sabe del entorno: mouseX, mouseY, width, height, mouseIsPressed (salas 16-17).
  • Decidir con if y distinguir = de == (salas 18-20).
  • Repetir con for y reconocer sus tres partes (salas 21-23).
  • Escribir texto en el lienzo con text(), textSize() y textAlign() (salas 24-25).
  • Definir funciones con parámetros y con return (salas 26-28).
  • Guardar muchos valores en un array, añadir y quitar elementos, y recorrerlo con for...of, forEach, map y filter (salas 29-33).
  • Juntar todo en dos sketches más largos, con arrays, funciones y recursividad (salas 34-35).

Ideas matemáticas clave

El lab es de programación; las ideas matemáticas son las que sostienen el dibujo.

  • Coordenadas. El lienzo es un plano cartesiano con el origen en la esquina superior izquierda y el eje y hacia abajo; una elipse o un rectángulo queda determinado por posición y tamaño.
  • Color RGB. Cada color es una terna (R, G, B) con valores de 0 a 255; (255, 0, 0) es rojo puro y (0, 0, 255), azul puro.
  • Resto de una división. En la sala 4 se usa x % 400: cuando x llega a 400, el resto vuelve a 0 y la bola empieza otra vez por la izquierda.
  • Variable como estado. Un contador que crece en cada fotograma y se compara con un límite (la bola que rebota en la sala 18).
  • Condiciones y comparaciones. Operadores >, >=, ==, !=; = asigna y no compara.
  • Iteración. Un for con inicio, condición y paso dibuja una fila de círculos con separación fija; cambiar el paso, el inicio o el fin cambia cuántos hay.
  • Función como transformación. Una función con return devuelve un valor (cubo(3) es 27); map aplica una función a cada elemento de un array.
  • Índices. Un array empieza en el índice 0: con lista = [1, 2, 3], lista[1] vale 2 y lista.indexOf(3), 2.
  • Recursividad. En el árbol de la sala 35, rama(len, n) se llama a sí misma con una longitud menor (ratio) y un nivel menos, y se detiene cuando n llega a 0; push() y pop() guardan y restauran la posición.

Notas para el aula

  • El alumno no escribe un programa completo: las tareas de escribir son de una o dos líneas y las demás son de mover controles, elegir opciones y ordenar líneas. Es una primera aproximación a p5.js, no un taller de programación libre.
  • Los retos de escribir comprueban lo escrito (la función y sus argumentos, o la forma de la expresión) y muestran un ejemplo cuando se falla; el docente puede ver qué probó el alumno, también los intentos fallidos.
  • Las preguntas sobre el uso de if (x = 5), que asigna en vez de comparar y en JavaScript no avisa, y sobre variables locales frente a globales son los puntos donde conviene detenerse con la clase.
  • Las dos últimas salas funcionan bien proyectadas: el alumno cambia gravedad, rebote, ángulo o profundidad y relaciona cada parámetro con la línea del código.

Nivel: bachillerato (Informática). No se necesitan conocimientos previos de programación. Se escribe JavaScript; la sala 20 recuerda que, a diferencia de Python, los paréntesis del if son obligatorios.

Contenidos por salas

Sala 1 · Unas pocas líneas... y esto pasa

Un dibujo animado con cinco anillos de círculos de colores que giran alrededor del centro, con un panel de código al lado. El dibujo tiene una simetría de orden 6 y son unas pocas líneas: dos bucles anidados, un ángulo a = TWO_PI / n * i y el color según la posición. Al mover el ratón por el lienzo cambia la velocidad de giro. Es una sala de presentación, sin preguntas: el alumno solo mira el resultado y el código que lo produce, que irá aprendiendo en las salas siguientes.

Tareas para el alumno

  • Mover el ratón sobre el lienzo y ver cómo cambia la velocidad de rotación.
  • Leer el código que genera el dibujo.

Sala 2 · setup(): preparar el lienzo

Un panel con el código de setup() y el lienzo que crea. Tres controles deslizantes cambian el ancho, el alto y el color de fondo, y el código se actualiza a la vez resaltando el número que ha cambiado. La idea es que setup() se ejecuta una sola vez, al principio, y es donde se decide el tamaño del lienzo y el fondo. Solo hay que observar.

Tareas para el alumno

  • Mover los deslizadores de ancho, alto y fondo.
  • Ver cómo cambian a la vez el lienzo y los argumentos de createCanvas() y background().

Sala 3 · Pon a prueba: setup()

Dos preguntas de opción múltiple sobre la sala anterior: cuántas veces se ejecuta setup() (60 veces por segundo, una sola vez, solo al hacer clic o siempre que cambia el ratón) y qué función crea el lienzo (drawCanvas(), createCanvas(), makeCanvas() o newSketch()). Se da una pista cuando se falla.

Tareas para el alumno

  • Elegir cuántas veces se ejecuta setup() (una sola vez).
  • Elegir qué función crea el lienzo (createCanvas()).

Sala 4 · draw(): la magia del movimiento

Un círculo se mueve por el lienzo con una x que crece con frameCount. Un deslizador (de 1 a 8) cambia la velocidad. draw() se ejecuta 60 veces por segundo y frameCount sube en 1 cada vez. Una nota explica el operador %: es el resto de una división (7 % 3 = 1, 10 % 4 = 2) y, cuando x llega a 400, vuelve a 0 y la bola empieza otra vez por la izquierda.

Tareas para el alumno

  • Cambiar la velocidad y ver el efecto en el movimiento.
  • Leer la nota sobre el resto de una división y relacionarla con la bola que vuelve al inicio.

Sala 5 · Pon a prueba: draw()

Dos preguntas de opción múltiple: dónde va el código que se anima continuamente (en setup(), en draw(), fuera de las dos funciones o en cualquier sitio) y qué variable de p5.js cuenta los fotogramas desde el inicio (frameNumber, frameCount, counter o tick).

Tareas para el alumno

  • Elegir dónde va el código que se anima (en draw()).
  • Elegir qué variable cuenta los fotogramas (frameCount).

Sala 6 · Formas básicas: elipse, rect, line

Un lienzo con una elipse, un rectángulo y una línea, y el código de las tres llamadas: ellipse(x, y, ancho, alto), rect(x, y, ancho, alto) y line(x1, y1, x2, y2). Cuatro deslizadores cambian la posición y el tamaño de la elipse. Todas las coordenadas se miden desde la esquina superior izquierda, que es el (0, 0). Solo hay que observar.

Tareas para el alumno

  • Mover los deslizadores de x, y, ancho y alto de la elipse.
  • Fijarse en cómo cada número del código cambia el dibujo.

Sala 7 · Pon a prueba: formas básicas

Dos preguntas de opción múltiple (qué función dibuja un rectángulo: square(), rect(), rectangle() o box(); y cómo se escribe ellipse, con sus cuatro argumentos) y un reto de ordenar las líneas de un draw() que pinta una elipse de 100 × 60 en (200, 150) sobre fondo gris. Idea: ellipse(x, y, ancho, alto) lleva la posición y el tamaño.

Tareas para el alumno

  • Elegir la función que dibuja un rectángulo (rect()).
  • Elegir la firma de ellipse (ellipse(x, y, ancho, alto)).
  • Ordenar las cuatro líneas de draw() para dibujar una elipse sobre fondo gris.

Sala 8 · fill(), stroke(), noStroke(): dar color a las formas

Un círculo con relleno y borde, y el código con fill(), stroke() y noStroke(). Tres deslizadores cambian el color de relleno en R, G y B (cada uno de 0 a 255) y otro, strokeWeight, el grosor del borde; con 0 se quita el borde. fill() pinta el interior, stroke() el borde y noStroke() lo elimina. Solo hay que observar.

Tareas para el alumno

  • Mover los deslizadores de R, G y B del relleno.
  • Cambiar el grosor del borde, hasta 0, y ver el efecto.

Sala 9 · Pon a prueba: fill y stroke

Dos preguntas de opción múltiple (qué función elimina el borde y cuál establece el relleno) y un reto de ordenar seis líneas de un draw() que dibuja un círculo rojo sin borde: background(200), fill(255, 0, 0), noStroke() y circle(200, 150, 80).

Tareas para el alumno

  • Elegir la función que elimina el borde (noStroke()).
  • Elegir la función que establece el relleno (fill()).
  • Ordenar las líneas para dibujar un círculo rojo sin borde.

Sala 10 · Escribe tú el código: color y formas

Primera sala en la que el alumno escribe código. Tres tareas, cada una con una casilla de texto: pintar de rojo el relleno, dibujar un rectángulo en unas coordenadas dadas (x = 20, y = 40, ancho 80, alto 30) y eliminar el contorno. Se comprueba que la función y los argumentos coinciden; si se acierta, el resultado aparece en el lienzo, y si no, se muestra un ejemplo.

Tareas para el alumno

  • Escribir fill(255, 0, 0);.
  • Escribir rect(20, 40, 80, 30);.
  • Escribir noStroke();.

Sala 11 · Espacio de color RGB: (R, G, B)

Un lienzo con el color de fondo elegido y un círculo con el color invertido, con tres deslizadores, uno por canal (de 0 a 255). Cada color se define con tres números: rojo (R), verde (G) y azul (B). Mover los deslizadores muestra cómo se mezclan los canales y cómo cambia el código. Solo hay que observar.

Tareas para el alumno

  • Mover los deslizadores de R, G y B y ver cómo se mezclan.
  • Fijarse en el color invertido del círculo.

Sala 12 · Pon a prueba: colores RGB

Un reto con deslizadores: conseguir el rojo puro, con un color objetivo y el color actual que se muestran uno junto al otro. Después una pregunta de opción múltiple: qué color produce fill(0, 0, 255) (verde, azul, rojo o blanco). Idea: el tercer número es el canal azul y 255 es la intensidad máxima.

Tareas para el alumno

  • Ajustar los deslizadores hasta obtener rojo puro (R = 255, G = 0, B = 0).
  • Elegir el color que produce fill(0, 0, 255) (azul).

Sala 13 · Variables globales y locales

Un sketch donde x es una variable global, que persiste entre fotogramas y crece, y radio es una variable local declarada dentro de draw(), que se reinicia en cada llamada. Un deslizador, vel, ajusta la velocidad, y un contador muestra el valor de x. Idea: lo declarado fuera de las funciones persiste entre fotogramas; lo declarado dentro empieza de cero en cada llamada.

Tareas para el alumno

  • Cambiar la velocidad y seguir el valor de x.
  • Comparar la variable global x con la local radio, que se reinicia.

Sala 14 · Pon a prueba: variables

Dos preguntas de opción múltiple: qué valor tiene let contador = 0 declarado dentro de draw() en el fotograma 100 (0, porque se reinicia en cada llamada) y qué hace vel += 2 (suma 2 a vel, igual que vel = vel + 2). Y un reto de ordenar un programa con dos variables globales y un draw(); el orden de las dos variables y el de las dos líneas dentro de draw() son intercambiables y se aceptan todos.

Tareas para el alumno

  • Elegir qué valor tiene una variable local en el fotograma 100 (0).
  • Elegir qué hace vel += 2.
  • Ordenar el código: globales primero y después draw().

Sala 15 · Escribe tú: modificar variables

Dos tareas con operadores de asignación sobre variables dadas: restar 20 a ancho y duplicar alto. Se aceptan la forma compuesta y la expandida (ancho -= 20 o ancho = ancho - 20; alto *= 2 o alto = alto * 2). Al acertar, el rectángulo del lienzo cambia de tamaño.

Tareas para el alumno

  • Escribir una línea que reste 20 a ancho (ancho -= 20).
  • Escribir una línea que duplique alto (alto *= 2).

Sala 16 · Variables que p5.js te regala

Un lienzo con un círculo que sigue al ratón con mouseX y mouseY, otro fijo en el centro con width/2 y height/2, y un texto con las coordenadas del ratón. Son variables que p5.js actualiza solas. La sala las enseña moviendo el ratón y pulsando; no hay deslizadores.

Tareas para el alumno

  • Mover el ratón y ver las coordenadas y el círculo que lo sigue.
  • Hacer clic y relacionar lo que se ve con mouseIsPressed y con las demás variables.

Sala 17 · Pon a prueba: variables del sistema

Dos preguntas de opción múltiple: qué variable contiene la posición horizontal del ratón (mouseY, mouseX, posX o xMouse) y cuál es true mientras el ratón está pulsado (mouseDown, mouseIsPressed, isClicked o pressed).

Tareas para el alumno

  • Elegir la variable de la posición horizontal del ratón (mouseX).
  • Elegir la variable que es true mientras se pulsa el ratón (mouseIsPressed).

Sala 18 · if: tomar decisiones en el código

Una bola rebota porque dos condiciones if detectan cuándo llega al borde; el código está al lado. Un deslizador (de 1 a 10) cambia la velocidad y un clic en el lienzo cambia el color de fondo. Idea: un if ejecuta un bloque solo si la condición es verdadera, y con dos de ellos se invierte la velocidad en los extremos.

Tareas para el alumno

  • Cambiar la velocidad y observar el rebote.
  • Hacer clic en el lienzo para cambiar el fondo.
  • Relacionar cada if del código con el borde que detecta.

Sala 19 · Pon a prueba: if

Tres retos. Primero una pregunta trampa: qué ejecuta if (x = 5), que no comprueba nada sino que asigna 5 a x y casi siempre entra en el bloque, sin que JavaScript avise. Después, marcar los operadores de comparación entre seis (>=, =>, ==, !=, = y >; son comparaciones >=, ==, != y >). Por último, ordenar las líneas de un rebote en el borde derecho.

Tareas para el alumno

  • Elegir qué ejecuta if (x = 5) (asigna 5 a x y casi siempre entra).
  • Marcar los operadores de comparación (>=, ==, !=, >).
  • Ordenar las líneas del rebote en el borde derecho.

Sala 20 · Escribe tú: condiciones if

Dos tareas para completar la condición de un if, mostrada como if ___ { ... }: «x es mayor que alto» y «x es igual que y». La condición se escribe con paréntesis, que en JavaScript son obligatorios (a diferencia de Python), y la segunda obliga a distinguir == de =. Se aceptan == y ===.

Tareas para el alumno

  • Escribir (x > alto).
  • Escribir (x == y).

Sala 21 · for: repetir sin copiar y pegar

Un solo bucle for dibuja una fila de círculos. Tres deslizadores cambian el paso (x +=), el inicio (x =) y el fin (x <=) del bucle, y el código se actualiza. Idea: un for repite el cuerpo mientras se cumple la condición y avanza la variable en cada vuelta, así que el paso, el inicio y el fin determinan cuántos círculos hay y dónde.

Tareas para el alumno

  • Mover los deslizadores de paso, inicio y fin.
  • Observar cómo cambia el número y la separación de los círculos.

Sala 22 · Pon a prueba: bucle for

Un lienzo con el bucle for (let x = 30; x <= 370; x += 40) que dibuja una fila de círculos. Una pregunta de opción múltiple con cuatro respuestas sobre el bucle (el valor inicial de x, la separación entre círculos, hasta dónde llega x y la posición Y del círculo) y un reto de ordenar las líneas para dibujar la fila. Idea: el paso del bucle fija la separación entre círculos.

Tareas para el alumno

  • Elegir la respuesta correcta sobre el bucle (la separación entre círculos).
  • Ordenar las líneas para dibujar una fila de círculos.

Sala 23 · Escribe tú: las tres partes del for

El bucle for tiene tres partes separadas por ;: inicialización, condición e incremento. El alumno rellena cada una en una casilla, con el resto del bucle a la vista. Se aceptan formas equivalentes, por ejemplo x < 400 o x <= 350 para la condición.

Tareas para el alumno

  • Escribir la inicialización (let x = 0).
  • Escribir la condición (x < 400 o x <= 350).
  • Escribir el incremento (x += 50).

Sala 24 · text(): escribir en el lienzo

Un texto grande centrado y otro pequeño con una variable, dibujados con text("cadena", x, y). Tres deslizadores cambian textSize, la posición x y la posición y, y el código se actualiza; también se usa textAlign(). Solo hay que observar.

Tareas para el alumno

  • Mover los deslizadores de tamaño del texto y de posición x e y.
  • Ver cómo cambian a la vez el texto y los argumentos de text().

Sala 25 · Pon a prueba: text()

Dos preguntas de opción múltiple (qué función dibuja texto en el lienzo, print(), text(), write() o draw(); y qué hace textAlign(CENTER, CENTER): centra el texto horizontal y verticalmente) y un reto de ordenar las líneas de un draw() que muestra «Hola p5.js!» en blanco sobre fondo oscuro.

Tareas para el alumno

  • Elegir la función que dibuja texto (text()).
  • Elegir qué hace textAlign(CENTER, CENTER).
  • Ordenar las líneas para mostrar el texto.

Sala 26 · Tus propias funciones: flor(x, y)

Una función flor(x, y) define una flor con un círculo central y cuatro pétalos, y se llama dos veces con coordenadas distintas. Cuatro deslizadores mueven cada una de las dos flores. Idea: una función se define una vez y se usa cuantas veces se quiera, con parámetros que cambian lo que dibuja.

Tareas para el alumno

  • Mover los deslizadores de las coordenadas de cada flor.
  • Comparar el código de la definición con las dos llamadas.

Sala 27 · Pon a prueba: funciones propias

Una pregunta de opción múltiple sobre qué hay que hacer antes de llamar a flor(100, 150) (definir function flor() antes de usarla) y un reto de ordenar las líneas de la definición de flor(x, y), con un círculo central y dos pétalos.

Tareas para el alumno

  • Elegir qué hace falta antes de llamar a una función propia (definirla).
  • Ordenar las líneas para definir flor(x, y).

Sala 28 · Escribe tú: definir funciones

Dos tareas: definir una función nada que no hace nada (con la sintaxis completa y las llaves) y definir cubo(n) que devuelva n al cubo. La segunda se comprueba ejecutando la función: cubo(3) debe dar 27. return hace que la función devuelva un valor que se puede usar donde se la llame; sin return devuelve undefined.

Tareas para el alumno

  • Escribir function nada() {}.
  • Escribir una función cubo(n) que devuelva n · n · n.

Sala 29 · Arrays: guardar muchos valores

Un array guarda varios elementos en una sola variable. Al hacer clic en el lienzo se añade un punto con push(), y un for...of dibuja cada uno; un rótulo muestra la longitud del array. Dos botones eliminan el último punto (pop()) o vacían el array ([]).

Tareas para el alumno

  • Hacer clic en el lienzo para añadir puntos con push().
  • Eliminar el último punto con «pop» y vaciar el array con el botón correspondiente.

Sala 30 · Pon a prueba: arrays

Dos preguntas de opción múltiple (qué hace xs.push(50) y cómo se accede al primer elemento de xs: xs[0]) y un reto de ordenar las líneas de un programa que declara un array, añade una posición y la dibuja con for...of. Idea: los índices empiezan en 0.

Tareas para el alumno

  • Elegir qué hace push() (añade un elemento al final).
  • Elegir cómo se accede al primer elemento (xs[0]).
  • Ordenar las líneas: declarar el array, añadir un elemento y dibujarlo.

Sala 31 · Escribe tú: operaciones con arrays

Se parte de let lista = [1, 2, 3]. Cuatro tareas: cuánto vale lista[1] (2), cuánto vale lista.indexOf(3) (2), cuánto vale lista.length tras ejecutar lista.pop() (2) y escribir el código que añade un 7 al final. La última se comprueba ejecutando lo escrito. Las tres primeras se contestan con un número.

Tareas para el alumno

  • Escribir cuánto vale lista[1] (2).
  • Escribir cuánto vale lista.indexOf(3) (2, el índice en que está el 3).
  • Escribir cuánto vale lista.length después de lista.pop() (2).
  • Escribir el código que añade el 7 al final de lista (por ejemplo lista.push(7)).

Sala 32 · forEach, map, filter: trabajar con arrays

Un gráfico de barras con los valores de un array. forEach dibuja todas las barras en azul, filter resalta en rojo las que superan un umbral y map crea un array nuevo con el doble de cada altura. Un deslizador mueve el umbral de filter (de 20 a 170) y se ve qué barras quedan resaltadas. Solo hay que observar.

Tareas para el alumno

  • Mover el umbral y ver qué barras selecciona filter.
  • Comparar las tres llamadas, forEach, map y filter, con lo que dibujan.

Sala 33 · Pon a prueba: forEach, map, filter

Dos preguntas de opción múltiple (qué devuelve map(), un array nuevo con los valores transformados; y para qué sirve filter(), para devolver los elementos que cumplen una condición) y un reto de ordenar las líneas de un programa que declara un array y usa forEach, map y filter sobre él.

Tareas para el alumno

  • Elegir qué devuelve map() (un array nuevo).
  • Elegir para qué sirve filter().
  • Ordenar las líneas del programa con forEach, map y filter.

Sala 34 · Proyecto: sistema de partículas

Un sketch completo que junta arrays, for...of, if, funciones y variables: un array de partículas que caen con gravedad y rebotan en el suelo y en los lados. Cuatro deslizadores ajustan gravedad, rebote, número de partículas y color (matiz), y cada clic en el lienzo lanza 8 partículas más. El código se actualiza al mover los controles. No hay preguntas: es manipular un programa más largo y leer cómo está hecho.

Tareas para el alumno

  • Ajustar gravedad, rebote, número de partículas y color.
  • Hacer clic en el lienzo para lanzar más partículas.
  • Localizar en el código el array, el bucle y las condiciones.

Sala 35 · Proyecto: árbol fractal recursivo

Un árbol dibujado con una función rama(len, n) que se llama a sí misma: cada rama se divide en dos más cortas, giradas a derecha e izquierda, hasta que el nivel n llega a 0. push() y pop() guardan y restauran la posición. Cuatro deslizadores cambian el ángulo, la profundidad, el ratio de reducción (en %) y la longitud del tronco. No hay preguntas: es manipular un programa más largo y leer cómo está hecho.

Tareas para el alumno

  • Cambiar el ángulo, la profundidad, el ratio y la longitud y ver cómo cambia el árbol.
  • Localizar en el código la llamada de rama a sí misma y los push()/pop().

Salas para proyectar

Las más vistosas para mostrar y discutir en clase.

★
Sala 1 · Unas pocas líneas... y esto pasa — Proyectada al empezar, permite preguntar cuántas líneas creen que hacen falta para un dibujo así y deja claro lo que se va a aprender.
★
Sala 19 · Pon a prueba: if — La pregunta de if (x = 5) hace ver que asignar y comparar son cosas distintas y que JavaScript no avisa; conviene discutirla con la clase.
★
Sala 35 · Proyecto: árbol fractal recursivo — Mover ángulo, profundidad y ratio muestra qué hace la recursividad con una función que se llama a sí misma, y es un buen cierre para proyectar.