make.tol de ChRules.Iterative

ChRules.Iterative es un programa iterativo de aplicacion de reglas de reescritura que: a) aplica a un area rectangular de caracteres, b) reglas de transformacion de areas rectangulares de caracteres y c) que juntas forman una base de reglas de transformacion del contenido de ese area para alcanzar un cierto objetivo, como por ejemplo, solucionar un problema Las reglas de ChRules.Iterative son del tipo [condicion, accion], esto es: a) si se cumple la condicion, el rectangulo condicion de la regla equipara con alguna subarea del area de trabajo b) entonces se aplica la accion de transformacion cambiando el contenido de la antigua subarea del area de trabajo por el nuevo rectangulo que proporciona la parte de la accion de la regla.

En las reglas de ChRules.Iterative, tanto la parte de la condicion como la de la accion son 2 rectangulos de caracteres. En principio 2 retangulos de identicas dimensiones, por ejemplo, de 3x4 caracteres, de 5x1 caracteres, 4x4 caracteres, etc. // Podrian diseñarse reglas cuyas condicion y accion fueran de diferentes dimensiones, pero en ese caso se cambiaria la forma del area dando lugar a casos dificiles de plantear y resolver, aunque no imposibles. La parte inicial del nombre del programa, ChRules, proviene de la caracteristica de ser reglas, Rules, de caracteres, Ch de Ch(aracters), por lo que se las podria llamar reglas de caracteres.

La idea basica del funcionamiento de ChRules.Iterative es la siguiente: a) si en el estado actual del area de caracteres existe algun subarea rectangular con el mismo contenido que la parte de condicion de una regla, b) entonces dicha regla es aplicable y, de aplicarse, el subarea rectangular del area de caracteres que coincide con la condicion es sobreescrita, conservando la forma, con el area rectangular de caracteres de la accion de la regla. Por tanto, estas reglas de rectangulos de caracteres pueden considerarse como reglas de reescritura, pero, a diferencia de otras reglas de reescritura, en vez de trabajar con secuencias de caracteres trabajan con areas rectangulares de caracteres.

Cada caso de estudio (problema a resolver) para ChRules.Iterative se define mediante: a) sus areas de trabajo iniciales, que pueden ser una o mas, para diferentes variantes del mismo problema y b) sus bases de reglas para su resolucion, generalmente una base, pero puede haber mas para diferentes formas de solucionar el problema y, aun mas, estas bases de reglas se pueden combinar mediante, el algebra de conjuntos de Tol, para crear nuevas bases de reglas para determinados tipos de problemas. // Por ejemplo, para el caso de los robots que buscan como salir de un laberinto se puenden: a) Definir distintos laberintos con diferentes posiciones de entrada y salidada de los robots y con uno o mas robots. b) Se puede definir una base de reglas para que el robot emplee el algoritmo llamado de la mano derecha y, tambien, su simetrico de la mano izquierda. c) Una base de reglas para resolver conflictos de bloqueo mutuo cuando 2 o mas robots intentan salir del laberinto. d) Crear una base de reglas conjunto con la base de reglas de resolucion de conflictos mas la base de reglas del algoritmo de la mano derecha (o de la izquierda).

Esta version del programa ChRules.Iterative tiene 3 particularidades que la definen: a) El ciclo del motor de comprobacion y aplicacion de reglas es iterativo. b) La seleccion de la subarea donde aplicar la regla es determinista. c) Pero en la seleccion de las reglas que hay aplicar se pueden programar 3 metodos distintos. Estos 3 metodos de seleccion de reglas son: c1) Seleccion completamente al azar. c2) Seleccion determinista siguiendo el mismo orden en el que se han definido las reglas de reescritura (cada regla prevalece sobre sus reglas sucesoras). c3) Seleccion segun un parametro rndCtr entre 0 y 1 segun el cual en rndCtr casos la seleccion es al azar y en el otro 1-rndCtr de los casos la seleccion es determinista, segun el orden de declaracion de las reglas.

