dddddd escribió:
Pongo un pseudo-python para ilustrar un
comentario. En spac no lo consigo darle formato.
Código:
class Caballo():
def asociar_accion(contexto_parser):
# llamada por el parser
if (contexto_parser.str_verbo == 'montar'):
# informamos de las acciones posibles para ese verbo
# podremos usar el contexto que nos da el parser (CD, CI, etc.)
if (contexto.tal == cual and ....):
# hay contexto suficiente, una única UA
UAs = (UA_poner_encima)
(...)
else:
# no hay contexto suficiente, informamos de todas las opciones
UAs = (UA_poner_encima, UA_acto_sexual) #lista en python
return UAs
def acc_poner_encima(contexto_accion):
# llamada por el parser
(...)
def acc_acto_sexual(contexto_accion):
(...)
A mi esa alternativa me parece simplemente mal, en seudo-python (por manejarse igual) para mi debería ser algo como:
1. Los objetos sólo deberían interactuar entre ellos y con lo que has llamado 'acciones universales' (no sé porqué universales cuando lo puedes llamar simplemente 'evento' o 'acciones'), así aprox.:
Código:
class Caballo():
def acc_poner_encima(contexto_accion):
# llamada por el parser
(...)
def acc_acto_sexual(contexto_accion):
(...)
2. pero.... esto es en realidad mala idea porque en muchas ocasiones no querrás 'interceptar' completamente la acción, así que yo lo veo más bien como:
Código:
class Caballo():
before_acc_poner_encima = {fun1,fun2}
before_acc_acto_sexual = {fun3}
after_acc_poner_encima = {}
after_acc_acto_sexual = {}
def fun1(contexto_accion):
(...retorna algo que indica si debe seguir o no...)
def fun2(contexto_accion):
(...)
def fun3(contexto_accion):
(...)
3. Si Caballo hereda de algo llamado 'Objeto' que tenga funcioncioncillas de esas predefinidas se simplifica así:
class Caballo(General.Objeto):
before_acc_poner_encima = {fun1,fun2}
before_acc_acto_sexual = {fun3}
def fun1(contexto_accion):
(...retorna algo que indica si debe seguir o no...)
def fun2(contexto_accion):
(...)
def fun3(contexto_accion):
(...)
[/code]
4. La sintaxis no debería estar 'incrustada' en el caballo, sino en el parser del jugador, así:
Código:
import gramatica from Gramatica.Jugador
import rules, actions from World;
class Parser.Jugador(General.Parser):
def parser(input):
(...separa el input, le aplica el vocabulario, sustituye pronombres, analiza sn...)
return contexto_parser
def asociar_accion(contexto_parser):
matches = gramatica.match(contexto_parser)
for( match in matches)
# verificar objetos por unas reglas del mundo
for( object in match.objects )
# marcamos que aún es válido
match.still(rules.visility(object))
match.still(rules.whatever(object))
(...)
# o incluso
for( rule in rules.toBeApplied )
match.still( rules( rule, object) )
(...)
# Descartados matches de objetos no usables
# Aplicamos otros descartes contextuales
(...)
# Aplicamos una priorización/desambiguación
(...)
# Aqui ya tenemos un 'match' seleccionado llamado 'match_selected'
# Dejamos ahora que cada objeto opine sobre la acción
for( object in match_selected.objects )
if object.before( match_selected.action, match_selected.role(object) )
(...esto puede interceptar la acción... hay que tratar los resultados, etc...)
# Finalmente llamamos a la 'acción' definida en general
if actions[match_selected.action].do( match_selected )
(... de nuevo tratamiento de errores, etc...)
# Ahora aplicar las reacciones y luego los afters
for ( object in player.location.objects )
object.react( match_selected )
for ( object in match_selected.objects )
if object.after( match_selected.action, match_selected.role(object) )
(...esto puede interceptar la acción... hay que tratar los resultados, etc...)
(...)
5. En la clase genérica 'Objeto' tendrías:
Código:
class Objeto():
def before(action, role):
(...invocación de la before_acc_adecuada...)
def after(action, role):
(...invocación de la before_acc_adecuada...)
Complicadillo, ¿no?
Pues la gracia es que si le añades un poco de 'azucar' sintático peculiar se llama Inform.
En mi blog, cuando pueda os completo la imagen de lo que le falta al Inform.