Algorithme de combat 2 le retour

J'ai vu plusieurs problèmes dans mon algo précédent. Des erreurs grossières (que personne n'a relevé ), des oublis, et un problème de fond, qui est qu'un gros groupe avec une bonne défense est à peu près invulnérable face à une multitude de petits groupes (normalement ils devraient pouvoir avoir le gros à l'usure...).

Du coup, je refais le post. Il ne faut pas se laisser effrayer par la taille des pavés qui suivent : ils reprennent en grande partie les derniers posts, même s'il y a pas mal de modifs.

ps : J'étais sensé relire les posts qui suivent mais j'ai eu la flemme, donc il ne serait pas étonnant qu'il reste des conneries au milieu ^^

Cas simple : 1 vs 1 avec unités au corps à corps uniquement :

L'exemple :
A : 200 fantassins légers (40 hp ; 20 atq ; 5 def)
D : 80 fantassins lourds (60 hp ; 25 atq ; 12 def) (edit : c'est 50 hp en réalité, mais peu importe)

I - On commence par regarder combien de dégâts peuvent infliger chaque type d'unité en un coup :
- quand une unité de A attaque une unité de D, l'unité de D perd 20-12 = 8hp
- quand une unité de D attaque une unité de A, l'unité de A perd 25-5 = 20hp

II - On calcule le rapport plusGrandGroupe / plusPetitGroupe, en ne s'intéressant qu'aux nombres d'unité, sans tenir compte de leur puissance. Ici, 200/80 = 2,5

III - On sait que le groupe A a 2,5 fois plus de membres, mais dans les faits ils seront gênés par leur nombre. Une partie d'entre eux passeront leur temps à chercher des ennemis. Il nous faut une fonction pour rendre plus concret le rapport obtenu en II. Exemple :

Code:

rapportForceEffectif = min ( rapportForce / 2 + 0.5 , 2)

Dans le cas présent, rapportForceEffectif = 2,5 / 2 + 0.5 = 1,75

IV - A partir de rapportForceEffectif, on voit qu'en réalité, seuls 80*1.75 = 140 membres du groupe A pourront se battre simultanément.

V - On calcule le résultat de la bataille opposant 140 fantassins légers à 80 fantassins lourds :
- 140 fantassins légers infligent chacun 8 hp de dégâts à leurs adversaires, soit un total de 1120 hp (18,67 fantassins lourds meurent donc)
- 80 fantassins lourds infligent chacun 20 hp de dégâts à leurs adversaires, soit un total de 1600 hp (40 fantassins légers meurent donc).

VI - A titre d'exemple, résultat d'une bataille à mort entre ces deux groupes :
- Avant le round 1 : A : 200 ; D : 80
- Fin du round 1 : A : 160 ; D : 61,33
- Fin du round 2 : A : 129,3333 ; D : 46,57777
- Fin du round 3 : A : 106,04 ; D : 34,85
- etc

Case simple 2 le retour : 1 vs 1 avec unités quelconques

Rien de bien méchant. Il faut juste vérifier que l'attaquant soit à portée du défenseur, vu que ce n'est plus forcément le cas...

Cas plus compliqué : n vs 1 avec unités au corps à corps uniquement

L'exemple :
A1 : 100 lanciers (40 hp ; 30 atq ; 5 def) (30 atq grâce au bonus contre la cavalerie)
A2 : 200 fantassins légers (40 hp ; 20 atq; 5 def)
A3 : 50 fantassins lourds (50 hp ; 25 atq ; 12 def)
D : 200 cavaleriers lourds (80 hp ; 30 atq ; 12 def)

I - On fait la même chose que dans le cas simple, mais avec tous les types d'unités :
- quand une unité de A1 attaque une unité de D, l'unité de D perd 30-12 = 18 hp
- quand une unité de A2 attaque une unité de D, l'unité de D perd 20-12 = 8 hp
- quand une unité de A3 attaque une unité de D, l'unité de D perd 25-12 = 13 hp
- quand une unité de D attaque une unité de A1, l'unité de A1 perd 30-5 = 25 hp
- quand une unité de D attaque une unité de A2, l'unité de A2 perd 30-5 = 25 hp
- quand une unité de D attaque une unité de A3, l'unité de A3 perd 30-12 = 18 hp

II - On calcule le rapport plusGrandGroupe / plusPetitGroupe. Ici, (100+200+50)/200 = 1,75

III - De la même manière que dans le cas précédent :
rapportForceEffectif = 1,75 / 2 + 0.5 = 1,375

IV - Pareil que le cas précédent, sauf qu'il faut le faire pour chacun des groupes concernés :
- A1 : 100/1,75*1,375 = 78,57 unités de ce groupe se battront
- A2 : 200/1,75*1,375 = 157,14 unités de ce groupe se battront
- A3 : 50/1,75*1,375 = 39,29 unités de ce groupe se battront

V - Etape supplémentaire par rapport au cas simple : déterminer quelles seront les cibles prioritaires du groupe D. On considère que 3/4 des forces du groupe D se battent d'une manière optimale, tandis que le 1/4 restant attaque aléatoirement (dans le feu de l'action, tout ne peut pas être parfait). Pour cela, on effectue des simulations de toutes les attaques possibles :
- Si 3/4 des forces de D attaquent A1, elles infligeront 3750 hp de dégâts. 93,75 lanciers mourront, ce qui fait que le groupe D subira 1687,5 hp de dégâts en moins le tour suivant.
- Si 3/4 des forces de D attaquent A2, elles infligeront 3750 hp de dégâts. 93,75 fantassins légers mourront, ce qui fait que le groupe D subira 750 hp de dégâts en moins le tour suivant.
- Si 3/4 des forces de D attaquent A3, elles infligeront 2700 hp de dégâts. 45 fantassins lourds mourront, ce qui fait que le groupe D subira 585 hp de dégâts en moins le tour suivant.

