Algorithme de combat

Donc, les détails pour l'implémentation :

- Déjà, il s'agit d'implémenter la méthode :

Code:

map<Groupe*,float> Regles::calculerAttaque(const std::vector<Groupe*>& attaquants, Groupe& def)

J'ai déjà fait une implémentation bidon juste pour tester si ça fonctionnait, mais elle est bien sûr à remplacer par le vrai algo.

- La classe Regles se trouve dans le dossier "jeu". Elle a le droit d'accéder aux données privées des objets Groupe. Cela permet en particulier de modifier l'attribut "taille"

- La méthode dont je parle est appelée automatiquement à chaque fin de tour (donc appui sur la touche Entrée), si des attaques ont été demandées. On peut donc effectuer des tests directement avec l'interface (qui fonctionne mal, mais quand même suffisamment bien pour ça).

- Quand un groupe est tué dans une bataille, il ne faut juste mettre sa taille à 0.0f, et non le supprimer.

Voilà, je crois que j'ai dit le principal.

ok j'v faire calculerAttaque

Cool :p

dans cette fonction, j'ai besoin de connaitre le type du terrain où ce trouve l'unité (attaquante et def ). Je fais comment ?

bon j'ai fais le truc basic
(attaquant[i]->getAtq * attaquant[i]->getTaille) - (def.getAtq * def.getTaille) = degatRecuParLeDef
def.taille = ((def.getHP * def.taille) - degatRecuParLeDef) / def.getHp // nb restant en vie.

Quand il y a plusieurs groupe en attaque, le défenseur contre attaque le groupe qui a le plus d'HP, pour ne pas taper dans le vent.

J'ai vu que getAtq prend comme paramètre un typeUnit et un typeTerrain, c'est le typeUnit ennemi et le typeTerrain où ce trouve le groupe (this) ou les ennemies ?
Par contre je ne sais pas comment accéder au typeTerrain, donc j'ai refais un getAtq de base qui return atq, c'est juste pour tester, apres j'utiliserai le bon qui prend les 2 paramètres.
Ca, ça marche niquel.

bug trouvé : oué y a plein de bug dans l'IHM XD, pour sélectionner un groupe ou une case, ça déconne un peut. Faudrait aussi mettre une image entre 2 groupe qui s'attaque pour que ça soit plus pratique :p
On peut déplacer la map a l'infini. Y a pas les bordures, ça plante quand on veut mettre un groupe sur la bordure. On peut mettre des unités dans l'eau profonde. Quand on tue un capitaine la partie continue.
Quand on clic hors plateau dès fois ça plante :/


Enfin bon, les bug c'est normal, s'il n'y en avaient pas, ce serait trop facile :p

voici le code

Code:

