| # EL CASO DE LAS RATAS HAMBRIENTAS

## Continuamos con la amorosa labor educativa de nuestros Personajes Semi Inteligentes, aunque de momento nos limitemos a cosas tan comunes como el enseñarles a evitar ser comidos por hambrientas ratas de castillo y a comérselas ellos para sobrevivir en este mundo hostil.

Estábamos tratando de evitar el tener que poner en cada línea un montón de IFs en el desarrollo de nuestro ejemplo alimenticio sobre quién se comía a quién en las mazmorras del tenebroso castillo.

Teníamos unas ratas hambrientas y un "mazmorriado" que tampoco le hacía ascos a un buen muslo rateril.

La forma habitual de planteamiento, llena de IFes, era:

IF (el jugador está en un calabozo) AND IF (las ratas están hambrientas) THEN PRINT (¡socorrooo, que me meriendan!).

IF (el jugador está en un calabozo) AND IF (las ratas están muertas) AND IF (el jugador tiene hambre) THEN PRINT (¡Mmmm, que ratas más exquisitas!).

IF (el jugador no está en el calabozo) THEN PRINT (¡viva la libertás!).

Y así sucesivamente. ¿Engorroso, verdad?

Pero también terminábamos diciendo que había un medio más fácil de hacerlo. ¡Pues veámoslo!

Lo primero que hay que hacer es enfocar el problema de una manera completamente diferente a la usual.

Retomemos el problema nutricional de las ratas y el prisionero, pero ésta vez representaremos el proceso de toma de decisiones en forma de árbol. (Ver dibujo de Guisela).

Este tipo de estructura es lo que se llama un "árbol de toma de decisiones" o "diagrama de flujo". Está compuesto de varios nódulos (los rectángulos) interconectados.

Los nódulos son de dos categorías.

- de decisión: son los que comprueban que se dé una determinada condición (por ejemplo, que el jugador esté en la mazmorra).
- terminales o de acción: que no comprueban condiciones y por lo tanto no tienen otra prolongación en forma de rama, sino que ejecutan una acción específica.

En el diagrama, hemos numerado cada nódulo y hemos puesto al lado a qué tipo pertenece (d=decisión) (a=acción).

Las condiciones que reproducimos son las mismas que con el ejemplo de los IFes, pero sin embargo has de notar que hemos añadido otro pequeño trozo para tener en cuenta una variante que no controlamos antes y cuyo equivalente en IFes sería:

IF (el jugador está en la mazmorra) AND IF (las ratas no tienen hambre) AND IF (las ratas no están muertas) THEN PRINT (estás a salvo... por ahora.).

La ventaja ahora es que en vez de tener que poner cada línea por separado, ahora podemos meter todo el árbol completo de decisiones y acciones dentro de un programa de BASIC en forma de DATAS e irlo desarrollando por medio de una pequeña y fácil rutina.

Desarrollar un árbol significa comenzar por la parte superior e ir haciendo camino hacia abajo, a lo largo de todas las ramas, hasta llegar a un nódulo terminal.

Una vez alcanzado uno de estos nódulos, sabremos que estamos al final de un proceso de toma de decisiones y que podemos ejecutar la acción indicada por ese nódulo en particular.

Veamos ahora cómo se hace para que un programa de BASIC desarrolle nuestro árbol de "ratas que comen o son comidas".

Todo lo que nuestro hipotético programa necesita saber es de qué tipo es cada nódulo, si de decisión o de acción.

Si es un nódulo decisorio, el programa también necesita saber:

- qué condición debe tomar para valoración (lo que hay dentro del nódulo).
- a cuál otro nódulo debe saltar si la condición se cumple, es decir, si es válida.
- a cuál otro nódulo saltar si la condición está en la mazmorra y las ratas están vivas pero no hambrientas.

Veamos lo que sucede... empezando por el nódulo uno. El programa comparará primero si es un nódulo terminal o es de decisión. Al ver que es decisorio, va en busca de la condición requerida o asociada y mira a ver si es verdadera o falsa.

Al buscar en la data para el nódulo 1, verá que es verdadera (lo hemos decretado así para nuestra suposición) y entonces buscará el próximo nódulo a saltar, el número 3.

