simulator.js de ChRules.RandRecursive

Reglas de reescritura de caracteres. Contiene todas las funciones para visualizar paso a paso la resolucion por Tol de uno o de varios casos de problemas. En general se entiende que hay a) una tabla indice de casos resueltos SimCasArr[pasos, nombre del caso], b) donde el caso en curso de simulacion es SimCasAct y su array de pasos que hay que visualizar es SimCasArr[SimCasAct][0] c) que cada caso consta de una serie de pasos, step, de resolucion donde la posicion del paso en curso es SimStpAct y d) que el area de visualizacion de pasos es SimStpDiv e) que se encuentra dentro de un panel de control de la simulacion, SimBox, f) con botones de inicio, SimBotExe, de parada, SimBotSto, stop, y de continuacion, SimBotCon.

//////////////////////////////////////////////////////////////////////////////
// FILE    : simulator.js
// AUTHOR  : http://www.asolver.com
// PURPOSE : Reglas de reescritura de caracteres.
// Contiene todas las funciones para visualizar paso a paso la resolucion por
// Tol de uno o de varios casos de problemas.
// En general se entiende que hay
// a) una tabla indice de casos resueltos SimCasArr[pasos, nombre del caso],
// b) donde el caso en curso de simulacion es SimCasAct y su array de pasos
//    que hay que visualizar es SimCasArr[SimCasAct][0]
// c) que cada caso consta de una serie de pasos, step, de resolucion donde
//    la posicion del paso en curso es SimStpAct y
// d) que el area de visualizacion de pasos es SimStpDiv
// e) que se encuentra dentro de un panel de control de la simulacion, SimBox,
// f) con botones de inicio, SimBotExe, de parada, SimBotSto, stop, y de
//    continuacion, SimBotCon.
//////////////////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////////////////
// CONSTANTS, los busca SimGetElements()
//////////////////////////////////////////////////////////////////////////////

var SimStpDiv; // Area de pasos de simulacion

var SimBotExe; // Boton de ejecucion
var SimBotSto; // Boton de parada, stop
var SimBotCon; // Boton de continuar

var SimCasFrm; // Campo selector del caso, dentro del form
var SimStpFrm; // Campo de visualizacion de pasos, step, dentro del form
var SimSpdFrm; // Campo selector de velocidad de simulacion, dentro del form


//////////////////////////////////////////////////////////////////////////////
// CONTROLS
//////////////////////////////////////////////////////////////////////////////

var SimCasAct = 0; // Numero del caso en curso, es una posicion en SimCasArr
var SimStpAct = 0; // Numero del paso en curso del caso en curso
var SimStpLst = 0; // Numero del ultimo paso (solo para visualizacion)

var SimAlt = 1;      // Si true se para
var SimTim = 100;    // Milisegundos de espera
var SimSep = "";     // Casillas de separacion


//////////////////////////////////////////////////////////////////////////////
// FUNCTIONS
//////////////////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////////////////
   function SimSepCreate(numEle, // Numero de caracteres
                         codChr) // Codigo del caracter separador

// PURPOSE: Crea y retorna un separador de numEle caracteres codChr para el
// final del area de simulacion.
// La llamada a esta funcion y el elemento separador puede depender del objeto
// de la simulacion.
// Termina el separador con un salto de linea
//////////////////////////////////////////////////////////////////////////////
{
  var simSep = "";

  for(var i=1; i<=numEle; i++) // Separador para base del area de simulacion
      { simSep = simSep + "<span class='sp'>"+codChr+"</span>"; }

  return(simSep + "<br />");
}


//////////////////////////////////////////////////////////////////////////////
   function SimExp(stpCod) // Paso de solucion codificado a expandir

// PURPOSE: Expande un paso codificado de simulacion, stpCod, donde cada
// caracter o conjunto de caracteres ha de ser expandido por el codigo Html
// adecuado para visualizar adecuadamente la simulacion.
// Es una funcion muy dependiente de cada caso concreto de simulacion.
// Ha de tenerse cuidado con el ; que esta en &nbsp;, por ejemplo.
//////////////////////////////////////////////////////////////////////////////
{
  var rep_nl = stpCod.replace(/;/g, "<br />"); // Cambia ; x new line antes

  var rep_sp = rep_nl.replace(/·/g, "&nbsp;"); // Cambia punto x blanco fijo

  return("<span class='ca'>" + rep_sp + SimSep + "</span>");
}


//////////////////////////////////////////////////////////////////////////////
   function SimCasFrmWrite()

// PURPOSE: Escribe un selector de formularios para todos los casos que estan
// disponibles. El texto de las etiquetas puede ser dependiente del problema.
//////////////////////////////////////////////////////////////////////////////
{
  var selIni = "<select onchange ='SimCase()' id='SimCasFrm'>";
  var selEnd = "</select>";
  var selAll = "";

  for(var arrPos=0; arrPos < SimCasArr.length; arrPos++) // Para los casos
  {
    var casArr = SimCasArr[arrPos][0]; // Array de pasos del caso
    var casNam = SimCasArr[arrPos][1]; // Nombre del caso
    var stpNum = casArr.length-1;      // Pasos del caso

    var lblPos = arrPos + 1; // Del 1 en adelante, no del 0 en adelante
    var selLbl = casNam + ": " + stpNum + " pasos";

    var selChk = " ";                        // En principio no seleccionado,
    if(arrPos==0) { selChk = " selected "; } // salvo que sea el primero

    var optTxt = "<option" + selChk + "value=" + arrPos + ">" +
                                                 selLbl + "</option>";
    selAll = selAll + optTxt;
  }
  document.write(selIni + selAll + selEnd);
}