map<Groupe*,float> Regles::calculerAttaque(const std::vector<Groupe*>& attaquants, Groupe& def)
{
    cout << "---------------------------------------- debut attaque -----------------------------------------------" << endl;

    /* Calcul des dégâts infligés à chaque attaquant */

    int degatsAttaquants;
    int groupeQuiALePlusDhp = 0, numGroupe;
    cout << "-------------- debut degats --------------" << endl;
    cout << "nb d'attaquant : " << attaquants.size() << endl;
    cout << "degats infliges a chaque attaquant" << endl;
    for (int i = 0; i < attaquants.size(); i++)
    {
        if ((attaquants[i]->getTypeUnite().getHp() * attaquants[i]->getTaille()) > groupeQuiALePlusDhp)
        {
            groupeQuiALePlusDhp = (attaquants[i]->getTypeUnite().getHp() * attaquants[i]->getTaille());
            numGroupe = i;
        }
    }
    cout << "groupe qui a le plus d'hp est le num " << numGroupe << endl;
    if ((def.getTypeUnite().getAtq() * def.getTaille() - attaquants[numGroupe]->getTypeUnite().getDef() * attaquants[numGroupe]->getTaille()) < 0)
        degatsAttaquants = 0;
    else degatsAttaquants = (def.getTypeUnite().getAtq() * def.getTaille() - attaquants[numGroupe]->getTypeUnite().getDef() * attaquants[numGroupe]->getTaille());
    cout << "degats infliges a attaquant num " << numGroupe << " : " << " ( " << def.getTypeUnite().getAtq() << " * " << def.getTaille() << " - " << attaquants[numGroupe]->getTypeUnite().getDef() << " * " << attaquants[numGroupe]->getTaille() << " ) = " << degatsAttaquants << endl;
    cout << "hp total de ce groupe : " << attaquants[numGroupe]->getTypeUnite().getHp() << " * " << attaquants[numGroupe]->getTaille() << " = " << attaquants[numGroupe]->getTypeUnite().getHp() * attaquants[numGroupe]->getTaille() << endl;


    /* Calcul des dégâts infligés au défenseur */

    float degatsDefenseur = 0.0f;
    cout << "degats infliges au defenseur : ";
    int degatsDef;
    for (int i = 0; i < attaquants.size(); i++)
    {
        if ((attaquants[i]->getTypeUnite().getAtq() * attaquants[i]->getTaille() - def.getTypeUnite().getDef() * def.getTaille()) < 0)
            degatsDef = 0;
        else degatsDef = (attaquants[i]->getTypeUnite().getAtq() * attaquants[i]->getTaille() - def.getTypeUnite().getDef() * def.getTaille());
        degatsDefenseur = degatsDefenseur + degatsDef;
        cout << degatsDefenseur << endl;
    }
    cout << "hp total du groupe defenseur : " << def.getTypeUnite().getHp() * def.getTaille() << endl;

    /* Création de l'objet dans lequel on sauvegardera l'ensemble des dégâts infligés */

    map<Groupe*,float> degats;
    cout << "-------------- fin degats --------------" << endl;
    cout << "-------------- debut modif taille --------------" << endl;
    /* Modification de l'attribut taille du défenseur */
    degats[&def] = degatsDefenseur;
    cout << "taille du defenseur : " << def.taille << endl;
    def.taille = (((def.getTypeUnite().getHp() * def.taille) - degatsDefenseur) / def.getTypeUnite().getHp());
    cout << "taille du defenseur : " << def.taille << endl;
    if (def.taille < 0)
        def.taille = 0;
    cout << "taille du defenseur : " << def.taille << endl;

    /* Modification de l'attribut taille des attaquants */

    for (int i = 0; i < attaquants.size(); i++)
    {
        degats[attaquants[i]] = degatsAttaquants;
        cout << "taille de l'attaquant num " << i << " : " << attaquants[i]->taille << endl;
        attaquants[i]->taille = (((attaquants[i]->getTypeUnite().getHp() * attaquants[i]->taille) - degatsAttaquants) / attaquants[i]->getTypeUnite().getHp());
        cout << "taille de l'attaquant num " << i << " : " << attaquants[i]->taille << endl;
        if (attaquants[i]->taille < 0)
            attaquants[i]->taille = 0;
        cout << "taille de l'attaquant num " << i << " : " << attaquants[i]->taille << endl;
    }
    cout << "-------------- fin modif taille --------------" << endl;
    cout << "----------------------------------------- fin attaque ---------------------------------------------" << endl;

    return degats;
}

Avec ça

Code:

int getAtq() { return atq; }
int getDef() { return def; }

Dans TypeUnite.h

Oh, t'as fait vite

Je jetterai un œil au code ce soir, pas trop le temps maintenant. Par contre, j'ai déjà des fonctions qu'il est important d'utiliser pour l'attaque et la défense :

Code:

int getAtq(TypeUnite& adversaire, TypeTerrain& terrain);
int getDef(TypeUnite& adversaire, TypeTerrain& terrain);

