Serie ficheros virtuales 

 

 

javascript ficheros virtuales

 

 

 

El juego de la vida de Jhon H.Conway

 

1 Introducción

2 Reglas del juego de la vida de Jhon H.Conway

3 Funciones de conversión fija

4 Definición de la estructura de soporte de la implementación

5 Implementación de la biblioteca de servicios “juvida_ficherosvirtuales_com.js

6 Interfaz de presentación

7 Código fuente

 

                                                                                                       ________           

                                                                       

1 Introducción

 

Este capítulo se dedicará a desarrollar un programa de generación de poblaciones de autómatas celulares bajo la reglas del juego de la vida de Jhon H.Conway

 

Se comenzará introduciendo las reglas del juego y a continuación se definirá una base de datos virtual para su implementación.

 

La implementación se llevará a cabo en javascript, siguiendo los pasos de la implementación para C ANSI presentada en el capítulo homónimo del blog base.

Concretamente, en los siguientes epígrafes de este capítulo presentaremos la definición del Juego De La Vida de Jhon H.Conway y luego acometeremos su implementación, así se definirá una base de datos virtual que servirá de soporte del código para implementar las reglas de evolución poblacional. Esta codificación se escribió anteriormente en C ANSI y en VBA y ahora la traduciremos a javascript.

 El modulo central se codificará como una biblioteca de servicios que hereda su código del SRjuvida original y que luego se utilizaran como soporte para presentar un ciclo continuo de autogeneración de juegos de la vida en una esquina del sitio ficherosvirtuales.com; la presentación heredará las hojas de estilo del desarrollo en VBA para excell anterior.

 Aquí se presentará una codificación extractada centrada en el propósito de mostrar la conversión de los desarrollos originales a javascript.

 

                                                                                                      ________


 

2 Reglas del juego de la vida de Jhon H.Conway

 

Estas reglas, inventadas por John H.Conway, modelan la vida de una sociedad de autómatas celulares del plano.

 

 

Para el modelado, hay que tener en cuenta que cada celda del plano puede contener un organismo y que cada celda tiene ocho vecinas que la rodean.

 

 

En cada generación los nacimientos y muertes siguen unas sencillas reglas:

 

·         Un organismo nace en cualquier celda vacía que tenga exactamente 3 vecinos

·         Un organismo muere por aislamiento si tiene menos de 2 vecinos

·         Un organismo muere por superpoblación si tiene más de 3 vecinos

·         El resto de celdas no se modifica

 

 

 

 

Veamos un ejemplo concreto de evolución de algunas figuras

 

 

           @          @       @

@@@       @ @        @ @      @

@ @       @ @

 

 

@         @@         @@       @@       @@      @@    @@      @@     @@     @@

@@        @@         @@       @@       @@      @@    @@      @@     @@     @@

 

 

 

                     @       @@@       @       @

  @       @@@      @@ @@     @@@      @ @      @

@@ @@    @@ @@              @@ @@

 @ @     @@ @@     @   @     @@@     @   @     @             @      @      

  @        @        @@@      @@@               @     @@@     @      @      @@@

                              @       @@@      @             @      @      

 

 

 

Y ahora una pantalla de muestra

 

 

                                                                                                      ________

 

 

3 Funciones de conversión de longitud fija

 

Para poder comparar los objetos auxiliares que emulan a los ítems poblacionales, se precisan métodos de conversión directa e inversa a String de forma que puedan compararse y ordenarse utilizando los propios métodos String.

 

Para facilitar esta tarea, se introducen las funciones de conversión alfanumérica de longitud fija que siguen

 

 

     

      // Conversor de clave a formato alfanumérico

     

      function SRRCAL_lLexi(Num)

{

            var lKTE = 1000000000; // Constante de normalización para long's

            var AlfaNum = " ";     // Valor de retorno

 

            AlfaNum = lKTE + Num + "";

            return AlfaNum;

      }

 

 

     

      // Conversor recíproco

     

      function SRRCAL_lLexiR(AlfaNum)