Los casos de estudio que incluye ChRules.Iterative son, por ejemplo: a) Automatas celulares con sus reglas de la vida, que pueden funcionar tanto de forma determinista como aletatoria. Este caso incluye un area y 2 bases de reglas. b) Robots en laberintos que encuentran la salida con el algoritmo de la mano derecha o el de la izquierda y que solo se pueden resolver aplicando las reglas de forma determinista, ya que al azar los robots suelen perderse y dar vueltas, aunque tarde o temprano terminarian por encontrar la salida, por casualidad. En este caso se incluyen varios laberintos y varias bases de reglas que se pueden combinar para crear otras. c) Relleno de figuras, que se resuelven bien de forma aleatoria y que tambien funcionan de manera determinista, se incluyen 2 areas y una base de reglas sencilla. d) Partidas de pong, el pingpong electronico, en las que de forma completamente al azar es dificil que los jugadores den mas de 2 toques seguidos sin perder, de forma completamente determinista lo habitual es que los jugadores no fallen nunca si las reglas estan bien definidas (pues las reglas del jugador se definen antes que las reglas del movimiento de la pelota), entrando facilmente en una partida que es un ciclo eterno y con una cierta proporcion de azar, por ejemplo, 0.15 o 0.20, en los que las partidas simulan ser mas reales con varios toques consecutivos pero sin hacerse eternas. e) Una simulacion de un sistema de sedimentacion, orden parcial, mediante un metodo similar al metodo de ordenacion llamado de la burbuja.

ChRules.Iterative visualiza sus resultados de 3 formas diferentes: a) Mediante una traza de evolucion del mapa por pantalla. b) Mediante una traza en un fichero en disco, escrita en Javascript, que se traslada tal y como esta a un simulador que permite la posterior simulacion de los resultados. c) Mediante paginas escritas en Html con los casos resueltos paso a paso. El programa se estructura en base a un probrama principal make.tol que se incluye: a) ficheros de funciones comunes de conjuntos y ficheros, b) ficheros de funciones por tipos de objeto que emplea, areas, reglas y motor de resulucion y c) tantos ficheros de aplicacion como tipos de casos se han programado, automatas celulares, robots y laberintos, juego del pong, etc.

La funcion principal de ChRules.Iterative se llama Set EngSol() que retorna la solucion en forma de un conjunto de textos y cuyos parametros son: a) Set linSet, que es el area a resolver, b) Set rulSet, que es la base de reglas que hay que aplicar, c) Real maxSta, que es el numero maximo de iteraciones, nuevos estados por los que puede pasar el area de entrada y que es util frente a ciclos eternos, d) Text preFil, que es la ruta y el nombre de 2 fichero, sin extension, que guardaran las trazas en Html y Javascript. e) Real numCol, que es el numero de columnas de las tablas de estados de la traza de salida en Html y f) Real rndCtr, que es el control del determinismo en la seleccion de las reglas: si es 0 es determinista, si es 1 es aleatorio y si esta entre 0 y 1 pseudoaletorio en una la proporcion que determine el valor de rndCtr.

ChRules.Iterative es un programa que se clasifica como: a) Iterativo y existiendo su version recursiva. b) De reglas, en este caso de ragas de areas rectangulares de caracteres, c) Que implementa, entre otros ejemplos, un automata celular. d) Con un comportamiento que, ademas de determinista, puede ser aleatorio o pseudoaleatorio. e) Que en el caso de los robots dentro de un laberinto, realiza una busqueda con el objetivo de encontrar, desde un punto, la salida. f) En sedimentacion implementa, parcialmente, un proceso de orden por el metodo de la burbuja. Se ha probado su funcionamiento para las versiones de Tol 1.1.1, 1.1.5, 1.1.6 y 2.0.1.

Pruebas

• Text trcDir
  Directorio de trazas Html y Javascript
• Text tstCmd
  Mandatos de que se le quiere dar al motor de reglas los de autómatas celulares, los de robots en laberintos, los ping pong, etc. con su base de hechos (area) y sus caracteristicas de aleatoriedad o no, etc.
• Real tstExe
  Aplica la reglas a areas dependiendo de tstCmd.
• Real tstJsc
  Reune los ficheros Javascript, lo prepara para el simulado y crea la tabla array indice a los diferentes casos.

