Estamos en un proceso de migración de contenidos desde el sitio scratchbydsigno.com.ar hacia este nuevo blog.

La prioridad está centrada en los 3 Tutoriales que constituyen la base de dicho sitio, para luego seguir con el resto de los contenidos.

En caso de que encuentres algún error de visualización, o links rotos, puedes comunicármelo usando el formulario de contacto...

4to paso: diseñar una interfaz (parte IV)

Con Pier metido por consejo médico en una "cura de sueño casera" —no hay como dormir una larga siesta para bajar el stress—, nosotros nos enfrentaremos a un nuevo mini-tutorial con el gato de Scratch como protagonista: su experiencia y aplomo serán necesarios más que nunca, y espero que también nos resulte contagiosa su actitud.
El objetivo del proyecto que abordaremos será trabajar específicamente sobre las dos metodologías de envío de mensajes, en un intento de dejar en claro sus diferencias de base y de dar un sustento concreto a la andanada de palabras proferida en la página previa (¡yo también me inclino por la praxis, no vayas a creer…!).
También aparecerá la idea de subrutina en tanto y cuanto nos valdremos de un script en particular para resolver una tarea específica (conviene aclarar que en Scratch 1.4 no es posible trabajar con subrutinas en un sentido estricto; en Scratch 2.0 si es posible.).

Stopping the cat

Refresquemos lo ya enunciado en la página previa acerca del funcionamiento que esperamos lograr en este proyecto:

"El gato deberá pasearse por el escenario hasta que lo detengamos tocándolo con el puntero del mouse; lo hará 2 veces en respuesta a dos criterios de programación distintos, y en la segunda oportunidad además de caminar nos maravillará con una serie de trucos visuales, los que sólo cesarán si se presiona la barra espaciadora por al menos 1 segundo… "

Como siempre aclaro, existen muchas maneras de conseguir esto, pero el camino que elegiremos tendrá que ver con un fin estrictamente "pedagógico" —palabra solemne si las hay—.
Es buen momento para mostrar las cartas: para cada "caminata" del gato usaremos un tipo de envío de mensaje distinto:
En la primera ocasión usaremos —y a modo de flashback— una solución "a la vieja escuela", en donde el algoritmo principal  llamará a una subrutina para resolver la tarea del desplazamiento de nuestro protagonista, tarea que finalizará cuando interceptemos la trayectoria del mismo con el puntero del mouse. La subrutina devolverá el control del proyecto al algoritmo principal una vez finalizada su labor.
Para la "segunda caminata" del gato el envío de mensaje que usaremos será del tipo sin espera, lo que posibilitará que el algoritmo transmisor siga procesando el resto de sus instrucciones independientemente de lo que suceda con la subrutina (¡subrutina que va a ser la misma que usamos antes!). Dentro de las mencionadas instrucciones estarán las que permitirán el cambio de color del gato —¡ya lo veréis, incrédulos!
Algo más: haremos uso y abuso de bloques decir ( ) por ( ) segundos no sólo con el fin de guiar a un posible usuario del proyecto, sino para ubicarnos nosotros mismos en una línea de tiempo donde se remarque lo que sucede con el trabajo de nuestros scripts (básicamente tener "señales" que indiquen en qué momento cesan su trabajo).
Basta de palabras y manos a la obra.

Solución old-school style

Una solución a la vieja escuela o solución clásica. Eso es lo que vamos a usar al principio de nuestra animación interactiva.
caminata 1
Comencemos esta vez un proyecto nuevo en Scratch, con lo que ya tendremos en primer plano a nuestro amigo el gato —que viene como siempre munido de 2 disfraces que nos serán muy útiles para simular una caminata—.
Yo por mi parte opté por cambiar el fondo del escenario (desde ya que esto no altera ninguna funcionalidad). Elegí desde la carpeta Outdoors  la imagen brick-wall1 en la cual se muestra una acera con una coqueta pared de ladrillos de fondo.
Vayamos ahora sí con la programación para el gato: como ves en la imagen previa en realidad consta de 2 scripts, en donde aparecen nuestras instrucciones bajo análisis:
  • dentro de lo que llamaremos script transmisor estará por supuesto el bloque de envío y espera, dedicado a transmitir un mensaje de nombre mensaje 1 —que deberemos crear oportunamente—
  • los bloques receptores de mensajes son siempre bloques de arranque (tipo sombrero), y es obvio entonces que lugar ocupará dentro de lo que denominaremos script receptor : ¡arriba de todo, señores!