{

            var lKTE = 1000000000; // Constante de normalización para long's

            var Num = 0;           // Valor de retorno

 

            Num = parseInt(AlfaNum) - lKTE;

            return Num;

      }

                                                                                                      ________

 

 

4 Definición de la estructura de soporte

 

Para una implementación de este modelo la herramienta de los ficheros virtuales es particularmente apropiada, pues se desarrollarán accesos por una vía de acceso principal en (i,j) y otra en (j,i) además de utilizar una instancia de base de datos principal y otra de trabajo asociada a la evolución en curso, ambas basadas en la misma definición de estructura de soporte, resultante de transcribir la utilizada en el desarrollo original en C ANSI.

 

 

      // Estructura del formato de registro del fichero de soporte de la evolución del Juego De La Vida

      //

      // Base 0   0         1         2         3         4

      //          01234567890123456789012345678901234567890

      // Base 1            1         2         3         4

      //          12345678901234567890123456789012345678901

 

      var aDS0 = "00000000000000000000000000000000000000000"; // Item nulo

     

              // "10000000011000000001100000000110000000011"; // Item muestra [(1,1):1]

              //           i         j         j         ia(a:0=Desactivo,1=Activo)

              //          10        10        10        101

              //                    20                   21 T:41

 

 

Esta estructura se concreta en objetos auxiliares que implementan métodos de conversión directa e inversa a String de forma que puedan compararse y ordenarse.

 

 

      var aDSo = [" "];          // Work paso de datos en formato alfanumérico datos ítem anterior sin envoltura

      var DSo = new KD(0, 0, 0); // Work paso de datos en formato objeto

 

      var aDSa = [" "];          // Work paso de datos en formato alfanumérico datos ítem anterior con envoltura

      var DSa = new KD(0, 0, 0); // Work paso de datos en formato objeto

 

      var aDSc = [" "];          // Work paso de datos en formato alfanumérico datos ítem en curso

      var DSc = new KD(0, 0, 0); // Work paso de datos en formato objeto

 

                                                                                                      ________

 

     

