Integración de bloques esenciales en Scratch 3: construir un proyecto coherente por módulos

Objetivo del capítulo: integrar bloques en un proyecto por módulos

En este capítulo vas a construir un proyecto integrador (un minijuego con estados MENÚ / JUEGO / FIN) organizado por módulos. La meta no es “usar muchos bloques”, sino conectar responsabilidades: un módulo define el estado global, otro gestiona la interacción, otro el progreso, otro aplica reglas, otro administra datos y otro coordina sprites. El resultado debe ser fácil de leer, probar y reiniciar.

Proyecto integrador propuesto: “Atrapa la Estrella” con estados

Idea: en el menú se muestran instrucciones; al iniciar, el jugador mueve un personaje para atrapar una estrella que aparece en posiciones aleatorias; cada captura suma puntos y registra una marca en una lista; al llegar a un puntaje objetivo o al agotarse el tiempo, se pasa a fin y se muestra un resumen.

• Sprites sugeridos: Jugador, Estrella, Botón Jugar (o área clicable), Panel (opcional).
• Escenario: 3 fondos opcionales (menú/juego/fin) o un solo fondo con elementos que se muestran/ocultan.

Diseño por módulos (mapa de responsabilidades)

Antes de programar, define módulos como “contratos”: qué hacen, qué variables/listas tocan y qué mensajes emiten/reciben. Esto evita mezclar lógica de juego con interfaz o datos.

Paso a paso: construcción del proyecto por secciones

Sección 1 — Módulo: control del estado global (variables)

Entregable: el proyecto cambia de MENÚ a JUEGO y a FIN, y puede reiniciarse sin recargar la página.

Bloques clave a usar: variables (estado, puntos, tiempo), asignaciones (fijar, cambiar), y mensajes para anunciar cambios.

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

Criterios de claridad del código:

• Un solo sprite (recomendado: Escenario) es el “dueño” de estado y decide transiciones.
• Las transiciones se hacen con mensajes, no duplicando lógica en cada sprite.
• Existe un guion explícito de reinicio que deja todo en valores conocidos.

Implementación sugerida (en el Escenario):

al presionar bandera verde  // reinicio total del sistema
fijar [estado v] a [MENU]
fijar [puntos v] a [0]
fijar [tiempo v] a [30]
borrar todos de [capturas v]
enviar [ir_menu v]

cuando reciba [solicitar_inicio v]
si <(estado) = [MENU]> entonces
  fijar [estado v] a [JUEGO]
  enviar [iniciar_juego v]
fin

cuando reciba [solicitar_fin v]
si <(estado) = [JUEGO]> entonces
  fijar [estado v] a [FIN]
  enviar [ir_fin v]
fin

Sección 2 — Módulo: coordinación (mensajes) como “API” del proyecto

Entregable: cada sprite reacciona a ir_menu, iniciar_juego e ir_fin mostrando/ocultando lo que corresponde, sin leer directamente guiones de otros sprites.

Bloques clave a usar: enviar, cuando reciba, y (si lo necesitas) enviar y esperar para secuencias de preparación.

Criterios de claridad del código:

• Lista corta de mensajes “oficiales” (3 a 6). Evita mensajes por cada detalle.
• Los nombres de mensajes describen intención: iniciar_juego mejor que msg1.
• Cada sprite tiene un bloque por mensaje con acciones de UI/estado local.

Ejemplo (Sprite Jugador):

cuando reciba [ir_menu v]
ocultar
ir a x:(0) y:(-80)

cuando reciba [iniciar_juego v]
mostrar
ir a x:(0) y:(-80)

cuando reciba [ir_fin v]
ocultar

Sección 3 — Módulo: interacción (eventos) sin romper estados

Entregable: desde el menú se puede iniciar; durante el juego el jugador se mueve; en fin no se mueve y puede reiniciar.

Bloques clave a usar: eventos de teclado/clic y una verificación de estado antes de actuar.

Criterios de claridad del código:

• Las entradas del usuario no cambian variables globales directamente; solicitan cambios mediante mensajes (solicitar_inicio, solicitar_fin o reiniciar).
• Las acciones de movimiento se ejecutan solo si estado = JUEGO.

Ejemplo (Sprite Botón Jugar o Escenario):

al hacer clic en este objeto
si <(estado) = [MENU]> entonces
  enviar [solicitar_inicio v]
fin

Ejemplo (Sprite Jugador, movimiento):

por siempre
si <(estado) = [JUEGO]> entonces
  si <tecla [flecha derecha v] presionada?> entonces cambiar x por (6)
  si <tecla [flecha izquierda v] presionada?> entonces cambiar x por (-6)
  si <tecla [flecha arriba v] presionada?> entonces cambiar y por (6)
  si <tecla [flecha abajo v] presionada?> entonces cambiar y por (-6)
fin

Sección 4 — Módulo: reglas (condicionales) para puntuar y validar

Entregable: al tocar la estrella se suma 1 punto, se registra la captura y la estrella “salta” a otra posición. Si se alcanza la meta, se solicita fin.

