#K$ Informations Générales
Ouvrir et fermer l'éditeur

Pour ouvrir l'éditeur d'intelligence, il faut d'abord ouvrir l'éditeur de caractéristiques. Lorsque celui est affiché, il affiche l'éditeur d'intelligence en même temps.
Pour fermer l'éditeur d'intelligence, soit vous fermez l'éditeur de caractéristiques soit vous cliquez sur le bouton "M" qui se trouve dans l'éditeur de caractéristiques.

Editer une Intelligence Artificielle

Lorsque l’éditeur de caractéristiques édite le modèle M, l’éditeur d’intelligence édite aussi le modèle M.
Lorsque l’éditeur de caractéristiques édite le personnage P qui est une instance du modèle M, l’éditeur d’intelligence édite le modèle M.

Aspect Visuel

{bmc edir2.shg}

#K$ Les Boutons
Appliquer l'IA

Le bouton  permet d’appliquer l’intelligence et les réflexes au modèle édité. Il commence par vérifier que les comportements (intelligence et réflexes) sont correctement écrits puis les traduits en données compréhensibles par le moteur d’intelligence.

Imprimer l'IA

Le bouton  permet de sauvegarder les règles de l’intelligence et les règles des réflexes.

Créer un nouveau comportement

Le bouton  permet de créer un nouveau comportement.

Changer le mode d'affichage

Le 4ème bouton permet de changer de mode d'affichage des comportements. Il y a deux modes d’affichage :
- un affichage sous forme de liste (mode )
- un affichage dans lequel chaque comportement est représenté par une boite contenant son nom
  (mode ).

Voir l'Intelligence

Le bouton  permet d'afficher l’intelligence.

Voir les Réflexes

Le bouton  permet d'afficher les réflexes.

Voir les Déclarations

Le bouton  permet d'afficher les déclarations , deux comportements sont présents un pour la déclaration des variables designer et un pour la définition des macros.

#K$ L'éditeur de comportements
Créer un nouveau comportement

On peut créer un comportement soit en utilisant le bouton , soit avec la touche "Inser" soit par un menu contextuel. Le comportement est alors créé sous la souris.

Détruire un comportement

On peut supprimer un comportement en cliquant dessus et en utilisant le menu contextuel ou alors en utilisant la touche "suppr".
On peut supprimer tous les comportements par le menu contextuel.

Renommer un comportement

On peut renommer le comportement en cliquant dessus et en utilisant le menu contextuel.

#K$ Editeur de texte (éditeur de règles)

C'est un éditeur de texte évolué. Ces caractéristiques sont les suivantes :
coloration des mots ;
complétion automatique;
gestion des undo/redo.

Voir Description du langage pour plus de précisions.

#Applique la nouvelle intelligence et les nouveaux réflexes au modèle édité. Il vérifie les éventuelles erreurs lexicales et syntaxiques ; ensuite il traduit l'intelligence et les réflexes en des données compréhensibles par le moteur d'intelligence.

#Imprime une partie ou toute l'intelligence.

#Créer un nouveau comportement.

# Ce bouton permet de changer de mode d'affichage des comportements. Il y a deux modes d’affichage :
- un affichage sous forme de liste (mode )
- un affichage dans lequel chaque comportement est représenté par une boite contenant son nom (mode ).

# Le bouton  permet d'afficher l'intelligence

# Le bouton  permet d'afficher les réflexes

# Le bouton  permet d'afficher les déclarations, deux comportements sont présents un pour la déclaration des variables designer et un pour la définition des macros.

#La coloration des mots

Les mots sont regroupés en trois catégories :
les mots clés du langage
les MétaActions
les conditions
les constantes

Les mots clés du langage sont affichés en rouge (par exemple le mot "si" sera affiché en rouge).
Les MétaActions sont affichées en vert (par exemple le mot "Poursuit" sera affiché en vert).
Les conditions sont affichées en bleu (par exemple le mot "BoutonAppuye" sera affiché en bleu).
Les constantes sont affichées en orange (par exemple le mot "Button_Up" sera affiché en orange).

#La complétion automatique