La función objeto asociada se define como sigue:

 

 

      function KD(i, j, a)

      {

     

            // Definición C original

           

            //static struct sDsKD

            //{

            // struct sDsK DK;     // Clave principal ij

            // struct sDsK01 DK01; // Clave inversa   ji

            // struct sDsD DD;     // Datos

            //} DSc, DSa;          // Escenario en curso y anterior

 

           

            // Ds de claves del fichero de soporte de ítem poblacional

           

           

            // Clave principal

           

            function K(i, j)

            {

           

                  // Definición C original

                 

                  //struct sDsK   // Estructura de claves de acceso a nodos (i,j)

                  //{

                  // long i;     // Índice i del nodo

                  // long j;     // Índice j del nodo

                  //};    

                 

                 

                  // Funciones de conversión asociadas

                 

                 

                  // K --> toString

                 

                  function toString()

                  {

                        var ci = " ";  // Paso de clave i

                        var cj = " ";  // Paso de clave j

                        var cij = " "; // Paso de clave ij. Valor de retorno

                       

                        // Construye conversión de clave a string normalizado

                       

                        ci = SRRCAL_lLexi(this.i);

                        cj = SRRCAL_lLexi(this.j);

                        cij = ci + cj;

                       

                        return cij;

                  }

                 

                 

                  // Recíproco

                 

                  function Parse(cK)

                  {

                        var ci = " "; // Paso de clave i

                        var cj = " "; // Paso de clave j

                 

                        ci = cK.substr(0, 10);

                        this.i = SRRCAL_lLexiR(ci);

                       

                        cj = cK.substr(10, 10);

                        this.j = SRRCAL_lLexiR(cj);

                       

                        return;

                  }

                 

                 

                  // Definición de objeto clave principal

                 

                  this.i = i;

                  this.j = j;

                  this.toString = toString;

                  this.Parse = Parse;

                 

                  return;

            }

           

           

            // Ds de claves por columna-fila

           

            function K01(i, j)

            {

           

                  // Definición C original

                 

                  //struct sDsK01 // Estructura de claves activo-desactivos

                  //{

                  // long j;     // Índice j del nodo

                  // long i;     // Índice i del nodo

                  //};

                 

                 

                  // Funciones de conversión asociadas

                 

                  // K01 --> toString

                 

                  function toString()

                  {

                        var cj = " ";  // Paso de clave j

                        var ci = " ";  // Paso de clave i

                        var cji = " "; // Paso de clave ji

                 

                 

                        // Construye conversión de clave a string normalizado

                       

                        cj = SRRCAL_lLexi(this.j);

                        ci = SRRCAL_lLexi(this.i);

                        cji = cj + ci;

                       

                        return cji;

                  }

                 

                 

                  // Recíproco

                 

                  function Parse(cK01)

                  {

                        var cj = " "; // Paso de clave j

                        var ci = " "; // Paso de clave i

                       

                        cj = cK01.substr(0, 10);

                        this.j = SRRCAL_lLexiR(cj);

 

                        ci = cK01.substr(10, 10);

                        this.i = SRRCAL_lLexiR(ci);

 

                        return;

                  }

                 

                 

                  // Definición de objeto clave columna-fila

                 

                  this.j = j;

                  this.i = i;

                  this.toString = toString;

                  this.Parse = Parse;

                 

                  return;

            }    

           

                       

           

            // Ds de datos del fichero de soporte  

           

            function D(a)

            {

           

                  // Definición C original

                 

                  //struct sDsD   // Estructura de datos asociados

                  //{

                  // short int a; // 0,1 Visualmente activo

                  //}; 

                 

                 

                  // Funciones de conversión asociadas

                 

                  // D --> String

                 

                  function toString()

                  {

                        return this.a;

                  }

                 

                 

                  // Recíproco

                 

                  function Parse(cD)

                  {

                        this.a = cD.substr(0, 1);

                       

                        return;

                  }

                 

                 

                  // Definición de objeto datos

                 

                  this.a = a;

                  this.toString = toString;

                  this.Parse = Parse;

                 

                  return;

            }    

           

                       

           

            // Funciones de conversión asociadas    

           

            // KD --> String

           

            function toString()

            {

                var cKD = " ";    // Valor de retorno

                 

                var cK = " ";     // Paso de KD.K

                var sK = new K(this.K.i, this.K.j);

                       

                var cK01 = " ";   // Paso de KD.K01

                var sK01 = new K01(this.K01.i, this.K01.j);

               

                var cD = " ";     // Paso de KD.D

                var sD = new D(this.D.a);

 

                cK   = sK.toString();

                cK01 = sK01.toString();

                cD   = sD.toString();

                 

                cKD  = cK + cK01 + cD;

                 

                return cKD;

            }

           

           

            // Recíproco

           

            function Parse(cKD)

            {

                var cK = " ";     // Paso de KD.K

                var sK = new K();

                       

                var cK01 = " ";   // Paso de KD.K01

                var sK01 = new K01();

               

                var cD = " ";     // Paso de KD.D

                var sD = new D();

           

                cK = cKD.substr(0, 20);

                sK.Parse(cK);

                 

                cK01 = cKD.substr(20, 20);

                sK01.Parse(cK01);

                 

                cD = cKD.substr(40, 1);

                sD.Parse(cD);

                 

                 

                this.K.i = sK.i;

                this.K.j = sK.j;

                 

                this.K01.j = sK01.j;

                this.K01.i = sK01.i;

                 

                this.D.a = sD.a;

                 

                return;

            }

     

     

           

        // Definición de objeto estructura de registro completo

 

        this.K = K;

        this.K01 = K01;

        this.D = D;

       

        this.toString = toString;

        this.Parse = Parse;

 

        var sK   = new K(i, j);

        var sK01 = new K01(i, j);

        var sD   = new D(a);

 

        this.K.i = sK.i;

        this.K.j = sK.j;

                 

        this.K01.j = sK01.j;

        this.K01.i = sK01.i;

                 

        this.D.k = sD.k;

        this.D.a = sD.a;

           

     

        return;

      }

     

     

      // Ds de lista de números para muestras aleatorias sin repetición

     

      //struct sK   // Estructura de claves de acceso a ítem k

      //{

      // long lk;   // Item k

      //} Kc;       // Work paso de datos PrChainR

     

      var Kc = [" "]; // Work paso de datos PrChainR

     

 

