jueves, 31 de diciembre de 2020

Como se hizo. Envío de datos a un juego desde un iframe html embebido en él

Los juegos del Proyecto AJDA y las escenas de descartes en general, pueden contener páginas html integradas en ellos, de forma  que un espacio del juego sea una página html. Vamos a analizar como se envían datos al juego desde el iframe html que está embebido  en él,lo cual tiene diversas utilidades que trataremos en otros artículos

El iframe que está embebido será una sencilla página html, que llamaremos hijo.html y que contiene en su cuerpo dos elementos de entrada de datos, un campo de texto (con identificador CT) y un selector (con identificador SL):

<input name="textfield" type="text" id="CT" value="Campo de texto" >

<select name="selec" id="SL">

      <option value="0" selected></option>

      <option value="1">A</option>

      <option value="2">B</option>

      <option value="3">C</option>

      <option value="4">D</option>

    </select>

Para que se puedan enviar los datos al juego, en la cabecera del iframe embebido en el juego se debe incluir el siguiente código:

<head>
<script>

      window.onload = function(evt) {

        //Envío de la variable SL del HTMLiFrame al juego que lo contiene
        var ct1 = document.getElementById("SL");
        // cuando el slector cambia, de valor se envía el dato al juego padre  y se realiza una actualizacion. 
         ct1.addEventListener("change", function(evt) {
          window.parent.postMessage({ type: "set", name: "SL", value: this.value }, '*');
          window.parent.postMessage({ type: "update" }, '*');
        });
  //Envío de la variable CT del HTMLiFrame al juego que lo contiene
        var ct2 = document.getElementById("CT");
        // cuando el campo de texto cambia, es decir hay un enter o click, se envia el valor al juego padre.
        ct2.addEventListener("change", function(evt) {
          window.parent.postMessage({ type: "set", name: "CT", value: this.value }, '*');
          window.parent.postMessage({ type: "update" }, '*');
        });
      }
  
</script>
</head>

Al modificarse los campos del iframe embebdido en el juego, se enviarán a éste con el nombre establecido en  type: "set", name: "NOMBRE DE LA VARIABLE QUE SE RECIBIRÁ EL JUEGO". En este caso el evento addEventListener, cuando se produce un cambio en el valor del elemento al que está asociado, desencadena el envío del valor del mismo a través de la variable definida en set en la instrucción  window.parent.postMessage.

miércoles, 30 de diciembre de 2020

Como se hizo. Envío de datos desde un juego a la página que lo contiene

Un juego puede enviar datos a la página html que lo contiene, es más, desde los juegos se pueden ejecutar sentencias no complejas de javascript. La forma de realizarlo se indica en este artículo.

En un evento o control, se ejecuta la acción abrir URL y en parámetro se introduce javascript:void(); poniendo dentro de los paréntesis la instrucción javascript que se desea ejecutar. Si se repite la instrucción javascript:void(); con su correspondiente instrucción javascript, dichas instrucciones se ejecutarán sucesivamente.

acción='abrir URL'

parámetro='javascript:void(INSTRUCCIONES JAVASCRIPT);

Vamos a incluir un ejemplo. En el cuerpo html de la página que contiene un juego tenemos los siguientes tres elementos cada uno con su id:

<span id="textoRecibido1">

<span id="textoRecibido2">

<span id="textoRecibido3">

Desde el juego, a través de un control o un evento vamos a ejecutar la acción abrir URL y a través de su parámetro invocaremos instrucciones javascrit con javascript:void(); a través de la cual enviaremos información a los elementos html desde el juego que la contiene:

  • Enviamos al elemento textoRecibido1 el valor 50 al ejecutar la acción abrir URL.

acción='abrir URL' parámetro='javascript:void(document.getElementById('textoRecibido1').textContent = '50');'

  • Enviamos al elemento textoRecibido2 la fecha actual a través de la función Date() al ejecutar la acción abrir URL.

acción='abrir URL' parámetro='javascript:void(document.getElementById('textoRecibido2').textContent = Date());' 

  • Enviamos al elemento textoRecibido3 el valor de la variable del juego [SAM] al ejecutar la acción abrir URL.

acción='abrir URL' parámetro='javascript:void(document.getElementById('textoRecibido3').textContent = [SAM]);' 