Le but est d'établir un classement des Ai les plus rentables. Ici, A1 est le plus rentable de loin, et A3 est le pire. Le groupe D attaquera donc A1. Dans un cas où abattre le groupe A1 ne mobiliserait pas toutes les forces de D, le reste (dans la limite des 3/4) attaque le second groupe le plus rentable, et ainsi de suite jusqu'à ce que toutes les forces de D soient utilisées.

VI - Calcul des dégâts de D sur les Ai :

- On commence par faire ce qui a été déterminé au point précédent : exploser A1. Forces restantes :
A1 : 6,25 lanciers
A2 : 200 fantassins légers
A3 : 50 fantassins lourds

Le 1/4 restant des forces de D représente 200*0.25 = 50 unités. On balance sur chacun des groupes restants un nombre d'unité proportionnel à leur taille, qui est ici de 6,25+200+50 = 256,25 unités
- A1 : 6,25 / 256,25 = 2,44% du total => On envoie 50*2,44% = 1,22 unités
- A2 : 200 / 256,25 = 78,05% du total => On envoie 50*78,05% = 39.025 unités
- A3 : 50 / 256,25 = 19,51 % du total => On envoie 50*19,51% = 9,755 unités

On peut maintenant calculer les dégâts supplémentaires infligés à chacun des Ai :
- A1 : 1,22*25 = 30,5 hp de dégâts, donc 0,7625 morts
- A2 : 39,025*25 = 975,625 hp de dégâts, donc 24,39 morts
- A3 : 9,755*18 = 175,59 hp de dégâts, donc 3,5118 morts

Bilan final des survivants dans les Ai :
A1 : 5,4875 lanciers
A2 : 175,61 fantassins légers
A3 : 46,4882 fantassins lourds

VII - Il ne reste plus qu'à calculer les dégâts des Ai sur D. Rappel des forces initiales, que l'on utilise à nouveau :
A1 : 100 lanciers (40 hp ; 30 atq ; 5 def) (30 atq grâce au bonus contre la cavalerie)
A2 : 200 fantassins légers (40 hp ; 20 atq; 5 def)
A3 : 50 fantassins lourds (50 hp ; 25 atq ; 12 def)
D : 200 cavaleriers lourds (80 hp ; 30 atq ; 12 def)

a) calcul du bonus pour les attaquants :
Le fait que les Ai attaquent sur plusieurs fronts leur octroie un avantage, qui dépendra du nombre de fronts, mais aussi grandement de leur homogénéité. Exemples :
- 100+100+100 vs x => un triple sandwich, qui doit avoir un bonus un minimum conséquent
- 150+100+50 vs x => même nombre d'unités, mais avantage moins grand pour l'attaquant, vu qu'un côté du sandwich est faiblard. Bonus comparable au cas 150+150 vs x
- 298+1+1 vs x => même nombre d'unités, mais là, c'est comme si l'attaquant fonçait dans le tas. Bonus nul.

Un algo pour quantifier la "qualité" d'une prise en sandwich (un autre recyclage de mon post précédent) :

