Le langage étant basé sur les termes de Prolog, on notera l'utilisation de la virgule pour séparer les éléments d'une liste. Les listes en Prolog sont écrites entre crochets. Ici les accolades sont converties en crochets par le compilateur. On peut utiliser les accolades ou les crochets (ou les deux).
Le jeu de base ne possède pas de conditions d'entrée ou de sortie. Ce sont les conditions par défaut qui seront utilisées, de manière à rentrer dans le jeu et à ne plus en sortir.
La clause <<import>> permet d'inclure la description d'un jeu dans le jeu en cours de définition. L'argument de <<import>> doit être le nom complet du jeu importé, c'est-à-dire le terme avec tous ses arguments. Si l'on importe le jeu <<question>>, il faut écrire <<question(_)>> pour traiter toutes les questions, ou <<question(p)>> pour ne prendre en compte que la question <<p>>. Mais <<import question>> produirait une erreur.
game jeu_de_base =
{
perception =
{
C => x b (C:t) | C\=($ _) % Mémorisation des coups autres que $
},
update =
{
x b (y ? Q:_) => x b y w y kif Q,
x b (y ! P:_) => x b y b P,
x b (y ! P:_) and x w x kif P => x b P,
x b P => -(x b -P),
x b (y ! P:_) => x b y b x a x kif P
},
generation =
{
true => $ x # 0.01 % fin du dialogue ...
},
interdiction =
{
x b (C:T) => -C | T<t # 100,
x w _ or x b y w _ => - $ x % ... si plus d'intention
}
}.
game question(Q) =
{
import jeu_de_base,
entrance = x w x kif Q,
invariant = x w x kif Q,
exit = x kif Q,
generation =
{
x w x kif Q => x ? Q # 10
},
update =
{
x kif Q => -(x w x kif Q)
}
}.
game reponse(Q) =
{
import jeu_de_base,
entrance = x b y w y kif Q and x b y a y kif Q,
invariant = x b y w y kif Q,
exit = x b y kif Q,
generation =
{
x b Q => x ! Q # 10,
-(x b Q) => x '!?' Q
},
update =
{
x b (P->Q) and -(x kif P) => x w x kif P,
x b y kif Q => -(x b y w y kif Q),
x b (x ! P:_) and x b y w y kif P => x b y b P
}
}.
game conflit(Q) =
{
import jeu_de_base,
entrance = x b y b -Q and x b Q,
invariant = x b y b -Q and x b Q,
exit = x b y b Q or x b -Q,
generation =
{
x b (P->Q) => x ! P # 100,
x b (P->Q) => x ! (P->Q),
x b Q => x ! Q
},
update =
{
x b y b Q => -(x b y b -Q),
x b -Q => -(x b Q)
}
}.
game mefiance(Q) =
{
import jeu_de_base,
entrance = x b y w Q and -(x b y a Q),
invariant = x b y w Q and -(x b y a Q),
exit = x b y a Q or -(x b y w Q),
update =
{
x b (y ! P:_) and x b (P -> (y a Q)) => x b P,
-(x b y a Q) => x w x kif y a Q
},
generation =
{
-(x b y a Q) => x ! -(y a Q)
}
}.