Faudrait peut-être y réfléchir un peu :p

Ce qui peut être un bon point de départ, c'est de partir sur un modèle similaire à ce qui a été vu en cours la dernière fois : un automate avec des transitions du genre (1/3)*aFaim + (2/3)*cheeseBurgerProche > 1/2 => à table !
(avec des variables aux valeurs comprises entre 0.0 (faux) et 1.0 (vrai).

Il faudrait définir les éléments que l'on prend en compte pour les transitions. Ex :
- vulnérabilité de son capitaine
- vulnérabilité des capitaines ennemis
- rapport de force global (en prenant en compte toutes les unités de la carte)
- rapport de force local (en prenant en compte seulement les unités d'une zone donnée)
- etc (c'est justement ce qui se cache derrière cet "etc" qui est à définir )

Et aussi les états (stratégies) possibles. Ex :
- foncer dans le tas
- affaiblir l'ennemi (attaque de groupes isolés)
- occuper les forces adverses pendant que l'un des groupes tente de tuer le capitaine adverse.
- fuite
- etc

Et même avant cela, il faudrait déjà réfléchir au comportement que l'on attend de "nos" troupes. Ex :
- massacrer tout ce qui bouge si le rapport de forces est clairement à notre avantage.
- affaiblir l'ennemi pour essayer de prendre le dessus sur son adversaire si les forces sont plus ou moins égales.
- jouer plus fourbement (essayer de tuer le capitaine en contournant les troupes, etc) quand on "voit" qu'une bataille rangée conduira à notre perte.
- fuite si des groupes vont être exterminés inutilement.
- etc

ps : je ne vois aucun inconvénient à ne pas tout faire hein, ne vous gênez pas pour parler de vos idées
En attendant il faudrait que je me bouge un peu pour finir mon schmilblick :p

Je vois que mon post n'a pas eu beaucoup de succès...

Bon, pour ce qui est de la définition des stratégies (foncer dans le tas, fuite, etc), on peut faire ça à la manière du design pattern état (state), donc en créant une classe par stratégie. Chaque classe aurait deux méthodes à définir :
- une qui compte tenu de la stratégie actuelle (utilisée au tour dernier) et du rapport de forces choisit la stratégie à adopter pour ce tour-ci.
- une autre permettant d'effectuer son tour de jeu (faire un ensemble de déplacements, fusions, divisions et attaques logiques compte tenu de la stratégie utilisée).

Pour le contenu de la première méthode, qui sera en partie commun à toutes les classes (voir que l'ennemi a deux fois plus de forces que soi, c'est indépendant de la stratégie utilisée), il faudra se mettre d'accord.

Pour la seconde méthode par contre, on peut assez facilement avoir une répartition du travail du genre :
- Robert définit le comportement de l'IA dans une stratégie de "foncer dans le tas" (et ne travaille donc que sur la classe associée à cet état).
- Marcel définit le comportement de l'IA dans une stratégie de "affaiblir l'ennemi".
- René définit le comportement de l'IA dans une stratégie de "occuper les forces adverses pendant que l'un de nos groupes tente de tuer le capitaine adverse".

Alors certes, je n'ai pas encore fait ce qu'il faut pour qu'on puisse commencer à coder ça, mais rien n'empêche de réfléchir à ce qui devrait être le plus facile : appliquer une stratégie une fois qu'elle a été choisie. Donc :

- Comment (quel algorithme) faire en sorte que nos troupes foncent dans le tas ? (et pas trop connement non plus)
- Comment faire en sorte que nos troupes essaient d'affaiblir l'ennemi ? (le but est donc ici de diminuer les forces ennemies davantage que les siennes)
- Comment faire en sorte d'occuper la défense ennemie pendant que d'autres forces foncent pour tuer le capitaine ennemi ?
- Comment fuir un champ de bataille efficacement ? (cad en minimisant les pertes, en sacrifiant éventuellement certaines unités pour en sauver d'autres, et surtout en essayant d'assurer la protection du capitaine)

(et il faudrait aussi trouver d'autres stratégies viables...)

On se proposais de se retrouver mercredi après les cours pour mieux discuter de l'IA pour se lancer sur une bonne base. Tu sera libre quentin ?

oué après prog agent avec notre coquin de ferber

reporté a vendredi après le TD d'IA. ok ? ^^

ok

Lorsqu'on s'est vu vendredi je ne sais plus quand, on parlait de déterminer une stratégie générale (du genre foncer dans le tas), et de donner des ordres à chaque unité individuellement pour mener à bien la stratégie. Mais finalement, on s'est dit hier avec Séb que ça ne serait vraiment pas terrible :
- lorsqu'on veut déplacer un ensemble de groupes, il faut commencer par déplacer les groupes les plus proches de l'objectif, sinon les groupes situés en arrière sont bloqués par ceux de devant.
- les groupes n'ayant pas tous la même vitesse (cavalerie légère = 8, fantassin lourd = 4 ^^), si chacun n'en fait qu'à sa tête, le groupe se divisera très vite.

Au lieu de se prendre la tête à régler ça en gardant un système d'ordres individualisés, autant ne pas descendre à un niveau plus bas qu'un ensemble de groupes. En plus ça tombe bien, vu que je n'ai pas fait grand chose depuis un moment je n'ai presque pas de code à reprendre (faudrait se bouger quand même :/)

ok :p

Voici comment je vais faire pour l'attaque bourrine

Code:


#ifndef ATTAQUEBERSERK
#define ATTAQUEBERSERK

#include <vector>

#include "../../gestion_donnees/Coordonnees.h"

class AttaqueBerserk
{

public:

// attaque sur le joueur numero joueur.
    AttaqueBerserk(int joueur);

// Etape 1.
// retourne les coordonnes du capitaine du joueur numero joueur.
    Coordonnees trouverCapitaine(int joueur);

// Etape 2.
// retourne la liste des positions des groupes qui protegent le capitaine. (protection directe, bloque le chemin pour aller au capitaine).
    std::vector<Coordonnees> quiProtegeLeCapitaine(const Coordonnees& capitaine);

// Etape 3.
// retourne la liste des positions des groupes qui defendent le capitaine. (protection indirecte, sont a faible distance du capitaine et pouvant venir rapidement le proteger).
    std::vector<Coordonnees> quiDefendLeCapitaine(const Coordonnees& capitaine);

// Etape 4.
// retourne la position la plus faible de la defence, la ou il faudra faire une attaque en force pour tuer le capitaine.
    Coordonnees trouverLaFailleDansLaDefence(std::vector<Coordonnees> protegent, std::vector<Coordonnees> defendent);

// Etape 5.
// procedure d'attaque.
    void lancerAttaque(int joueur);

private:

// le joueur qui subi l'attaque
    int leJoueur;

// coordonnes du capitaine du joueur.
    Coordonnees capitaineDuJoueur;

// liste des positions des groupes qui protegent le capitaine.
    std::vector<Coordonnees> unitesProtegentCapitaine;

// liste des positions des groupes qui defendent le capitaine.
    std::vector<Coordonnees> unitesDefendentCapitaine;

// position la plus faible de la defence.
    Coordonnees laFaille;

};

#endif


Code:


AttaqueBerserk::AttaqueBerserk(int joueur)
{
   leJoueur = joueur;
   capitaineDuJoueur = trouverCapitaine(leJoueur);
   unitesProtegentCapitaine = quiProtegeLeCapitaine(capitaineDuJoueur);
   unitesDefendentCapitaine = quiDefendLeCapitaine(capitaineDuJoueur);
   laFaille = trouverLaFailleDansLaDefence(unitesProtegentCapitaine, unitesDefendentCapitaine);
   lancerAttaque(leJoueur);
}


Pour le moment derrière chaque fonction y a rien, mais je suis en train de le faire.
Dite moi ce que vous en penser

Faut aussi faire attention à ne pas exposer ton propre capitaine

oué ça sera dans lancerAttaque, garder un peut de def

Pour ma partie de l'IA, il y aura un groupe d'unité avec l'ordre "fuir" déjà ou est ce que c'est ma méthode qui doit deviner ou est le champ de bataille a fuir ?

Quentin >

Un petit détail important : dans AttaqueBerserk(int joueur); il faut que joueur soit le numéro du joueur qui exécute la stratégie, et non de la cible (sinon on se mélangera complètement avec les autres stratégies :p)

Sinon c'est bien ça oui. Par contre, tu n'auras pas vraiment besoin de gérer l'attaque.

L'idée, c'est qu'il y a une classe Organisation qui associe des ensembles de groupes aux tâches (bas niveau) qui doivent être effectuées. Exemple :
- groupe d'archer et de cavalerie lourde : protection rapprochée du capitaine
- lanciers : déplacement en (14,26)
- fantassin léger : défendre position (18,25)
- fantassin lourd : attaquer position (11,4)

Le rôle des classes dérivées de Strategie, comme la tienne ou celle de Séb, se limite à choisir une organisation, donc de partitionner ses groupes au besoin (un gros qui bourrine, un petit qui surveille le capitaine de près par exemple), et de donner à chaque partie des ordres, sous forme d'objet Ordre.

La méthode executer des objets Ordre se charge de les appliquer, en prenant en charge tout ce qui est plus de l'ordre de la micro-gestion (faire que dans un déplacement les unités les plus rapides ne laissent pas les plus lentes en retrait, que les terrains choisis soient ceux sur lesquels on a un bonus, etc).

Séb >

Je pense qu'il serait mieux que ce soit ta méthode, même si ça peut paraître un peu bizarre. Si ce n'est pas celle là qui le fait, il faut en trouver une autre, et ça risque de l'être encore plus.

Bon ben du coup je pense procéder comme ça :

Un passage sur toutes nos unités pour déterminer un coefficient d'importance (le capitaine au max, puis le reste suivant la force du groupe).
Un second passage pour déterminer le coefficient de danger (si il y a une unité ennemie plus forte que nous qui peut nous attaquer au prochain tour).

Puis on fait fuir les unités par ordre d'importance et de danger (le capitaine avec un groupe qui peut le tuer a côté aura la priorité max, le capitaine bien protéger a l'autre bout de la map ne bougera pas), en suicidant les unités de faible importance comme bouclier humain des unités a haute importance.

Il y aura une info pour récupérer l'ancienne mission d'un groupe d'unité donc ? si une unité va se faire buter mais que c'est parcque on l'avais mis la exprès pour ralentir l'ennemie faut pas la bouger.

En fait, au moment où tu arrives dans ta méthode principale, les ordres en place sont toujours les précédents.
Le boulot de cette méthode est justement de les mettre à jour (ou pas), afin qu'ils soient exécutés juste après.

ps :

en suicidant les unités de faible importance comme bouclier humain des unités a haute importance.

Facile à dire, très dur à faire :p

ce que ca me gonfle en tout cas


Les ordres des groupes, ou on les récupere ? et il faudrais faire une liste de tous les ordres qu'on creer.

On les récupère via un objet Organisation, qui lui même se récupère via l'objet IA du joueur en question. Mais je ne sais pas exactement comment, faut que j'y réfléchisse. Pour le moment je me suis occupé de résoudre le bug que j'avais eu hier, et d'améliorer la navigation sur la carte (scrolling à la souris, zoom à la molette)

La liste des ordres, pour le moment :
- AttaquerPosition (prend un vecteur de groupes et une Coordonnees en param de constructeur)
- DefendrePosition (prend un vecteur de groupes et une Coordonnees en param de constructeur)
- SeDeplacer (vecteur de groupes + Coordonnees)
- DefendreCapitaine (vecteur de groupes)

Je pense qu'on peut faire le principal avec ça, les détails étant à la charge des objets Ordre eux-même. D'ailleurs, toutes ces fonctions là, c'est sans doute le plus chiant à coder, et je ne suis pas motivé non plus

Tu peut rajouter "faire la chair a canon sur tel position" vu que je pourrais pas utiliser "défendre position" pour ça.


EDIT : ah et il faut changer :
- DefendreCapitaine (vecteur de groupes)

en :
- Defendre (groupe, vecteur de groupes)


car :
1) ça doit pas être bien différent
2) ça me permettrait de demander a des cavalier de défendre des archers en train de fuir
3) ça évite de nous bloquer la possibilité de créer des scénarios avec plusieurs capitaines

Pourquoi pas, par contre faut pas rêver pour le point 3, il n'y a pas que ça qui déconne

ah bon bah osef ^^

Je pense partir sur un truc comme ça :


créer map danger => attribuer a chaque case un "indice de danger" déterminer par les cases accessibles par les unités ennemies et par leur puissance
pour chaque unités
| déterminer importance => plus l'unité est forte, plus elle est importante
| déterminer priorité de fuite => calcul sur le degré de danger et l'indice d'importance

pour chaque unité en fuite par ordre décroissant d'importance
|si elle peut arriver jusque un endroit sécurisé
| |donner l'ordre de déplacement
|sinon
| |si peut fusionner avec une autre unité pour augmenter sa force
| | |donner ordre
| |sinon
| | |si une unité de faible importance est assez prêt pour faire le bouclier humain
| | | |lui donner l'ordre
| | |se déplacer dans l'endroit le plus sur



Y aurait-il des trous béant que j'aurais laisser passer sans voir ? ^^