Disponiendo de esta base de datos, la implementación surge de forma natural; así, para pasar de una generación a la siguiente, se volcará la situación actual al duplicado de trabajo, incluyendo los puntos frontera, y a continuación se leerá este duplicado temporal aplicándose a cada ítem el conjunto de reglas del juego.

 

 

El epígrafe siguiente se dedica a presentar la implementación del proceso que se acaba de resumir.

 

                                                                                                      ________

 

 

5 Implementación de la biblioteca de servicios “juvida_ficherosvirtuales_com.js

 Para codificar la implementación en javascript primero se ha convertido el código C ANSI “SRjvida” original de la serie de la manera expuesta anteriormente, y luego se ha encapsulado siguiendo lo indicado también en un capítulo previo.

 Tras estos pasos resulta una biblioteca de servicios en javascript donde se exportan los métodos relacionados al final del módulo como “this.método”. En estas bibliotecas, cada método exportado se ha codificado previamente como función resultante de traducir la colección de funciones del programa de servicio original. 

 

 Veamos ahora un extracto del procedimiento seguido tomando como ejemplo el método SRjvida.open:

 

function juvida_ficherosvirtuales_com()

{

 

 

    // Los miembros exportados se encuentran al final del modulo

 

      //------------------------------------------------------------------------------

      // Variables globales

      //------------------------------------------------------------------------------

     

      var w = new w_ficherosvirtuales_com();

     

. . .

 

 

 

//-----------------------------------------------------------------------------

// Procedimientos internos

//-----------------------------------------------------------------------------

     

      . . .

 

 

//-----------------------------------------------------------------------------

// Procedimientos soporte de miembros exportados

//-----------------------------------------------------------------------------

 

( Se presenta ahora el código completo de la función “SRjvida_Open” que luego se exporta como método  [this.] “Open  al final del módulo)

 

 

 

//-----------------------------------------------------------------------------

// Apertura común

//-----------------------------------------------------------------------------

function SRjvida_Open()

{

 var lNID = 0;   // Nid asignado al fichero de soporte de datos

 var lNID01=0;   // Nid asignado al lógico ji

 

 

 // Crea ficheros virtuales de soporte. En curso y anterior

 

 lNID = w.NID("PVIDAC");

 if (lNID) return lNID;

 

 

     

      // Estructura del formato de registro del fichero de soporte de la evolución del Juego De La Vida

      // Base 0   0         1         2         3         4

      //          01234567890123456789012345678901234567890

      // Base 1            1         2         3         4

      //          12345678901234567890123456789012345678901

              // "10000000011000000001100000000110000000011"; // Ítem muestra

              //           i         j         j         ia(0=Desactivo,1=Activo)

              //          10        10        10        101

              //                    20                   21 T:41

 

     

 // Fichero de población en curso

 

      lNID = w.NEW("PVIDAC", 20, 41);

      lNID01 = w.CRTLF("PVIDAC01", "PVIDAC", 1 + 20, 20);

 

 

 // Fichero de población anterior con envoltura

 

 lNID = w.NEW("PVIDAA", 20, 41);

 lNID01 = w.CRTLF("PVIDAA01", "PVIDAA", 1 + 20, 20);

 

 

 // Fichero de población anterior sin envoltura

 

 lNID = w.NEW("PVIDAO", 20, 41);

 lNID01 = w.CRTLF("PVIDAO01", "PVIDAO", 1 + 20, 20);

 

 return lNID;

}

     

      . . .

 

 

     

      // Miembros de juvida_ficherosvirtuales_com exportados

     

   

     

      this.Open  = SRjvida_Open;

      this.Close = SRjvida_Close;

     

      this.lLexi  = SRRCAL_lLexi;

      this.lLexiR = SRRCAL_lLexiR;

     

      this.CLRF    = SRjvida_CLRF;

      this.Gen     = SRjvida_Gen;

      this.New     = SRjvida_New;

      this.Npob    = SRjvida_Npob;

      this.Ocupada = SRjvida_Ocupada;

      this.Read    = SRjvida_Read;

      this.Ref     = SRjvida_Ref;

      this.Write   = SRjvida_Write;

 

      this.OcupadaAntOrigen = SRjvida_OcupadaAntOrigen;

      this.OcupadaAnt       = SRjvida_OcupadaAnt;

     

      this.ReadAntOrigen = SRjvida_ReadAntOrigen;

      this.ReadAnt       = SRjvida_ReadAnt;

     

      this.H  = SRjvida_H;

      this.HD = SRjvida_HD;

      this.HI = SRjvida_HI;

 

this.V  = SRjvida_V;

      this.VI = SRjvida_VI;

      this.VS = SRjvida_VS;

     

      this.j00 = SRjvida_00;

      this.j09 = SRjvida_09;

      this.j0j = SRjvida_0j;

      this.j90 = SRjvida_90;

      this.j99 = SRjvida_99;

      this.j9j = SRjvida_9j;

 

 return;

}

                                                                                                      ________

 

 