Code:


max = "puissance" du plus gros Ai
nbRetenuPourBonus = 0;
pour chaque Ai
  nbRetenuPourBonus += puissance(Ai) / max


La "puissance" se définit comme étant une valeur proportionnelle la capacité de Ai à infliger des dégâts à D.

Code:


Pouet = attaque(Ai) - defense(D) // une indication des dégâts qu'une unité de Ai fait au groupe D
Gneuh = hp(Ai) / (attaque(D) - defense(Ai)) // proportionnel à la durée durant laquelle une unité de Ai peut survivre face à D
puissance = taille(Ai) * Pouet * Gneuh // => indication à peu près valable de la force du groupe Ai face à D.


nbRetenuPourBonus peut ensuite être utilisé pour calculer le bonus à donner aux attaquants. Exemple d'algo à la con pour avoir ça :

Code:

si nbRetenu < 1,5 => aucun bonus
sinon si nbRetenu < 2 => bonus de 5%
sinon si nbRetenu < 2,5 => bonus de 7%
sinon si nbRetenu < 3 => bonus de 8%
sinon bonus de 9%

Calculons ce bonus avec l'exemple. On commence par calculer ce que j'ai appelé "puissance" dans mon algo :
- puissance de A1 : 100*(30-12)*40/(30-5) = 2880 points
- puissance de A2 : 200*(20-12)*40/(30-5) = 2560 points
- puissance de A3 : 50*(25-12)*50/(30-12) = 1806 points

nbRetenuPourBonus = 2880/2880 + 2560/2880 + 1806/2880 = 2,516

Donc bonus de 8%.

c) calcul des dégâts
On peut enfin calculer des dégâts que les Ai infligent à D, en utilisant les valeurs calculées aux points I (dégâts de base) et IV (malus lié au surnombre)
degatsBase = 78,57*18 + 157,14*8 + 39,29*13 = 3182,15 hp
bonus = 3182,15*8% = 254,572 hp
degatsTotaux = 3436,722 hp (soit 42,96 morts)

Bilan final des survivants :
A1 : 5,4875 lanciers
A2 : 175,61 fantassins légers
A3 : 46,4882 fantassins lourds
D : 157,04 cavaliers lourds

Cas général : n vs 1 avec unités quelconques

Idem cas précédent. Par contre, la présence d'unité se battant à distance change quelques détails :
- certains groupes peuvent être hors de portée du défenseur. Dans ces cas là, le défenseur concentre son attaque sur les groupes qu'il peut taper, ou il serre les fesses s'il n'y en a aucun...
- dans le partie VII, le bonus lié aux attaques en sandwich ne doit considérer que les unités attaquant au corps à corps (donc sur les cases collées à celle du défenseur)

j'ai pas encore lu désolé, il est 2h du mat et ce matin je commence a 8h donc je le lirai cet aprem
les modif dans la gestion de données et de mon algo de combat n'ont pas pris en compte ce qui a dans ce sujet, vu que je ne l'ai pas lu. Donc si je dois faire des modif, ça viendra plus tard :p après la lecture ^^

Bonne nuit

ARG j'ai raté le TP5 de prog agent, j'ai pas entendu le réveil

ps: je met en rouge les erreurs dans tes messages plus haut

question : Qui vérifie si un attaquant est a distance d'attaque du défenseur ? l'algo de combat ou ton truc qui dit attaque accepté ?

on va avoir un problème.