//////////////////////////////////////////////////////////////////////////////
  function SimUpdate()

// PURPOSE: Cambia el contenido del area de simulacion para que se visualice
// el codigo del paso actual del caso actual.
//////////////////////////////////////////////////////////////////////////////
{ 
  var casArr = SimCasArr[SimCasAct][0]; // Array de pasos del caso actual

  SimStpDiv.innerHTML = SimExp(casArr[SimStpAct]); // Expande
}


//////////////////////////////////////////////////////////////////////////////
   function SimGetElements()

// PURPOSE: Busca todos los elementos (areas, botones, etc.) necesarios para
// realizar la simulacion, todos tienen nombres fijos.
//////////////////////////////////////////////////////////////////////////////
{
  SimStpDiv = document.getElementById("SimStpDiv"); // Area de simulacion

  SimBotExe = document.getElementById("SimBotExe"); // Boton de inicio
  SimBotSto = document.getElementById("SimBotSto"); // Boton de parada
  SimBotCon = document.getElementById("SimBotCon"); // Boton de continuar

  SimCasFrm = document.getElementById("SimCasFrm"); // Selector casos
  SimStpFrm = document.getElementById("SimStpFrm"); // Visualizador pasos
  SimSpdFrm = document.getElementById("SimSpdFrm"); // Selector de velocidad

  SimSep = SimSepCreate(15, "&nbsp;"); // Crea un elemento separador
  
  SimUpdate(); // Visualizar el primer paso del primer caso para rellenar
}


//////////////////////////////////////////////////////////////////////////////
function SimStpFrmWrite()

// PURPOSE: Actualiza el campo del frame que indica el paso actual y el total
// de pasos del caso en curso.
//////////////////////////////////////////////////////////////////////////////
{ SimStpFrm.value = SimStpAct + " | " + SimStpLst; }


//////////////////////////////////////////////////////////////////////////////
function SimTimeoutCicle()

// PURPOSE: Ciclo de visualizacion de la solucion mientras no se llegue al
// final de la simulacion o no se pare el ciclo SimAlt = true.
//////////////////////////////////////////////////////////////////////////////
{ 
       if(SimAlt==1) { SimAlt = 1; }                   // Para el ciclo
  else if(SimStpAct >= SimCasArr[SimCasAct][0].length) // Final
  {
    SimAlt = 1;
    SimAct = 0;
  } 
  else // Ejecucion normal
  { 
    SimStpFrmWrite();                       // Visualiza el contador de pasos
    SimUpdate();                            // Actualizar el paso
    SimStpAct++;                            // Incrementa el contador
    setTimeout("SimTimeoutCicle()",SimTim); // Autoprograma el siguiente paso
  }
}


//////////////////////////////////////////////////////////////////////////////
function SimSpeed()

// PURPOSE: Cambia la velocidad segun la indicacion del selector de velocidad.
//////////////////////////////////////////////////////////////////////////////
{ SimTim = SimSpdFrm.value; }


//////////////////////////////////////////////////////////////////////////////
function SimCase()

// PURPOSE: Cambia el caso segun la indicacion del selector de casos.
//////////////////////////////////////////////////////////////////////////////
{
  SimCasAct = SimCasFrm.value; // Selecciona un nuevo caso
  SimStpAct = 0;               // Estado de salida y no cambia a parado
  SimStpLst = SimCasArr[SimCasAct][0].length - 1; // Ultimo paso
  SimUpdate();                 // Visualizar este primer estado
  SimStpFrmWrite();            // Visualiza el contador de pasos
}


//////////////////////////////////////////////////////////////////////////////
function SimExecute()

// PURPOSE: Inicia el ciclo desde el principio si estaba parado.
//  Se activa mediante el boton de ejecutar.
//////////////////////////////////////////////////////////////////////////////
{
  if(SimAlt) // Si estaba parado lo pone en marca con el contador a cero
  {
    SimAlt = 0;                                     // No se para el ciclo
    SimStpAct = 0;                                  // Vuelve al primer paso
    SimStpLst = SimCasArr[SimCasAct][0].length - 1; // Ultimo paso
    SimTimeoutCicle();                              // Comienza el ciclo
  }
}


//////////////////////////////////////////////////////////////////////////////
function SimStop()

// PURPOSE: Para el ciclo de visualizacion.
// Se activa mediante el boton de parar.
//////////////////////////////////////////////////////////////////////////////
{
  SimAlt = 1; // Para el ciclo
}


//////////////////////////////////////////////////////////////////////////////
function SimContinue()

// PURPOSE: Sigue el ciclo de visualizacion por donde fuera si estaba parado.
// Se activa mediante el boton de continuar.
//////////////////////////////////////////////////////////////////////////////
{
  if(SimAlt) // Si estaba parado lo pone en marca con el contador que llevaba
  {
    SimAlt = 0;               // No se para el ciclo
    SimTimeoutCicle();        // Comienza el ciclo
  }
}