6 Interfaz de presentación

 

 
En el blog hermano VBA Ficheros virtuales se implementó una versión para excell del programa para generar evoluciones poblacionales del juego de la vida, con los servicios centrales de generación  implementados como complemento excell y la presentación visual dejándola de cuenta de una hoja como la siguiente

 

 

Si utilizamos en esta hoja la opción de salvar como página web podemos copiar las instrucciones css para poder reproducir la presentación en un desarrollo javascript dinámico.

 

 

De hecho, en el sitio web principal de la serie se presenta un sudoku animado en la esquina superior derecha con un resultado gráfico como sigue:

 

 

 

 

El código css resultante asociado se puede consultar en el epígrafe final del capítulo dedicado al código fuente.

 

 

En cuanto al propio código del interfaz, se divide en dos partes. La primera se asocia a un frame padre auxiliar oculto y en ella radica la generación de las poblaciones  y el repositorio de datos utilizando ficheros virtuales. La segunda gestiona la presentación alimentándose de los datos almacenados en el frame padre. Aquí presentaremos el código principal, al final del capítulo se puede enlazar al conjunto completo del código.

 

                                                                                                          ________

 

 

El código html de la carga principal consta de dos partes sencillas. Primero la estructura de marcos principal: AutoJuVida.html

 

 

<HTML>

 

<SCRIPT LANGUAGE="Javascript" SRC="w_ficherosvirtuales_com.js"></SCRIPT>        [soporte de ficheros virtuales para paso de datos]

<SCRIPT LANGUAGE="Javascript" SRC="juvida_ficherosvirtuales_com.js"></SCRIPT>   [soporte de servicios del juego de la vida]

<SCRIPT LANGUAGE="Javascript" SRC="AutoJuVida.js"></SCRIPT>                     [parte de programación de cabecera]

 

 

<HEAD>

<TITLE>Juego de la vida en ficheros virtuales</TITLE>

</HEAD>

 

 

<FRAMESET id="AutoCabecera" COLS="900, *">   

 

 

  <FRAME SRC="Cabecera.html" NAME="Izquierda" MARGINWIDTH="10" MARGINHEIGTH="0">                         [Esta parte es estática]

 

  <FRAME SRC="AutoJuVida_Derecha.html" NAME="Derecha" MARGINWIDTH="10" MARGINHEIGTH="0" scrolling="no">  [Esta parte ejecuta la programación]

 

 

</FRAMESET>

 

 

</HTML>

 

                                                                                                          ________

 

 

 

