Secciones de la página

bat. tol

Declaraciones

Constantes

Time oriented language

Árbol de ficheros

Tol

Artículos del sitio

Presentación de Tol

Todos los programas

Simuladores visuales

Sitios que me gustan

Por categorías

Algoritmia

Búsqueda y ordenación

Computación fisiológica

Editorial y edición

Gráficos de datos

Herramientas y utilidades

Hipertexto

Informática forense

Lectura óptica de datos

Metaprogramación

No determinista

Ofimática

Recursión e iteración

Reglas y restricciones

Series y estadística









bat.tol de ChRules.RandRecursive

Base de reglas y area para una batalla entre bombarderos que lanzan bombas y lanzaderas para lanzar misiles. Aunque pareciendo diferentes las fuerzas y tecnicas de ambos contendientes son identicas y estan equilibradas. // Esta base de reglas representa una batalla fundamentalmente destructiva donde 2 bandos de bombarderos y lanzaderas de misiles se enfrentan de una forma equilibrada. // Esto es, todas las reglas a favor o en contra de uno de ellos tienen sus reglas equivalentes a favor o en contra del otro. // Adicionalmente, incluye pequeñas tactivas defensivas como: a) contrarrestar con una bomba un misil del contrario, b) contrarrestar con un misil una bomba del contrario, c) cerrar las defensas para evitar un impacto. // Tambien incluye ciertas complicaciones durante el combare, como por ejemplo: a) que bombas y misiles pueden sufrir desviaciones y b) que con al menos una defensa averiada ni los bombarderos y ni las lanzaderas pueden cerrarse ni moverse.

Declaraciones

Constantes

  • Set BatAre
    Campo de batalla entre bombarderos y lanzaderas.
  • Set BatRul
    Base de reglas de la batalla que incluyen reglas de ataque, de defensa, de efectos imprevistos como el desvio de misiles y bombas, etc.

Constantes

Set BatAre

//////////////////////////////////////////////////////////////////////////////
Set BatAre = AreaBuild(
[["---------------",
  "(+)·(+)·(+)·(+)",
  "···············",
  "···············",
  "···············",
  "···············",
  "···············",
  "[^]·[^]·[^]·[^]",
  "---------------"]]);
//////////////////////////////////////////////////////////////////////////////
PutDescription("Campo de batalla entre bombarderos y lanzaderas.", BatAre);
//////////////////////////////////////////////////////////////////////////////

Set BatRul

//////////////////////////////////////////////////////////////////////////////
Set BatRul = SetOfSet(
  RuleBuild([["O => ·",         
              "·    O"]]),     // Bomba cae

  RuleBuild([["· => |",         
              "|    ·"]]),     // Misil sube

  RuleBuild([["O => ·",         
              "-    -"]]),     // Bomba se pierde sin causar daños

  RuleBuild([["- => -",         
              "|    ·"]]),     // Misil se pierde sin causar daños

  RuleBuild([["O· => ··",         
              "··    ·O"]]),   // Bomba se desvia a la derecha

  RuleBuild([["·O => ··",         
              "··    O·"]]),   // Bomba se desvia a la izquierda

  RuleBuild([["·· => ·|",         
              "|·    ··"]]),   // Misil se desvia a la derecha

  RuleBuild([["·· => |·",         
              "·|    ··"]]),   // Misil se desvia a la izquierda

  RuleBuild([["O => ·",         
              "|    ·"]]),     // Misil y bomba se destruyen mutuamente

  RuleBuild([["O => ·",         
              "[    ·"]]),     // Bomba destruye protector izquierdo

  RuleBuild([["O => ·",         
              "^    ·"]]),     // Bomba destruye lanzador de misiles

  RuleBuild([["O => ·",         
              "]    ·"]]),     // Bomba destruye protector derecho

  RuleBuild([["( => ·",         
              "|    ·"]]),     // Misil destruye protector izquierdo

  RuleBuild([["+ => ·",         
              "|    ·"]]),     // Misil destruye lanzador de bombas

  RuleBuild([[") => ·",         
              "|    ·"]]),     // Misil destruye protector derecho

  RuleBuild([["(+) => ·()",    
              "···    ···", 
              "|··    |··"]]), // Borbardero intenta evitar misil izquierdo

  RuleBuild([["(+) => ()·",    
              "···    ···", 
              "··|    ··|"]]), // Borbardero intenta evitar misil derecho

  RuleBuild([["O·· => O··",    
              "···    ···", 
              "[^]    ·[]"]]), // Lanzadera intenta evitar bomba izquierda

  RuleBuild([["··O => ··O",    
              "···    ···", 
              "[^]    []·"]]), // Lanzadera intenta evitar bomba derecha

  RuleBuild([["(+) => (+)",    
              "···    ·O·", 
              "·|·    ·|·"]]), // Borbardero intenta evitar misil central

  RuleBuild([["·O· => ·O·",    
              "···    ·|·", 
              "[^]    [^]"]]), // Lanzadera intenta evitar bomba central

  RuleBuild([["()· => (+)"]]), // Bombardero se abre para bombardear

  RuleBuild([["·() => (+)"]]), // Bombardero se abre para bombardear

  RuleBuild([["[]· => [^]"]]), // Lanzadera se abre para disparar

  RuleBuild([["·[] => [^]"]]), // Lanzadera se abre para disparar

  RuleBuild([["+ => +",    
              "·    O", 
              "·    ·", 
              "·    ·", 
              "·    ·", 
              "·    ·", 
              "^    ^"]]),     // Borbardero ataca lanzadera

  RuleBuild([["+ => +",    
              "·    ·", 
              "·    ·", 
              "·    ·", 
              "·    ·", 
              "·    |", 
              "^    ^"]]),     // Lanzadera ataca borbardero

  RuleBuild([["+ => +",    
              "·    O", 
              "·    ·", 
              "·    ·", 
              "·    ·", 
              "·    ·", 
              "(    ("]]),     // Borbardero ataca protector izquierdo

  RuleBuild([["+ => +",    
              "·    O", 
              "·    ·", 
              "·    ·", 
              "·    ·", 
              "·    ·", 
              ")    )"]]),     // Borbardero ataca protector derecho

  RuleBuild([["( => (",    
              "·    ·", 
              "·    ·", 
              "·    ·", 
              "·    ·", 
              "·    |", 
              "^    ^"]]),     // Lanzadera ataca protector izquierdo

  RuleBuild([[") => )",    
              "·    ·", 
              "·    ·", 
              "·    ·", 
              "·    ·", 
              "·    |", 
              "^    ^"]]));    // Lanzadera ataca protector derecho
