Bucles en Scratch 3: repetición, iteración y control del tiempo

¿Por qué repetimos en Scratch?

En Scratch, repetir no es “hacer lo mismo por pereza”: es una forma de automatizar tareas que ocurren muchas veces. Los bucles sirven principalmente para tres cosas:

• Automatizar movimientos: caminar, patrullar, girar, rebotar.
• Automatizar animaciones: alternar disfraces, parpadear, simular correr.
• Automatizar comprobaciones: revisar constantemente si toca un borde, si llegó a un punto, si se cumple una condición para terminar.

La ventaja es doble: el proyecto queda más corto y más fácil de ajustar. Si quieres que un personaje avance más rápido, cambias un número dentro del bucle en vez de editar muchas instrucciones repetidas.

Tres modelos de ejecución: por siempre, repetir (N) y repetir hasta

1) por siempre: repetición sin final automático

Este bucle repite su contenido continuamente mientras el programa esté en marcha. Es ideal para comportamientos “de fondo” que deben estar activos todo el tiempo, como vigilar colisiones o mantener una animación.

Ejemplo típico: animación continua del personaje.

por siempre  {  siguiente disfraz  esperar (0.1) segundos  }

Cuándo usarlo: cuando no existe un “final natural” y el comportamiento debe mantenerse (por ejemplo, un enemigo patrullando o un efecto visual constante).

Continúa en nuestra aplicación.

• Escuche el audio con la pantalla apagada.
• Obtenga un certificado al finalizar.
• ¡Más de 5000 cursos para que explores!

O continúa leyendo más abajo...

Descargar la aplicación

2) repetir (N): repetición con cantidad fija

Este bucle ejecuta exactamente N iteraciones y luego termina. Es perfecto para acciones con duración o cantidad conocida: dar 10 pasos, parpadear 5 veces, girar 36 veces para completar una vuelta con pasos de 10 grados.

Ejemplo: avanzar 100 pasos en 20 iteraciones de 5 pasos.

repetir (20)  {  mover (5) pasos  }

Cuándo usarlo: cuando puedes expresar el objetivo como “haz esto N veces”.

3) repetir hasta <condición>: repetición controlada por una meta

Este bucle repite hasta que la condición sea verdadera. Es útil cuando no sabes cuántas veces hará falta repetir: depende de lo que ocurra en el juego.

Ejemplo: avanzar hasta tocar un color (por ejemplo, la meta).