(si tu n'utilises pas celle là les bonus et malus liés aux unités et aux terrains passent à la trappe, ce qui est un poil dommage ^^)

oui je sais. D'où ma question, comment faire pour avoir accès au typeTerrain ?
C'était ma question dans les deux post d'avant :p. Désolé pour le multi post XD

J'avais pas vu le premier post :p

Pour avoir un TypeTerrain :

Code:

Coordonnees coord;
coord.x = 2; // au hasard
coord.y = 2;
Partie& partie = GestionnaireDonnees::getInstance().getPartie();
TypeTerrain& type = partie.getTerrain(coord);

(si mes souvenirs sont bons c'est ça )

un groupe connait ses coordonnées ?

Pour :
int getAtq(TypeUnite& adversaire, TypeTerrain& terrain);
int getDef(TypeUnite& adversaire, TypeTerrain& terrain);

terrain, c'est le terrain de qui ? celui qui tape ou celui qui est tapé ? pareil pour les deux ou différent ?

Non, il faut passer par la fonction Groupe* Partie::getGroupe(const Coordonnees&) qui retourne le groupe présent à un endroit donné.

Ça me fait penser que j'ai dit une grosse connerie. Le prototype de la méthode à faire n'est pas

Code:

map<Groupe*,float> Regles::calculerAttaque(const std::vector<Groupe*>& attaquants, Groupe& def)

mais

Code:

map<Groupe*,float> Regles::calculerAttaque(const std::vector<Coordonnees>& attaquants, Coordonnees& def)

(sinon il est impossible de connaître les coordonnées des forces en présence)

Il va donc falloir que je modifie un poil mon code avant que tu puisses tester tes modifications ^^


Sinon, le terrain doit être celui sur lequel se trouve l'unité pour laquelle on appelle la fonction (donc l'attaquant dans le premier cas, et le défenseur dans le second).

map<Groupe*,float> Regles::calculerAttaque(const std::vector<Coordonnees>& attaquants, Coordonnees& def)

Ah comme ça, ça me va niquel
Fais moi signe quand tu a fais la modif et envoi moi la

pour getTerrain, y a que celui la

Code:

TypeTerrain& getTerrain(const int& x, const int& y);

:p

Ah tiens, j'avais pas vu. Enfin bon, pour ce que ça change...

voila j'ai fini

Code:

map<Groupe*,float> Regles::calculerAttaque(const std::vector<Coordonnees>& attaquants, Coordonnees& def)
{
    cout << "---------------------------------------- debut attaque -----------------------------------------------" << endl;

    /* Calcul des dégâts infligés à chaque attaquant */

    int degatsAttaquants;
    int groupeQuiALePlusDhp = 0, numGroupe;
    cout << "-------------- debut degats --------------" << endl;
    cout << "nb d'attaquant : " << attaquants.size() << endl;
    cout << "degats infliges a chaque attaquant" << endl;
    for (unsigned int i = 0; i < attaquants.size(); i++)
    {
        if ((partie.getGroupe(attaquants[i])->getTypeUnite().getHp() * partie.getGroupe(attaquants[i])->getTaille()) > groupeQuiALePlusDhp)
        {
            groupeQuiALePlusDhp = (int) (partie.getGroupe(attaquants[i])->getTypeUnite().getHp() * partie.getGroupe(attaquants[i])->getTaille());
            numGroupe = i;
        }
    }
    cout << "groupe qui a le plus d'hp est le num " << numGroupe << endl;
    if ((partie.getGroupe(def)->getTypeUnite().getAtq(partie.getGroupe(attaquants[numGroupe])->getTypeUnite(), partie.getTerrain(def.x, def.y)) * partie.getGroupe(def)->getTaille() - partie.getGroupe(attaquants[numGroupe])->getTypeUnite().getDef(partie.getGroupe(def)->getTypeUnite(), partie.getTerrain(attaquants[numGroupe].x, attaquants[numGroupe].y)) * partie.getGroupe(attaquants[numGroupe])->getTaille()) < 0)
        degatsAttaquants = 0;
    else degatsAttaquants = (int) (partie.getGroupe(def)->getTypeUnite().getAtq(partie.getGroupe(attaquants[numGroupe])->getTypeUnite(), partie.getTerrain(def.x, def.y)) * partie.getGroupe(def)->getTaille() - partie.getGroupe(attaquants[numGroupe])->getTypeUnite().getDef(partie.getGroupe(def)->getTypeUnite(), partie.getTerrain(attaquants[numGroupe].x, attaquants[numGroupe].y)) * partie.getGroupe(attaquants[numGroupe])->getTaille());
    cout << "degats infliges a attaquant num " << numGroupe << " : " << " ( " << partie.getGroupe(def)->getTypeUnite().getAtq(partie.getGroupe(attaquants[numGroupe])->getTypeUnite(), partie.getTerrain(def.x, def.y)) << " * " << partie.getGroupe(def)->getTaille() << " - " << partie.getGroupe(attaquants[numGroupe])->getTypeUnite().getDef(partie.getGroupe(def)->getTypeUnite(), partie.getTerrain(attaquants[numGroupe].x, attaquants[numGroupe].y)) << " * " << partie.getGroupe(attaquants[numGroupe])->getTaille() << " ) = " << degatsAttaquants << endl;
    cout << "hp total de ce groupe : " << partie.getGroupe(attaquants[numGroupe])->getTypeUnite().getHp() << " * " << partie.getGroupe(attaquants[numGroupe])->getTaille() << " = " << partie.getGroupe(attaquants[numGroupe])->getTypeUnite().getHp() * partie.getGroupe(attaquants[numGroupe])->getTaille() << endl;


    /* Calcul des dégâts infligés au défenseur */

    float degatsDefenseur = 0.0f;
    cout << "degats infliges au defenseur : ";
    int degatsDef;
    for (unsigned int i = 0; i < attaquants.size(); i++)
    {
        if ((partie.getGroupe(attaquants[i])->getTypeUnite().getAtq(partie.getGroupe(def)->getTypeUnite(), partie.getTerrain(attaquants[i].x, attaquants[i].y)) * partie.getGroupe(attaquants[i])->getTaille() - partie.getGroupe(def)->getTypeUnite().getDef(partie.getGroupe(attaquants[i])->getTypeUnite(), partie.getTerrain(def.x, def.y)) * partie.getGroupe(def)->getTaille()) < 0)
            degatsDef = 0;
        else degatsDef = (int) (partie.getGroupe(attaquants[i])->getTypeUnite().getAtq(partie.getGroupe(def)->getTypeUnite(), partie.getTerrain(attaquants[i].x, attaquants[i].y)) * partie.getGroupe(attaquants[i])->getTaille() - partie.getGroupe(def)->getTypeUnite().getDef(partie.getGroupe(attaquants[i])->getTypeUnite(), partie.getTerrain(def.x, def.y)) * partie.getGroupe(def)->getTaille());
        degatsDefenseur = degatsDefenseur + degatsDef;
        cout << degatsDefenseur << endl;
    }
    cout << "hp total du groupe defenseur : " << partie.getGroupe(def)->getTypeUnite().getHp() * partie.getGroupe(def)->getTaille() << endl;

    /* Création de l'objet dans lequel on sauvegardera l'ensemble des dégâts infligés */

    map<Groupe*,float> degats;
    cout << "-------------- fin degats --------------" << endl;
    cout << "-------------- debut modif taille --------------" << endl;
    /* Modification de l'attribut taille du défenseur */
    degats[partie.getGroupe(def)] = degatsDefenseur;
    cout << "taille du defenseur : " << partie.getGroupe(def)->taille << endl;
    partie.getGroupe(def)->taille = (((partie.getGroupe(def)->getTypeUnite().getHp() * partie.getGroupe(def)->taille) - degatsDefenseur) / partie.getGroupe(def)->getTypeUnite().getHp());
    cout << "taille du defenseur : " << partie.getGroupe(def)->taille << endl;
    if (partie.getGroupe(def)->taille < 0)
        partie.getGroupe(def)->taille = 0;
    cout << "taille du defenseur : " << partie.getGroupe(def)->taille << endl;

    /* Modification de l'attribut taille des attaquants */

    for (unsigned int i = 0; i < attaquants.size(); i++)
    {
        degats[partie.getGroupe(attaquants[i])] = degatsAttaquants;
        cout << "taille de l'attaquant num " << i << " : " << partie.getGroupe(attaquants[i])->taille << endl;
        partie.getGroupe(attaquants[i])->taille = (((partie.getGroupe(attaquants[i])->getTypeUnite().getHp() * partie.getGroupe(attaquants[i])->taille) - degatsAttaquants) / partie.getGroupe(attaquants[i])->getTypeUnite().getHp());
        cout << "taille de l'attaquant num " << i << " : " << partie.getGroupe(attaquants[i])->taille << endl;
        if (partie.getGroupe(attaquants[i])->taille < 0)
            partie.getGroupe(attaquants[i])->taille = 0;
        cout << "taille de l'attaquant num " << i << " : " << partie.getGroupe(attaquants[i])->taille << endl;
    }
    cout << "-------------- fin modif taille --------------" << endl;
    cout << "----------------------------------------- fin attaque ---------------------------------------------" << endl;

    return degats;
}

passe moi la version que tu as modifié car dans effectuerAttaquesEnAttente()
y a l'ancien calculerAttaque et pas le nouveau pour que je test si tout marche bien

Merki. bouboup

Je vais encore faire traîner un peu ça : j'ai 3 tonnes de trucs à installer sur un pc pour demain (pc de 10 ans, sans USB2 ni RJ45, donc tout prend du temps )

J'ai (enfin) jeté un œil à l'algo. Pour le moment ça m'a l'air d'aller, les problèmes résidant avant tout dans le fait que seule la première partie du schmilblick est implémentée. Je parle des cas du genre :
- 2x50 griffons contre 120 griffons => 2x19 survivants contre 119 (alors que logiquement les 120 devraient avoir à peu près autant de pertes que leurs adversaires)
(edit : et aussi dans le fait que mon algo est en fait assez pourri. Il faudra que je change quelques trucs ^^)

bon voila j'ai corrigé le bug, en faite dans la map des dégâts je donné tout les dégâts que le groupe en def faisait a ceux qui attaqué. Donc la je met dans le map que les dégâts du groupe def et celui du groupe attaquant qui a le plus d'hp (donc les autres groupe attaquant reçoivent zéro dégâts )

Code:

modif ;)