//////////////////////////////////////////////////////////////////////////////
PutDescription(
"Base de reglas de la batalla que incluyen reglas de ataque, de defensa,
de efectos imprevistos como el desvio de misiles y bombas, etc.",
BatAre);
//////////////////////////////////////////////////////////////////////////////

Time oriented language

//////////////////////////////////////////////////////////////////////////////
// FILE    : bat.tol
// AUTHOR  : http://www.asolver.com
// PURPOSE : Base de reglas y area para una batalla entre bombarderos que
// lanzan bombas y lanzaderas para lanzar misiles.
// Aunque pareciendo diferentes las fuerzas y tecnicas de ambos contendientes
// son identicas y estan equilibradas.
//
// Esta base de reglas representa una batalla fundamentalmente destructiva
// donde 2 bandos de bombarderos y lanzaderas de misiles se enfrentan de una
// forma equilibrada.
//
// Esto es, todas las reglas a favor o en contra de uno de ellos tienen sus
// reglas equivalentes a favor o en contra del otro.
//
// Adicionalmente, incluye pequeñas tactivas defensivas como:
// a) contrarrestar con una bomba un misil del contrario,
// b) contrarrestar con un misil una bomba del contrario,
// c) cerrar las defensas para evitar un impacto.
//
// Tambien incluye ciertas complicaciones durante el combare,
// como por ejemplo:
// a) que bombas y misiles pueden sufrir desviaciones y
// b) que con al menos una defensa averiada
//    ni los bombarderos y ni las lanzaderas pueden cerrarse ni moverse.
//////////////////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////////////////
// CONSTANTS
//////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////
Set BatAre = AreaBuild(
[["---------------",
  "(+)·(+)·(+)·(+)",
  "···············",
  "···············",
  "···············",
  "···············",
  "···············",
  "[^]·[^]·[^]·[^]",
  "---------------"]]);