L'exemple :
A : 200 fantassins légers (40 hp ; 20 atq ; 5 def)
D : 80 fantassins lourds (60 hp ; 25 atq ; 12 def) (edit : c'est 50 hp en réalité, mais peu importe)

I - On commence par regarder combien de dégâts peuvent infliger chaque type d'unité en un coup :
- quand une unité de A attaque une unité de D, l'unité de D perd 20-12 = 8hp
- quand une unité de D attaque une unité de A, l'unité de A perd 25-5 = 20hp

si
L'exemple :
A : 200 fantassins légers (40 hp ; 20 atq ; 5 def)
D : 80 Tank (60 hp ; 25 atq ; 30 def)

I - On commence par regarder combien de dégâts peuvent infliger chaque type d'unité en un coup :
- quand une unité de A attaque une unité de D, l'unité de D perd 20-30 = -10hp (donc ça le heal :p )
- quand une unité de D attaque une unité de A, l'unité de A perd 25-5 = 20hp

c'est ce qui ce passe pour le capitaine.
Donc comment faire ?

C'est pas un bien gros problème ça :p

On peut faire comme dans Age of empires II : dire que toute attaque fait perdre au moins 1hp à l'ennemi ^^

ps : j'ai corrigé les erreurs (ces copiers collers, ça fait toujours des merdes ). Par contre, pour le moment j'ai la flemme de vérifier que je n'ai pas utilisé ces faux résultats dans mes calculs suivants, donc il en reste peut-être encore

Cédric a écrit:C'est pas un bien gros problème ça :p

On peut faire comme dans Age of empires II : dire que toute attaque fait perdre au moins 1hp à l'ennemi ^^

J'ai déjà pensais a ça. Ce qui fait que pour tuer le capitaine, il faut un groupe de 80 personnes, vu qu'il a 80 hp :p
Un peut illogique non ? 79 vs 1 le 1 win et 80 vs 1 les 80 win :p

Bien vu

Il faudrait rééquilibrer un poil les stats, en faisant en sorte que la plus forte défense reste un poil en dessous de la plus faible attaque. Au moins c'est un moyen facile d'arranger les choses ^^

(et en y repensant, il n'est pas très logique par exemple qu'un archer ait moins d'attaque qu'un chevalier n'a de défense)

Question : comment on fait pour savoir si qqun est a porté de qqun d'autre ? Dans le pathfinding quand on clic sur un perso, toute les cases a sa porté sont éclairé. Je cherche un algo pour le trouver, mais je trouve pas.


Edit :
J'ai trouvé un truc qui marche sur des hexa map, mais les hexa de nos map ne sont pas placé au bon endroit
les coordonnées de nos hexa devraient etre comme ça (un lien ici).
On fait comment alors ?

Bon voila ça marche, je suis trop fort
En faite, j'ai trouvé une formule qui transforme des coordonnées Hexa-map en coordonnées D6 et avec les D6 je trouve la distance entre deux Héxa en une ligne (une toute pitite formule ). Donc me rester plus qu'a trouver comment passer de nos coordonnées en coordonnées Héxa-map. Et j'ai réussi
Je suis trop fort merci merci merci merci merci :p

Donc la c'est bon, si qqun est a distance d'attaque, il peut attaquer sinon ouwned
bouboup

Cédric a écrit:Bien vu

Il faudrait rééquilibrer un poil les stats, en faisant en sorte que la plus forte défense reste un poil en dessous de la plus faible attaque. Au moins c'est un moyen facile d'arranger les choses ^^

(et en y repensant, il n'est pas très logique par exemple qu'un archer ait moins d'attaque qu'un chevalier n'a de défense)

Sinon on peut faire genre

A : 200 fantassins légers (40 hp ; 20 atq ; 5 def)
D : 80 fantassins lourds (50 hp ; 25 atq ; 12 def)

I - On commence par regarder combien de dégâts peuvent infliger chaque type d'unité en un coup :
- quand une unité de A attaque une unité de D, l'unité de D perd

(20-12)*200 = 1600 hp // ici le nombre d'adversaire ne compte pas
((20*200) - (12*80)) = 4000 - 960 = 3040 hp // ici le nombre d'adversaire est pris en compte
(3040+1600)/2 = 2320 hp // ici on fait la moyenne des deux, comme ça si la def est plus forte que l'atq, les attaquants font quand même des dégât. Et si le groupe de def est beaucoup plus nombreux que l'attaquant, l'attaquant fait quand même des dégâts.
Donc le groupe D perd un total de 2320 hp, soit 2320/50 = 46,4 unités

- quand une unité de D attaque une unité de A, l'unité de A perd 25-5 = 20hp

(25-5)*80 = 1600 hp
((25*80) - (5*200)) = 2000 - 1000 = 1000 hp
(1600+1000)/2 = 1300 hp
Donc le groupe A perd un total de 1300 hp, soit 1300/40 = 32,5 unités

--------------------------------------

Vous en pensez quoi ?

bon voila. J'ai pas fais le truc des moyennes des dégâts, car j'attends de savoir ce que vous en pensez
Donc pour le moment les dégâts minimum sont a 1 :p donc il faut 80 personnes pour tuer le capitaine
Mais y faut changer ça

Voici le code

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;
}


A mettre dans Regles.cpp
La fonction bool estADistance(Coordonnees attaquant, Coordonnees def, int porteeAttaquant) dit si l'attaquant est a distance d'attaque du défenseur.