Cool :p
Pas trop le temps de tester ça par contre, ni de continuer le projet pour le moment : on est un peu à l'arrache en ihm, avec notre truc à finir pour mardi ^^

Algo combat final

Code:

bool estADistance(Coordonnees attaquant, Coordonnees def, int porteeAttaquant)
{
    int AxD6, AyD6, BxD6, ByD6, dx, dy, distance;
    int AxHEXA, AyHEXA, BxHEXA, ByHEXA;

/// Passage en coordonnée Héxa-map

    AxHEXA = attaquant.x;
    BxHEXA = def.x;

    if ((AxHEXA % 2) == 0)
        AyHEXA = ((attaquant.y - 1) * 2);
    else AyHEXA = (((attaquant.y - 1) * 2) - 1);

    if ((BxHEXA % 2) == 0)
        ByHEXA = ((def.y - 1) * 2);
    else ByHEXA = (((def.y - 1) * 2) - 1);

/// Passage en D6

    AxD6 = (AxHEXA + AyHEXA) / 2;
    AyD6 = (AyHEXA - AxHEXA) / 2;
    BxD6 = (BxHEXA + ByHEXA) / 2;
    ByD6 = (ByHEXA - BxHEXA) / 2;

    dx = BxD6 - AxD6;
    dy = ByD6 - AyD6;

    distance = (fabs(dx) + fabs(dy) + fabs(dx-dy)) / 2;

//    cout << "distance entre les 2 unitées : " << distance << " | pour une portée de : " << porteeAttaquant << endl;

    if (distance <= porteeAttaquant)
    {
//        cout << "unité a portée." << endl;
        return true;
    }
    else
    {
//        cout << "l'unité en " << attaquant.x << " " << attaquant.y << " n'est pas a portée d'attaque." << endl;
        return false;
    }
}