Como hemos comentado inicialmente, no sólo se pueden enviar datos, sino que se pueden ejecutar funciones javascript de distinta naturaleza, como por ejemplo:

  • Cambiar los estilos de la página:

javascript:void(document.body.style.backgroundColor='yellow');

  • Poner mensajes emergentes, que pueden incluir variables númericas o de texto:

javascript:void(alert(('Mensaje emergente')); 

javascript:void(alert(([variableNumerica]); 

javascript:void(alert(('[variableTexto]'));  

  • Abrir una ventana nueva:

javascript:void(alert(window.open('http://newton.proyectodescartes.org/juegosdidacticos/','','scrollbars=1,with=400, height=300'));  

  • Pasar datos una web independiente:

javascript:void(alert(window.open(' 'web-receptora.html?= '+dat1+';@&'+dat2+'@&'+dat3+'&'+dat4','','with=300, height=300' ')); 

Como se hizo. Envío de datos desde un juego a un iframe html embebido en él

Los juegos del Proyecto AJDA y las escenas de descartes en general, pueden contener páginas html embebidas en ellos, es decir, que un espacio del juego sea una página html. Esto se ha utilizado en los juegos para cargar ficheros de preguntas a través de una página html (con contenido javascript) embebida en ellos.

Partamos de una sencilla página html, que llamaremos hijo.html y que contiene dos elementos identificados como: textoRecibido1 y textoRecibido2.

<body>

<div align="center">PÁGINA HIJO</div>

<span id="textoRecibido1"></span>        
<span id="textoRecibido2"></span> 

</body>

Ahora tenemos un juego, en el que definimos un espacio, llamado E2, en el que insertamos un espacio tipo HTMLIFrame en el que estará la página hijo.html.

value="tipo='HTMLIFrame' id='E2' x='90' y='90' ancho='50%' alto='50%'  archivo='hijo.html'

El juego puede enviar datos de variables al iframe embebido en él en el momento en el que se ejecuta la instrucción:

Nombre del espacio del HTMLIFrame en el juego.set('VARIABLE RECIBIDA POR LA PÁGINA HIJO.',VARIABLE ENVIADA POR EL JUEGO)

Para que los datos enviados por el juegos puedan ser recibidos por la página hijo, en la cabecera de la página hijo.html hay que introducir el siguiente código javascript, mediante el cual vamos a enviar dos variables desde el juego que contiene al iframe html:

<head>
<script>

window.addEventListener("load", function(evt) 
{
    window.addEventListener("message", funcionQueManejaLosMensajes);

   var data = evt.data;

  // Se envía la variable V1JUG desde el juego a la página hijo que la recibe como V1HIJ. 
  //En momento del juego en el que se quiera enviar se  pone la función E2.set('V1HIJ.',V1JUG)
         if ((data.type === "set")&&(data.name==="V1HIJ")) {
         // data.name es el nombre de la variable
         // data.value es el valor de la variable
   document.getElementById("textoRecibido1").textContent = data.value;
  }
         else if (data.type === "update") {
         }

  // Se envía la variable V2JUG desde el juego a la página hijo que la recibe como V2HIJ. 
  //En momento del juego en el que se quiera enviar se  pone la función E2.set('V2HIJ.',V2JUG)
         if ((data.type === "set")&&(data.name==="V2HIJ")) {
         // data.name es el nombre de la variable
         // data.value es el valor de la variable
   document.getElementById("textoRecibido2").textContent = data.value;
  }
         else if (data.type === "update") {
         }

});

</script>
</head>
  • Inicialmente se incluye un manejador (listener –oyente–) de eventos que actúa en este caso cuando se genera un mensaje (evento message) ejecutando la función que hemos llamado funcionQueManejaLosMensajes, es decir, que cuando el iframe recibe un mensaje (en este caso del juego, se ejecuta la función que maneja los mensajes, en este caso recibe los datos).
  • A continuación, desde el juego se han enviado dos variables que son recibidas como VIHIJ y V2HIJ. En los dos casos, en la condición lógica de la instrucción if, se identifica que data.type sea set y qué control ha sido el activado comparando data.name con V1HIJ o V2HIJ (estos son los nombres que se ponen entre comillas en el primer parámetro de la función set). Después se actúa de acuerdo a lo especificado en cada caso. Esa acción se inicia capturando el elemento de la página html cuyo id coincide con el indicado en document.getElementById("textoRecibido1"), en este caso "textoRecibido1" se corresponde con el id del elemento de hijo.html (análogamente pasa con "textoRecibido2"). La acción que se ejecuta en este ejemplo es cambiar el contenido de los elementos identificados como "textoRecibido" por el valor recibido del juego que está en data.value.
  • En los dos casos se ve cómo se gestiona respectivamente el evento mensaje generado por los controles V1HIJ y V2HIJ mediante la función set (en este caso el mensaje generado por update() no realiza nada, pues no se usa en el juego, recordamos que la función de update es actualizar la página después de cargar los datos).

Como se hizo. Envío de datos desde un juego embebido en un iframe a la página que lo contiene

Estudiemos el caso en el que tenemos un juego contenido en un iframe de otra página padre y que desde el juego se quieren enviar datos de algunas de sus variables a la página html padre que lo contiene.

Indicamos el código html del cuerpo de una página padre, que contiene dos elementos (identificados como: textoRecibido1 y textoRecibido2) y un juegos (juego.html), embebido como iframe.

<body>

<div align="center">PÁGINA PADRE</div>

<span id="textoRecibido1"></span>        
<span id="textoRecibido2"></span> 

</div><iframe id="JUEGO" src="juego.html" width=1000 height=700 frameborder=0 seamless scrolling="no"></iframe>
</body>

Para que los datos enviados por el juegos puedan ser recibidos por la página padre que los contiene, en la cabecera de la página padre hay que introducir el siguiente código javascript, mediante el cual vamos a enviar dos variables desde el juego embebido:

<head>
<script>

window.addEventListener("load", function(evt) 
{
    window.addEventListener("message", funcionQueManejaLosMensajes);

   var data = evt.data;

  // Se envía la variable V1JUG desde el juego a la página padre que la recibe como V1PAD. 
  //En momento del juego en el que se quiera enviar se  pone la función parent.set('V1PAD.',V1JUG)
         if ((data.type === "set")&&(data.name==="V1PAD")) {
         // data.name es el nombre de la variable
         // data.value es el valor de la variable
   document.getElementById("textoRecibido1").textContent = data.value;
  }
         else if (data.type === "update") {
         }

  // Se envía la variable V2JUG desde el juego a la página padre que la recibe como V2PAD. 
  //En momento del juego en el que se quiera enviar se  pone la función parent.set('V2PAD.',V2JUG)
         if ((data.type === "set")&&(data.name==="V2PAD")) {
         // data.name es el nombre de la variable
         // data.value es el valor de la variable
   document.getElementById("textoRecibido2").textContent = data.value;
  }
         else if (data.type === "update") {
         }

});

</script>
</head>

  • Los eventos iniciales window.addEventListener son los que permiten que el navegador este preparado para enviar y recibir los datos en cuanto se de la orden.
  • La define la variable data, en la que se recogerán la información de las variables que se reciban y envíen.
  • La instrucción condicional  if ((data.type === "set")&&(data.name === "NOMBRE VARIABLE")) {...} comprueba que el nombre de la variable espera recibir y el tipo, si estos son correctos ejecuta la acción que se le encomiende, en este caso cambiar el valor de un elemento por el de la variable recibida (document.getElementById("textoRecibido1").textContent = data.value). 
  • En el momento del juego en el que se quiera enviar el valor de la variable debe indicarse mediante la instrucción: parent.set('VARIABLE RECIBIDA POR LA PÁGINA PADRE.',VARIABLE ENVIADA POR EL JUEGO). Al ejecutarse parent.set en el juego los valores son automáticamente recibidos por la página padre.
Este intercambio de información entre juego y página html que lo contiene es importante para poder enviar y recibir datos desde dispositivos externos a los juegos, aumentando la interactividad de los mismos. 

Como se hizo. Envío de datos a un juego embebido en un iframe desde la página que lo contiene

Los juegos didácticos del proyecto AJDA son escenas de DescartesJS que se encuentran dentro de una página o documento html, la cual puede estar como un iframe de una página padre padre html que la contenga. Es decir, tenemos un juego que es un iframe de otra página padre. 

En este artículo vamos a tratar como enviar datos desde la página html padre al juego embebido como iframe en ella. 

Indicamos el código html del cuerpo de una página padre, que contiene tres controles (dos campos de texto, un botón y un selector) y un juegos (juego.html), embebido como iframe.

<body>

<div align="center">PÁGINA PADRE</div>

<input id="fecha" type="text" />  
<input id="curso" type="text" />
<input id="enviar" type="button" value="enviar curso">  
<select name="selec" id="respuesta">
      <option value="0" selected></option>
      <option value="1">A</option>
      <option value="2">B</option>
      <option value="3">C</option>
      <option value="4">D</option>
    </select>

</div><iframe id="JUEGO" src="juego.html" width=1000 height=700 frameborder=0 seamless scrolling="no"></iframe>
</body>

Para que los datos que se introduzcan en los campos de la página padre puedan ser recibidos por el juego, en la cabecera de la página padre hay que introducir el siguiente código javascript, mediante el cual vamos a enviar tres variables hacia el juego embebido de tres formas diferentes:

<head>
<script>

window.addEventListener("load", function(evt) 
{
    function funcionQueManejaLosMensajes(evt) {}

     //Envio de variable de forma automática, tras hacer cualquier acción en el navegador
     var contenido = document.getElementById("fecha");
     var iframe = document.getElementById("JUEGO");

     contenido.addEventListener("change", function(evt) 
       {
    iframe.contentWindow.postMessage({ type: "set", name: "enviofecha", value: contenido.value }, '*');
    iframe.contentWindow.postMessage({ type: "update" }, '*');
       });

   //Envio de variable al pulsar el botón enviar
   var contenido1 = document.getElementById("curso");
   var boton1 = document.getElementById("enviar");
   var iframe = document.getElementById("JUEGO");

   boton1.addEventListener("click", function(evt) 
      {
  iframe.contentWindow.postMessage({ type: "set", name: "enviocurso", value: contenido1.value }, '*');
  iframe.contentWindow.postMessage({ type: "update" }, '*');
      });

  //Envio de variable al cambiar el valor del campo selector
  var contenido2 = document.getElementById("respuesta");
  var iframe = document.getElementById("JUEGO");

  contenido2.addEventListener("change", function(evt) 
     {
 iframe.contentWindow.postMessage({ type: "set", name: "m1", value: contenido2.value }, '*');
 iframe.contentWindow.postMessage({ type: "update" }, '*');
    });

});

</script>
</head>
  • Los eventos iniciales window.addEventListener son los que permiten que el navegador este preparado para enviar y recibir los datos en cuanto se de la orden.
  • La define la variable data, en la que se recogerán la información de las variables que se reciban y envíen.
  • Después se ha definido la variable o variables cuyo/s contenido se quiere enviar (contenido, contenido1, contenido2) y en las cuales se ha introducido el valor de los diferentes controles creados en la página padre.
  • En la variable iframe se ha introducido el elemento iframe en el que se encuentra el juego.
  • Mediante el evento variable.addEventListener("acción", function(evt) {...} se indica que al realizar la "acción" indicada sobre la variable se ejecutará la función (en este caso el envío de datos).
  • La acción de enviar los datos se realiza mediante iframe.contentWindow.postMessage, en la cual se indica los datos de la variable cuyo valor se envía y el nombre de la variable que la recibe.
 iframe.contentWindow.postMessage({ type: "set", name: "NOMBRE DE LA VARIABLE QUE SE USARÁ EN EL JUEGO Y QUE RECIBE LOS DATOS", value: VARIABLE DE LA PÁGINA PADRE CUYOS DATOS SE QUIEREN ENVIAR.value }, '*');
 iframe.contentWindow.postMessage({ type: "update" }, '*');

Cuando se realicen los eventos indicados, el juego recibirá los valores de los variables y los podrá utilizar. En el código utilizado, las variables recibidas sería: enviofecha, enviocurso y m1.

Este intercambio de información entre juego y página html que lo contiene es importante para poder enviar y recibir datos desde dispositivos externos a los juegos, aumentando la interactividad de los mismos. 

Como se hizo. Envío de datos a un juego desde la página que lo contiene

Los juegos didácticos del proyecto AJDA son escenas de DescartesJS que se encuentran dentro de una página o documento html.

Pongamos que tenemos una página html en cuyo cuerpo están los siguientes elementos:

<body>

<div align="center">PÁGINA PADRE</div>

<input id="fecha" type="text" />  
<input id="curso" type="text" />
<input id="enviar" type="button" value="enviar curso">  
<select name="selec" id="respuesta">
      <option value="0" selected></option>
      <option value="1">A</option>
      <option value="2">B</option>
      <option value="3">C</option>
      <option value="4">D</option>
    </select>

<ajs>
Aquí iría el código del juego
</ajs>
</body>

En algunas ocasiones puede ser necesario pasar datos de variables desde el documento html al juego. El código javascript que debe insertarse en la cabecera de la página html que contiene el juego es el siguiente:

<head>
<script>

window.addEventListener("load", function(evt) 
{
    window.addEventListener("message", funcionQueManejaLosMensajes);

    var data = evt.data;

     //Envio de variable de forma automática, tras hacer cualquier acción en el navegador
     var contenido = document.getElementById("fecha");

     contenido.addEventListener("change", function(evt) 
       {
    window.postMessage({ type: "set", name: "enviofecha", value: contenido.value }, '*');
    window.postMessage({ type: "update" }, '*');
       });

   //Envio de variable al pulsar el botón enviar
   var contenido1 = document.getElementById("curso");
   var boton1 = document.getElementById("enviar");

   boton1.addEventListener("click", function(evt) 
      {
  window.postMessage({ type: "set", name: "enviocurso", value: contenido1.value }, '*');
  window.postMessage({ type: "update" }, '*');
      });

  //Envio de variable al cambiar el valor del campo selector
  var contenido2 = document.getElementById("respuesta");

  contenido2.addEventListener("change", function(evt) 
     {
 window.postMessage({ type: "set", name: "m1", value: contenido2.value }, '*');
 window.postMessage({ type: "update" }, '*');
    });

});

</script>
</head>

En juego recibirá las variables: enviofecha, enviocurso y m1, cuando se desencadenen los eventos correspondientes que disparan su envío.

Detallamos la instrucción que realiza el envío de las variables:

         window.postMessage({

           type: "set",
             name: "VARIABLE QUE RECIBIRÁ EL JUEGO",
                  value: VARIABLE DEL DOCUMENTO HTML QUE SE QUIERE PASAR AL JUEGO
      }, '*');
         window.postMessage({
             type: "update"
         }, '*');


Con este código, los datos de la VARIABLE DEL DOCUMENTO HTML QUE SE QUIERE PASAR AL JUEGO, se pasarán al éste mediante la VARIABLE QUE RECIBIRÁ EL JUEGO. El juego utilizará la VARIABLE QUE RECIBIRÁ EL JUEGO con los datos recibidos como una variable más del mismo.

El código debe ir entre etiquetas <scripts></scripts> y mediante instrucciones javascript se puede controlar cuando se ejecuta mediante la utilización de condicionales, funciones y/o eventos.

El evento window.addEventListener("load", function(evt) {...} permite que se produzca la transferencia de varuibles.

La instrucción window.postMessage({ }) puede repetirse tantas veces como variables quieran pasarse desde el documento html al juego.

Una aplicación práctica de esto es la carga en juegos del idioma o por defecto o del fichero de preguntas por defecto.

Como se hizo. Carga de idioma por defecto

Por cuestiones de seguridad informática, los navegadores no permiten la lectura directa, es decir, a través de código de programación, de ficheros alojados en el equipo local del usuario.

Los juegos didácticos del Proyecto AJDA cargan el idioma de la interfaz de ficheros de texto (hay un fichero .txt para cada idioma). Cuando el juego se ejecuta desde la web de AJDA (a través de Internet) no hay problema ya que los ficheros de idioma se cargan desde el servidor web y el navegador lo permite sin problema. Sin embargo, cuando los juegos se ejecutan directamente desde el equipo local del usuario, los navegadores no permiten la carga de los ficheros de idiomas por las mencionadas cuestiones de seguridad.

Si no se carga la interfaz, el juego no puede utilizarse directamente desde el ordenador del cliente. Para solucionar este problema, los juegos se han diseñado para que el fichero de idioma por defecto (esp.txt), se cargue de forma automática al principio del juego desde la web del Proyecto ADJA, utilizando las tecnologías AJAX, tal y como comentamos a continuación.

En la cabecera de cada juego, entre las etiquetas <head> y </head>, se introduce el siguiente código javascript que comentamos a continuación:

<script>

var nombreJuego = "Nombre del fichero que contiene el juego";
var idm;

function leerIdioma(urlIDM)
{
var xmlhttp = new XMLHttpRequest();
xmlhttp.onreadystatechange = function()
     {
    if ( xmlhttp.readyState == 4 && xmlhttp.status==200 )
           {  
idm = xmlhttp.responseText;
 
      window.addEventListener("load", function(evt) 
                     {
        window.postMessage({
          type: "set",
            name: "IDMDEFECTO",
              value: idm
     }, '*');
        window.postMessage({
            type: "update"
        }, '*');
      });
        }
}
xmlhttp.open("POST", urlIDM, false);
xmlhttp.send(); 
}
var urlIDM = servidor  + rutaJuegosPrefijo + nombreJuego + rutaIdioma;
leerIdioma(urlIDM);

</script>
  • Las variables: urlIDM, servidor, rutaJuegosPrefijo, nombreJuego, rutaIdioma, sirven para indicar la ruta completa en la que se encuentra el fichero de idioma por defecto dentro de la web del Proyecto AJDA.
  • La llamada a la función leerIdioma(urlIDM) se realiza después de ser definida, por lo que se ejecuta automáticamente, pasándole como parámetro la variable que contiene la ruta del fichero de idioma que se encuentra en la web de AJDA (urlIDM).
  • La leerIdioma(urlIDM) es la que se encarga de traer los datos del fichero de idioma por defecto a través de las tecnología AJAX y su funcionamiento es el siguiente:
    • Primero se crea el objeto javascript XMLHttpRequest(), que permite traer información de una URL en segundo plano (puede traer datos de otra web).
    • Después se indica que cada vez que cambie el estado de la propiedad readyState (estado de la llamada a la información pedida) por el objeto XMLHttpRequest(), a través del evento onreadystatechange, se ejecute la siguiente función (ver siguiente punto).
    • La función en primer lugar comprueba que la respuesta es completa (xmlhttp.readyState ==4) y correcta (xmlhttp.status==200). En caso de serlo se introduce en la variable idm los datos recibidos en el objeto xmlhttp en formato texto (.responseText).
    • A continuación se desencadena un evento window.addEventListener, que pasa el valor de la variable idm a la variable IDMDEFECTO y envía el valor de IDMDEFECTO a la escena del juego que está en la misma página, en su parte <body>, a través de la instrucción  window.postMessage (que tiene el formato indicado en el código).
    • Por último se indica la forma de comunicación: método (GET/POST), dirección URL y sincronicidad (true/false, false indica que se haga de forma síncrona) (xmlhttp.open("POST", urlIDM, false)), a través de la cual se van a enviar los datos solicitados y se ordena su envío (xmlhttp.send()).
En la parte del juego, al comenzar este se ordena ejecutar automáticamente la función: FICHEROIDIOMA(), que es un algoritmo que realiza lo siguiente:
  • Introduce el valor de IDMDEFECTO en la variable cadena3b (cadena3b=IDMDEFECTO).
  • Crea la variable cadena3 que lo que hace es preparar la variable cadena3b para que pueda ser transformada en un vector (cadena3='<IDM>\n'+cadena3b+'</IDM>').
  • Convierte la variable cadena3 en el vector IDM (_StrToVector_(cadena3,'IDM')).
A partir de este momento, los valores del vector IDM (IDM[0], IDM[1], IDM[2]... ), pueden ser usados en los nombres de los controles y textos de la interfaz del juego.

Como se hizo. Fichero de resultados

Otra opción que presentan los juegos del Proyecto AJDA consiste en la posibilidad de guardar, en cualquier momento de la partida, los resultados que los jugadores están obteniendo en la misma a través del botón resultados, situado en la parte superior izquierda.

Al ser pulsado se podrá guardar un fichero de texto, con el nombre deseado, que contendrá los datos más significativos que cada jugador lleva en el momento del juego en el que es generado.

Desde el punto de vista de la programación de juego, cuando se acciona el citado control se desencadenan las siguientes acciones:

  • Se introducen los datos significativos de la situación de la partida en las diferentes filas de un vector denominado RS1 (RS1[0]=var0; RS1[1]=var1; RS1[2]=var2;...).
  • Se ejecuta la función algorítmica guardar(), que pasa todos los valores del vector RS1 a la variable texto de la siguiente forma:
inicio='texto=''; ter=0; maximo=nº lineas necesarias' 
hacer='texto=(ter<maximo-1)?(texto+RS1[ter]+'\n'):texto+RS1[ter]; ter=ter+1' 
mientras='ter<maximo'

  • La instrucción _Save_('resultado.txt',texto), guarda los datos de la variable texto en un fichero de texto, cuyo nombre por defecto es resultado.txt.

Se debe tener en cuenta lo siguiente:
  • Se pueden guardar tantos ficheros de resultados como se deseen y conviene indicar en el nombre del fichero una referencia de cuando fue generado.
  • El fichero de resultados se genera en el idioma que esté definida la interfaz en el momento de guardarse.
  • No se debe confundir el fichero de resultados con el de guardar partidas para después continuarlas posteriormente. El fichero de resultados es legible y editable y no sirve para reanudar partidas.
  • Los datos incluidos en el fichero de resultados son característicos de cada juego.
  • La finalidad de este tipo de fichero es dejar un registro de los resultados de la actividad en cualquier momento.

martes, 29 de diciembre de 2020

Como se hizo. Juegos con tiempo

En parte de los juegos de AJDA es necesario utilizar y medir el tiempo de duración de las preguntas u otras acciones del juego.

El tiempo es un valor que se introduce en una o varias variables y cuya variación se controla normalmente a través del algoritmo de la pestaña Animación del editor de DescartesJS.


A través del mismo se inicializan las variables y se establece cuando empieza, se para, reanuda, etc, a través de las instrucciones incluidas en sus apartados hacer y mientras. A través del mismo se pueden introducir varias variables para controlar más de un tiempo, por ejemplo, para controlar un tiempo para cada jugador.

Sin embargo, es importante tener en cuenta que la ejecución del algoritmo puede ser más o menos rápida dependiendo del equipo informático en el que se ruede. Además, en muchas ocasiones puede ser conveniente poder modular el transcurso del mismo.

Por ello, los juegos que utilizan tiempo, llevan un control tipo barra para modulación de la velocidad del mismo en la parte superior derecha. Este control, llamado habitualmente TIM, puede ser modificado en cualquier momento del juego y cuyo valor se incluyen en los incrementos y decrementos de tiempo de los juegos.



Otra cuestión relacionada con el tiempo es que cuando los cronómetros se presentan en pantalla y se quiere que el valor del tiempo aparezca centrado en ellos, al pasar de 3 cifras, a 2 o a 1, la posición del valor del tiempo del cronómetro se descentra. Actualmente DescartesJS contiene funciones que permiten centrar los textos, pero cuando la mayoría de los juegos fueron realizados dichas instrucciones no estaban implementadas. Para ello se utilizaron condicionales que desplazaban la posición de los textos según su número de cifras:

 [20+((t>=10)?5),30]

Otra opción más reciente fue utilizar controles tipo botón, que no ejecutasen ninguna acción para utiliza cronómetros y marcadores con valores centrados.

Como se hizo. Efectos sonoros

Los juegos didácticos del Proyecto AJDA cuentan con efectos sonoros, que pueden activarse o desactivarse en cualquier momento del juego a través del correspondiente control situado en la parte superior derecha:


Al ser pulsado este control el valor de la variable MUS cambia de 0 a 1 y viceversa a través del siguiente cálculo:

MUS=(MUS=0)?1:0

Cuando MUS=0, la música está activada y cuando MUS=1 está desactivada. La imagen que se muestra en el control de sonido depende del valor de la variable MUS.

[(MUS=0)?'sonido-on.png':'sonido-off.png']

Cada uno de los efectos sonoros de los juegos se encuentra en un fichero con extensión .mp3 y estos se activan normalmente a través de eventos que se de forma alterna cuando se cumplen una determinadas condiciones establecidas por la dinámica del juego.

evento='si;' condición='(condiciones) acción='reproducir' parámetro='agua.mp3'

Cuando el efecto sonoro es de mayor duración y este se quiere detener cuando se cumpla una determinada condición, se incluye la palabra stop tras el nombre del fichero en el evento correspondiente.

evento='si;' condición='(condiciones) acción='reproducir' parámetro='agua.mp3 stop'

El fichero de texto que contiene el efecto sonoro se encuentra el el mismo directorio o carpeta del juego. Si un fichero de sonido se sustituye por otro con el mismo nombre, el sonido presentado sería el del nuevo fichero.

Actualmente DescartesJS tiene la posibilidad de incluir reproductores de audio y vídeo, con panel de controles de reproducción y parámetros específicos que permiten el control de las mismas mediante instrucciones de Descartes.