//////////////////////////////////////////////////////////////////////////////
Text trcDir = "trace";
//////////////////////////////////////////////////////////////////////////////
PutDescription("Directorio de trazas Html y Javascript",trcDir);
//////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////
Text tstCmd = "fllRndupK"; // Caso de estudio
//////////////////////////////////////////////////////////////////////////////
PutDescription(
"Mandatos de que se le quiere dar al motor de reglas los de autómatas
celulares, los de robots en laberintos, los ping pong, etc. con su
base de hechos (area) y sus caracteristicas de aleatoriedad o no, etc.",
tstCmd);
//////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////
Real tstExe = Case(
  tstCmd == "bubSedUp1", 
  {
    Text trcPth = trcDir+"/"+"burbuja_y_sedimentos";
    Set  rulApp = EngSol(BubSed, BubUp1, 900, trcPth, 2, TRUE); // Al azar
    Card(rulApp)
  },
  tstCmd == "celRndP31", 
  {
    Text trcPth = trcDir+"/"+"automata_celular_al_azar";
    Set  rulApp = EngSol(CelP31, CelRb1, 900, trcPth, 2, TRUE); // Al azar
    Card(rulApp)
  },
  tstCmd == "celDetP31", 
  {
    Text trcPth = trcDir+"/"+"automata_celular_determinista";
    Set  rulApp = EngSol(CelP31, CelRb1, 900, trcPth, 2, FALSE); // Determin
    Card(rulApp)
  },
  tstCmd == "ponUpA020", 
  {
    Text trcPth = trcDir+"/"+"partida_de_pong_al_20"; // Ruta de las trazas
    Set  rulApp = EngSol(PonUpA, PonRb1, 600, trcPth, 6, 0.20); // 20% azar
    Card(rulApp)
  },
  tstCmd == "ponUpA015", 
  {
    Text trcPth = trcDir+"/"+"partida_de_pong_al_15"; // Ruta de las trazas
    Set  rulApp = EngSol(PonUpA, PonRb1, 600, trcPth, 6, 0.15); // 15% azar
    Card(rulApp)
  },
  tstCmd == "ponUpA000", 
  {
    Text trcPth = trcDir+"/"+"partida_de_pong_eterna"; // Ruta de las trazas
    Set  rulApp = EngSol(PonDwA, PonRb1, 600, trcPth, 6, FALSE); // Determin
    Card(rulApp)
  },
  tstCmd == "ponUpA100", 
  {
    Text trcPth = trcDir+"/"+"partida_de_pong_azarosa"; // Ruta de las trazas
    Set  rulApp = EngSol(PonUpA, PonRb1, 600, trcPth, 6, TRUE); // Al azar
    Card(rulApp)
  },
  tstCmd == "labMax001", 
  {
    Text trcPth = trcDir+"/"+"laberinto_mas_grande"; // Ruta de las trazas
    Set  rulApp = EngSol(LabA11, LabOutRgh, 300, trcPth, 2, FALSE);
    Card(rulApp)
  },
  tstCmd == "labMaxLft", 
  {
    Text trcPth = trcDir+"/"+"laberinto_mano_izquierda"; // Ruta de las trazas
    Set  rulApp = EngSol(LabA11, LabOutLft, 300, trcPth, 2, FALSE);
    Card(rulApp)
  },
  tstCmd == "labMinN02", // Cuando se chocan lo arreglan, se aplica la LabRb2
  {
    Text trcPth = trcDir+"/"+"laberinto_2_negociadores"; // Ruta de las trazas
    Set  rulApp = EngSol(LabA02, LabNegOutRgh, 197, trcPth, 4, FALSE);
    Card(rulApp)
  },
  tstCmd == "labMinC02", // Se chocan y se autobloquean
  {
    Text trcPth = trcDir+"/"+"laberinto_2_cabezones"; // Ruta de las trazas
    Set  rulApp = EngSol(LabA02, LabOutRgh, 197, trcPth, 4, FALSE);
    Card(rulApp)
  },
  tstCmd == "labMin001",
  {
    Text trcPth = trcDir+"/"+"laberinto_mini_1_robot"; // Ruta de las trazas
    Set  rulApp = EngSol(LabA01, LabOutRgh, 100, trcPth, 4, FALSE);
    Card(rulApp)
  },
  tstCmd == "labMinRnd",
  {
    Text trcPth = trcDir+"/"+"laberinto_robot_loco"; // Ruta de las trazas
    Set  rulApp = EngSol(LabA11, LabOutRgh, 500, trcPth, 4, TRUE); // Random
    Card(rulApp)
  },
  tstCmd == "fllRndBox",
  {
    Text trcPth = trcDir+"/"+"rellena_caja_al_azar"; // Ruta de las trazas
    Set  rulApp = EngSol(FllBox, FllRb1, 500, trcPth, 2, TRUE); // Random
    Card(rulApp)
  },
  tstCmd == "fllRndupK",
  {
    Text trcPth = trcDir+"/"+"rellena_k_al_azar"; // Ruta de las trazas
    Set  rulApp = EngSol(FllupK, FllRb1, 300, trcPth, 2, TRUE); // Random
    Card(rulApp)
  },
  TRUE,            FALSE); // No hace nada
