Secciones de la página

wal. tol

Declaraciones

Constantes

¿wal. tol o bat. tol?

Á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









wal.tol de ChRules.RandRecursive

Base de reglas y area para derribar un muro con misiles. Es una base de reglas fundamentalmente destructiva, donde una serie de lanzaderas de misiles tratan de derribar un muro en el que a su vez sus elementos son explosivos y al recibir un impacto pueden producir cadenas de destruccion que se transmiten a sus elementos adyacentes en secuencia. // Esta base de reglas incluye un ultima regla de deteccion del final del proceso de deteccion de reglas y que construye la frase clasica de game over,

Declaraciones

Constantes

  • Set WalAre
    Campo de batalla entre bombarderos y lanzaderas.
  • Set WalRul
    Base de reglas para el derribo sistematico de un muro con 2 tipos de elementos grandes y pequeños hasta su derribo final.

Constantes

Set WalAre

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

Set WalRul

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

  RuleBuild([["··· => |||",         
              "·|·    ···"]]),   // Misil se despliega en 3 cabezas

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

  RuleBuild([["o => 0",         
              "|    ·"]]),       // Misil impacta e inicio de explosion

  RuleBuild([["0 => ·",         
              "|    ·"]]),       // Misil impacta seco y destructivo

  RuleBuild([["o0 => 0·"]]),     // Explosion hacia la izquierda

  RuleBuild([["0o => ·0"]]),     // Explosion hacia la derecha

  RuleBuild([["o => 0",         
              "0    ·"]]),       // Explosion hacia a arriba

  RuleBuild([["0 => ·",         
              "o    0"]]),       // Explosion hacia a bajo

  RuleBuild([["0 => 0",    
              "·    ·", 
              "·    ·", 
              "·    ·", 
              "·    |", 
              "^    ^"]]),     // Dispara corto sobre elemento grande

  RuleBuild([["o => o",    
              "·    ·", 
              "·    ·", 
              "·    ·", 
              "·    |", 
              "^    ^"]]),      // Dispara corto sobre elemento pequeño


  RuleBuild([["0 => 0",    
              "·    ·", 
              "·    ·", 
              "·    ·", 
              "·    ·", 
              "·    |", 
              "^    ^"]]),     // Dispara largo sobre elemento grande

  RuleBuild([["o => o",    
              "·    ·", 
              "·    ·", 
              "·    ·", 
              "·    ·", 
              "·    |", 
              "^    ^"]]),      // Dispara largo sobre elemento pequeño

  RuleBuild([["--------------- => ---------------",     
              "···············    G A M E O V E R"]])); // Fin del juego
//////////////////////////////////////////////////////////////////////////////
PutDescription(
"Base de reglas para el derribo sistematico de un muro con 2 tipos de
elementos grandes y pequeños hasta su derribo final.",
WalAre);
//////////////////////////////////////////////////////////////////////////////

¿wal.tol o bat.tol?

//////////////////////////////////////////////////////////////////////////////
// FILE    : bat.tol
// AUTHOR  : http://www.asolver.com
// PURPOSE : Base de reglas y area para derribar un muro con misiles.
// Es una base de reglas fundamentalmente destructiva,
// donde una serie de lanzaderas de misiles tratan de derribar un muro
// en el que a su vez sus elementos son explosivos y
// al recibir un impacto pueden producir cadenas de destruccion que
// se transmiten a sus elementos adyacentes en secuencia.
//
// Esta base de reglas incluye un ultima regla de deteccion del final del
// proceso de deteccion de reglas y que construye la frase clasica de
// game over,
//////////////////////////////////////////////////////////////////////////////


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

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


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

  RuleBuild([["··· => |||",         
              "·|·    ···"]]),   // Misil se despliega en 3 cabezas

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

  RuleBuild([["o => 0",         
              "|    ·"]]),       // Misil impacta e inicio de explosion

  RuleBuild([["0 => ·",         
              "|    ·"]]),       // Misil impacta seco y destructivo

  RuleBuild([["o0 => 0·"]]),     // Explosion hacia la izquierda

  RuleBuild([["0o => ·0"]]),     // Explosion hacia la derecha

  RuleBuild([["o => 0",         
              "0    ·"]]),       // Explosion hacia a arriba

  RuleBuild([["0 => ·",         
              "o    0"]]),       // Explosion hacia a bajo

  RuleBuild([["0 => 0",    
              "·    ·", 
              "·    ·", 
              "·    ·", 
              "·    |", 
              "^    ^"]]),     // Dispara corto sobre elemento grande

  RuleBuild([["o => o",    
              "·    ·", 
              "·    ·", 
              "·    ·", 
              "·    |", 
              "^    ^"]]),      // Dispara corto sobre elemento pequeño


  RuleBuild([["0 => 0",    
              "·    ·", 
              "·    ·", 
              "·    ·", 
              "·    ·", 
              "·    |", 
              "^    ^"]]),     // Dispara largo sobre elemento grande

  RuleBuild([["o => o",    
              "·    ·", 
              "·    ·", 
              "·    ·", 
              "·    ·", 
              "·    |", 
              "^    ^"]]),      // Dispara largo sobre elemento pequeño

  RuleBuild([["--------------- => ---------------",     
              "···············    G A M E O V E R"]])); // Fin del juego
//////////////////////////////////////////////////////////////////////////////
PutDescription(
"Base de reglas para el derribo sistematico de un muro con 2 tipos de
elementos grandes y pequeños hasta su derribo final.",
WalAre);
//////////////////////////////////////////////////////////////////////////////

Á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