map<Groupe*,float> Regles::calculerAttaque(const std::vector<Coordonnees>& attaquants, Coordonnees& def)
{

    cout << "---------------------------------------- debut attaque -----------------------------------------------" << endl;

/// Calcul des dégâts infligés au défenseur

    cout << "-------------- debut degats --------------" << endl;
    cout << "nb d'attaquant : " << attaquants.size() << endl;
    cout << "degats infliges au defenseur : " << endl;
    int degatsDefenseur = 0, degatsDunGroupe = 0;
    std::vector<Coordonnees> attaquantsQuiTouche;
//    attaquantsQuiTouche.clear();
    for (unsigned int i = 0; i < attaquants.size(); i++)
    {
        if (estADistance(attaquants[i], def, partie.getGroupe(attaquants[i])->getTypeUnite().getPortee()))
        {
            attaquantsQuiTouche.push_back(attaquants[i]);
            degatsDunGroupe = partie.getGroupe(attaquants[i])->getTypeUnite().getAtq(partie.getGroupe(def)->getTypeUnite(), partie.getTerrain(attaquants[i].x, attaquants[i].y)) - partie.getGroupe(def)->getTypeUnite().getDef(partie.getGroupe(attaquants[i])->getTypeUnite(), partie.getTerrain(def.x, def.y));
            if (degatsDunGroupe < 0)
                degatsDunGroupe = 1;
            degatsDunGroupe = degatsDunGroupe * partie.getGroupe(attaquants[i])->getTaille();
            cout << "le groupe " << partie.getGroupe(attaquants[i])->getTypeUnite().getNom() << " inflige " << degatsDunGroupe << " degats." << endl;
            degatsDefenseur = degatsDefenseur + degatsDunGroupe;
        }
    }
    cout << "le groupe def a prit un total de " << degatsDefenseur << " degats." << endl;
    cout << "hp total du groupe defenseur : " << partie.getGroupe(def)->getTypeUnite().getHp() * partie.getGroupe(def)->getTaille() << endl;



/// Calcul des dégâts infligés aux attaquants

    int degatsAttaquants = 0, hpTotalDuGroupe = 0;
    std::map<int, Coordonnees> classementGroupeParHP;

// classer les groupes par ordre du plus au moins d'hp
    for (unsigned int i = 0; i < attaquantsQuiTouche.size(); i++)
    {
        hpTotalDuGroupe = (partie.getGroupe(attaquants[i])->getTypeUnite().getHp() * partie.getGroupe(attaquants[i])->getTaille());
//        cout << "hpTotalDuGroupe " << partie.getGroupe(attaquants[i])->getTypeUnite().getNom() << " : " << hpTotalDuGroupe << endl;
//        cout << "position de ce groupe : " << attaquants[i].x << " " << attaquants[i].y << endl;
        classementGroupeParHP[hpTotalDuGroupe] = attaquants[i];
    }

// regarder si celui qui a le plus d'hp est a porté sinon le suivant...
    std::map<int, Coordonnees>::reverse_iterator rit;
    for ( rit=classementGroupeParHP.rbegin() ; rit != classementGroupeParHP.rend(); rit++ )
    {
        if (estADistance(def , rit->second, partie.getGroupe(def)->getTypeUnite().getPortee()))
        {
            cout << "groupe avec + d'hp et est ripostable est le groupe de " << partie.getGroupe(rit->second)->getTypeUnite().getNom() << " avec " << rit->first << " hp." << endl;
            if ((partie.getGroupe(def)->getTypeUnite().getAtq(partie.getGroupe(rit->second)->getTypeUnite(), partie.getTerrain(def.x, def.y)) - partie.getGroupe(rit->second)->getTypeUnite().getDef(partie.getGroupe(def)->getTypeUnite(), partie.getTerrain(rit->second.x, rit->second.y)) < 0))
                degatsAttaquants = 1;
            else degatsAttaquants = (int) (partie.getGroupe(def)->getTypeUnite().getAtq(partie.getGroupe(rit->second)->getTypeUnite(), partie.getTerrain(def.x, def.y)) - partie.getGroupe(rit->second)->getTypeUnite().getDef(partie.getGroupe(def)->getTypeUnite(), partie.getTerrain(rit->second.x, rit->second.y)));
            degatsAttaquants = degatsAttaquants * partie.getGroupe(def)->getTaille();
            cout << "degats infliges a ce groupe " << " : " << " ( " << partie.getGroupe(def)->getTypeUnite().getAtq(partie.getGroupe(rit->second)->getTypeUnite(), partie.getTerrain(def.x, def.y)) << " - " << partie.getGroupe(rit->second)->getTypeUnite().getDef(partie.getGroupe(def)->getTypeUnite(), partie.getTerrain(rit->second.x, rit->second.y)) << " ) " << " * " << partie.getGroupe(def)->getTaille() << " = " << degatsAttaquants << endl;
            cout << "hp total de ce groupe : " << partie.getGroupe(rit->second)->getTypeUnite().getHp() << " * " << partie.getGroupe(rit->second)->getTaille() << " = " << partie.getGroupe(rit->second)->getTypeUnite().getHp() * partie.getGroupe(rit->second)->getTaille() << endl;
            break;
        }
    }

    cout << "-------------- fin degats --------------" << endl;

/// Création de l'objet dans lequel on sauvegardera l'ensemble des dégâts infligés

    cout << "-------------- debut modif taille --------------" << endl;
    map<Groupe*,float> degats;

// Modification de l'attribut taille du défenseur
    if (degatsDefenseur > 0)
    {
        degats[partie.getGroupe(def)] = degatsDefenseur;
        cout << "taille du defenseur : " << partie.getGroupe(def)->taille << endl;
        partie.getGroupe(def)->taille = (((partie.getGroupe(def)->getTypeUnite().getHp() * partie.getGroupe(def)->taille) - degatsDefenseur) / partie.getGroupe(def)->getTypeUnite().getHp());
        cout << "taille du defenseur : " << partie.getGroupe(def)->taille << endl;
        if (partie.getGroupe(def)->taille < 0)
            partie.getGroupe(def)->taille = 0;
        cout << "taille du defenseur : " << partie.getGroupe(def)->taille << endl;
    }
// Modification de l'attribut taille des attaquants
    if (degatsAttaquants > 0)
    {
//    for (unsigned int i = 0; i < attaquants.size(); i++)
//    {
//        degats[partie.getGroupe(attaquants[i])] = degatsAttaquants;
        degats[partie.getGroupe(rit->second)] = degatsAttaquants;
        cout << "taille de l'attaquant " << " : " << partie.getGroupe(rit->second)->taille << endl;
        partie.getGroupe(rit->second)->taille = (((partie.getGroupe(rit->second)->getTypeUnite().getHp() * partie.getGroupe(rit->second)->taille) - degatsAttaquants) / partie.getGroupe(rit->second)->getTypeUnite().getHp());
        cout << "taille de l'attaquant " << " : " << partie.getGroupe(rit->second)->taille << endl;
        if (partie.getGroupe(rit->second)->taille < 0)
            partie.getGroupe(rit->second)->taille = 0;
        cout << "taille de l'attaquant " << " : " << partie.getGroupe(rit->second)->taille << endl;
//    }
    }
    cout << "-------------- fin modif taille --------------" << endl;
    cout << "----------------------------------------- fin attaque ---------------------------------------------" << endl;

    return degats;
}