El proceso se repite y el programa salta a los datos asociados al nódulo 3, que en éste caso con falsos, lo que lo lleva al nódulo 4.

Al repetirse otra vez todo el proceso en el nódulo 4, el programa es enviado al 6. Como el nódulo 6 es terminal, no conduce a ningún otro, por lo tanto el programa se terminará allí, con la impresión del mensaje "Estás a salvo... por ahora."

El arbolito que hemos visto es muy simple, pero no dudes que, en una aventura, pronto tendrás un enorme y frondoso baobab de gran complejidad programatoria.

Pero aunque nuestro árbol compruebe cientos de entradas y condiciones, tendrá la ventaja de que, por su propia estructura, consumirá muy poca memoria.

El secreto será en la forma en que dicha estructura puede ser trasladada a un programa BASIC de una manera muy simple y fácil.

Lo primero que tenemos que hacer es guardar toda nuestra información para las condiciones en una matriz, de forma tal que nos podamos referir a ellas por medio de números.

Una matriz es una estructura usada en programación que nos permite almacenar los datos de un programa.

Así por ejemplo, la condición "¿está el jugador en la mazmorra?", que, como toda condición, puede evaluarse como cero (falsa) o no-cero (verdadera), tendrá su valor guardado en la matriz de condición 1.

También el valor para la condición "¿están las ratas hambrientas?" se guardará en la matriz de condición 2, y así sucesivamente.

O séase, que todo lo que necesitamos es montar una matriz que contenga la información para cada nódulo. La llamaremos x (porque somos muy originales).

Ante todo hay que dimensionarla (si no, no se puede usar), es decir, definir la cantidad de elementos de que va a constar, así como su distribución.

Con DIM x (9,4) daremos a nuestra matriz 36 elementos, siendo 9 el número de nódulos y 4 el número de datas diferentes que necesitamos guardar para cada nódulo y que serán:

1. El tipo de nódulo. 0 indicará que es decisivo, 1 indicará que es activo.
2. Si es nódulo decisivo hay que darle el número de condición que debe comprobar.
3. Si es nódulo decisivo hay que darle el número de nódulo a saltar si es falsa la condición comprobada.
4. Si es nódulo decisivo hay que darle el número de nódulo a saltar si es verdadera la condición comprobada.

OJO: En el caso de que se trate de nódulos de acción, los elementos 2 y 3 se pondrán a cero y el 4 llevará el número usado para sacar el mensaje correspondiente en la base de datos.

Como ejemplo, van las datas para los tres primeros nódulos:

10 FOR n = 1 to 4 : READ x (1,n) : NEXT n
20 DATA 0,1,2,3, (el primer nódulo)
30 DATA 1,0,0 (número de mensaje que lleva el nódulo 2A)
40 DATA 0,0,4,5 (el nódulo 3)

Por supuesto, esto lo ampliaríamos para cada uno de los nueve nódulos de nuestra matriz.

Y ahora viene la MAGIA POTAGIA: podemos desarrollar el árbol completo, simplemente poniendo una variable, llamada 'nodulonúmero', a un valor de 1 (uno) y usando la siguiente rutina:

IF x (nodulonúmero, 1) = 1 THEN (salir del árbol porque hemos alcanzado un nódulo terminal)
LET nodulonúmero = x (nodulonúmero, x (nodulonúmero, 2) + 3) : GOTO (principio de la línea y repite el proceso)

La primera parte de la rutina lo único que hace es comprobar si se ha alcanzado un nódulo terminal, y si ello es así, salta fuera del desarrollo.

Lo importante está en la segunda parte, y en la manera en cómo se asigna un nuevo número de nódulo y la variable nódulonúmero.

Ello se hace tomando el dato apropiado al nódulo ACTUAL y seleccionando de la matriz el número adecuado de nódulo a saltar.

Lo hacemos sumándole el valor del número de condición llevado en x (n,2) el número 3, lo que nos dará o bien x (n,3) si la condición es falsa, o x (n,4) si es verdadera.

La rutina simplemente se repite, llamándose a sí misma hasta encontrar un nódulo terminal.

En un próximo capítulo veremos esta técnica en acción y también continuaremos con el nacimiento y desarrollo de nuestro personaje.

Andrés R. Samudio.