//////////////////////////////////////////////////////////////////////////////
PutDescription("Aplica la reglas a areas dependiendo de tstCmd.", tstExe);
//////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////
Real tstJsc = EngJavascript(trcDir, "simulator/src"); // Dirs traza y .js
//////////////////////////////////////////////////////////////////////////////
PutDescription(
"Reune los ficheros Javascript, lo prepara para el simulado y crea la tabla
array indice a los diferentes casos.",
tstJsc);
////////////////////////////////////////////////////////////////////////////// 

Text WriteLn("\nChRules.Iterative make: end");

//////////////////////////////////////////////////////////////////////////////
// FILE    : make.tol
// AUTHOR  : http://www.asolver.com
// CLASS   : Iterativo; Regla; Autómata celular; Aleatorio; Buscar; Ordenar
// VERSION : Tol 1.1.1; Tol 1.1.5; Tol 1.1.6; Tol 2.0.1
// PURPOSE : ChRules.Iterative es un programa iterativo de aplicacion de
// reglas de reescritura que:
// a) aplica a un area rectangular de caracteres,
// b) reglas de transformacion de areas rectangulares de caracteres y
// c) que juntas forman una base de reglas de transformacion del contenido
//    de ese area para alcanzar un cierto objetivo, como por ejemplo,
//    solucionar un problema
// 
// Las reglas de ChRules.Iterative son del tipo [condicion, accion], esto es:
// a) si se cumple la condicion, el rectangulo condicion de la regla equipara
//    con alguna subarea del area de trabajo
// b) entonces se aplica la accion de transformacion cambiando el contenido
//    de la antigua subarea del area de trabajo por el nuevo rectangulo que
//    proporciona la parte de la accion de la regla.
// _
// En las reglas de ChRules.Iterative, tanto la parte de la condicion
// como la de la accion son 2 rectangulos de caracteres.
// En principio 2 retangulos de identicas dimensiones, por ejemplo,
// de 3x4 caracteres, de 5x1 caracteres, 4x4 caracteres, etc.
//
// Podrian diseñarse reglas cuyas condicion y accion fueran de diferentes
// dimensiones, pero en ese caso se cambiaria la forma del area dando lugar
// a casos dificiles de plantear y resolver, aunque no imposibles.
// 
// La parte inicial del nombre del programa, ChRules, proviene de la
// caracteristica de ser reglas, Rules, de caracteres, Ch de Ch(aracters),
// por lo que se las podria llamar reglas de caracteres.
// _
// La idea basica del funcionamiento de ChRules.Iterative es la siguiente:
// a) si en el estado actual del area de caracteres
//    existe algun subarea rectangular con el mismo contenido que
//    la parte de condicion de una regla,
// b) entonces dicha regla es aplicable y, de aplicarse,
//    el subarea rectangular del area de caracteres que coincide con la
//    condicion es sobreescrita, conservando la forma,
//    con el area rectangular de caracteres de la accion de la regla.
// 
// Por tanto, estas reglas de rectangulos de caracteres  pueden considerarse
// como reglas de reescritura, pero,
// a diferencia de otras reglas de reescritura,
// en vez de trabajar con secuencias de caracteres
// trabajan con areas rectangulares de caracteres.
// _
// Cada caso de estudio (problema a resolver) para ChRules.Iterative se define
// mediante:
// a) sus areas de trabajo iniciales, que pueden ser una o mas,
//    para diferentes variantes del mismo problema y
// b) sus bases de reglas para su resolucion, generalmente una base,
//    pero puede haber mas para diferentes formas de solucionar el problema y,
//    aun mas, estas bases de reglas se pueden combinar mediante,
//    el algebra de conjuntos de Tol,
//    para crear nuevas bases de reglas para determinados tipos de problemas.
//
// Por ejemplo, para el caso de los robots que buscan como salir de un
// laberinto se puenden:
// a) Definir distintos laberintos con diferentes posiciones de entrada y
//    salidada de los robots y con uno o mas robots.
// b) Se puede definir una base de reglas para que
//    el robot emplee el algoritmo llamado de la mano derecha y, tambien,
//    su simetrico de la mano izquierda.
// c) Una base de reglas para resolver conflictos de bloqueo mutuo cuando 2
//    o mas robots intentan salir del laberinto.
// d) Crear una base de reglas conjunto con
//    la base de reglas de resolucion de conflictos mas
//    la base de reglas del algoritmo de la mano derecha (o de la izquierda).
// _
// Esta version del programa ChRules.Iterative tiene 3 particularidades que
// la definen:
// a) El ciclo del motor de comprobacion y aplicacion de reglas es iterativo.
// b) La seleccion de la subarea donde aplicar la regla es determinista.
// c) Pero en la seleccion de las reglas que hay aplicar se pueden programar
//    3 metodos distintos.
// 
// Estos 3 metodos de seleccion de reglas son:
// c1) Seleccion completamente al azar.
// c2) Seleccion determinista siguiendo el mismo orden en el que se han
//     definido las reglas de reescritura
//     (cada regla prevalece sobre sus reglas sucesoras).
// c3) Seleccion segun un parametro rndCtr entre 0 y 1 segun el cual
//     en rndCtr casos la seleccion es al azar y
//     en el otro 1-rndCtr de los casos la seleccion es determinista,
//     segun el orden de declaracion de las reglas.
// _
// Los casos de estudio que incluye  ChRules.Iterative son, por ejemplo:
// a) Automatas celulares con sus reglas de la vida,
//    que pueden funcionar tanto de forma determinista como aletatoria.
//    Este caso incluye un area y 2 bases de reglas.
// b) Robots en laberintos que encuentran la salida con el algoritmo de la
//    mano derecha o el de la izquierda y que solo se pueden resolver
//    aplicando las reglas de forma determinista,
//    ya que al azar los robots suelen perderse y dar vueltas,
//    aunque tarde o temprano terminarian por encontrar la salida,
//    por casualidad.
//    En este caso se incluyen varios laberintos y varias bases de reglas que
//    se pueden combinar para crear otras.
// c) Relleno de figuras, que se resuelven bien de forma aleatoria y
//    que tambien funcionan de manera determinista,
//    se incluyen 2 areas y una base de reglas sencilla.
// d) Partidas de pong, el pingpong electronico, en las que
//    de forma completamente al azar es dificil que los jugadores den mas de
//    2 toques seguidos sin perder,
//    de forma completamente determinista lo habitual es que los jugadores no
//    fallen nunca si las reglas estan bien definidas
//    (pues las reglas del jugador se definen antes que
//    las reglas del movimiento de la pelota),
//    entrando facilmente en una partida que es un ciclo eterno
//    y con una cierta proporcion de azar, por ejemplo, 0.15 o 0.20,
//    en los que las partidas simulan ser mas reales con varios toques
//    consecutivos pero sin hacerse eternas.
// e) Una simulacion de un sistema de sedimentacion, orden parcial, mediante
//    un metodo similar al metodo de ordenacion llamado de la burbuja.
// _
// ChRules.Iterative visualiza sus resultados de 3 formas diferentes:
// a) Mediante una traza de evolucion del mapa por pantalla.
// b) Mediante una traza en un fichero en disco, escrita en Javascript,
//    que se traslada tal y como esta a un simulador que
//    permite la posterior simulacion de los resultados.
// c) Mediante paginas escritas en Html con los casos resueltos paso a paso.
// 
// El programa se estructura en base a un probrama principal make.tol que
// se incluye:
// a) ficheros de funciones comunes de conjuntos y ficheros,
// b) ficheros de funciones por tipos de objeto que emplea, areas, reglas y
//    motor de resulucion y
// c) tantos ficheros de aplicacion como tipos de casos se han programado,
//    automatas celulares, robots y laberintos, juego del pong, etc.
// _
// La funcion principal de ChRules.Iterative se llama Set EngSol() que retorna
// la solucion en forma de un conjunto de textos y cuyos parametros son:
// a) Set linSet, que es el area a resolver,
// b) Set rulSet, que es la base de reglas que hay que aplicar,
// c) Real maxSta, que es el numero maximo de iteraciones,
//    nuevos estados por los que puede pasar el area de entrada y
//    que es util frente a ciclos eternos,
// d) Text preFil, que es la ruta y el nombre de 2 fichero, sin extension,
//    que guardaran las trazas en Html y Javascript.
// e) Real numCol, que es el numero de columnas de las tablas de estados
//    de la traza de salida en Html y
// f) Real rndCtr, que es el control del determinismo en la seleccion de las
//    reglas: si es 0 es determinista, si es 1 es aleatorio y si esta entre
//    0 y 1 pseudoaletorio en una la proporcion que determine el valor de
//    rndCtr.
// _
// ChRules.Iterative es un programa que se clasifica como:
// a) Iterativo y existiendo su version recursiva.
// b) De reglas, en este caso de ragas de areas rectangulares de caracteres,
// c) Que implementa, entre otros ejemplos, un automata celular.
// d) Con un comportamiento que, ademas de determinista, puede ser aleatorio o
//    pseudoaleatorio.
// e) Que en el caso de los robots dentro de un laberinto, realiza una
//    busqueda con el objetivo de encontrar, desde un punto, la salida.
// f) En sedimentacion implementa, parcialmente, un proceso de orden por el
//    metodo de la burbuja.
// 
// Se ha probado su funcionamiento para las versiones de Tol 1.1.1, 1.1.5,
// 1.1.6 y 2.0.1.
//////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////
// INCLUDE
//////////////////////////////////////////////////////////////////////////////
Text WriteLn("\nChRules.Iterative make: begin");