La complétion automatique d’un mot se fait en utilisant la touche "²". Par exemple si on tape "s" puis "²" alors le mot clé "si" apparaîtra, de même si on tape "a" puis "²" alors le mot "alors" apparaîtra, de même pour les MétaActions et les conditions. De plus si on écrit "si " puis "²" alors les conditions sont proposées dans une boite de dialogue. De même après "alors" puis "²" les MétaActions sont proposées dans une boite de dialogue. Si plusieurs mots clés (langage, actions ou conditions) commencent par le même début (exemple: pour l'instant deux actions commencent par "ChangeC") lors de la complétion (avec "²") une boite de dialogue sera proposée avec les mots clés commençant par ce même début (exemple: "ChangeC" puis "²" proposera "ChangeComportement",  "ChangeComportementRefelexe").

#Undo/Redo (Faire/Défaire)

Pour utiliser le Undo, il faut appuyer sur la touche Ctrl et (en même temps) la touche "Z".
Pour utiliser le Redo, il faut appuyer sur la touche Ctrl et (en même temps) la touche "A".
Une boite de dialogue apparait lorsqu'aucun Undo ou Redo n'est disponible.
Undo/Redo dans l'éditeur de comportements

La création, suppression et modification (changement de nom) d'un comportement sont gérées.
Si vous détruisez tous les comportements et que vous appuyez sur Ctrl+"Z", tous les comportements précédemment détruits seront recréés.
Undo/Redo dans l'éditeur de règles

Les actions classiques telles que la frappe d'un caractère, l'insertion d'un bloc de texte et la suppression d'un bloc de texte sont gérées.
De plus, la complétion automatique est aussi prise en compte.

# K $ Description du langage
Remarques
Les mots clés du langage seront écrits en gras.
Les constantes (l’étiquette d’une règle ...) et variables seront écrites italique gras.

Informations générales 

Vous pouvez (devez !!) utiliser des commentaires dans l'éditeur de règles en utilisant le point virgule ";".

Un comportement est constitué de deux parties distinctes :
- l'emploi du temps
- les règles d'interruptions

Dans l'emploi du temps et les règles d'interruptions, vous pouvez utilisez des conditions, des opérations, des variables designers, des macros et des listes.

# K $ L'emploi du temps
Description

L'emploi du temps commence par le mot "EmploiTemps".
L’emploi du temps est une suite d’opérations. C’est cette suite d’opérations qui sera exécutée si aucune règle d’interruption n’est valable.

Syntaxe

L'emploi du temps est une liste d'opérations.

Exemple

EmploiTemps
ParcourirChemin("MonChemin")
ExecuteActionModule("Tourelle","Tir")
ParcourirChemin("MonChemin2")

# K $Les règles d'interruption
Syntaxe

Les règles d'interruption commence par le mot "RegleInterruption".
Une règle d’interruption est constituée d’une partie d’initialisation (pour le calcul de la condition) et d’une opération conditionnelle c’est-à-dire :

Soit
initialisation pour le calcul de la condition
si conditions
alors opérations
finsi

Soit
initialisation pour le calcul de la condition
si conditions
alors opérations
sinon opérations
finsi

Exemple

RegleInterruption
AffecteListeAvecZonePerso(liste,"ZDDtruc")
si
	PersoExisteDansListe(liste,"ed")
alors
	ChangeAction("walk")
	ChangeMonComportement("marcher")
finsi

# K $Les conditions
Syntaxe

Une condition est une suite de conditions simples séparées par des opérateurs booléens (Ket, Kou et Knon).

Une condition simple peut avoir plusieurs formes :
une fonction sans paramètres (par exemple CollisionAvecMur).
une fonction avec des paramètres (par exemple BoutonAppuye("Button_Up")).
un test (par exemple moi.force<4 qui retourne vrai si la force du personnage est inférieure à 4).
Exemple

Ksi
  (
       (TailleDeListe(Liste1) <> 4)
   et
       (non(moi.force <> 3))
  )
Kalors
....
Ksinon
....
Kfinsi

# K $Les opérations
Syntaxe

Une opération peut avoir plusieurs formes :
Initialisation des paramètres de l’ActionDesigner
MétaAction(ActionDesigner, paramètres de la MétaAction)
variable := expression
variable += expression
variable -= expression
variable *= expression
variable ++
variable –
perso.variable := expression
perso.variable += expression
perso.variable -= expression
perso.variable *= expression
perso.variable ++
perso.variable --

Une variable peut être soit une variable designer soit une caractéristique du personnage.
Une expression est une expression mathématique, c’est une suite de mini-expressions séparées par des opérateurs mathématiques ( + - * ).
Une mini expression peut être :
une constante
une variable
une fonction (par exemple TailleDeListe(liste) )
une caractéristique d’un personnage.

Pour accéder à une caractéristique d’un personnage, on utilise le point "." :
pour le personnage courant : on accédera à sa force en écrivant : moi.force.
pour un personnage qui se nomme "toto" : on accédera à sa force en écrivant : "toto".force.
pour un personnage représenté par une variable designer (variable qui a pour nom MonPerso) : on accédera à sa force en écrivant : MonPerso.force.

Les MétaActions sont définies une fois pour toute (il est impossible à un designer de fabriquer une nouvelle MétaAction). Comme MétaAction, il y aura par exemple AllerVers et Exécuter.
Une ActionDesigner est définie par le designer dans l’éditeur d’action.
Si l’ActionDesigner a des paramètres, il FAUT initialiser ces paramètres avant d’appeler la MétaAction.

Exemples

moi.force := moi.force * 2 ; (you can also write "moi.force *= 2")

moi.point_de_vie += pomme.point_de_vie

Poursuit("toto",2) ; s'arrête à 2 mètres de "toto"

# K $Les variables designer
Déclaration

Les variables designer DOIVENT être déclarées dans la section prévue à cet effet. Pour cela, il faut appuyer sur le bouton  et entrer les déclarations dans le comportement "Variables designer".
Syntaxe

La déclaration et l’initialisation des variables designer se fait de la manière suivante :

variable type    variable name : initial value
variable type    variable name : initial value
....

Les types possibles sont les suivants :
KBooleen
KEntier_128a127
KEntier0a255
KEntier_32767a32768
KEntier0a65535
KEntier (de -2147483647 à 2147482648)
KEntierPositif (de 0 à 4294967295)
KReel
KPoint3D
KWayPoint
KPerso
KListe (la valeur initiale représente le nombre maximum de personnages que la liste peut contenir)
KChemin
	
Exemple

Booleen	Armure	: 	Faux
0a255	CompteurBalles	:	11
Liste	ListeVue 	:	4 ; quatre persos au maximum dans cette liste
Booléen	Ailes	:	Vrai
WayPoint	Nrj	:	NullePart
WayPoint	Munitions	:	PorteSortie
Liste	Liste_Amis_vues	:	6
Perso 	MeilleurAmi	:	Personne
Point 3D	DernierPtVie	: 	NullePart

# K $Les macros
Déclaration

Les macros DOIVENT être déclarées dans la section "déclaration". Pour cela, il faut appuyer sur le bouton  et entrer les déclarations dans le comportement "Macros".
Syntaxe

La déclaration des macros se fait de la manière suivante :

Macro macro1 name :
macro1 definition
Macro macro2 name :
macro2 definition
....

La définition de la macro est une suite d’opérations.

Exemple

Macro TirGrossePierre :
PersoACreer := GrossePierre
ComportementALaCreation := CréeGrossePierre
ExecuteAction("Tir")
Macro GardeChateau :
ParcourirChemin("TourDuChateau")

# K $Les listes

Les fonctions disponibles sont les suivantes :
fonctions de déclarations
fonctions d'affectations
fonctions de contrôle des personnages d'une liste
fonctions donnant l'état d'une liste
fonctions de spécifications des listes
fonctions de trie
fonctions d'ensembles
 K # Déclaration

Liste  MaListe : 5
Avec cette déclaration MaListe ne peut avoir au plus que 5 personnages.
La liste est toujours initialisée à vide.

K # Affectation

AffecteListeAvecZonePerso(MaListe,"LesYeux")
A chaque fois que cette affectation est exécutée la variable MaListe contiendra tous les personnages détectés dans la zone.

ListeA := ListeB
Tous les personnages de la liste B sont recopiés dans la Liste A (si la taille de la liste A est suffisamment grande).

K # Contrôle des personnages d'une liste

AjoutePersoDansListe (MaListe, "Garde")
Par défaut, le personnage Garde se rajoutera en queue de Maliste.

AjoutePersoDansListeA (MaListe, "Garde", 4)
Ajoute Garde après le quatrième personnage. (ou à la fin de la liste si elle a moins de cinq éléments)

PrendPersoDansListe (MaListe, 1)
Retourne le premier personnage de la liste MaListe.

PrendPersoDansListe (MaListe, 4)
Retourne le 4éme personnage de la liste MaListe (ou le dernier si la liste a moins de quatre éléments).

PersoExisteDansListe (MaListe, "Garde")
Retourne vrai si le personnage "Garde" est dans la liste MaListe.

TrouveEtDetruitPersoDansListe (MaListe, "Garde")

DetruitPersoDansListe (MaListe, 10)
Si la liste à moins de 10 personnages, rien ne sera détruit.

K # Etat d'une liste

TailleDeListe (Maliste)
Donne le nombre de personnages dans la liste MaListe.

Si TesteListeVide (Maliste) alors ...
Indique si la liste est vide ou non.

K # Spécification des listes

RQ : Non disponible actuellement.

SelectDansListe (MaListe, Force > 3)
Après l’exécution de cette fonction, il ne reste que les personnages ayant une force supérieure à 3.

DétruirePersoSi (MaListe, Force > 3)
Après l’exécution de cette fonction, il ne reste que les personnages ayant une force inférieure ou égale à 3.

K # Trier une liste

RQ : Non disponible actuellement.

TrieListe (Maliste, 3, OrdreCroissant, Résistance)
Après l’exécution de cette fonction, MaListe contient dans l’ordre croissant les 3 personnages dont la résistance est la plus forte.

TrieListe (MalisteB, PourTout, OrdreDecroissant,  Force + Résistance)
Après l’exécution de cette fonction, MaListeB est trié dans l’ordre décroissant par rapport à la somme de force et de résistance.

K # Fonctions d'ensemble sur les listes

Remarques :
	ListeA, ListeB et ListeC doivent être différentes.
	Le résultat (ici ListeC) peut être tronqué si sa taille n'est pas suffisante.
	
ListeUnion (ListeC,ListeA,ListeB)
La liste C contient tous les personnages rencontrés dans la liste A ou dans la liste B.

ListeIntersection (ListeC,ListeA,ListeB)
La liste C contient les personnages appartenant à fois à la liste A et à la liste B.

ListeDifference(ListeC,ListeA,ListeB)
La liste C contient les personnages de la liste A ne se trouvant pas dans la liste B.

# Un commentaire est une explication de votre code. Il aide les autres designers à comprendre ce que vous avez voulu faire.

# Une condition est un test.

# Une opération peut être une MetaAction, une action designer ou autre.

# Une règle d'interruption est une règle qui peut arrêter l'emploi du temps.