El código que ejecuta la programación (AutoJuVida_Derecha.html) también es muy simple porque lo que hace es invocar la rutina de carga PrJVGeneracionAuto que genera la presentación final:

 

 

<HTML>

 

<SCRIPT LANGUAGE="Javascript" SRC="AutoJuVida_Detalle.js"></SCRIPT>

 

<HEAD>

 

<TITLE>AutoJuegoDeLaVida Derecha</TITLE>

 

<link rel="stylesheet" type="text/css" href="AutoJuVida.css">

 

</HEAD>

 

<BODY BGCOLOR='#F0F8FF' onload='PrJVGeneracionAuto()'>

</BODY>

 

</HTML>

                                                                                                          ________

 

 

 

Ahora presentaremos la rutina principal del frame padre:

 

 

// Variables globales

 

var j = new juvida_ficherosvirtuales_com(); // Soporte de generaciones del juego de la vida

var wJV = new w_ficherosvirtuales_com();    // Soporte infraestructura ficheros virtuales

 

 

//-------------------------------------------------------------------------------------

// Proceso Principal: PrJVGeneracion

//

// Descripcion: (Re)Generacion de Juegos De La Vida

//

// Parametros:

// (entrada)  N : Dimension poblacional (N*N)

//            M : Marco de referencia (M > N)

//

// Retorno:   Ninguno

// 

//-------------------------------------------------------------------------------------

function PrJVGeneracion(N, M)

{

 var lResul = 0; // Control de resultados intermedios

 var lNpob = 0;  // Dimension poblacional

 var C = 0;      // Aux.paso contador de muestras

 

 

 // Time inicial

 

 var DateIni = new Date();

 

 

 // Filtro longitud

 

 if (N > M) N = M;

 

 

 

 // (Re)generacion de juego de la vida

 

 j.Open();

 

 Npob = j.New(N);

 

 

 

 // Guarda parametros de referencia

 

 lResul = PrJVGuardaN(N);

 lResul = PrJVGuardaM(M);

 

 

 

 // Actualiza contadores

 

 C = PrJVLeeCuentaMuestras();

 ++C;

 

 lResul = PrJVGuardaCuentaMuestras(C);

 

 lResul = PrJVGuardaCuentaIteraciones(0);

 

 

 

 // Time final

 

 var DateFin = new Date();

 

 

 

 // Graba DifTime

 

 lResul = PrJVGrabaDifTime("TOTAL", DateIni, DateFin);

 

 

 

 // Fin de proceso

 

 return;

}

                                                                                                          ________

 

 

El juego de detalle consta de dos procesos principales. El autoarranque que invoca la hoja de carga, y la evolución automática posterior.

 

La primera tiene el siguiente código

 

 

//-------------------------------------------------------------------------------------

// Proceso Principal: PrJVGeneracionAuto

//

// Descripcion: Generacion automatica de Juegos De La Vida

//

//-------------------------------------------------------------------------------------

function PrJVGeneracionAuto()

{

 

 var C = parent.PrJVLeeCuentaMuestras(); // Aux.paso contador de muestras padre

 

 

 

 // Dimension dft (Primera vez la mitad)

 

 var M = 24;

 

 if (!C) M /= 2;

 

 var N = Math.floor(66 * M / 100);

 

 

 // Regeneracion

 

 parent.PrJVGeneracion(N, M);

 

 parent.PrJVGuardaNpob4(0);

 parent.PrJVGuardaNpob3(0);

 parent.PrJVGuardaNpob2(0);

 parent.PrJVGuardaNpob1(0);

 

 

 // AutoPresentacion

   

 clearTimeout(ID_Timeout_JVAutoMostrarResultados);

 ID_Timeout_JVAutoMostrarResultados = setTimeout("PrJVMostrarResultados()", 1675);

 

 

 return;

}

                                                                                                          ________

 

Que continua en

 

//-------------------------------------------------------------------------------------

// Funcion: PrJVMostrarResultados

//

// Descripcion: Pruebas de Magic. Presenta resultados

//