Antes de seguir, una pregunta disparada "a boca de jarro" : ¿en que momento dirá Perfecto el gato? Pensalo y contestalo antes de correr el programa por primera vez.

Si entendiste lo central de lo tratado en la página anterior posiblemente hayas llegado a una respuesta correcta, la que habrás verificado al correr el programa con la bandera verde —la única verdad es la realidad, diría el general… ¿o un tal Aristóteles?
Fijate que el criterio de programación que fue usado encaja perfectamente con la idea de subrutina de la que hablamos en su momento: una línea de programa que "cede" la ejecución de una tarea específica a un subprograma, tal como sucede en nuestro caso.
Cuando el gato es tocado por el puntero del mouse se detiene el bucle que se encarga de la tan mentada caminata, y el script receptor se detiene. Esto es "percibido" (por buscar una palabra) por el script transmisor: es lo que espera para salir de su estado de inacción. Como la instrucción siguiente al envío de mensaje es decir (Perfecto) por (2) segundos, es la última acción (por ahora) que se llevará a cargo en nuestro proyecto…
Creo que es un ejemplo más que claro para entender como funciona el mecanismo de envío de mensajes con espera, y de cómo afecta al script transmisor.

Pausa para la reflexión

Hay una pregunta más que atinente que no nos deberíamos dejar de hacer: ¿es realmente necesaria y está cabalmente aprovechada la división de las instrucciones vinculadas al gato en dos scripts separados? [releer si es necesario].
alternativa sin mensaje
La imagen mostrando un único script que ya podés ver da una respuesta aparentemente contundente al intríngulis planteado. Este script por sí solito es capaz de brindar un idéntico comportamiento al que nosotros planteamos.
Desde ya que podríamos afirmar que el mismo no es aprovechable desde el punto de vista pedagógico, bla, bla… pero es momento de pensar en que el gato tendrá que hacer una segunda caminata, y que el tener un script dedicado a ese metier en particular quizás nos ayude a simplificar la programación que sigue: es esto lo que justifica la división en 2 scripts, no la pedagogía.
También hay que tener en cuenta que, paralelamente al desplazamiento por el escenario, durante la 2da caminata deberán ejecutarse instrucciones que posibiliten el cambio de color de nuestro amigo, las que deben incluir el sensado de un comando de "parada" independiente (la barra espaciadora): esto implica la necesidad de al menos 2 scripts funcionando simultáneamente…

Hay un aspecto más general que justifica la existencia de scripts dedicados a labores específicas: la posibilidad de reutilización de los mismos por parte de cualquiera de los otros scripts del proyecto, invocándolos a través del envío de un mensaje. Esto permite una mejor organización del programa, y permite ahorrar "líneas de código" —en el caso de Scratch evita una inserción excesiva de bloques de instrucción—

Estas palabras cobrarán sentido en sólo un momento

En pos de una caminata psicodélica

Nos queda ahora resolver la segunda "caminata" de nuestro proyecto, en donde el gato deberá ejecutar de manera simultánea dos juegos distintos de instrucciones, hasta que cada uno de ellos sea interrumpido por la intervención del usuario.
Estás en presencia del programa terminado.
2 caminatas
La primera parte del script transmisor es idéntica a lo que ya usamos para la primer caminata usando envío y espera (llega hasta decir (Perfecto) por (2) segundos).
El script receptor no sufrió ninguna alteración, y sigue activándose al recibir el mensaje mensaje 1.