repetir hasta <tocando color [#00FF00]?>  {  mover (3) pasos  esperar (0.02) segundos  }

Cuándo usarlo: cuando el final depende de una situación (llegar a un lugar, alcanzar un valor, tocar un objeto).

Iteración: pensar en “pasos discretos”

Una iteración es una vuelta del bucle: un “paso” del proceso. Pensar en iteraciones te ayuda a diseñar movimientos y animaciones de forma controlada.

Movimiento fluido = pasos pequeños + esperas pequeñas

Para que un movimiento se vea fluido, conviene repartirlo en muchas iteraciones con desplazamientos pequeños y una espera corta. Si mueves muchos pasos de golpe, el personaje “salta” en pantalla.

Ejemplo práctico: recorrer 120 pasos de forma suave.

repetir (40)  {  mover (3) pasos  esperar (0.02) segundos  }

Aquí hay 40 iteraciones. Cada iteración avanza 3 pasos y deja 0.02 s para que la pantalla se actualice de forma perceptible.

Animación fluida = cambiar un poco y esperar un poco

En una animación por disfraces, la espera controla la “velocidad” del cambio. Sin espera, el cambio puede ser tan rápido que no se aprecia o consume recursos innecesarios.

por siempre  {  siguiente disfraz  esperar (0.08) segundos  }

Evitar bucles infinitos no deseados

Un bucle infinito no siempre es malo: por siempre es infinito por diseño. El problema aparece cuando un bucle que debería terminar no tiene una salida clara, o cuando un por siempre bloquea otras acciones importantes.

Señales de un bucle problemático

• El personaje se queda “atascado” repitiendo algo y no responde.
• Una acción que debería terminar (llegar a un punto) nunca termina.
• El proyecto se vuelve lento porque un bucle hace demasiado trabajo sin pausas.

Diseñar condiciones de salida claras (para repetir hasta)

Para que repetir hasta sea seguro, la condición debe poder volverse verdadera. Comprueba estas tres ideas:

• La condición depende de algo que cambia dentro del bucle (posición, variable, tiempo, etc.).
• El cambio va en la dirección correcta (si quieres llegar a x=100, asegúrate de que x aumenta).
• Hay un “plan B” si algo impide cumplir la condición (por ejemplo, un límite de intentos o un temporizador).

Técnica 1: “límite de intentos” para evitar atascos

Si el personaje podría no llegar nunca (por ejemplo, porque hay un obstáculo), añade un contador de seguridad.

fijar [intentos v] a (0)  repetir hasta <<tocando [Meta v]?> o <(intentos) > (200)>>  {  mover (2) pasos  cambiar [intentos v] por (1)  esperar (0.01) segundos  }

Así el bucle termina si llega a la meta o si ya lo intentó demasiadas veces.

Técnica 2: “tiempo máximo” como salida

Otra salida clara es un tiempo límite. Esto es útil en persecuciones o búsquedas.

reiniciar cronómetro  repetir hasta <<tocando [Meta v]?> o <(cronómetro) > (3)>>  {  mover (3) pasos  esperar (0.02) segundos  }

Técnica 3: Pausas pequeñas para no saturar

En bucles que revisan cosas constantemente (por ejemplo, comprobar si toca algo), una espera pequeña reduce carga y hace el comportamiento más estable.

por siempre  {  si <tocando [Enemigo v]?> entonces {  ... }  esperar (0.01) segundos  }

Guía práctica: convertir una secuencia repetida manualmente en un bucle

Una habilidad clave es detectar patrones repetidos y reemplazarlos por un bucle. Esto hace tu código más corto y fácil de modificar.

Ejercicio 1: de “caminar” escrito a mano a repetir (N)

Situación: tienes una secuencia donde el personaje avanza 10 veces el mismo bloque.

Antes (manual):

mover (5) pasos  mover (5) pasos  mover (5) pasos  mover (5) pasos  mover (5) pasos  mover (5) pasos  mover (5) pasos  mover (5) pasos  mover (5) pasos  mover (5) pasos

Paso a paso para convertirlo:

• Cuenta cuántas veces se repite el patrón: aquí son 10.
• Identifica el bloque o grupo de bloques que se repite: mover (5) pasos.
• Envuelve ese patrón con repetir (10).

Después (con bucle):

repetir (10)  {  mover (5) pasos  }

Reto: cambia el 10 por 20 y observa cómo el cambio es inmediato sin duplicar bloques.

Ejercicio 2: de “animación” manual a por siempre con control de tiempo

Situación: alternas disfraces varias veces para simular correr.

Antes (manual):

siguiente disfraz  siguiente disfraz  siguiente disfraz  siguiente disfraz

Paso a paso:

• Decide si debe durar “siempre” o solo un rato. Para correr mientras el juego está activo, usa por siempre.
• Añade una espera para controlar la velocidad de la animación.

Después:

por siempre  {  siguiente disfraz  esperar (0.1) segundos  }

Prueba: cambia 0.1 a 0.05 (más rápido) o 0.2 (más lento).

Ejercicio 3: de repetir una comprobación a repetir hasta con salida clara

Situación: quieres que el personaje avance hasta llegar a una zona, pero sin quedarse bloqueado.

Paso a paso:

• Define una condición de meta medible: por ejemplo, tocando color o tocando objeto.
• Dentro del bucle, realiza un avance pequeño.
• Añade una espera pequeña para fluidez.
• Agrega una salida de seguridad (intentos o tiempo).

Solución ejemplo (con intentos):

fijar [intentos v] a (0)  repetir hasta <<tocando color [#00FF00]?> o <(intentos) > (300)>>  {  mover (2) pasos  cambiar [intentos v] por (1)  esperar (0.02) segundos  }

Mini-laboratorio: ajustar fluidez con iteraciones

Este ejercicio te entrena a pensar en iteraciones y tiempo.

Objetivo

Hacer que un sprite recorra la pantalla en aproximadamente 2 segundos con movimiento suave.

Propuesta guiada

• Elige un total aproximado de pasos, por ejemplo 200.
• Divide en iteraciones: 50 iteraciones de 4 pasos (50×4=200).
• Reparte el tiempo total en esperas: si quieres ~2 s, usa esperar (0.04) porque 50×0.04=2.

repetir (50)  {  mover (4) pasos  esperar (0.04) segundos  }

Variación: mantén el total de pasos, pero cambia el número de iteraciones (más iteraciones = pasos más pequeños) y ajusta la espera para conservar la duración.