//////////////////////////////////////////////////////////////////////////////
PutDescription("Campo de batalla entre bombarderos y lanzaderas.", BatAre);
//////////////////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////////////////
Set BatRul = SetOfSet(
  RuleBuild([["O => ·",         
              "·    O"]]),     // Bomba cae

  RuleBuild([["· => |",         
              "|    ·"]]),     // Misil sube

  RuleBuild([["O => ·",         
              "-    -"]]),     // Bomba se pierde sin causar daños

  RuleBuild([["- => -",         
              "|    ·"]]),     // Misil se pierde sin causar daños

  RuleBuild([["O· => ··",         
              "··    ·O"]]),   // Bomba se desvia a la derecha

  RuleBuild([["·O => ··",         
              "··    O·"]]),   // Bomba se desvia a la izquierda

  RuleBuild([["·· => ·|",         
              "|·    ··"]]),   // Misil se desvia a la derecha

  RuleBuild([["·· => |·",         
              "·|    ··"]]),   // Misil se desvia a la izquierda

  RuleBuild([["O => ·",         
              "|    ·"]]),     // Misil y bomba se destruyen mutuamente

  RuleBuild([["O => ·",         
              "[    ·"]]),     // Bomba destruye protector izquierdo

  RuleBuild([["O => ·",         
              "^    ·"]]),     // Bomba destruye lanzador de misiles

  RuleBuild([["O => ·",         
              "]    ·"]]),     // Bomba destruye protector derecho

  RuleBuild([["( => ·",         
              "|    ·"]]),     // Misil destruye protector izquierdo

  RuleBuild([["+ => ·",         
              "|    ·"]]),     // Misil destruye lanzador de bombas

  RuleBuild([[") => ·",         
              "|    ·"]]),     // Misil destruye protector derecho

  RuleBuild([["(+) => ·()",    
              "···    ···", 
              "|··    |··"]]), // Borbardero intenta evitar misil izquierdo

  RuleBuild([["(+) => ()·",    
              "···    ···", 
              "··|    ··|"]]), // Borbardero intenta evitar misil derecho

  RuleBuild([["O·· => O··",    
              "···    ···", 
              "[^]    ·[]"]]), // Lanzadera intenta evitar bomba izquierda

  RuleBuild([["··O => ··O",    
              "···    ···", 
              "[^]    []·"]]), // Lanzadera intenta evitar bomba derecha

  RuleBuild([["(+) => (+)",    
              "···    ·O·", 
              "·|·    ·|·"]]), // Borbardero intenta evitar misil central

  RuleBuild([["·O· => ·O·",    
              "···    ·|·", 
              "[^]    [^]"]]), // Lanzadera intenta evitar bomba central

  RuleBuild([["()· => (+)"]]), // Bombardero se abre para bombardear

  RuleBuild([["·() => (+)"]]), // Bombardero se abre para bombardear

  RuleBuild([["[]· => [^]"]]), // Lanzadera se abre para disparar

  RuleBuild([["·[] => [^]"]]), // Lanzadera se abre para disparar

  RuleBuild([["+ => +",    
              "·    O", 
              "·    ·", 
              "·    ·", 
              "·    ·", 
              "·    ·", 
              "^    ^"]]),     // Borbardero ataca lanzadera

  RuleBuild([["+ => +",    
              "·    ·", 
              "·    ·", 
              "·    ·", 
              "·    ·", 
              "·    |", 
              "^    ^"]]),     // Lanzadera ataca borbardero

  RuleBuild([["+ => +",    
              "·    O", 
              "·    ·", 
              "·    ·", 
              "·    ·", 
              "·    ·", 
              "(    ("]]),     // Borbardero ataca protector izquierdo

  RuleBuild([["+ => +",    
              "·    O", 
              "·    ·", 
              "·    ·", 
              "·    ·", 
              "·    ·", 
              ")    )"]]),     // Borbardero ataca protector derecho

  RuleBuild([["( => (",    
              "·    ·", 
              "·    ·", 
              "·    ·", 
              "·    ·", 
              "·    |", 
              "^    ^"]]),     // Lanzadera ataca protector izquierdo

  RuleBuild([[") => )",    
              "·    ·", 
              "·    ·", 
              "·    ·", 
              "·    ·", 
              "·    |", 
              "^    ^"]]));    // Lanzadera ataca protector derecho
//////////////////////////////////////////////////////////////////////////////
PutDescription(
"Base de reglas de la batalla que incluyen reglas de ataque, de defensa,
de efectos imprevistos como el desvio de misiles y bombas, etc.",
BatAre);
//////////////////////////////////////////////////////////////////////////////

Árbol de ficheros

ChRules.RandRecursive programa de aplicacion de reglas de rectangulos de caracteres

  • ←make.tol aplica unas bases de reglas de reescritura a varios escenarios
  • ←make.bat mandato de ejecucion del programa de aplicacion de reglas
  • tol directorios que contienen fichero de codigo fuente Tol
    • app directorio con areas, bases de hechos, y con bases de reglas
      • ←rnd.tol test del comportamiento aleatorio del motor recursivo
      • ←cua.tol base de reglas para crecimiento cuadriaculando un area
      • ←cel.tol automata celular de movimiento, reproduccion y muerte
      • ←bat.tol batalla entre 2 frentes con pequeñas tacticas defensivas
      • ←wal.tol base de reglas fundamentalmete destructiva de su area
    • ←inc.tol para la inclusion de todas las bases de reglas del programa
  • simulator directorio del simulador del motor de reglas en Javascript
    • css directorio para css, Cascading Style Sheets, del simulador
      • ←simulator.css css para simular areas de aplicacion de las reglas
    • src directorio de codigo fuente Javascript del simulador de reglas
      • ←simulator.js simula el funcionamiento del motor de aplicacion de reglas
      • ←simulatorarray.js array con ejemplos de evolucion para cada base de reglas
  • →startlog.txt log Tol de lectura de reglas y evolucion del automata celular
  • →traceseg.txt traza de evolucion del automata celular casi en Javasript
  • →simulator.html simulador del motor recursivo de reglas de areas de caracteres
  • →chrules_randrecursive.pdf funciones del motor de aplicacion de reglas de caracteres

2015 asolver.com | Aviso legal | XHTML | Δ Θ Ξ | Creative Commons | Mapa y funciones del sitio

Tol