//-------------------------------------------------------------------------------------

function PrJVMostrarResultados()

{

     

      // Lee parametros

     

      var N = parent.PrJVLeeN();

      var M = parent.PrJVLeeM();

 

 

      // Construye el documento de resultados a visualizar (Con autobucle de evolucion poblacional)

 

      document.writeln("<HTML>");

 

      document.writeln("<HEAD>");

           

      document.writeln("<TITLE>AutoJuegoDeLaVida</TITLE>");

           

      document.writeln('<link rel="stylesheet" type="text/css" href="AutoJuVida.css">');

           

      document.writeln("</HEAD>");

           

      if (N <= 0 || M <= 0) document.writeln("<BODY onload='PrJVGeneracionAuto()'>")

      else                  document.writeln("<BODY onload='PrJVAutoEvolucion()'>")

           

      document.writeln("<" + "SCRIPT LANGUAGE='Javascript' SRC='AutoJuVida_Detalle.js'><" + "/SCRIPT>");

           

      document.writeln("<a name='_top'></a>");

           

   

 

      // Muestra la evolución poblacional

 

      if (N > 0 && M > 0)

      {

           

            // Muestra JuVida

           

            PrJVMuestraPoblacion();

           

            document.writeln("<BR>");

      }

 

     

      document.writeln("</BODY>");

      document.writeln("<HTML>");

           

      document.close();

     

      return;

}  

                                                                                                        ________

 

 

Aparecen dos nuevas rutinas. PrJVMuestraPoblacion que presenta la población en curso y PrJVAutoEvolucion que va progresando automáticamente la evolución poblacional. Con estas rutinas, cuyo código no se va a presentar aquí para evitar extendernos en exceso, se cerraría la codificación, que puede consultarse en detalle en el siguiente epígrafe.

 

                                                                                                          ________

 

 

7 Código fuente

 

 

A continuación se presentan los enlaces para consultar el detalle completo del código. Se indica entre paréntesis el formato de extensión original de los ficheros de código que se presentan:

 

 

Servicios de soporte de los ficheros virtuales : http://jsc.ficherosvirtuales.com/AutoJuVida_Web/w_ficherosvirtuales_com(.js)

Servicios de soporte del juego de la vida . .  : http://jsc.ficherosvirtuales.com/AutoJuVida_Web/juvida_ficherosvirtuales_com(.js)

 

Código de cabecera del interfaz de presentación: http://jsc.ficherosvirtuales.com/AutoJuVida_Web/AutoJuVida(.js)

Código de detalle del interfaz de presentación : http://jsc.ficherosvirtuales.com/AutoJuVida_Web/AutoJuVida_Detalle(.js)

 

Código de cabecera del control de temporizador : http://jsc.ficherosvirtuales.com/AutoJuVida_Web/ControlTemporizador(.js)

Código de detalle del control de temporizador  : http://jsc.ficherosvirtuales.com/AutoJuVida_Web/ControlTemporizador_Detalle(.js)

Hoja de estilo asociada . . . . . . . . . . .  : http://jsc.ficherosvirtuales.com/AutoJuVida_Web/ControlTemporizador(.css)

 

 

Hoja html de prueba . . . . . . . . . . . . .  : http://jsc.ficherosvirtuales.com/AutoJuVida_Web/AutoJuVida(.html)

Hoja de estilo asociada . . . . . . . . . . .  : http://jsc.ficherosvirtuales.com/AutoJuVida_Web/AutoJuVida(.css)

 

Hoja frame izquierda  . . . . . . . . . . . .  : http://jsc.ficherosvirtuales.com/AutoJuVida_Web/Cabecera(.html)

Hoja de estilo asociada . . . . . . . . . . .  : http://jsc.ficherosvirtuales.com/AutoJuVida_Web/Cabecera(.css)

Hoja frame derecha  . . . . . . . . . . . . .  : http://jsc.ficherosvirtuales.com/AutoJuVida_Web/AutoJuVida_Derecha(.html)

 

 

 

 

                                                                                                          ________