Bloques clave a usar: detección de contacto, condicionales, actualización de variables, y mensajes para fin.

Criterios de claridad del código:

• La regla “capturar estrella” vive en un solo lugar (recomendado: en la Estrella o en un módulo de reglas), no duplicada.
• La meta de puntos está en una variable (meta) o constante clara.
• La regla no cambia estado directamente: envía solicitar_fin.

Ejemplo (Sprite Estrella):

cuando reciba [iniciar_juego v]
mostrar
ir a posición aleatoria

por siempre
si <(estado) = [JUEGO]> entonces
  si <tocando [Jugador v]?> entonces
    cambiar [puntos v] por (1)
    añadir (unir [captura en ] (tiempo actual)) a [capturas v]
    ir a posición aleatoria
    si <(puntos) >= (10)> entonces
      enviar [solicitar_fin v]
    fin
  fin
fin

Si no quieres usar “tiempo actual”, registra un contador de capturas o la posición: añadir (unir (x posición) (unir [ , ] (y posición))) a [capturas].

Sección 5 — Módulo: progreso (bucles) con temporizador y ritmo

Entregable: el juego dura 30 segundos; el tiempo baja de 1 en 1; al llegar a 0 se solicita fin aunque no se haya llegado a la meta.

Bloques clave a usar: bucles (por siempre o repetir hasta), esperas, actualización de tiempo, y mensajes.

Criterios de claridad del código:

• El temporizador se inicia solo cuando llega iniciar_juego.
• El temporizador se detiene cuando estado deja de ser JUEGO.
• Evita tener dos temporizadores activos (un error típico). Usa un solo guion responsable.

Ejemplo (Escenario):

cuando reciba [iniciar_juego v]
fijar [tiempo v] a [30]
repetir hasta <(estado) != [JUEGO]>
  esperar (1) segundos
  cambiar [tiempo v] por (-1)
  si <(tiempo) <= (0)> entonces
    enviar [solicitar_fin v]
  fin
fin

Sección 6 — Módulo: datos (listas) para registrar y mostrar resumen

Entregable: la lista capturas se vacía al reiniciar; durante el juego se agregan elementos; en FIN se muestra un resumen simple (por ejemplo, cantidad de capturas y las últimas 3).

Bloques clave a usar: borrar todos, añadir, longitud de, elemento ( ) de.

Criterios de claridad del código:

• La lista tiene un propósito explícito (historial), no se usa como “basurero” de valores.
• El resumen se calcula en un guion de FIN, no mezclado con la lógica de captura.

Ejemplo (Escenario o Sprite Panel):

cuando reciba [ir_fin v]
mostrar
// ejemplo de resumen en una variable texto
fijar [resumen v] a (unir [Puntos: ] (puntos))
// últimas 3 capturas (si existen)
si <(longitud de [capturas v]) >= (1)> entonces
  fijar [resumen v] a (unir (resumen) (unir [ | Última: ] (elemento (longitud de [capturas v]) de [capturas v])))
fin

Si quieres mostrar “últimas 3”, repite el patrón con índices longitud, longitud-1, longitud-2 verificando límites.

Checklist de entregables por módulo (para autoevaluación)

Pauta de pruebas (normales, extremos y reinicio completo)

Casos normales

• Inicio estándar: Bandera verde → aparece MENÚ → clic en Jugar → entra a JUEGO con puntos=0, tiempo=30, lista vacía.
• Captura: tocar estrella una vez → puntos aumenta en 1, se agrega 1 elemento a capturas, la estrella cambia de posición.
• Fin por meta: llegar a 10 puntos → pasa a FIN y muestra resumen coherente con puntos y lista.
• Fin por tiempo: dejar correr el tiempo sin capturar → al llegar a 0 pasa a FIN.

Casos extremos (para detectar errores de estado y duplicación)

• Doble inicio: en MENÚ, hacer clic rápido varias veces en Jugar → debe iniciar una sola vez (sin duplicar temporizador ni sumar puntos “fantasma”).
• Movimiento fuera de estado: en MENÚ y en FIN, presionar flechas → el jugador no debe moverse ni afectar reglas.
• Colisión continua: mantener al jugador encima de la estrella → debe sumar de forma controlada (si suma demasiado rápido, agrega una pequeña espera o reubica inmediatamente).
• Lista vacía en FIN: terminar por tiempo sin capturas → el resumen no debe intentar leer elementos inexistentes (verifica longitud antes de acceder).

Reinicio completo (sin recargar)

• Reinicio desde FIN: define una acción (por ejemplo, tecla R o botón) que envíe un mensaje reiniciar o vuelva a ejecutar el guion de bandera verde. Verifica que: estado vuelve a MENU, puntos a 0, tiempo a 30, capturas se borra, sprites vuelven a su visibilidad/posición inicial.
• Reinicio durante JUEGO: reiniciar a mitad de partida → no quedan bucles activos del temporizador anterior y la estrella/jugador vuelven a condiciones iniciales.