Re: [Mine-dev] Help!!! Macros y sucesos

[Andres Moya]

El dom, 03 de 08 de 2003 a las 15:51, address@hidden escribió:
> Estoy perdido en un mar de dudas. No entiendo el diseño del sistema de
> macros. ¿Quién las declara, quién las instancia, quién las utiliza?
> Estas tareas parecen estar diseminadas entre las clases Objeto, Guion
> y Accion, aparte el hecho de que hay "macros principales" y "macros
> extra".

Si, reconozco que el tema de las macros está muy poco claro en el
código. Yo mismo me hago líos a veces cuando lo reviso. Algún día de
estos haré un poco de refactoring para intentar hacerlo más legible.

A ver si puedo explicar un poco la secuencia.

En primer lugar, hay que distinguir la DECLARACIÓN de una macro de su
USO. La declaración es una construcción "estática", que se realiza una
vez al instanciar un objeto, sala o pnj, y sus guiones incluidos, e
incluye los *nombres* y *tipos* de las macros posibles en un suceso
determinado. El uso es una acción "dinámica", en la que al guión se le
pasan los *nombres* y los *valores* de las macros cada vez que el guión
se vaya a ejecutar realmente.

De momento no existe clase Suceso, cada suceso consiste en un string con
el nombre del mismo, y un guión asociado (que podrá ser un módulo más
adelante). Durante el parseado del objeto, sala o pnj desde el fichero
XML, se instancian los sucesos y los guiones asociados. Y al constructor
del guion se le pasan las declaraciones de las macros existentes en ese
suceso en particular.

Por ejemplo, pongamos el suceso personaje_come de la entidad Objeto (en
realidad es igual con todos los sucesos de objeto, excepto
personaje_usa_con). Al parsear el fichero XML, cuando se llega al
suceso, se crea una instancia de Guion, y al constructor se le pasa la
declaración de las macros de personaje_come, que son: $usuario (de tipo
Personaje), $sala (de tipo Sala) y $objeto (de tipo Objeto). 

El guion utiliza esto para "inventarse" los valores de los parámetros de
los requisitos y acciones que no aparezcan explícitamente en el fichero
XML.

Por ejemplo, dentro del guión descrito en el fichero XML existe la
<acción base="Personaje" nombre="actuar_uno_mismo" texto="te comes la
manzana"/>. Si os fijáis, no se indica el parámetro id. El constructor
del guión, entonces, asigna como valor de id la macro $usuario, que es
la primera que encuentra de tipo Personaje. Tiene sentido, se
sobreentiende que el personaje que actúa para sí mismo es el que se está
comiendo la manzana.

Con lo cual, el guión instanciado contiene una acción "actuar_uno_mismo"
con un parámetro id que vale "$usuario" y otro texto que vale "te comes
la manzana".

Luego llega el caso de que algún jugador ejecuta el comando +comer sobre
esa instancia concreta de manzana. Entonces es invocado el método
personaje_come(self, usuario) del objeto, que es el método de respuesta
al suceso personaje_come. Este método ya conoce cuál es el personaje que
está comiendose la manzana (lo recibe como parámetro), también puede
averiguar la sala en la que está, y conoce también el objeto (él mismo,
self). Con todo esto, llama al método ejecutar() del guion, y le pasa
las macros de nuevo, esta vez sin tipos y con valores.

El método ejecutar del guión llama a su vez, al ejecutar() de la acción
actuar_uno_mismo, la cual lo primero que hace es resolver los
parámetros. El primero es id y vale "$usuario". Por el $, detecta que es
una macro, y busca su valor en las macros que le han pasado. Al final el
valor de id vale la instancia de Personaje que está +comiendo. El
segundo parámetro es texto, y vale "te comes la manzana". Como no
empieza por $, es un valor directo, y no hay que hacer nada más.
Finalmente, se llama al método actuar_uno_mismo() del personaje en
cuestión, con el texto indicado.

Es un flujo complicadillo, pero yo creo que es correcto y funciona
bastante bien. El problema es de legibilidad, creo que hay que modificar
los nombres y mejorar los comentarios. Quizá incluso sea necesario hacer
una clase Suceso.


Por cierto, lo de las macros extra: esto es para los guiones que tienen
su propio fichero descriptor XML, y se pueden llamar desde otros
ficheros. Por ejemplo, pongamos un guion alimento_comer.xml, que
contiene una acción actuar_uno_mismo. El parámetro id está implicito,
igual que antes. Y el parámetro texto ahora vale "$texto_comer".

$texto_comer es una macro, pero esta vez no sale del suceso, sino de la
llamada al guion desde otro fichero. Por ejemplo, en el descriptor
manzana01.xml, dentro del suceso personaje_come se llama al guion,
indicando <guion id="alimento_comer" texto_comer="Te comes la manzana">.

Si te fijas, la declaración de las macros extra es distinta: se realiza
estáticamente al parsear los ficheros, pero no se le pasa el nombre y el
tipo, sino el nombre y el valor directo, ya que este valor es fijo y no
depende de quién, cuándo y dónde se ejecute el guion.

En el constructor del guion, las macros extra se guardan tal cual. Y
durante la ejecución del guion, las extra son añadidas a las macros
normales que se reciben.

Espero que te haya aclarado algo, y no te lo haya embarullado aún más.
:P

-- 
Andrés Moya <address@hidden>

Omnis enim res, quae dando non deficit, dum habetur et non datur, nondum
habetur, quomodo habenda est (San Agustin, hablando de SW libre en el
siglo IV)