//////////////////////////////////////////////////////////////////////////////
Set  allInc = Include("tol/inc.tol");
//////////////////////////////////////////////////////////////////////////////
PutDescription("Inclusion de las funciones comunes y de aplicacion.", allInc);
//////////////////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////////////////
// TEST
//////////////////////////////////////////////////////////////////////////////
Text WriteLn("\nChRules.Iterative make: test");

//////////////////////////////////////////////////////////////////////////////
Text trcDir = "trace";
//////////////////////////////////////////////////////////////////////////////
PutDescription("Directorio de trazas Html y Javascript",trcDir);
//////////////////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////////////////
Text tstCmd = "fllRndupK"; // Caso de estudio
//////////////////////////////////////////////////////////////////////////////
PutDescription(
"Mandatos de que se le quiere dar al motor de reglas los de autómatas
celulares, los de robots en laberintos, los ping pong, etc. con su
base de hechos (area) y sus caracteristicas de aleatoriedad o no, etc.",
tstCmd);
//////////////////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////////////////
Real tstExe = Case(
  tstCmd == "bubSedUp1", 
  {
    Text trcPth = trcDir+"/"+"burbuja_y_sedimentos";
    Set  rulApp = EngSol(BubSed, BubUp1, 900, trcPth, 2, TRUE); // Al azar
    Card(rulApp)
  },
  tstCmd == "celRndP31", 
  {
    Text trcPth = trcDir+"/"+"automata_celular_al_azar";
    Set  rulApp = EngSol(CelP31, CelRb1, 900, trcPth, 2, TRUE); // Al azar
    Card(rulApp)
  },
  tstCmd == "celDetP31", 
  {
    Text trcPth = trcDir+"/"+"automata_celular_determinista";
    Set  rulApp = EngSol(CelP31, CelRb1, 900, trcPth, 2, FALSE); // Determin
    Card(rulApp)
  },
  tstCmd == "ponUpA020", 
  {
    Text trcPth = trcDir+"/"+"partida_de_pong_al_20"; // Ruta de las trazas
    Set  rulApp = EngSol(PonUpA, PonRb1, 600, trcPth, 6, 0.20); // 20% azar
    Card(rulApp)
  },
  tstCmd == "ponUpA015", 
  {
    Text trcPth = trcDir+"/"+"partida_de_pong_al_15"; // Ruta de las trazas
    Set  rulApp = EngSol(PonUpA, PonRb1, 600, trcPth, 6, 0.15); // 15% azar
    Card(rulApp)
  },
  tstCmd == "ponUpA000", 
  {
    Text trcPth = trcDir+"/"+"partida_de_pong_eterna"; // Ruta de las trazas
    Set  rulApp = EngSol(PonDwA, PonRb1, 600, trcPth, 6, FALSE); // Determin
    Card(rulApp)
  },
  tstCmd == "ponUpA100", 
  {
    Text trcPth = trcDir+"/"+"partida_de_pong_azarosa"; // Ruta de las trazas
    Set  rulApp = EngSol(PonUpA, PonRb1, 600, trcPth, 6, TRUE); // Al azar
    Card(rulApp)
  },
  tstCmd == "labMax001", 
  {
    Text trcPth = trcDir+"/"+"laberinto_mas_grande"; // Ruta de las trazas
    Set  rulApp = EngSol(LabA11, LabOutRgh, 300, trcPth, 2, FALSE);
    Card(rulApp)
  },
  tstCmd == "labMaxLft", 
  {
    Text trcPth = trcDir+"/"+"laberinto_mano_izquierda"; // Ruta de las trazas
    Set  rulApp = EngSol(LabA11, LabOutLft, 300, trcPth, 2, FALSE);
    Card(rulApp)
  },
  tstCmd == "labMinN02", // Cuando se chocan lo arreglan, se aplica la LabRb2
  {
    Text trcPth = trcDir+"/"+"laberinto_2_negociadores"; // Ruta de las trazas
    Set  rulApp = EngSol(LabA02, LabNegOutRgh, 197, trcPth, 4, FALSE);
    Card(rulApp)
  },
  tstCmd == "labMinC02", // Se chocan y se autobloquean
  {
    Text trcPth = trcDir+"/"+"laberinto_2_cabezones"; // Ruta de las trazas
    Set  rulApp = EngSol(LabA02, LabOutRgh, 197, trcPth, 4, FALSE);
    Card(rulApp)
  },
  tstCmd == "labMin001",
  {
    Text trcPth = trcDir+"/"+"laberinto_mini_1_robot"; // Ruta de las trazas
    Set  rulApp = EngSol(LabA01, LabOutRgh, 100, trcPth, 4, FALSE);
    Card(rulApp)
  },
  tstCmd == "labMinRnd",
  {
    Text trcPth = trcDir+"/"+"laberinto_robot_loco"; // Ruta de las trazas
    Set  rulApp = EngSol(LabA11, LabOutRgh, 500, trcPth, 4, TRUE); // Random
    Card(rulApp)
  },
  tstCmd == "fllRndBox",
  {
    Text trcPth = trcDir+"/"+"rellena_caja_al_azar"; // Ruta de las trazas
    Set  rulApp = EngSol(FllBox, FllRb1, 500, trcPth, 2, TRUE); // Random
    Card(rulApp)
  },
  tstCmd == "fllRndupK",
  {
    Text trcPth = trcDir+"/"+"rellena_k_al_azar"; // Ruta de las trazas
    Set  rulApp = EngSol(FllupK, FllRb1, 300, trcPth, 2, TRUE); // Random
    Card(rulApp)
  },
  TRUE,            FALSE); // No hace nada
//////////////////////////////////////////////////////////////////////////////
PutDescription("Aplica la reglas a areas dependiendo de tstCmd.", tstExe);
//////////////////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////////////////
Real tstJsc = EngJavascript(trcDir, "simulator/src"); // Dirs traza y .js
//////////////////////////////////////////////////////////////////////////////
PutDescription(
"Reune los ficheros Javascript, lo prepara para el simulado y crea la tabla
array indice a los diferentes casos.",
tstJsc);
////////////////////////////////////////////////////////////////////////////// 


//////////////////////////////////////////////////////////////////////////////
// END
//////////////////////////////////////////////////////////////////////////////
Text WriteLn("\nChRules.Iterative make: end");