Langage IA

[VLanvin]

Etant donné qu'on en a parlé, j'ouvre ce ticket pour discuter du langage de script des IAs. Voilà une idée globale qu'on avait eue avec @iSheeft :

L'idée serait d'avoir plusieurs primitives que l'interpréteur appelerait pour chaque unité. Par exemple, lorsque une infantrie doit se déplacer, l'interpréteur cherche la primitive "infantry" de type "move", et l'exécute. Cette primitive renvoie (normalement) une position représentant la position où l'IA souhaite se déplacer. Ensuite, si possible, l'interpréteur cherche la primitive "infantry" de type "attack", qui renvoie la position où attaquer. Dans ces primitives, on peut accéder à une variable externe (fournie par l'interpréteur) "range", représentant les positions accessibles/attaquables (selon la primitive). On aurait quelque chose d'assez similaire pour les bâtiments.

On aurait aussi la possibilité de déclarer des variables globales (partagées par toutes les primitives), de faire du précalcul (hors de toute primitive), ou des variables locales (dans les primitives).

Finalement, on aurait un point d'entrée "main", appelé par l'interpréteur tant qu'il reste des unités/batiments non utilisés (ou que le joueur n'a pas appelé "pass ()"), et dont la fonction serait de renvoyer la prochaine unité/batiment à utiliser.

Voici un exemple d'utilisation :

// define globals 
int im_a_global = 10;

// do preprocessing
im_a_global = 11;

// called when "main" has selected an infantry or a bazooka for the next movement
attack infantry, bazooka {
  //do stuff, define locals
  position fire_to;

  //can access a variable "range" containing
  //the list of attackable positions
  fire_to = range[i];

  //return a position to attack 
  return fire_to;
}

move infantry {
  //move stuff
  //can access a variable "range" containing
  //the list of accessible positions
  //return a position (move to)
}

attack default {
  //do more stuff
}

move default {
  //move more stuff
}

main {
  unit next_unit = my_most_op_unit ();
  //return the next unit that should play
  return next_unit;
}

[VLanvin]

Pour ce qui est des types, il serait bien d'avoir : -Des entiers (int) -Des booléens (bool) -Des chaînes (string) --surtout pour débuguer -Des listes ('a list) --polymorphe, non hétérogène -Des tableaux ('a array) --idem -Flèches ('a -> 'b) --ne serait-ce que pour les fonctions exposées -Types option ? ('a option)

Eventuellement des alias (pour forcer un certain typage sur le type de retour des primitives) : -type position (aka. int * int) -type unit -type building -type tile -type battlefield (aka. tile array array)

On exposerait suffisament de fonctions pour, par exemple : -récupérer l'unité (éventuelle) à une position donnée -récupérer l'armée d'un joueur -itérer sur cette armée -récupérer les données d'une tile -récupérer une tile à une position donnée -etc....

A partir de ça, on pourra exposer des primitives bien plus puissantes comme, par exemple, récupérer l'unité la plus proche et la plus efficace contre une unité donnée.

[VLanvin]

J'ajoute une idée de @OlivierMarty (désolé du spam, mais ce sont des parties assez différentes, je préfère donc bien séparer). L'idée serait d'avoir un point d'entrée init afin de bien distinguer le précalcul qui se fait avant chaque tour du précalcul qui se fait une fois au début de la partie. On aurait alors l'ordre suivant :

• On lance une partie, on parse les IA (on obtient un AST)
• On lance un rapide type-checker sur l'AST obtenu
• On exécute la partie "globale" de chaque IA, pour cette partie elles ont droit à plus de temps et de ressources
• Le jeu commence, à chaque tour d'une IA on :
• Appelle la fonction init, l'IA dispose pour cela d'un nombre moyen de ressources et de temps
• Appelle la fonction main (l'IA dispose maintenant d'un temps limité)
• Pour l'unité renvoyée on appelle la primitive move correspondante
• Puis la primitive action
• On itère (à partir de l'étape 2, ie. on ne rappelle pas init)