Explicación breve (2 veces breve)

NOTA

Observad que estamos reutilizando el script receptor, con las consiguientes ventajas ya mencionadas en su oportunidad.
La segunda caminata comenzará al ser enviado por segunda vez el mensaje 1, pero esta vez el bloque utilizado no contempla ninguna espera, por lo que el script transmisor continuará procesando las instrucciones subsiguientes al mismo tiempo que nuestro gato vuelve a evolucionar elegantemente por el escenario.
Por su parte el script transmisor, a los 5 segundos de enviar por segunda vez mensaje 1, entrará en un loop dedicado específicamente a dar un efecto psicodélico sobre el gato (muy de los '70 ), el cual sólo podrá ser detenido presionando la barra espaciadora por al menos 1 segundo.
Fijate que el programa deberá encontrar dicha tecla presionada en el momento en que esté evaluando el sensor ¿tecla (espacio) presionada? para que esta condición pueda tomarse como verdadera, y consiguientemente se finalice la ejecución del bucle. Idealmente este sensor debería ser evaluado cada 0.5 seg —es el valor de la espera—, por lo que 1 seg bastaría para conseguir la interrupción del efecto (situación que el gato se encargará de comentar).

PARA VER

Podés visitar esta página dentro del sitio de Scratch para ver este mini-proyecto en acción, e incluso descargarlo (si estás suscripto como usuario).
Para cerrar: en esta segunda caminata se dará la situación de que encontremos "corriendo" dos hilos de ejecución, cada uno de los cuales será independiente del otro; estos podrán ser interrumpidos por el usuario en el orden y momento que él lo decida (puede ocurrir que el gato quede caminando con un color fijo distinto al original, o puede que quede parado mostrando el cambio en sus colores desde una posición única… dependerá de cómo el usuario interactúe con nuestro proyecto).
Antes de seguir, asegurate de haber entendido las diferencias conceptuales entre los dos tipos de envío de mensajes, de las ventajas de reusar scripts (like a subroutine, man) y, si te animás, ¡te desafío a que crees tu propio programa usando ambas ideas…!

enviar a todos [despierten a Pier]

¡Vayan sacando a Pier de su reparadora siesta! Con lo que vimos en estas 3 últimas páginas tendremos los recursos suficientes como para continuar nuestro proyecto original ("¿era algo sobre polígonos regulares, no?").
Mientras nuestro amigo artista se va despabilando, te sugiero fervorosamente que releas la primera página de este 4to paso:
  • te permitirá refrescar las nuevas metas que agregamos a nuestro proyecto, y
  • podrás repasar —con mucho más conocimiento de causa— lo que vislumbramos iba a ser una brillante estrategia: dividir la ejecución del proyecto en una secuencia de 4 etapas bien diferenciadas, las cuales van a poder comunicarse apelando al uso de mensajes.
Como ya sabrás, tengo la costumbre de dar anticipos: vamos a trabajar sobre el desarrollo de los algoritmos requeridos para cada una de las etapas, y en como implementar el envío de mensajes que deben vincularlos.
Las etapas 1 y 3 no presentarán mayores inconvenientes: la primera por ser más que simple de analizar y ejecutar, la etapa 3 porque en ella sólo habrá que retocar levemente lo ya hecho en el 3er paso de este Tutorial (de manera de adaptarlo a las nuevas circunstancias). Pero las etapas 2 y 4 …¡mamma mía!
PD: no quería cerrar este mini-tutorial sin dejar de agradecer la invalorable colaboración del gato de Scratch durante el transcurso del mismo… ¡gracias por tu contagioso aplomo y por tu paciencia, querido gato!
Última actualización: Febrero 27, 2014

No hay comentarios.:

Publicar un comentario

© Scratch CodeLab | D153ñ0 b454d0 3n l4 pl4n71ll4 SimpleRWD d3 Oloblogger