Exemplo n.º 1
0
 //Loohy
 public void CheckPV(MoteurGraphique moteurgraphique_, HUD hud_)
 {
     foreach (Armee item in listeDesJoueurs)
     {
         item.checkPV(moteurgraphique_, this);
     }
     CheckVictoire(hud_);
 }
Exemplo n.º 2
0
 //Loohy
 public void Initialize(string nomDeLaMap_, List<string> nomDesArmees_, List<int> difficultes_, List<int> camp_, List<Color> couleurs_,
     e_typeDePartie conditionsDeVictoire_, e_brouillardDeGuerre fog_, int tempsMax_, int limiteDeTours_ = 0)
 {
     Jackman = new HUD();
     Divers.telechargerMap(ref earthPenguin, nomDeLaMap_);
     earthPenguin.invisible();
     earthPenguin.fog = fog_;
     earthPenguin.viderVue();
     gameplay.initializeWithListedArmies(nomDesArmees_, difficultes_, camp_, couleurs_,
         earthPenguin, conditionsDeVictoire_, Jackman, limiteDeTours_);
     time = 0;
     lastUpdatesTime = 0;
     tempsMax = tempsMax_;
     earthPenguin.centrerSur(16, 16);
 }
Exemplo n.º 3
0
 public void AttaqueSud(MoteurGraphique moteurgraphique_, SystemeDeJeu gameplay_, ref e_modeAction mood_, HUD hud_)
 {
     if (j + 1 < moteurgraphique_.largeur && moteurgraphique_.map[i, j + 1].presence)
     {
         mouvOrNot = false;
         Initiative(gameplay_.listeDesJoueurs[moteurgraphique_.map[i, j + 1].
             pointeurArmee].bataillon[moteurgraphique_.map[i, j + 1].pointeurUnite], 1,
             moteurgraphique_, gameplay_, ref mood_, hud_);
         sousrect.X = 128;
     }
 }
Exemplo n.º 4
0
 public void AttaqueOuest(MoteurGraphique moteurgraphique_, SystemeDeJeu gameplay_, ref e_modeAction mood_, HUD hud_)
 {
     mouvOrNot = false;
     Initiative(gameplay_.listeDesJoueurs[moteurgraphique_.map[i - 1, j].
         pointeurArmee].bataillon[moteurgraphique_.map[i - 1, j].pointeurUnite], 1,
         moteurgraphique_, gameplay_, ref mood_, hud_);
     sousrect.X = 256;
 }
Exemplo n.º 5
0
        public void UpdatePouvoir(MoteurGraphique moteurgraphique_, SystemeDeJeu gameplay_, ref e_modeAction mood_, HUD hud_)
        {
            if (Mouse.GetState().RightButton == ButtonState.Pressed && attaqOrNot)
            {
                foreach (int portee_ in SHORYUKEN.porteePouvoir)
                {
                    if (SHORYUKEN.vertical)
                    {
                        int k = 0;
                        #region 1
                        if (i + k >= 0 && i + k < moteurgraphique_.longueur
                                                && j + (portee_ - k) >= 0 && j + (portee_ - k) < moteurgraphique_.largeur)
                        {
                            if (moteurgraphique_.map[i + k, j + (portee_ - k)].presence &&
                                   moteurgraphique_.map[i + k, j + (portee_ - k)].estEnSurbrillance &&
                                   moteurgraphique_.map[i + k, j + (portee_ - k)].visible &&
                                   attaqOrNot)
                            {
                                mouvOrNot = false;
                                SHORYUKEN.UtiliserPouvoir(this, moteurgraphique_, gameplay_, i + k, j + (portee_ - k), ref mood_, hud_);
                                gameplay_.CheckPV(moteurgraphique_, hud_);
                            }
                        }
                        #endregion
                        #region 2
                        if (i - k >= 0 && i - k < moteurgraphique_.longueur
                                                 && j - (portee_ - k) >= 0 && j - (portee_ - k) < moteurgraphique_.largeur)
                        {
                            if (moteurgraphique_.map[i - k, j - (portee_ - k)].presence &&
                                   moteurgraphique_.map[i - k, j - (portee_ - k)].estEnSurbrillance &&
                                   moteurgraphique_.map[i - k, j - (portee_ - k)].visible &&
                                   attaqOrNot)
                            {
                                mouvOrNot = false;
                                SHORYUKEN.UtiliserPouvoir(this, moteurgraphique_, gameplay_, i - k, j - (portee_ - k), ref mood_, hud_);
                                gameplay_.CheckPV(moteurgraphique_, hud_);
                            }
                        }
                        #endregion
                        #region 3
                        if (i + (portee_ - k) >= 0 && i + (portee_ - k) < moteurgraphique_.longueur
                                                 && j - k >= 0 && j - k < moteurgraphique_.largeur)
                        {
                            if (moteurgraphique_.map[i + (portee_ - k), j - k].presence &&
                                   moteurgraphique_.map[i + (portee_ - k), j - k].estEnSurbrillance &&
                                   moteurgraphique_.map[i + (portee_ - k), j - k].visible &&
                                   attaqOrNot)
                            {
                                mouvOrNot = false;
                                SHORYUKEN.UtiliserPouvoir(this, moteurgraphique_, gameplay_, i + (portee_ - k), j - k, ref mood_, hud_);
                                gameplay_.CheckPV(moteurgraphique_, hud_);
                            }
                        }
                        #endregion
                        #region 4
                        if (i - (portee_ - k) >= 0 && i - (portee_ - k) < moteurgraphique_.longueur
                                                 && j + k >= 0 && j + k < moteurgraphique_.largeur)
                        {
                            if (moteurgraphique_.map[i - (portee_ - k), j + k].presence &&
                                   moteurgraphique_.map[i - (portee_ - k), j + k].estEnSurbrillance &&
                                   moteurgraphique_.map[i - (portee_ - k), j + k].visible &&
                                   attaqOrNot)
                            {
                                mouvOrNot = false;
                                SHORYUKEN.UtiliserPouvoir(this, moteurgraphique_, gameplay_, i - (portee_ - k), j + k, ref mood_, hud_);
                                gameplay_.CheckPV(moteurgraphique_, hud_);
                            }
                        }
                        #endregion
                    }
                    else
                    {
                        for (int k = 0; k <= portee_; k++)
                        {
                            #region 1
                            if (i + k >= 0 && i + k < moteurgraphique_.longueur
                                                    && j + (portee_ - k) >= 0 && j + (portee_ - k) < moteurgraphique_.largeur)
                            {
                                if (moteurgraphique_.map[i + k, j + (portee_ - k)].presence &&
                                       moteurgraphique_.map[i + k, j + (portee_ - k)].estEnSurbrillance &&
                                       moteurgraphique_.map[i + k, j + (portee_ - k)].visible &&
                                       attaqOrNot)
                                {
                                    mouvOrNot = false;
                                    SHORYUKEN.UtiliserPouvoir(this, moteurgraphique_, gameplay_, i + k, j + (portee_ - k),
                                        ref mood_, hud_);
                                    gameplay_.CheckPV(moteurgraphique_, hud_);
                                }
                            }
                            #endregion
                            #region 2
                            if (i - k >= 0 && i - k < moteurgraphique_.longueur
                                                     && j - (portee_ - k) >= 0 && j - (portee_ - k) < moteurgraphique_.largeur)
                            {
                                if (moteurgraphique_.map[i - k, j - (portee_ - k)].presence &&
                                       moteurgraphique_.map[i - k, j - (portee_ - k)].estEnSurbrillance &&
                                       moteurgraphique_.map[i - k, j - (portee_ - k)].visible &&
                                       attaqOrNot)
                                {
                                    mouvOrNot = false;
                                    SHORYUKEN.UtiliserPouvoir(this, moteurgraphique_, gameplay_, i - k, j - (portee_ - k), ref mood_, hud_);
                                    gameplay_.CheckPV(moteurgraphique_, hud_);
                                }
                            }
                            #endregion
                            #region 3
                            if (i + (portee_ - k) >= 0 && i + (portee_ - k) < moteurgraphique_.longueur
                                                     && j - k >= 0 && j - k < moteurgraphique_.largeur)
                            {
                                if (moteurgraphique_.map[i + (portee_ - k), j - k].presence &&
                                       moteurgraphique_.map[i + (portee_ - k), j - k].estEnSurbrillance &&
                                       moteurgraphique_.map[i + (portee_ - k), j - k].visible &&
                                       attaqOrNot)
                                {
                                    mouvOrNot = false;
                                    SHORYUKEN.UtiliserPouvoir(this, moteurgraphique_, gameplay_, i + (portee_ - k), j - k, ref mood_, hud_);
                                    gameplay_.CheckPV(moteurgraphique_, hud_);
                                }
                            }
                            #endregion
                            #region 4
                            if (i - (portee_ - k) >= 0 && i - (portee_ - k) < moteurgraphique_.longueur
                                                     && j + k >= 0 && j + k < moteurgraphique_.largeur)
                            {
                                if (moteurgraphique_.map[i - (portee_ - k), j + k].presence &&
                                       moteurgraphique_.map[i - (portee_ - k), j + k].estEnSurbrillance &&
                                       moteurgraphique_.map[i - (portee_ - k), j + k].visible &&
                                       attaqOrNot)
                                {
                                    mouvOrNot = false;
                                    SHORYUKEN.UtiliserPouvoir(this, moteurgraphique_, gameplay_, i - (portee_ - k), j + k, ref mood_, hud_);
                                    gameplay_.CheckPV(moteurgraphique_, hud_);
                                }
                            }
                            #endregion
                        }
                    }
                }

            }
        }
Exemplo n.º 6
0
 public void Initiative(Unite ennemi_, int porteDeFrappe_, MoteurGraphique moteurgraphique_,
     SystemeDeJeu gameplay_, ref e_modeAction mood, HUD hud_)
 {
     if (!ennemi_.estInvisible)
     {
         estInvisible = false;
         assassin = ennemi_.numeroArmee;
         ennemi_.assassin = numeroArmee;
         if ((initiative + bonusInitiative) >= ennemi_.initiative)
         {
             Frappe(ennemi_, porteDeFrappe_, moteurgraphique_, gameplay_, hud_);
         }
         else
         {
             ennemi_.Frappe(this, porteDeFrappe_, moteurgraphique_, gameplay_, hud_);
         }
         mood = e_modeAction.Mouvement;
         attaqOrNot = false;
     }
 }
Exemplo n.º 7
0
 public void Update(MoteurGraphique loohy_, SystemeDeJeu gameplay_, ref e_modeAction mood_, /*Lecteur coldman_,*/ HUD hud_)
 {
     if (bataillon[uniteselect].fileDeMouvements.Count == 0)
     {
         switch (mood_)
         {
             case e_modeAction.Attaque:
                 bataillon[uniteselect].Attaquer(loohy_, gameplay_, ref mood_, hud_);
                 break;
             case e_modeAction.Pouvoir:
                 if (bataillon[uniteselect].SHORYUKEN != null)
                 {
                     bataillon[uniteselect].UpdatePouvoir(loohy_, gameplay_, ref mood_, hud_);
                 }
                 break;
             default:
                 bataillon[uniteselect].Mouvement(loohy_, gameplay_.listeDesJoueurs[gameplay_.tourencours], gameplay_);
                 break;
         }
     }
     loohy_.porteeEgal0();
     if (gameplay_.mood == e_modeAction.Attaque)
     {
         bataillon[uniteselect].lookAtPortee(loohy_);
     }
     if (gameplay_.mood == e_modeAction.Pouvoir)
     {
         bataillon[uniteselect].lookAtPorteePouvoir(loohy_);
     }
     if ((bataillon[uniteselect].state == e_EtatAnim.repos1 || bataillon[uniteselect].state == e_EtatAnim.repos2)
         && !hud_.sontvises())
     {
         Selectionner(loohy_, /*coldman_,*/ hud_);
     }
     foreach (Unite item in bataillon)
     {
         item.lireLaFile(loohy_, gameplay_.listeDesJoueurs[gameplay_.tourencours], gameplay_);
     }
 }
Exemplo n.º 8
0
        public void Selectionner(MoteurGraphique moteurgraphique_, /*Lecteur coldman_, */HUD hud_)
        {
            if (Keyboard.GetState().IsKeyDown(Keys.Tab) && clic)
            {
                suivant(moteurgraphique_, true, hud_);
                Random r = new Random();
                MoteurSon.PlayFX(espece.ToString()+ r.Next(100)%3);
            }

            if (Keyboard.GetState().IsKeyUp(Keys.Tab) && Mouse.GetState().LeftButton != ButtonState.Pressed)
            {
                clic = true;
            }

            for (int i = 0; i < effectif; i++)
            {
                if (moteurgraphique_.map[bataillon[i].i, bataillon[i].j].estEnSurbrillance
                    && Mouse.GetState().LeftButton == ButtonState.Pressed && clic && bataillon[i].alive)
                {
                    //coldman_.Play(bataillon[uniteselect].nom);
                    clic = false;
                    uniteselect = i;
                    bataillon[uniteselect].lookAtCheminsInitialize(moteurgraphique_);
                    Random r = new Random();
                    MoteurSon.PlayFX(espece.ToString() + r.Next(100) % 3);
                }
            }
        }
 public void checkContenuDansPorteeDebileJoute(MoteurGraphique moteurgraphique_, int portee_, Unite moi_, SystemeDeJeu gameplay_, HUD hud_)
 {
     //cible : gameplay_.armees[moteurgraphique_.map[i_, j_].pointeurArmee].bataillon[moteurgraphique_.map[i_, j_].pointeurUnite]
     cibleAcquise = false;
     for (int k = 0; k < portee_; k++)
     {
         if (moi_.i + k >= 0 && moi_.i + k < moteurgraphique_.longueur
             && moi_.j + (portee_ - k) >= 0 && moi_.j + (portee_ - k) < moteurgraphique_.largeur)
         {
             if (moteurgraphique_.map[moi_.i + k, moi_.j + (portee_ - k)].presence && cibleAcquise == false &&
                 moi_.attaqOrNot && moi_.numeroArmee != moteurgraphique_.map[moi_.i + k, moi_.j + (portee_ - k)].pointeurArmee)
             {
                 moi_.Initiative(gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i + k, moi_.j + (portee_ - k)].pointeurArmee]
                     .bataillon[moteurgraphique_.map[moi_.i + k, moi_.j + (portee_ - k)].pointeurUnite], portee_,
                     moteurgraphique_, gameplay_, ref gameplay_.mood, hud_);
                 cibleAcquise = true;
             }
         }
         if (moi_.i - k >= 0 && moi_.i - k < moteurgraphique_.longueur
              && moi_.j - (portee_ - k) >= 0 && moi_.j - (portee_ - k) < moteurgraphique_.largeur)
         {
             if (moteurgraphique_.map[moi_.i - k, moi_.j - (portee_ - k)].presence && cibleAcquise == false &&
                 moi_.attaqOrNot && moi_.numeroArmee != moteurgraphique_.map[moi_.i - k, moi_.j - (portee_ - k)].pointeurArmee)
             {
                 moi_.Initiative(gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i - k, moi_.j - (portee_ - k)].pointeurArmee]
                     .bataillon[moteurgraphique_.map[moi_.i - k, moi_.j - (portee_ - k)].pointeurUnite], portee_,
                     moteurgraphique_, gameplay_, ref gameplay_.mood, hud_);
                 cibleAcquise = true;
             }
         }
         if (moi_.i + (portee_ - k) >= 0 && moi_.i + (portee_ - k) < moteurgraphique_.longueur
              && moi_.j - k >= 0 && moi_.j - k < moteurgraphique_.largeur)
         {
             if (moteurgraphique_.map[moi_.i + (portee_ - k), moi_.j - k].presence && cibleAcquise == false &&
                 moi_.attaqOrNot && moi_.numeroArmee != moteurgraphique_.map[moi_.i + (portee_ - k), moi_.j - k].pointeurArmee)
             {
                 moi_.Initiative(gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i + (portee_ - k), moi_.j - k].pointeurArmee]
                     .bataillon[moteurgraphique_.map[moi_.i + (portee_ - k), moi_.j - k].pointeurUnite], portee_,
                     moteurgraphique_, gameplay_, ref gameplay_.mood, hud_);
                 cibleAcquise = true;
             }
         }
         if (moi_.i - (portee_ - k) >= 0 && moi_.i - (portee_ - k) < moteurgraphique_.longueur
              && moi_.j + k >= 0 && moi_.j + k < moteurgraphique_.largeur)
         {
             if (moteurgraphique_.map[moi_.i - (portee_ - k), moi_.j + k].presence && cibleAcquise == false &&
                 moi_.attaqOrNot && moi_.numeroArmee != moteurgraphique_.map[moi_.i - (portee_ - k), moi_.j + k].pointeurArmee)
             {
                 moi_.Initiative(gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i - (portee_ - k), moi_.j + k].pointeurArmee]
                     .bataillon[moteurgraphique_.map[moi_.i - (portee_ - k), moi_.j + k].pointeurUnite], portee_,
                     moteurgraphique_, gameplay_, ref gameplay_.mood, hud_);
                 cibleAcquise = true;
             }
         }
     }
 }
        public void PlayMoyenJoute(Unite moi_, MoteurGraphique moteurgraphique_, SystemeDeJeu gameplay_, Armee armee_, HUD hud_)
        {
            List<int> porteesDeMeilleuresPrecisions = new List<int>();

            #region obtenirUneListeDesMeilleuresPorteesDePrecision

            for (int f = 10; f > 0; f--)
            {
                for (int g = 6; g > 0; g--)
                {
                    if (moi_.portee[g] == f)
                    {
                        porteesDeMeilleuresPrecisions.Add(g);
                    }
                }
            }
            #endregion

            if (moi_.attaqOrNot)
            {
                for (int portee_ = 0; portee_ < porteesDeMeilleuresPrecisions.Count - 1; portee_++)
                {
                    checkContenuDansPorteeMoyenJoute(moteurgraphique_, porteesDeMeilleuresPrecisions[portee_], moi_, gameplay_, armee_, hud_);
                }
            }

            deplacementMoyenJoute(moteurgraphique_, gameplay_, moi_, armee_, hud_);
            if (moi_.attaqOrNot)
            {
                for (int portee_ = 0; portee_ < porteesDeMeilleuresPrecisions.Count - 1; portee_++)
                {
                    checkContenuDansPorteeMoyenJoute(moteurgraphique_, porteesDeMeilleuresPrecisions[portee_], moi_, gameplay_, armee_, hud_);
                }
            }

            deplacementMoyenJoute(moteurgraphique_, gameplay_, moi_, armee_, hud_);

            finish = true;
        }
        public void PlayFacileTresor(Unite moi_, MoteurGraphique moteurgraphique_, SystemeDeJeu gameplay_, Armee armee_, HUD hud_)
        {
            deplacementFacileTresor(moteurgraphique_, gameplay_, moi_, armee_);
            if (moi_.i != gameplay_.tresor_i && moi_.j != gameplay_.tresor_j)
            {
                for (int portee_ = 1; portee_ < 7; portee_++)
                {
                    if (moi_.portee[portee_] > -1)
                    {
                        checkContenuDansPorteeFacileTresor(moi_, gameplay_, moteurgraphique_, armee_, hud_);
                    }
                }
            }
            else
            {
                deplacementFacileTresor(moteurgraphique_, gameplay_, moi_, armee_);
            }

            finish = true;
        }
        public void PlayFacileJoute(Unite moi_, MoteurGraphique moteurgraphique_, SystemeDeJeu gameplay_, Armee armee_, HUD hud_)
        {
            List<int> porteeeeeeeeeeesValables = new List<int>();
            for (int i = 0; i < 7; i++)
            {
                if (moi_.portee[i] > 0)
                {
                    porteeeeeeeeeeesValables.Add(i);
                }
            }

            foreach (int portee_ in porteeeeeeeeeeesValables)
            {
                checkContenuDansPorteeFacileJoute(moteurgraphique_, portee_, moi_, gameplay_, armee_, hud_);
            }

            deplacementFacileJoute(moteurgraphique_, gameplay_, moi_, armee_);

            if (moi_.attaqOrNot)
            {
                foreach (int portee_ in porteeeeeeeeeeesValables)
                {
                    checkContenuDansPorteeFacileJoute(moteurgraphique_, portee_, moi_, gameplay_, armee_, hud_);
                }
            }

            finish = true;
        }
 public void PlayFacileEchiquier(Unite moi_, MoteurGraphique moteurgraphique_, SystemeDeJeu gameplay_, Armee armee_, HUD hud_)
 {
     for (int portee_ = 1; portee_ < 7; portee_++)
     {
         if (moi_.portee[portee_] > -1)
         {
             checkContenuDansPorteeFacileEchiquier(moteurgraphique_, portee_, moi_, gameplay_, armee_, hud_);
         }
     }
     if (moi_.attaqOrNot)
     {
         deplacementFacileEchiquier(gameplay_, moteurgraphique_, moi_);
         for (int portee_ = 1; portee_ < 7; portee_++)
         {
             if (moi_.portee[portee_] > -1)
             {
                 checkContenuDansPorteeFacileEchiquier(moteurgraphique_, portee_, moi_, gameplay_, armee_, hud_);
             }
         }
     }
     finish = true;
 }
        public void PlayDifficileJoute(Unite moi_, MoteurGraphique moteurgraphique_, SystemeDeJeu gameplay_, Armee armee_, HUD hud_)
        {
            List<int> porteesDeMeilleuresPrecisions = new List<int>();

            #region obtenirUneListeDesMeilleuresPorteesDePrecision

            for (int f = 10; f > 0; f--)
            {
                for (int g = 6; g > 0; g--)
                {
                    if (moi_.portee[g] == f)
                    {
                        porteesDeMeilleuresPrecisions.Add(g);
                    }
                }
            }
            #endregion

            if (moi_.typeUnite == e_typeUnite.Elite)
            {
                deplacementDifficileJoute(moteurgraphique_, moi_, gameplay_, armee_, hud_);

                for (int i = moi_.SHORYUKEN.porteePouvoir.Count - 1; i >= 0; i--)
                {
                    checkContenuDansCasePouvoirJoute(moteurgraphique_, moi_, gameplay_, moi_.SHORYUKEN.porteePouvoir[i], hud_);
                }

                deplacementDifficileJoute(moteurgraphique_, moi_, gameplay_, armee_, hud_);

                if (moi_.attaqOrNot)
                {
                    for (int i = moi_.SHORYUKEN.porteePouvoir.Count - 1; i >= 0; i--)
                    {
                        checkContenuDansCasePouvoirJoute(moteurgraphique_, moi_, gameplay_, moi_.SHORYUKEN.porteePouvoir[i], hud_);
                    }
                }
            }

            deplacementDifficileJoute(moteurgraphique_, moi_, gameplay_, armee_, hud_);

            if (moi_.attaqOrNot)
            {
                for (int i = 0; i < porteesDeMeilleuresPrecisions.Count; i++)
                {
                    checkContenuDansPorteeMoyenJoute(moteurgraphique_, porteesDeMeilleuresPrecisions[i], moi_, gameplay_, armee_, hud_);
                }
            }

            deplacementDifficileJoute(moteurgraphique_, moi_, gameplay_, armee_, hud_);

            if (moi_.attaqOrNot)
            {
                for (int i = 0; i < porteesDeMeilleuresPrecisions.Count; i++)
                {
                    checkContenuDansPorteeMoyenJoute(moteurgraphique_, porteesDeMeilleuresPrecisions[i], moi_, gameplay_, armee_, hud_);
                }
            }

            deplacementDifficileJoute(moteurgraphique_, moi_, gameplay_, armee_, hud_);

            finish = true;
        }
 public void PlayDebileJoute(Unite moi_, MoteurGraphique moteurgraphique_, SystemeDeJeu gameplay_, HUD hud_)
 {
     if (moi_.mouvement > 0 && moi_.attaqOrNot)
     {
         for (int portee_ = 1; portee_ < 7; portee_++)
         {
             if (moi_.portee[portee_] > -1)
             {
                 checkContenuDansPorteeDebileJoute(moteurgraphique_, portee_, moi_, gameplay_, hud_);
             }
         }
         deplacementRandomJoute(moteurgraphique_, gameplay_.listeDesJoueurs[gameplay_.tourencours], moi_, gameplay_);
         if (!ilABouger)
         {
             finish = true;
         }
     }
     else
     {
         finish = true;
     }
 }
Exemplo n.º 16
0
 public void UpdateSelonIAouNon(MoteurGraphique loohy_, SystemeDeJeu gameplay_, ref e_modeAction mood_,
     /*Lecteur coldman_,*/ HUD hud_, ref int time_, ref bool transition_)
 {
     if (IA)
     {
         UpdateIA(loohy_, gameplay_,/* coldman_,*/ hud_, ref time_, ref transition_);
     }
     else
     {
         Update(loohy_, gameplay_, ref mood_, /*coldman_, */hud_);
     }
 }
Exemplo n.º 17
0
 public void utiliserIA(MoteurGraphique moteurgraphique_, SystemeDeJeu gameplay_, HUD hud_)
 {
     bataillon[uniteselect].utiliserIA(moteurgraphique_, this, gameplay_, hud_);
 }
        public void checkContenuDansPorteeFacileColline(MoteurGraphique moteurgraphique_, int portee_, Unite moi_, SystemeDeJeu gameplay_, Armee armee_, HUD hud_)
        {
            int absx = moteurgraphique_.longueur / 2;
            int ordy = moteurgraphique_.largeur / 2;
            if (moi_.alive)
            {
                if (moi_.i != absx || moi_.j != ordy)
                {
                    #region siPersonneOuUnAlliePossedeColline

                    if (moteurgraphique_.map[absx, ordy].pointeurArmee == -1 || gameplay_.listeDesJoueurs[moteurgraphique_.map[absx, ordy].pointeurArmee].camp ==
                            gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i, moi_.j].pointeurArmee].camp)
                    {
                        checkContenuDansPorteeMoyenJoute(moteurgraphique_, portee_, moi_, gameplay_, armee_, hud_);
                    }

                    #endregion

                    #region siUnEnnemiPossedeLaColline

                    else
                    {
                        for (int p = 1; p < 7; p++) // ici aussi il faut que 7 soit remplacé par la portée d'attaque max de l'unité moi_
                        {
                            for (int k = 0; k < p; k++)
                            {
                                if (moi_.attaqOrNot)
                                {
                                    if (moi_.i + k >= 0 && moi_.i + k < moteurgraphique_.longueur &&
                                        moi_.j + (p - k) >= 0 && moi_.j + (p - k) < moteurgraphique_.largeur)
                                    {
                                        if (moi_.i + k == absx && moi_.j + (p - k) == ordy)
                                        {
                                            moi_.Initiative(gameplay_.listeDesJoueurs[moteurgraphique_.map[absx, ordy].pointeurArmee].bataillon[moteurgraphique_.map[absx, ordy].pointeurUnite], p, moteurgraphique_, gameplay_, ref gameplay_.mood, hud_);
                                        }
                                        else if (moi_.i - k >= 0 && moi_.i - k < moteurgraphique_.longueur &&
                                                 moi_.j - (p - k) >= 0 && moi_.j - (p - k) < moteurgraphique_.largeur)
                                        {
                                            if (moi_.i - k == absx && moi_.j - (p - k) == ordy)
                                            {
                                                moi_.Initiative(gameplay_.listeDesJoueurs[moteurgraphique_.map[absx, ordy].pointeurArmee].bataillon[moteurgraphique_.map[absx, ordy].pointeurUnite], p, moteurgraphique_, gameplay_, ref gameplay_.mood, hud_);
                                            }
                                            else if (moi_.i + (p - k) >= 0 && moi_.i + (p - k) < moteurgraphique_.longueur &&
                                                     moi_.j - k >= 0 && moi_.j - k < moteurgraphique_.largeur)
                                            {
                                                if (moi_.i + (p - k) == absx && moi_.j - k == ordy)
                                                {
                                                    moi_.Initiative(gameplay_.listeDesJoueurs[moteurgraphique_.map[absx, ordy].pointeurArmee].bataillon[moteurgraphique_.map[absx, ordy].pointeurUnite], p, moteurgraphique_, gameplay_, ref gameplay_.mood, hud_);
                                                }
                                                else if (moi_.i - (p - k) >= 0 && moi_.i - (p - k) < moteurgraphique_.longueur &&
                                                         moi_.j + k >= 0 && moi_.j + k < moteurgraphique_.largeur)
                                                {
                                                    if (moi_.i - (p - k) == absx && moi_.j + k == ordy)
                                                    {
                                                        moi_.Initiative(gameplay_.listeDesJoueurs[moteurgraphique_.map[absx, ordy].pointeurArmee].bataillon[moteurgraphique_.map[absx, ordy].pointeurUnite], p, moteurgraphique_, gameplay_, ref gameplay_.mood, hud_);
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }

                    #endregion
                }
            }
        }
Exemplo n.º 19
0
 public void suivant(MoteurGraphique moteurgraphique_, bool centrer_, HUD hud_)
 {
     do
     {
         uniteselect = (uniteselect + 1) % effectif;
     } while (!bataillon[uniteselect].alive || !atLeastOneAlive);
     clic = false;
     if (bataillon[uniteselect].alive)
     {
         if (centrer_)
         {
             moteurgraphique_.centrerSur(bataillon[uniteselect].i, bataillon[uniteselect].j);
         }
         bataillon[uniteselect].lookAtCheminsInitialize(moteurgraphique_);
     }
 }
        public void checkContenuDansCasePouvoirJoute(MoteurGraphique moteurgraphique_, Unite moi_, SystemeDeJeu gameplay_, int portee_, HUD hud_)
        {
            bool aEteRemove = false;
            List<Unite> ciblesPotentielles = new List<Unite>();
            List<int> porteesPotentielles = new List<int>();
            List<Unite> ciblesPotentielles2 = new List<Unite>();
            List<int> porteesPotentielles2 = new List<int>();
            List<Unite> ciblesPotentielles3 = new List<Unite>();
            List<int> porteesPotentielles3 = new List<int>();

            #region boucleCiblesPotentiellesDeBase

            for (int k = 0; k < portee_; k++)
            {
                if (moi_.i + k >= 0 && moi_.i + k < moteurgraphique_.longueur && moi_.j + (portee_ - k) >= 0 && moi_.j + (portee_ - k) < moteurgraphique_.largeur)
                {
                    if (moteurgraphique_.map[moi_.i + k, moi_.j + (portee_ - k)].presence)
                    {
                        ciblesPotentielles.Add(gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i + k, moi_.j + (portee_ - k)].pointeurArmee].bataillon[moteurgraphique_.map[moi_.i + k, moi_.j + (portee_ - k)].pointeurUnite]);
                        porteesPotentielles.Add(portee_);
                    }
                }
                if (moi_.i - k >= 0 && moi_.i - k < moteurgraphique_.longueur && moi_.j - (portee_ - k) >= 0 && moi_.j - (portee_ - k) < moteurgraphique_.largeur)
                {
                    if (moteurgraphique_.map[moi_.i - k, moi_.j - (portee_ - k)].presence)
                    {
                        ciblesPotentielles.Add(gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i - k, moi_.j - (portee_ - k)].pointeurArmee].bataillon[moteurgraphique_.map[moi_.i - k, moi_.j - (portee_ - k)].pointeurUnite]);
                        porteesPotentielles.Add(portee_);
                    }
                }

                if (moi_.i + (portee_ - k) >= 0 && moi_.i + (portee_ - k) < moteurgraphique_.longueur && moi_.j - k >= 0 && moi_.j - k < moteurgraphique_.largeur)
                {
                    if (moteurgraphique_.map[moi_.i + (portee_ - k), moi_.j - k].presence)
                    {
                        ciblesPotentielles.Add(gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i + (portee_ - k), moi_.j - k].pointeurArmee].bataillon[moteurgraphique_.map[moi_.i + (portee_ - k), moi_.j - k].pointeurUnite]);
                        porteesPotentielles.Add(portee_);
                    }
                }
                if (moi_.i - (portee_ - k) >= 0 && moi_.i - (portee_ - k) < moteurgraphique_.longueur && moi_.j + k >= 0 && moi_.j + k < moteurgraphique_.largeur)
                {
                    if (moteurgraphique_.map[moi_.i - (portee_ - k), moi_.j + k].presence)
                    {
                        ciblesPotentielles.Add(gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i - (portee_ - k), moi_.j + k].pointeurArmee].bataillon[moteurgraphique_.map[moi_.i - (portee_ - k), moi_.j + k].pointeurUnite]);
                        porteesPotentielles.Add(portee_);
                    }
                }
            }

            for (int i = ciblesPotentielles.Count - 1; i >= 0; i--)
            {
                if (!ciblesPotentielles[i].alive)
                {
                    ciblesPotentielles.RemoveAt(i);
                    porteesPotentielles.RemoveAt(i);
                }
            }
            #endregion

            #region selonLeTypeDePouvoir

            #region pouvoirDegat

            if (moi_.SHORYUKEN.type == e_typeDePouvoir.Degat)
            {
                for (int i = ciblesPotentielles.Count - 1; i >= 0; i--)
                {
                    if (gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i, moi_.j].pointeurArmee].camp == gameplay_.listeDesJoueurs[moteurgraphique_.map[ciblesPotentielles[i].i, ciblesPotentielles[i].j].pointeurArmee].camp)
                    {
                        ciblesPotentielles.RemoveAt(i);
                        porteesPotentielles.RemoveAt(i);
                    }
                }

                while (ciblesPotentielles.Count > 1)
                {
                    for (int i = ciblesPotentielles.Count - 2; i >= 0; i--)
                    {
                        if (ciblesPotentielles[i].pvactuel < ciblesPotentielles[i + 1].pvactuel)
                        {
                            ciblesPotentielles.RemoveAt(i + 1);
                            porteesPotentielles.RemoveAt(i + 1);
                        }
                        else if (ciblesPotentielles[i].pvactuel > ciblesPotentielles[i + 1].pvactuel)
                        {
                            ciblesPotentielles.RemoveAt(i);
                            porteesPotentielles.RemoveAt(i);
                        }
                        else
                        {
                            if (ciblesPotentielles[i].typeUnite == e_typeUnite.Elite)
                            {
                                ciblesPotentielles.RemoveAt(i + 1);
                                porteesPotentielles.RemoveAt(i + 1);
                            }
                            else if (ciblesPotentielles[i + 1].typeUnite == e_typeUnite.Elite)
                            {
                                ciblesPotentielles.RemoveAt(i);
                                porteesPotentielles.RemoveAt(i);
                            }
                            else if (ciblesPotentielles[i].typeUnite == e_typeUnite.Heros)
                            {
                                ciblesPotentielles.RemoveAt(i + 1);
                                porteesPotentielles.RemoveAt(i + 1);
                            }
                            else
                            {
                                ciblesPotentielles.RemoveAt(i);
                                porteesPotentielles.RemoveAt(i);
                            }
                        }
                    }
                }
                if (ciblesPotentielles.Count > 0)
                {
                    moi_.SHORYUKEN.UtiliserPouvoir(moi_, moteurgraphique_, gameplay_, ciblesPotentielles[0].i, ciblesPotentielles[0].j, ref gameplay_.mood, hud_);
                }
            }
            #endregion

            #region pouvoirSoin

            else if (moi_.SHORYUKEN.type == e_typeDePouvoir.Soin)
            {
                for (int i = ciblesPotentielles.Count - 1; i >= 0; i--)
                {
                    if (gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i, moi_.j].pointeurArmee].camp != gameplay_.listeDesJoueurs[moteurgraphique_.map[ciblesPotentielles[i].i, ciblesPotentielles[i].j].pointeurArmee].camp)
                    {
                        ciblesPotentielles.RemoveAt(i);
                        porteesPotentielles.RemoveAt(i);
                    }
                }

                for (int i = ciblesPotentielles.Count - 1; i >= 0; i--)
                {
                    if (ciblesPotentielles[i].pvactuel >= ciblesPotentielles[i].pvmax / 2)
                    {
                        ciblesPotentielles.RemoveAt(i);
                        porteesPotentielles.RemoveAt(i);
                    }
                }

                for (int elektek = ciblesPotentielles.Count - 1; elektek >= 0; elektek--)
                {
                    if (ciblesPotentielles[elektek].typeUnite == e_typeUnite.Elite)
                    {
                        ciblesPotentielles2.Add(ciblesPotentielles[elektek]);
                        porteesPotentielles2.Add(porteesPotentielles[elektek]);
                    }
                    if (ciblesPotentielles[elektek].typeUnite == e_typeUnite.Heros)
                    {
                        ciblesPotentielles3.Add(ciblesPotentielles[elektek]);
                        porteesPotentielles3.Add(porteesPotentielles[elektek]);
                    }
                }

                if (ciblesPotentielles2.Count > 0)
                {
                    ciblesPotentielles = ciblesPotentielles2;
                    porteesPotentielles = porteesPotentielles2;
                }
                else if (ciblesPotentielles3.Count > 0)
                {
                    ciblesPotentielles = ciblesPotentielles3;
                    porteesPotentielles = porteesPotentielles3;
                }

                while (ciblesPotentielles.Count > 1)
                {
                    for (int magmar = ciblesPotentielles.Count - 2; magmar >= 0; magmar--)
                    {
                        if (ciblesPotentielles[magmar].pvactuel < ciblesPotentielles[magmar + 1].pvactuel)
                        {
                            ciblesPotentielles.RemoveAt(magmar + 1);
                            porteesPotentielles.RemoveAt(magmar + 1);
                        }
                        else
                        {
                            ciblesPotentielles.RemoveAt(magmar);
                            porteesPotentielles.RemoveAt(magmar);
                        }
                    }
                }

                if (ciblesPotentielles.Count > 0)
                {
                    moi_.SHORYUKEN.UtiliserPouvoir(moi_, moteurgraphique_, gameplay_, ciblesPotentielles[0].i, ciblesPotentielles[0].j, ref gameplay_.mood, hud_);
                }
            }
            #endregion

            #region pouvoirBoost

            else
            {
                for (int elektor = ciblesPotentielles.Count - 1; elektor >= 0; elektor--)
                {
                    if (gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i, moi_.j].pointeurArmee].camp != gameplay_.listeDesJoueurs[moteurgraphique_.map[ciblesPotentielles[elektor].i, ciblesPotentielles[elektor].j].pointeurArmee].camp)
                    {
                        ciblesPotentielles.RemoveAt(elektor);
                        porteesPotentielles.RemoveAt(elektor);
                    }
                }

                for (int artikodin = ciblesPotentielles.Count - 1; artikodin >= 0; artikodin--)
                {
                    aEteRemove = false;
                    if (ciblesPotentielles[artikodin].typeUnite == e_typeUnite.Elite)
                    {
                        ciblesPotentielles.RemoveAt(artikodin);
                        aEteRemove = true;
                    }
                    if (aEteRemove == false && ciblesPotentielles[artikodin].typeUnite == e_typeUnite.Heros == false)
                    {
                        moi_.SHORYUKEN.UtiliserPouvoir(moi_, moteurgraphique_, gameplay_, ciblesPotentielles[artikodin].i, ciblesPotentielles[artikodin].j, ref gameplay_.mood, hud_);
                    }
                }

                if (moi_.attaqOrNot)
                {
                    while (ciblesPotentielles.Count > 1)
                    {
                        for (int sulfura = ciblesPotentielles.Count - 2; sulfura >= 0; sulfura--)
                        {
                            if (ciblesPotentielles[sulfura].pvactuel < ciblesPotentielles[sulfura + 1].pvactuel)
                            {
                                ciblesPotentielles.RemoveAt(sulfura);
                                porteesPotentielles.RemoveAt(sulfura);
                            }
                            else
                            {
                                ciblesPotentielles.RemoveAt(sulfura + 1);
                                porteesPotentielles.RemoveAt(sulfura + 1);
                            }
                        }
                    }

                    if (ciblesPotentielles.Count > 0)
                    {
                        moi_.SHORYUKEN.UtiliserPouvoir(moi_, moteurgraphique_, gameplay_, ciblesPotentielles[0].i, ciblesPotentielles[0].j, ref gameplay_.mood, hud_);
                    }
                }
            }
            #endregion

            #endregion
        }
Exemplo n.º 21
0
 public void UpdateIA(MoteurGraphique moteurgraphique_, SystemeDeJeu gameplay_, /*Lecteur coldman_,*/ HUD hud_, ref int time_, ref bool transition_)
 {
     if (!bataillon[uniteselect].IA.finish)
     {
         utiliserIA(moteurgraphique_, gameplay_, hud_);
     }
     else
     {
         if (allFinished())
         {
             gameplay_.FinDeTour(moteurgraphique_, /*coldman_,*/ hud_, ref time_, ref transition_);
         }
         else
         {
             suivant(moteurgraphique_, false, hud_);
         }
     }
 }
        /* pour la fonction ci-dessous (et toutes les checkContenu) il faut que dans son appel portee_ soit les differentes portées d'attaque de l'unité
           ce qui n'est pas le cas pour l'instant d'ou les "trop loin" qui apparaissent souvent dans les animations */
        public void checkContenuDansPorteeFacileJoute(MoteurGraphique moteurgraphique_, int portee_, Unite moi_, SystemeDeJeu gameplay_, Armee armee_, HUD hud_)
        {
            //cible : gameplay_.armees[moteurgraphique_.map[i_, j_].pointeurArmee].bataillon[moteurgraphique_.map[i_, j_].pointeurUnite]
            List<Unite> ciblesPotentielles = new List<Unite>();
            List<int> porteesPotentielles = new List<int>();

            if (moi_.alive)
            {
                if (moi_.attaqOrNot)
                {
                    #region boucleTestCiblesPotentielles

                    for (int k = 0; k < portee_; k++)
                    {
                        if (moi_.i + k >= 0 && moi_.i + k < moteurgraphique_.longueur
                            && moi_.j + (portee_ - k) >= 0 && moi_.j + (portee_ - k) < moteurgraphique_.largeur)
                        {
                            if (moteurgraphique_.map[moi_.i + k, moi_.j + (portee_ - k)].presence &&
                                    gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i, moi_.j].pointeurArmee].camp != gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i + k, moi_.j + (portee_ - k)].pointeurArmee].camp)
                            {
                                ciblesPotentielles.Add(gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i + k, moi_.j + (portee_ - k)].pointeurArmee].
                                    bataillon[moteurgraphique_.map[moi_.i + k, moi_.j + (portee_ - k)].pointeurUnite]);
                                porteesPotentielles.Add(portee_);
                            }
                        }
                        if (moi_.i - k >= 0 && moi_.i - k < moteurgraphique_.longueur
                             && moi_.j - (portee_ - k) >= 0 && moi_.j - (portee_ - k) < moteurgraphique_.largeur)
                        {
                            if (moteurgraphique_.map[moi_.i - k, moi_.j - (portee_ - k)].presence &&
                                    gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i, moi_.j].pointeurArmee].camp != gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i - k, moi_.j - (portee_ - k)].pointeurArmee].camp)
                            {
                                ciblesPotentielles.Add(gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i - k, moi_.j - (portee_ - k)].pointeurArmee].
                                    bataillon[moteurgraphique_.map[moi_.i - k, moi_.j - (portee_ - k)].pointeurUnite]);
                                porteesPotentielles.Add(portee_);
                            }
                        }
                        if (moi_.i + (portee_ - k) >= 0 && moi_.i + (portee_ - k) < moteurgraphique_.longueur
                             && moi_.j - k >= 0 && moi_.j - k < moteurgraphique_.largeur)
                        {
                            if (moteurgraphique_.map[moi_.i + (portee_ - k), moi_.j - k].presence &&
                                    gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i, moi_.j].pointeurArmee].camp != gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i + (portee_ - k), moi_.j - k].pointeurArmee].camp)
                            {
                                ciblesPotentielles.Add(gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i + (portee_ - k), moi_.j - k].pointeurArmee].
                                    bataillon[moteurgraphique_.map[moi_.i + (portee_ - k), moi_.j - k].pointeurUnite]);
                                porteesPotentielles.Add(portee_);
                            }
                        }
                        if (moi_.i - (portee_ - k) >= 0 && moi_.i - (portee_ - k) < moteurgraphique_.longueur
                             && moi_.j + k >= 0 && moi_.j + k < moteurgraphique_.largeur)
                        {
                            if (moteurgraphique_.map[moi_.i - (portee_ - k), moi_.j + k].presence &&
                                    gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i, moi_.j].pointeurArmee].camp != gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i - (portee_ - k), moi_.j + k].pointeurArmee].camp)
                            {
                                ciblesPotentielles.Add(gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i - (portee_ - k), moi_.j + k].pointeurArmee].
                                    bataillon[moteurgraphique_.map[moi_.i - (portee_ - k), moi_.j + k].pointeurUnite]);
                                porteesPotentielles.Add(portee_);
                            }
                        }
                    }
                    for (int i = 0; i < ciblesPotentielles.Count - 1; i++)
                    {
                        if (!ciblesPotentielles[i].alive)
                        {
                            ciblesPotentielles.RemoveAt(i);
                            porteesPotentielles.RemoveAt(i);
                        }
                    }

                    #endregion

                    #region attaqueEfficacementUniteAvecLeMoinsDePV

                    //for (int w = ciblesPotentielles.Count - 1; w >= 0; w--)
                    //{
                    //    if (moi_.typedAttaque[porteesPotentielles[w]] == true)
                    //    {
                    //        if (moi_.attaque <= ciblesPotentielles[w].armure + ciblesPotentielles[w].bonusArmure)
                    //        {
                    //            ciblesPotentielles.RemoveAt(w);
                    //            porteesPotentielles.RemoveAt(w);
                    //        }
                    //    }
                    //    else
                    //    {
                    //        if (moi_.attaque <= ciblesPotentielles[w].resistance + ciblesPotentielles[w].bonusresistance)
                    //        {
                    //            ciblesPotentielles.RemoveAt(w);
                    //            porteesPotentielles.RemoveAt(w);
                    //        }
                    //    }
                    //}

                    for (int galopa = 0; galopa < ciblesPotentielles.Count; galopa++)
                    {
                        if (Math.Abs((moi_.i - ciblesPotentielles[galopa].i) + (moi_.j - ciblesPotentielles[galopa].j)) >= 7)
                        {
                            ciblesPotentielles.RemoveAt(galopa);
                            porteesPotentielles.RemoveAt(galopa);
                        }
                    }

                    for (int ponyta = 0; ponyta < ciblesPotentielles.Count; ponyta++)
                    {
                        if (moi_.portee[Math.Abs((moi_.i - ciblesPotentielles[ponyta].i) + (moi_.j - ciblesPotentielles[ponyta].j))] <= 0)
                        {
                            ciblesPotentielles.RemoveAt(ponyta);
                            porteesPotentielles.RemoveAt(ponyta);
                        }
                    }

                    do
                    {
                        for (int i = 0; i < ciblesPotentielles.Count - 1; i++)
                        {
                            if (ciblesPotentielles[i].pvactuel < ciblesPotentielles[i + 1].pvactuel)
                            {
                                ciblesPotentielles.RemoveAt(i + 1);
                                porteesPotentielles.RemoveAt(i + 1);
                            }
                            else
                            {
                                ciblesPotentielles.RemoveAt(i);
                                porteesPotentielles.RemoveAt(i);
                            }
                        }
                    } while (ciblesPotentielles.Count > 1);

                    if (ciblesPotentielles.Count > 0)
                    {
                        moi_.Initiative(ciblesPotentielles[0], porteesPotentielles[0], moteurgraphique_, gameplay_, ref gameplay_.mood, hud_);
                    }
                    #endregion
                }
            }
        }
Exemplo n.º 23
0
 public void Riposte(Unite ennemi_, int porteeDeFrappe_, MoteurGraphique moteurgraphique_, SystemeDeJeu gameplay_,
     string txt_, int dgts_,//--
     Color clr_, e_race e_race_, HUD hud_)
 {
     string txt1, txt2;
     int dgts1, dgts2;
     Color clr1, clr2;
     e_race e_race1, e_race2;
     if (pvactuel > 0)
     {
         #region frapper
         if (typedAttaque[porteeDeFrappe_])
         {
             //type dattaque : physique si typedAttaque[porteedeFrappe]= vrai
             #region Physique
             if ((precision + bonusprecision) * portee[porteeDeFrappe_] / 10 - ennemi_.esquive >= (r.Next(1000) % 100))
             {
                 if (r.Next(1000) % 100 < (coupcritique + bonusCoupcritique))
                 {
                     if (ennemi_.armure < (attaque + bonusAttaque) * 2)
                     {
                         ennemi_.pvactuel -= ((attaque + bonusAttaque) * 2 - ennemi_.armure);
                         txt2 = "Coup Critique !!";
                         dgts2 = ((attaque + bonusAttaque) * 2 - ennemi_.armure);
                     }
                     else
                     {
                         txt2 = "  Inefficace !  ";
                         dgts2 = 0;
                     }
                 }
                 else
                 {
                     if (ennemi_.armure < (attaque + bonusAttaque))
                     {
                         ennemi_.pvactuel -= ((attaque + bonusAttaque) - ennemi_.armure);
                         txt2 = "    Attaque !   ";
                         dgts2 = ((attaque + bonusAttaque) - ennemi_.armure);
                     }
                     else
                     {
                         txt2 = "  Inefficace !  ";
                         dgts2 = 0;
                     }
                 }
             }
             else
             {
                 xp += 1;
                 if (portee[porteeDeFrappe_] == 0)
                 {
                     txt2 = "   Trop loin !  ";
                     dgts2 = 0;
                 }
                 else
                 {
                     txt2 = "      Rate !    ";
                     dgts2 = 0;
                 }
             }
             #endregion
         }
         else
         {
             #region Magique
             if ((precision + bonusprecision) * portee[porteeDeFrappe_] / 10 - ennemi_.esquive >= (r.Next(1000) % 100))
             {
                 if (r.Next(1000) % 100 < (coupcritique + bonusCoupcritique))
                 {
                     if (ennemi_.resistance < (puissance + bonuspuissance) * 2)
                     {
                         ennemi_.pvactuel -= ((puissance + bonuspuissance) * 2 - ennemi_.resistance);
                         txt2 = "Coup Critique !!";
                         dgts2 = ((puissance + bonuspuissance) * 2 - ennemi_.armure);
                     }
                     else
                     {
                         txt2 = "  Inefficace !  ";
                         dgts2 = 0;
                     }
                 }
                 else
                 {
                     if (ennemi_.resistance < (puissance + bonuspuissance))
                     {
                         ennemi_.pvactuel -= ((puissance + bonuspuissance) - ennemi_.resistance);
                         txt2 = "    Attaque !   ";
                         dgts2 = ((puissance + bonuspuissance) - ennemi_.armure);
                     }
                     else
                     {
                         txt2 = "  Inefficace !  ";
                         dgts2 = 0;
                     }
                 }
             }
             else
             {
                 xp += 1;
                 if (portee[porteeDeFrappe_] == 0)
                 {
                     txt2 = "   Trop loin !  ";
                     dgts2 = 0;
                 }
                 else
                 {
                     txt2 = "      Rate !    ";
                     dgts2 = 0;
                 }
             }
             #endregion
         }
         #endregion
     }
     else
     {
         txt2 = "  Deja morte !  ";
         dgts2 = 0;
     }
     txt1 = txt_;
     dgts1 = dgts_;
     clr1 = clr_;
     e_race1 = e_race_;
     clr2 = gameplay_.listeDesJoueurs[numeroArmee].couleur;
     e_race2 = gameplay_.listeDesJoueurs[numeroArmee].espece;
     hud_.fight(ennemi_, this, txt1, dgts1, clr1, txt2, dgts2, clr2, e_race1, e_race2);
     gameplay_.CheckPV(moteurgraphique_, hud_);
 }
        public void checkContenuDansPorteeFacileTresor(Unite moi_, SystemeDeJeu gameplay_, MoteurGraphique moteurgraphique_, Armee armee_, HUD hud_)
        {
            List<int> porteeeeeeeeeeesValables = new List<int>();

            for (int i = 0; i < 7; i++)
            {
                if (moi_.portee[i] > 0)
                {
                    porteeeeeeeeeeesValables.Add(i);
                }
            }
            if (moteurgraphique_.map[gameplay_.tresor_i, gameplay_.tresor_j].presence == true)
            {
                if (gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i, moi_.j].pointeurArmee].camp != gameplay_.listeDesJoueurs[moteurgraphique_.map[gameplay_.tresor_i, gameplay_.tresor_j].pointeurArmee].camp)
                {
                    if (Math.Abs((moi_.i - gameplay_.tresor_i) + (moi_.j - gameplay_.tresor_j)) < 7)
                    {
                        if (moi_.portee[Math.Abs((moi_.i - gameplay_.tresor_i) + (moi_.j - gameplay_.tresor_j))] > 0)
                        {
                            moi_.Initiative(gameplay_.listeDesJoueurs[moteurgraphique_.map[gameplay_.tresor_i, gameplay_.tresor_j].pointeurArmee].bataillon[moteurgraphique_.map[gameplay_.tresor_i, gameplay_.tresor_j].pointeurUnite], Math.Abs((moi_.i - gameplay_.tresor_i) + (moi_.j - gameplay_.tresor_j)), moteurgraphique_, gameplay_, ref gameplay_.mood, hud_);
                        }
                        else
                        {
                            foreach (int portee_ in porteeeeeeeeeeesValables)
                            {
                                checkContenuDansPorteeMoyenJoute(moteurgraphique_, portee_, moi_, gameplay_, armee_, hud_);
                            }
                        }
                    }

                    else
                    {
                        foreach (int portee_ in porteeeeeeeeeeesValables)
                        {
                            checkContenuDansPorteeMoyenJoute(moteurgraphique_, portee_, moi_, gameplay_, armee_, hud_);
                        }
                    }
                }
            }
        }
Exemplo n.º 25
0
 public void utiliserIA(MoteurGraphique moteurgraphique_, Armee armee_, SystemeDeJeu gameplay_, HUD hud_)
 {
     if (fileDeMouvements.Count == 0)
     {
         IA.Play(this, moteurgraphique_, armee_, gameplay_, hud_);
     }
 }
        public void checkContenuDansPorteeMoyenEchiquier(MoteurGraphique moteurgraphique_, int portee_, Unite moi_, SystemeDeJeu gameplay_, Armee armee_, HUD hud_)
        {
            List<Unite> ciblesPotentielles = new List<Unite>();
            List<int> porteesPotentielles = new List<int>();
            int abscisseHerosEnnemi = -1;
            int ordonneeHerosEnnemi = -1;

            if (moi_.alive)
            {
                foreach (Unite unite in gameplay_.listeDesJoueurs[(gameplay_.tourencours + 1) % 2].bataillon)
                {
                    if (unite.typeUnite == e_typeUnite.Heros)
                    {
                        abscisseHerosEnnemi = unite.i;
                        ordonneeHerosEnnemi = unite.j;
                    }
                }

                #region boucleTestCiblesPotentielles

                if (moi_.attaqOrNot && moi_.typeUnite != e_typeUnite.Heros)
                {
                    for (int k = 0; k < portee_; k++)
                    {
                        if (moi_.i + k >= 0 && moi_.i + k < moteurgraphique_.longueur
                            && moi_.j + (portee_ - k) >= 0 && moi_.j + (portee_ - k) < moteurgraphique_.largeur)
                        {
                            if (moteurgraphique_.map[moi_.i + k, moi_.j + (portee_ - k)].presence &&
                                    gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i, moi_.j].pointeurArmee].camp != gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i + k, moi_.j + (portee_ - k)].pointeurArmee].camp)
                            {
                                ciblesPotentielles.Add(gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i + k, moi_.j + (portee_ - k)].pointeurArmee].
                                    bataillon[moteurgraphique_.map[moi_.i + k, moi_.j + (portee_ - k)].pointeurUnite]);
                                porteesPotentielles.Add(k);
                            }
                        }
                        if (moi_.i - k >= 0 && moi_.i - k < moteurgraphique_.longueur
                             && moi_.j - (portee_ - k) >= 0 && moi_.j - (portee_ - k) < moteurgraphique_.largeur)
                        {
                            if (moteurgraphique_.map[moi_.i - k, moi_.j - (portee_ - k)].presence &&
                                    gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i, moi_.j].pointeurArmee].camp != gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i - k, moi_.j - (portee_ - k)].pointeurArmee].camp)
                            {
                                ciblesPotentielles.Add(gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i - k, moi_.j - (portee_ - k)].pointeurArmee].
                                    bataillon[moteurgraphique_.map[moi_.i - k, moi_.j - (portee_ - k)].pointeurUnite]);
                                porteesPotentielles.Add(k); ;
                            }
                        }
                        if (moi_.i + (portee_ - k) >= 0 && moi_.i + (portee_ - k) < moteurgraphique_.longueur
                             && moi_.j - k >= 0 && moi_.j - k < moteurgraphique_.largeur)
                        {
                            if (moteurgraphique_.map[moi_.i + (portee_ - k), moi_.j - k].presence &&
                                    gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i, moi_.j].pointeurArmee].camp != gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i + (portee_ - k), moi_.j - k].pointeurArmee].camp)
                            {
                                ciblesPotentielles.Add(gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i + (portee_ - k), moi_.j - k].pointeurArmee].
                                    bataillon[moteurgraphique_.map[moi_.i + (portee_ - k), moi_.j - k].pointeurUnite]);
                                porteesPotentielles.Add(k);
                            }
                        }
                        if (moi_.i - (portee_ - k) >= 0 && moi_.i - (portee_ - k) < moteurgraphique_.longueur
                             && moi_.j + k >= 0 && moi_.j + k < moteurgraphique_.largeur)
                        {
                            if (moteurgraphique_.map[moi_.i - (portee_ - k), moi_.j + k].presence &&
                                    gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i, moi_.j].pointeurArmee].camp != gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i - (portee_ - k), moi_.j + k].pointeurArmee].camp)
                            {
                                ciblesPotentielles.Add(gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i - (portee_ - k), moi_.j + k].pointeurArmee].
                                    bataillon[moteurgraphique_.map[moi_.i - (portee_ - k), moi_.j + k].pointeurUnite]);
                                porteesPotentielles.Add(k);
                            }
                        }
                    }

                #endregion

                    #region attaquerHerosOuUniteAvecPlusBasPV
                    do
                    {
                        if (moi_.attaqOrNot)
                        {
                            for (int i = ciblesPotentielles.Count - 1; i >= 0; i--)
                            {
                                if (!ciblesPotentielles[i].alive)
                                {
                                    ciblesPotentielles.RemoveAt(i);
                                    porteesPotentielles.RemoveAt(i);
                                }
                            }

                            for (int j = 0; j < ciblesPotentielles.Count - 1; j++)
                            {
                                if (ciblesPotentielles[j].i == abscisseHerosEnnemi && ciblesPotentielles[j].j == ordonneeHerosEnnemi)
                                {
                                    moi_.Initiative(ciblesPotentielles[j], porteesPotentielles[j], moteurgraphique_, gameplay_, ref gameplay_.mood, hud_);
                                    ciblesPotentielles.RemoveRange(0, ciblesPotentielles.Count - 1);
                                }
                            }

                            if (moi_.attaqOrNot)
                            {
                                for (int i = ciblesPotentielles.Count - 2; i >= 0; i--)
                                {
                                    if (ciblesPotentielles[i].pvactuel < ciblesPotentielles[i + 1].pvactuel)
                                    {
                                        ciblesPotentielles.RemoveAt(i + 1);
                                        porteesPotentielles.RemoveAt(i + 1);
                                    }
                                    else
                                    {
                                        ciblesPotentielles.RemoveAt(i);
                                        porteesPotentielles.RemoveAt(i);
                                    }
                                }
                            }
                        }
                    } while (ciblesPotentielles.Count > 1 && moi_.attaqOrNot);

                    if (ciblesPotentielles.Count > 0)
                    {
                        moi_.Initiative(ciblesPotentielles[0], porteesPotentielles[0], moteurgraphique_, gameplay_, ref gameplay_.mood, hud_);
                    }
                }
                    #endregion
            }
        }
Exemplo n.º 27
0
        public void Attaquer(MoteurGraphique moteurgraphique_, SystemeDeJeu gameplay_, ref e_modeAction mood_, HUD hud_)
        {
            if ((i + 1 < moteurgraphique_.longueur && moteurgraphique_.map[i + 1, j].presence)
                && ((Keyboard.GetState().IsKeyDown(Keys.F)
                || (moteurgraphique_.map[i + 1, j].estEnSurbrillance && Mouse.GetState().RightButton == ButtonState.Pressed))
                && attaqOrNot))
            {
                AttaqueEst(moteurgraphique_, gameplay_, ref mood_, hud_);
            }
            if ((j > 0 && moteurgraphique_.map[i, j - 1].presence)
                && ((Keyboard.GetState().IsKeyDown(Keys.R)
                || (moteurgraphique_.map[i, j - 1].estEnSurbrillance && Mouse.GetState().RightButton == ButtonState.Pressed))
                && attaqOrNot))
            {
                AttaqueNord(moteurgraphique_, gameplay_, ref mood_, hud_);
            }
            if ((i > 0 && moteurgraphique_.map[i - 1, j].presence)
                && ((Keyboard.GetState().IsKeyDown(Keys.E)
                || (moteurgraphique_.map[i - 1, j].estEnSurbrillance && Mouse.GetState().RightButton == ButtonState.Pressed))
                && attaqOrNot))
            {
                AttaqueOuest(moteurgraphique_, gameplay_, ref mood_, hud_);
            }
            if ((j + 1 < moteurgraphique_.largeur && moteurgraphique_.map[i, j + 1].presence)
                && ((Keyboard.GetState().IsKeyDown(Keys.D)
                || (moteurgraphique_.map[i, j + 1].estEnSurbrillance && Mouse.GetState().RightButton == ButtonState.Pressed))
                && attaqOrNot))
            {
                AttaqueSud(moteurgraphique_, gameplay_, ref mood_, hud_);
            }

            #region attaque a distance
            if (Mouse.GetState().RightButton == ButtonState.Pressed && attaqOrNot)
            {
                for (int portee_ = 1; portee_ < 7; portee_++)
                {
                    if (portee[portee_] != 0)
                    {
                        for (int k = 0; k < portee_; k++)
                        {
                            if (i + k >= 0 && i + k < moteurgraphique_.longueur
                                && j + (portee_ - k) >= 0 && j + (portee_ - k) < moteurgraphique_.largeur)
                            {
                                if (moteurgraphique_.map[i + k, j + (portee_ - k)].presence &&
                                       moteurgraphique_.map[i + k, j + (portee_ - k)].estEnSurbrillance &&
                                       moteurgraphique_.map[i + k, j + (portee_ - k)].visible &&
                                       attaqOrNot)
                                {
                                    mouvOrNot = false;
                                    Initiative(gameplay_.listeDesJoueurs[moteurgraphique_.map[i + k, j + (portee_ - k)].
                                         pointeurArmee].bataillon[moteurgraphique_.map[i + k, j + (portee_ - k)].pointeurUnite],
                                         portee_, moteurgraphique_, gameplay_, ref mood_, hud_);
                                    gameplay_.CheckPV(moteurgraphique_, hud_);
                                }
                            }
                            if (i - k >= 0 && i - k < moteurgraphique_.longueur
                                 && j - (portee_ - k) >= 0 && j - (portee_ - k) < moteurgraphique_.largeur)
                            {
                                if (moteurgraphique_.map[i - k, j - (portee_ - k)].presence &&
                                       moteurgraphique_.map[i - k, j - (portee_ - k)].estEnSurbrillance &&
                                       moteurgraphique_.map[i - k, j - (portee_ - k)].visible &&
                                       attaqOrNot)
                                {
                                    mouvOrNot = false;
                                    Initiative(gameplay_.listeDesJoueurs[moteurgraphique_.map[i - k, j - (portee_ - k)].
                                        pointeurArmee].bataillon[moteurgraphique_.map[i - k, j - (portee_ - k)].pointeurUnite],
                                        portee_, moteurgraphique_, gameplay_, ref mood_, hud_);
                                    gameplay_.CheckPV(moteurgraphique_, hud_);
                                }
                            }
                            if (i + (portee_ - k) >= 0 && i + (portee_ - k) < moteurgraphique_.longueur
                                 && j - k >= 0 && j - k < moteurgraphique_.largeur)
                            {
                                if (moteurgraphique_.map[i + (portee_ - k), j - k].presence &&
                                       moteurgraphique_.map[i + (portee_ - k), j - k].estEnSurbrillance &&
                                       moteurgraphique_.map[i + (portee_ - k), j - k].visible &&
                                       attaqOrNot)
                                {
                                    mouvOrNot = false;
                                    Initiative(gameplay_.listeDesJoueurs[moteurgraphique_.map[i + (portee_ - k), j - k].
                                        pointeurArmee].bataillon[moteurgraphique_.map[i + (portee_ - k), j - k].pointeurUnite],
                                        portee_, moteurgraphique_, gameplay_, ref mood_, hud_);
                                    gameplay_.CheckPV(moteurgraphique_, hud_);
                                }
                            }
                            if (i - (portee_ - k) >= 0 && i - (portee_ - k) < moteurgraphique_.longueur
                                 && j + k >= 0 && j + k < moteurgraphique_.largeur)
                            {
                                if (moteurgraphique_.map[i - (portee_ - k), j + k].presence &&
                                       moteurgraphique_.map[i - (portee_ - k), j + k].estEnSurbrillance &&
                                       moteurgraphique_.map[i - (portee_ - k), j + k].visible &&
                                       attaqOrNot)
                                {
                                    mouvOrNot = false;
                                    Initiative(gameplay_.listeDesJoueurs[moteurgraphique_.map[i - (portee_ - k), j + k].
                                        pointeurArmee].bataillon[moteurgraphique_.map[i - (portee_ - k), j + k].pointeurUnite],
                                        portee_, moteurgraphique_, gameplay_, ref mood_, hud_);
                                    gameplay_.CheckPV(moteurgraphique_, hud_);
                                }
                            }
                        }
                    }
                }
            }
            #endregion
        }
        public void checkContenuDansPorteeMoyenJoute(MoteurGraphique moteurgraphique_, int portee_, Unite moi_, SystemeDeJeu gameplay_, Armee armee_, HUD hud_)
        {
            //cible : gameplay_.armees[moteurgraphique_.map[i_, j_].pointeurArmee].bataillon[moteurgraphique_.map[i_, j_].pointeurUnite]
            List<Unite> ciblesPotentielles = new List<Unite>();
            List<int> porteesPotentielles = new List<int>();

            #region boucleTestCiblesPotentielles
            if (moi_.attaqOrNot)
            {
                for (int k = 0; k < portee_; k++)
                {
                    if (moi_.i + k >= 0 && moi_.i + k < moteurgraphique_.longueur
                        && moi_.j + (portee_ - k) >= 0 && moi_.j + (portee_ - k) < moteurgraphique_.largeur)
                    {
                        if (moteurgraphique_.map[moi_.i + k, moi_.j + (portee_ - k)].presence &&
                                gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i, moi_.j].pointeurArmee].camp != gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i + k, moi_.j + (portee_ - k)].pointeurArmee].camp)
                        {
                            ciblesPotentielles.Add(gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i + k, moi_.j + (portee_ - k)].pointeurArmee].
                                bataillon[moteurgraphique_.map[moi_.i + k, moi_.j + (portee_ - k)].pointeurUnite]);
                            porteesPotentielles.Add(portee_);
                        }
                    }
                    if (moi_.i - k >= 0 && moi_.i - k < moteurgraphique_.longueur
                         && moi_.j - (portee_ - k) >= 0 && moi_.j - (portee_ - k) < moteurgraphique_.largeur)
                    {
                        if (moteurgraphique_.map[moi_.i - k, moi_.j - (portee_ - k)].presence &&
                                gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i, moi_.j].pointeurArmee].camp != gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i - k, moi_.j - (portee_ - k)].pointeurArmee].camp)
                        {
                            ciblesPotentielles.Add(gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i - k, moi_.j - (portee_ - k)].pointeurArmee].
                                bataillon[moteurgraphique_.map[moi_.i - k, moi_.j - (portee_ - k)].pointeurUnite]);
                            porteesPotentielles.Add(portee_);
                        }
                    }
                    if (moi_.i + (portee_ - k) >= 0 && moi_.i + (portee_ - k) < moteurgraphique_.longueur
                         && moi_.j - k >= 0 && moi_.j - k < moteurgraphique_.largeur)
                    {
                        if (moteurgraphique_.map[moi_.i + (portee_ - k), moi_.j - k].presence &&
                                gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i, moi_.j].pointeurArmee].camp != gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i + (portee_ - k), moi_.j - k].pointeurArmee].camp)
                        {
                            ciblesPotentielles.Add(gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i + (portee_ - k), moi_.j - k].pointeurArmee].
                                bataillon[moteurgraphique_.map[moi_.i + (portee_ - k), moi_.j - k].pointeurUnite]);
                            porteesPotentielles.Add(portee_);
                        }
                    }
                    if (moi_.i - (portee_ - k) >= 0 && moi_.i - (portee_ - k) < moteurgraphique_.longueur
                         && moi_.j + k >= 0 && moi_.j + k < moteurgraphique_.largeur)
                    {
                        if (moteurgraphique_.map[moi_.i - (portee_ - k), moi_.j + k].presence &&
                                gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i, moi_.j].pointeurArmee].camp != gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i - (portee_ - k), moi_.j + k].pointeurArmee].camp)
                        {
                            ciblesPotentielles.Add(gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i - (portee_ - k), moi_.j + k].pointeurArmee].
                                bataillon[moteurgraphique_.map[moi_.i - (portee_ - k), moi_.j + k].pointeurUnite]);
                            porteesPotentielles.Add(portee_);
                        }
                    }
                }

                for (int i = 0; i < ciblesPotentielles.Count - 1; i++)
                {
                    if (!ciblesPotentielles[i].alive)
                    {
                        ciblesPotentielles.RemoveAt(i);
                        porteesPotentielles.RemoveAt(i);
                    }
                }

            #endregion

                #region attaqueEfficacementUniteAvecLaMeilleurePrecisionEtLeMoinsDePV

                for (int w = ciblesPotentielles.Count - 1; w >= 0; w--)
                {
                    if (moi_.typedAttaque[porteesPotentielles[w]] == true)
                    {
                        if (moi_.attaque + moi_.bonusAttaque <= ciblesPotentielles[w].armure + ciblesPotentielles[w].bonusArmure)
                        {
                            ciblesPotentielles.RemoveAt(w);
                            porteesPotentielles.RemoveAt(w);
                        }
                    }
                    else
                    {
                        if (moi_.attaque + moi_.bonusresistance <= ciblesPotentielles[w].resistance + ciblesPotentielles[w].bonusresistance)
                        {
                            ciblesPotentielles.RemoveAt(w);
                            porteesPotentielles.RemoveAt(w);
                        }
                    }
                }

                while (ciblesPotentielles.Count > 1)
                {
                    for (int j = 0; j < ciblesPotentielles.Count - 1; j++)
                    {
                        if (ciblesPotentielles[j].pvactuel < ciblesPotentielles[j + 1].pvactuel)
                        {
                            ciblesPotentielles.RemoveAt(j + 1);
                            porteesPotentielles.RemoveAt(j + 1);
                        }
                        else
                        {
                            ciblesPotentielles.RemoveAt(j);
                            porteesPotentielles.RemoveAt(j);
                        }
                    }
                }

                if (ciblesPotentielles.Count > 0)
                {
                    moi_.Initiative(ciblesPotentielles[0], porteesPotentielles[0], moteurgraphique_, gameplay_, ref gameplay_.mood, hud_);
                }
            }
                #endregion
        }
Exemplo n.º 29
0
        public void Frappe(Unite ennemi_, int porteeDeFrappe_, MoteurGraphique moteurgraphique_, SystemeDeJeu gameplay_, HUD hud_)
        {
            string txt1;
            int dgts1;
            Color clr1;
            e_race race1;
            #region frapper
            if (typedAttaque[porteeDeFrappe_])
            {
                //type dattaque : physique si typedAttaque[porteedeFrappe]= vrai
                #region Physique
                if ((precision + bonusprecision) * portee[porteeDeFrappe_] / 10 - ennemi_.esquive >= (r.Next(1000) % 100))
                {
                    if (r.Next(1000) % 100 < (coupcritique + bonusCoupcritique))
                    {
                        if (ennemi_.armure < (attaque + bonusAttaque) * 2)
                        {
                            ennemi_.pvactuel -= ((attaque + bonusAttaque) * 2 - ennemi_.armure);
                            txt1 = "Coup Critique !!";
                            dgts1 = ((attaque + bonusAttaque) * 2 - ennemi_.armure);
                        }
                        else
                        {
                            txt1 = "  Inefficace !  ";
                            dgts1 = 0;
                        }
                    }
                    else
                    {
                        if (ennemi_.armure < (attaque + bonusAttaque))
                        {
                            ennemi_.pvactuel -= ((attaque + bonusAttaque) - ennemi_.armure);
                            txt1 = "    Attaque !   ";
                            dgts1 = ((attaque + bonusAttaque) - ennemi_.armure);
                        }
                        else
                        {
                            txt1 = "  Inefficace !  ";
                            dgts1 = 0;
                        }
                    }

                    xp += 3;
                    ennemi_.xp += 1;
                }
                else
                {
                    xp += 1;
                    if (portee[porteeDeFrappe_] == 0)
                    {
                        txt1 = "   Trop loin !  ";
                        dgts1 = 0;
                    }
                    else
                    {
                        txt1 = "      Rate !    ";
                        dgts1 = 0;
                    }
                }
                #endregion
            }
            else
            {
                #region magique
                if ((precision + bonusprecision) * portee[porteeDeFrappe_] / 10 - ennemi_.esquive >= (r.Next(1000) % 100))
                {
                    if (r.Next(1000) % 100 < (coupcritique + bonusCoupcritique))
                    {
                        if (ennemi_.resistance < (puissance + bonuspuissance) * 2)
                        {
                            ennemi_.pvactuel -= ((puissance + bonuspuissance) * 2 - ennemi_.resistance);
                            txt1 = "Coup Critique !!";
                            dgts1 = ((puissance + bonuspuissance) * 2 - ennemi_.armure);
                        }
                        else
                        {
                            txt1 = "  Inefficace !  ";
                            dgts1 = 0;
                        }
                    }
                    else
                    {
                        if (ennemi_.resistance < (puissance + bonuspuissance))
                        {
                            ennemi_.pvactuel -= ((puissance + bonuspuissance) - ennemi_.resistance);
                            txt1 = "    Attaque !   ";
                            dgts1 = ((puissance + bonuspuissance) - ennemi_.armure);
                        }
                        else
                        {
                            txt1 = "  Inefficace !  ";
                            dgts1 = 0;
                        }
                    }

                    xp += 3;
                    ennemi_.xp += 1;
                }
                else
                {
                    xp += 1;
                    if (portee[porteeDeFrappe_] == 0)
                    {
                        txt1 = "   Trop loin !  ";
                        dgts1 = 0;
                    }
                    else
                    {
                        txt1 = "      Rate !    ";
                        dgts1 = 0;
                    }
                }
                #endregion
            }
            #endregion
            clr1 = gameplay_.listeDesJoueurs[numeroArmee].couleur;
            race1 = gameplay_.listeDesJoueurs[numeroArmee].espece;
            ennemi_.Riposte(this, porteeDeFrappe_, moteurgraphique_, gameplay_, txt1, dgts1, clr1, race1, hud_);
        }
        public void deplacementDifficileJoute(MoteurGraphique moteurgraphique_, Unite moi_, SystemeDeJeu gameplay_, Armee armee_, HUD hud_)
        {
            dejaBienPlace = false;
            ilABouger = false;
            bool yaUnEnnemiFaible = false;
            List<Unite> unitesEnnemis = new List<Unite>();
            List<int> distanceAvecEnnemis = new List<int>();
            List<Vector2> positionsEnnemies = new List<Vector2>();
            List<Unite> unitesAlliees = new List<Unite>();
            List<int> distanceAvecAlliees = new List<int>();
            List<Vector2> positionsAlliees = new List<Vector2>();
            List<int> porteesDeMeilleuresPrecisionsPouvoir = new List<int>();
            int porteeMaxPouvoir = 0;

            #region obtenirPorteeMaxPouvoir

            if (moi_.typeUnite == e_typeUnite.Elite)
            {
                for (int carapuce = 0; carapuce < moi_.SHORYUKEN.porteePouvoir.Count; carapuce++)
                {
                    if (moi_.SHORYUKEN.porteePouvoir[carapuce] > porteeMaxPouvoir)
                    {
                        porteeMaxPouvoir = moi_.SHORYUKEN.porteePouvoir[carapuce];
                    }
                }
            }
            #endregion

            #region ajouterToutesLesUnitesEnnemies

            for (int wazaaa = 0; wazaaa < gameplay_.listeDesJoueurs.Count; wazaaa++)
            {
                if (gameplay_.listeDesJoueurs[wazaaa].camp != gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i, moi_.j].pointeurArmee].camp)
                {
                    foreach (Unite unite in gameplay_.listeDesJoueurs[wazaaa].bataillon)
                    {
                        if (unite.alive && Math.Abs(moi_.i - unite.i) + Math.Abs(moi_.j - unite.j) <= (moi_.mouvement + porteeMaxPouvoir))
                        {
                            unitesEnnemis.Add(unite);
                            distanceAvecEnnemis.Add(Math.Abs(moi_.i - unite.i) + Math.Abs(moi_.j - unite.j));
                            positionsEnnemies.Add(new Vector2(unite.i, unite.j));
                        }
                    }
                }
            }

            #endregion

            #region ajouterToutesLesUnitesAlliees

            foreach (Unite bulbizarre in gameplay_.listeDesJoueurs[moteurgraphique_.map[moi_.i, moi_.j].pointeurArmee].bataillon)
            {
                unitesAlliees.Add(bulbizarre);
                distanceAvecAlliees.Add(Math.Abs((moi_.i - bulbizarre.i) + (moi_.j - bulbizarre.j)));
                positionsAlliees.Add(new Vector2(bulbizarre.i, bulbizarre.j));
            }

            #endregion

            if (moi_.typeUnite == e_typeUnite.Elite)
            {
                for (int f = 10; f > 0; f--)
                {
                    for (int g = moi_.SHORYUKEN.porteePouvoir.Count - 1; g >= 0; g--)
                    {
                        if (moi_.SHORYUKEN.porteePouvoir[g] == f)
                        {
                            porteesDeMeilleuresPrecisionsPouvoir.Add(g);
                        }
                    }
                }
            }

            if (ilABouger == false && dejaBienPlace == false)
            {
                if (moi_.typeUnite == e_typeUnite.Elite && moi_.energieactuel >= moi_.SHORYUKEN.coutEnergie)
                {
                    if (moi_.SHORYUKEN.type == e_typeDePouvoir.Degat)
                    {
                        #region trouverEnnemiLeMieuxPlace

                        if (moi_.SHORYUKEN.vertical == false)
                        {
                            #region preTestDuLosange

                            for (int i = distanceAvecEnnemis.Count - 1; i >= 0; i--)
                            {
                                ilAFaussementBouger = false;

                                for (int n = porteesDeMeilleuresPrecisionsPouvoir.Count - 1; n > 0; n--)
                                {
                                    for (int j = 0; j <= porteesDeMeilleuresPrecisionsPouvoir[n] - 1; j++)
                                    {
                                        if (porteesDeMeilleuresPrecisionsPouvoir[n] == distanceAvecEnnemis[i])
                                        {
                                            ilAFaussementBouger = true;
                                        }
                                        else
                                        {
                                            if ((int)positionsEnnemies[i].X + j >= 0 && (int)positionsEnnemies[i].X + j < moteurgraphique_.longueur &&
                                                (int)positionsEnnemies[i].Y + (porteesDeMeilleuresPrecisionsPouvoir[n] - j) >= 0 && (int)positionsEnnemies[i].Y + (porteesDeMeilleuresPrecisionsPouvoir[n] - j) < moteurgraphique_.largeur)
                                            {
                                                if (moteurgraphique_.map[(int)positionsEnnemies[i].X + j, (int)positionsEnnemies[i].Y + (porteesDeMeilleuresPrecisionsPouvoir[n] - j)].cheminValid)
                                                {
                                                    ilAFaussementBouger = true;
                                                }
                                                else if ((int)positionsEnnemies[i].X - j >= 0 && (int)positionsEnnemies[i].X - j < moteurgraphique_.longueur &&
                                                         (int)positionsEnnemies[i].Y - (porteesDeMeilleuresPrecisionsPouvoir[n] - j) >= 0 && (int)positionsEnnemies[i].Y - (porteesDeMeilleuresPrecisionsPouvoir[n] - j) < moteurgraphique_.largeur)
                                                {
                                                    if (moteurgraphique_.map[(int)positionsEnnemies[i].X - j, (int)positionsEnnemies[i].Y - (porteesDeMeilleuresPrecisionsPouvoir[n] - j)].cheminValid)
                                                    {
                                                        ilAFaussementBouger = true;
                                                    }
                                                    else if ((int)positionsEnnemies[i].X + (porteesDeMeilleuresPrecisionsPouvoir[n] - j) >= 0 && (int)positionsEnnemies[i].X + (porteesDeMeilleuresPrecisionsPouvoir[n] - j) < moteurgraphique_.longueur &&
                                                             (int)positionsEnnemies[i].Y - j >= 0 && (int)positionsEnnemies[i].Y - j < moteurgraphique_.largeur)
                                                    {
                                                        if (moteurgraphique_.map[(int)positionsEnnemies[i].X + (porteesDeMeilleuresPrecisionsPouvoir[n] - j), (int)positionsEnnemies[i].Y - j].cheminValid)
                                                        {
                                                            ilAFaussementBouger = true;
                                                        }
                                                        else if ((int)positionsEnnemies[i].X - (porteesDeMeilleuresPrecisionsPouvoir[n] - j) >= 0 && (int)positionsEnnemies[i].X - (porteesDeMeilleuresPrecisionsPouvoir[n] - j) < moteurgraphique_.longueur &&
                                                                 (int)positionsEnnemies[i].Y + j >= 0 && (int)positionsEnnemies[i].Y + j < moteurgraphique_.largeur)
                                                        {
                                                            if (moteurgraphique_.map[(int)positionsEnnemies[i].X - (porteesDeMeilleuresPrecisionsPouvoir[n] - j), (int)positionsEnnemies[i].Y + j].cheminValid)
                                                            {
                                                                ilAFaussementBouger = true;
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }

                                if (ilAFaussementBouger == false)
                                {
                                    distanceAvecEnnemis.RemoveAt(i);
                                    unitesEnnemis.RemoveAt(i);
                                    positionsEnnemies.RemoveAt(i);
                                }
                            }
                            #endregion
                        }
                        else
                        {
                            #region preTestDeLaLigneDroite

                            for (int salameche = distanceAvecEnnemis.Count - 1; salameche >= 0; salameche--)
                            {
                                ilAFaussementBouger = false;
                                for (int reptincel = porteesDeMeilleuresPrecisionsPouvoir.Count - 1; reptincel >= 0; reptincel--)
                                {
                                    if (porteesDeMeilleuresPrecisionsPouvoir[reptincel] == distanceAvecEnnemis[salameche] && (moi_.i == unitesEnnemis[salameche].i || moi_.j == unitesEnnemis[salameche].j))
                                    {
                                        ilAFaussementBouger = true;
                                    }
                                    else if ((int)positionsEnnemies[salameche].X + porteesDeMeilleuresPrecisionsPouvoir[reptincel] >= 0 && (int)positionsEnnemies[salameche].X + porteesDeMeilleuresPrecisionsPouvoir[reptincel] < moteurgraphique_.longueur)
                                    {
                                        if (moteurgraphique_.map[(int)positionsEnnemies[salameche].X + porteesDeMeilleuresPrecisionsPouvoir[reptincel], moi_.j].cheminValid)
                                        {
                                            ilAFaussementBouger = true;
                                        }
                                        else if ((int)positionsEnnemies[salameche].X - porteesDeMeilleuresPrecisionsPouvoir[reptincel] >= 0 && (int)positionsEnnemies[salameche].X - porteesDeMeilleuresPrecisionsPouvoir[reptincel] < moteurgraphique_.longueur)
                                        {
                                            if (moteurgraphique_.map[(int)positionsEnnemies[salameche].X - porteesDeMeilleuresPrecisionsPouvoir[reptincel], moi_.j].cheminValid)
                                            {
                                                ilAFaussementBouger = true;
                                            }
                                            else if ((int)positionsEnnemies[salameche].Y + porteesDeMeilleuresPrecisionsPouvoir[reptincel] >= 0 && (int)positionsEnnemies[salameche].Y + porteesDeMeilleuresPrecisionsPouvoir[reptincel] < moteurgraphique_.largeur)
                                            {
                                                if (moteurgraphique_.map[moi_.i, (int)positionsEnnemies[salameche].Y + porteesDeMeilleuresPrecisionsPouvoir[reptincel]].cheminValid)
                                                {
                                                    ilAFaussementBouger = true;
                                                }
                                                else if ((int)positionsEnnemies[salameche].Y - porteesDeMeilleuresPrecisionsPouvoir[reptincel] >= 0 && (int)positionsEnnemies[salameche].Y - porteesDeMeilleuresPrecisionsPouvoir[reptincel] < moteurgraphique_.largeur)
                                                {
                                                    if (moteurgraphique_.map[moi_.i, (int)positionsEnnemies[salameche].Y - porteesDeMeilleuresPrecisionsPouvoir[reptincel]].cheminValid)
                                                    {
                                                        ilAFaussementBouger = true;
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                if (ilAFaussementBouger == false)
                                {
                                    distanceAvecEnnemis.RemoveAt(salameche);
                                    unitesEnnemis.RemoveAt(salameche);
                                    positionsEnnemies.RemoveAt(salameche);
                                }
                            }
                            #endregion
                        }

                        #region avoirPlusQuUnEnnemi

                        while (distanceAvecEnnemis.Count > 1)
                        {
                            for (int i = distanceAvecEnnemis.Count - 2; i >= 0; i--)
                            {
                                if (gameplay_.listeDesJoueurs[moteurgraphique_.map[(int)positionsEnnemies[i].X, (int)positionsEnnemies[i].Y].pointeurArmee].bataillon[moteurgraphique_.map[(int)positionsEnnemies[i].X, (int)positionsEnnemies[i].Y].pointeurUnite].pvactuel <
                                    gameplay_.listeDesJoueurs[moteurgraphique_.map[(int)positionsEnnemies[i + 1].X, (int)positionsEnnemies[i + 1].Y].pointeurArmee].bataillon[moteurgraphique_.map[(int)positionsEnnemies[i + 1].X, (int)positionsEnnemies[i + 1].Y].pointeurUnite].pvactuel)
                                {
                                    unitesEnnemis.RemoveAt(i + 1);
                                    positionsEnnemies.RemoveAt(i + 1);
                                    distanceAvecEnnemis.RemoveAt(i + 1);
                                }
                                else if (gameplay_.listeDesJoueurs[moteurgraphique_.map[(int)positionsEnnemies[i].X, (int)positionsEnnemies[i].Y].pointeurArmee].bataillon[moteurgraphique_.map[(int)positionsEnnemies[i].X, (int)positionsEnnemies[i].Y].pointeurUnite].pvactuel >
                                         gameplay_.listeDesJoueurs[moteurgraphique_.map[(int)positionsEnnemies[i + 1].X, (int)positionsEnnemies[i + 1].Y].pointeurArmee].bataillon[moteurgraphique_.map[(int)positionsEnnemies[i + 1].X, (int)positionsEnnemies[i + 1].Y].pointeurUnite].pvactuel)
                                {
                                    unitesEnnemis.RemoveAt(i);
                                    positionsEnnemies.RemoveAt(i);
                                    distanceAvecEnnemis.RemoveAt(i);
                                }
                                else
                                {
                                    if (gameplay_.listeDesJoueurs[moteurgraphique_.map[(int)positionsEnnemies[i].X, (int)positionsEnnemies[i].Y].pointeurArmee].bataillon[moteurgraphique_.map[(int)positionsEnnemies[i].X, (int)positionsEnnemies[i].Y].pointeurUnite].typeUnite == e_typeUnite.Elite)
                                    {
                                        unitesEnnemis.RemoveAt(i + 1);
                                        positionsEnnemies.RemoveAt(i + 1);
                                        distanceAvecEnnemis.RemoveAt(i + 1);
                                    }
                                    else if (gameplay_.listeDesJoueurs[moteurgraphique_.map[(int)positionsEnnemies[i + 1].X, (int)positionsEnnemies[i + 1].Y].pointeurArmee].bataillon[moteurgraphique_.map[(int)positionsEnnemies[i + 1].X, (int)positionsEnnemies[i + 1].Y].pointeurUnite].typeUnite == e_typeUnite.Elite)
                                    {
                                        unitesEnnemis.RemoveAt(i);
                                        positionsEnnemies.RemoveAt(i);
                                        distanceAvecEnnemis.RemoveAt(i);
                                    }
                                    else
                                    {
                                        unitesEnnemis.RemoveAt(i);
                                        positionsEnnemies.RemoveAt(i);
                                        distanceAvecEnnemis.RemoveAt(i);
                                    }
                                }
                            }
                        }
                        #endregion

                        #endregion

                        #region deplacementVersEnnemiLePlusPratique

                        if (distanceAvecEnnemis.Count > 0)
                        {
                            if (moi_.SHORYUKEN.vertical == false)
                            {
                                #region seMettreALaMeilleurePorteeLosange

                                for (int i = 0; i < porteesDeMeilleuresPrecisionsPouvoir.Count; i++)
                                {
                                    for (int j = 0; j <= porteesDeMeilleuresPrecisionsPouvoir[i] - 1; j++)
                                    {
                                        if (ilABouger == false && dejaBienPlace == false)
                                        {
                                            if (porteesDeMeilleuresPrecisionsPouvoir[i] == distanceAvecEnnemis[0])
                                            {
                                                dejaBienPlace = true;
                                                moi_.SHORYUKEN.UtiliserPouvoir(moi_, moteurgraphique_, gameplay_, unitesEnnemis[0].i, unitesEnnemis[0].j, ref gameplay_.mood, hud_);
                                            }
                                            else
                                            {
                                                if ((int)positionsEnnemies[0].X + j >= 0 && (int)positionsEnnemies[0].X + j < moteurgraphique_.longueur &&
                                                    (int)positionsEnnemies[0].Y + (porteesDeMeilleuresPrecisionsPouvoir[i] - j) >= 0 && (int)positionsEnnemies[0].Y + (porteesDeMeilleuresPrecisionsPouvoir[i] - j) < moteurgraphique_.largeur)
                                                {
                                                    if (moteurgraphique_.map[(int)positionsEnnemies[0].X + j, (int)positionsEnnemies[0].Y + (porteesDeMeilleuresPrecisionsPouvoir[i] - j)].cheminValid)
                                                    {
                                                        ilABouger = true;
                                                        moi_.PathFindingLoohy(moteurgraphique_, (int)positionsEnnemies[0].X + j, (int)positionsEnnemies[0].Y + (porteesDeMeilleuresPrecisionsPouvoir[i] - j));
                                                    }
                                                    else if ((int)positionsEnnemies[0].X - j >= 0 && (int)positionsEnnemies[0].X - j < moteurgraphique_.longueur &&
                                                             (int)positionsEnnemies[0].Y - (porteesDeMeilleuresPrecisionsPouvoir[i] - j) >= 0 && (int)positionsEnnemies[0].Y - (porteesDeMeilleuresPrecisionsPouvoir[i] - j) < moteurgraphique_.largeur)
                                                    {
                                                        if (moteurgraphique_.map[(int)positionsEnnemies[0].X - j, (int)positionsEnnemies[0].Y - (porteesDeMeilleuresPrecisionsPouvoir[i] - j)].cheminValid)
                                                        {
                                                            ilABouger = true;
                                                            moi_.PathFindingLoohy(moteurgraphique_, (int)positionsEnnemies[0].X - j, (int)positionsEnnemies[0].Y - (porteesDeMeilleuresPrecisionsPouvoir[i] - j));
                                                        }
                                                        else if ((int)positionsEnnemies[0].X + (porteesDeMeilleuresPrecisionsPouvoir[i] - j) >= 0 && (int)positionsEnnemies[0].X + (porteesDeMeilleuresPrecisionsPouvoir[i] - j) < moteurgraphique_.longueur &&
                                                                 (int)positionsEnnemies[0].Y - j >= 0 && (int)positionsEnnemies[0].Y - j < moteurgraphique_.largeur)
                                                        {
                                                            if (moteurgraphique_.map[(int)positionsEnnemies[0].X + (porteesDeMeilleuresPrecisionsPouvoir[i] - j), (int)positionsEnnemies[0].Y - j].cheminValid)
                                                            {
                                                                ilABouger = true;
                                                                moi_.PathFindingLoohy(moteurgraphique_, (int)positionsEnnemies[0].X + (porteesDeMeilleuresPrecisionsPouvoir[i] - j), (int)positionsEnnemies[0].Y - j);
                                                            }
                                                            else if ((int)positionsEnnemies[0].X - (porteesDeMeilleuresPrecisionsPouvoir[i] - j) >= 0 && (int)positionsEnnemies[0].X - (porteesDeMeilleuresPrecisionsPouvoir[i] - j) < moteurgraphique_.longueur &&
                                                                     (int)positionsEnnemies[0].Y + j >= 0 && (int)positionsEnnemies[0].Y + j < moteurgraphique_.largeur)
                                                            {
                                                                if (moteurgraphique_.map[(int)positionsEnnemies[0].X - (porteesDeMeilleuresPrecisionsPouvoir[i] - j), (int)positionsEnnemies[0].Y + j].cheminValid)
                                                                {
                                                                    ilABouger = true;
                                                                    moi_.PathFindingLoohy(moteurgraphique_, (int)positionsEnnemies[0].X - (porteesDeMeilleuresPrecisionsPouvoir[i] - j), (int)positionsEnnemies[0].Y + j);
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                #endregion
                            }
                            else
                            {
                                #region seMettreALaMeilleurePorteeDroite

                                for (int raichu = porteesDeMeilleuresPrecisionsPouvoir.Count - 1; raichu >= 0; raichu--)
                                {
                                    if (porteesDeMeilleuresPrecisionsPouvoir[raichu] == distanceAvecEnnemis[0] && (moi_.i == unitesEnnemis[0].i || moi_.j == unitesEnnemis[0].j))
                                    {
                                        dejaBienPlace = true;
                                        moi_.SHORYUKEN.UtiliserPouvoir(moi_, moteurgraphique_, gameplay_, unitesEnnemis[0].i, unitesEnnemis[0].j, ref gameplay_.mood, hud_);
                                    }
                                    else if ((int)positionsEnnemies[0].X + porteesDeMeilleuresPrecisionsPouvoir[raichu] >= 0 && (int)positionsEnnemies[0].X + porteesDeMeilleuresPrecisionsPouvoir[raichu] < moteurgraphique_.longueur)
                                    {
                                        if (moteurgraphique_.map[(int)positionsEnnemies[0].X + porteesDeMeilleuresPrecisionsPouvoir[raichu], moi_.j].cheminValid)
                                        {
                                            ilABouger = true;
                                            moi_.PathFindingLoohy(moteurgraphique_, (int)positionsEnnemies[0].X + porteesDeMeilleuresPrecisionsPouvoir[raichu], moi_.j);
                                        }
                                        else if ((int)positionsEnnemies[0].X - porteesDeMeilleuresPrecisionsPouvoir[raichu] >= 0 && (int)positionsEnnemies[0].X - porteesDeMeilleuresPrecisionsPouvoir[raichu] < moteurgraphique_.longueur)
                                        {
                                            if (moteurgraphique_.map[(int)positionsEnnemies[0].X - porteesDeMeilleuresPrecisionsPouvoir[raichu], moi_.j].cheminValid)
                                            {
                                                ilABouger = true;
                                                moi_.PathFindingLoohy(moteurgraphique_, (int)positionsEnnemies[0].X - porteesDeMeilleuresPrecisionsPouvoir[raichu], moi_.j);
                                            }
                                            else if ((int)positionsEnnemies[0].Y + porteesDeMeilleuresPrecisionsPouvoir[raichu] >= 0 && (int)positionsEnnemies[0].Y + porteesDeMeilleuresPrecisionsPouvoir[raichu] < moteurgraphique_.largeur)
                                            {
                                                if (moteurgraphique_.map[moi_.i, (int)positionsEnnemies[0].Y + porteesDeMeilleuresPrecisionsPouvoir[raichu]].cheminValid)
                                                {
                                                    ilABouger = true;
                                                    moi_.PathFindingLoohy(moteurgraphique_, moi_.i, (int)positionsEnnemies[0].Y + porteesDeMeilleuresPrecisionsPouvoir[raichu]);
                                                }
                                                else if ((int)positionsEnnemies[0].Y - porteesDeMeilleuresPrecisionsPouvoir[raichu] >= 0 && (int)positionsEnnemies[0].Y - porteesDeMeilleuresPrecisionsPouvoir[raichu] < moteurgraphique_.largeur)
                                                {
                                                    if (moteurgraphique_.map[moi_.i, (int)positionsEnnemies[0].Y - porteesDeMeilleuresPrecisionsPouvoir[raichu]].cheminValid)
                                                    {
                                                        ilABouger = true;
                                                        moi_.PathFindingLoohy(moteurgraphique_, moi_.i, (int)positionsEnnemies[0].Y - porteesDeMeilleuresPrecisionsPouvoir[raichu]);
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                #endregion
                            }
                        }
                        #endregion
                    }
                    else
                    {
                        for (int alakazam = 0; alakazam < unitesAlliees.Count; alakazam++)
                        {
                            if (unitesAlliees[alakazam].pvactuel < unitesAlliees[alakazam].pvmax / 2)
                            {
                                yaUnEnnemiFaible = true;
                            }
                        }

                        if (yaUnEnnemiFaible)
                        {
                            #region trouverAllieLeMieuxPlace

                            #region preTestDuLosange

                            for (int i = distanceAvecAlliees.Count - 1; i >= 0; i--)
                            {
                                ilAFaussementBouger = false;

                                for (int n = porteesDeMeilleuresPrecisionsPouvoir.Count - 1; n >= 0; n--)
                                {
                                    for (int j = 0; j <= porteesDeMeilleuresPrecisionsPouvoir[n] - 1; j++)
                                    {
                                        if (porteesDeMeilleuresPrecisionsPouvoir[n] == distanceAvecAlliees[i])
                                        {
                                            ilAFaussementBouger = true;
                                        }
                                        else
                                        {
                                            if ((int)positionsAlliees[i].X + j >= 0 && (int)positionsAlliees[i].X + j < moteurgraphique_.longueur &&
                                                (int)positionsAlliees[i].Y + (porteesDeMeilleuresPrecisionsPouvoir[n] - j) >= 0 && (int)positionsAlliees[i].Y + (porteesDeMeilleuresPrecisionsPouvoir[n] - j) < moteurgraphique_.largeur)
                                            {
                                                if (moteurgraphique_.map[(int)positionsAlliees[i].X + j, (int)positionsAlliees[i].Y + (porteesDeMeilleuresPrecisionsPouvoir[n] - j)].cheminValid)
                                                {
                                                    ilAFaussementBouger = true;
                                                }
                                                else if ((int)positionsAlliees[i].X - j >= 0 && (int)positionsAlliees[i].X - j < moteurgraphique_.longueur &&
                                                         (int)positionsAlliees[i].Y - (porteesDeMeilleuresPrecisionsPouvoir[n] - j) >= 0 && (int)positionsAlliees[i].Y - (porteesDeMeilleuresPrecisionsPouvoir[n] - j) < moteurgraphique_.largeur)
                                                {
                                                    if (moteurgraphique_.map[(int)positionsAlliees[i].X - j, (int)positionsAlliees[i].Y - (porteesDeMeilleuresPrecisionsPouvoir[n] - j)].cheminValid)
                                                    {
                                                        ilAFaussementBouger = true;
                                                    }
                                                    else if ((int)positionsAlliees[i].X + (porteesDeMeilleuresPrecisionsPouvoir[n] - j) >= 0 && (int)positionsAlliees[i].X + (porteesDeMeilleuresPrecisionsPouvoir[n] - j) < moteurgraphique_.longueur &&
                                                             (int)positionsAlliees[i].Y - j >= 0 && (int)positionsAlliees[i].Y - j < moteurgraphique_.largeur)
                                                    {
                                                        if (moteurgraphique_.map[(int)positionsAlliees[i].X + (porteesDeMeilleuresPrecisionsPouvoir[n] - j), (int)positionsAlliees[i].Y - j].cheminValid)
                                                        {
                                                            ilAFaussementBouger = true;
                                                        }
                                                        else if ((int)positionsAlliees[i].X - (porteesDeMeilleuresPrecisionsPouvoir[n] - j) >= 0 && (int)positionsAlliees[i].X - (porteesDeMeilleuresPrecisionsPouvoir[n] - j) < moteurgraphique_.longueur &&
                                                                 (int)positionsAlliees[i].Y + j >= 0 && (int)positionsAlliees[i].Y + j < moteurgraphique_.largeur)
                                                        {
                                                            if (moteurgraphique_.map[(int)positionsAlliees[i].X - (porteesDeMeilleuresPrecisionsPouvoir[n] - j), (int)positionsAlliees[i].Y + j].cheminValid)
                                                            {
                                                                ilAFaussementBouger = true;
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }

                                if (ilAFaussementBouger == false)
                                {
                                    distanceAvecAlliees.RemoveAt(i);
                                    unitesAlliees.RemoveAt(i);
                                    positionsAlliees.RemoveAt(i);
                                }
                            }
                            #endregion

                            #region avoirPlusQuUnEnnemi

                            for (int leveinard = unitesAlliees.Count - 1; leveinard >= 0; leveinard--)
                            {
                                if (!unitesAlliees[leveinard].alive)
                                {
                                    unitesAlliees.RemoveAt(leveinard);
                                    positionsAlliees.RemoveAt(leveinard);
                                    distanceAvecAlliees.RemoveAt(leveinard);
                                }
                            }

                            while (distanceAvecAlliees.Count > 1)
                            {
                                for (int i = distanceAvecAlliees.Count - 2; i >= 0; i--)
                                {
                                    if (gameplay_.listeDesJoueurs[moteurgraphique_.map[(int)positionsAlliees[i].X, (int)positionsAlliees[i].Y].pointeurArmee].bataillon[moteurgraphique_.map[(int)positionsAlliees[i].X, (int)positionsAlliees[i].Y].pointeurUnite].pvactuel <
                                        gameplay_.listeDesJoueurs[moteurgraphique_.map[(int)positionsAlliees[i + 1].X, (int)positionsAlliees[i + 1].Y].pointeurArmee].bataillon[moteurgraphique_.map[(int)positionsAlliees[i + 1].X, (int)positionsAlliees[i + 1].Y].pointeurUnite].pvactuel)
                                    {
                                        unitesAlliees.RemoveAt(i + 1);
                                        positionsAlliees.RemoveAt(i + 1);
                                        distanceAvecAlliees.RemoveAt(i + 1);
                                    }
                                    else if (gameplay_.listeDesJoueurs[moteurgraphique_.map[(int)positionsAlliees[i].X, (int)positionsAlliees[i].Y].pointeurArmee].bataillon[moteurgraphique_.map[(int)positionsAlliees[i].X, (int)positionsAlliees[i].Y].pointeurUnite].pvactuel <
                                             gameplay_.listeDesJoueurs[moteurgraphique_.map[(int)positionsAlliees[i + 1].X, (int)positionsAlliees[i + 1].Y].pointeurArmee].bataillon[moteurgraphique_.map[(int)positionsAlliees[i + 1].X, (int)positionsAlliees[i + 1].Y].pointeurUnite].pvactuel)
                                    {
                                        unitesAlliees.RemoveAt(i);
                                        positionsAlliees.RemoveAt(i);
                                        distanceAvecAlliees.RemoveAt(i);
                                    }
                                    else
                                    {
                                        if (gameplay_.listeDesJoueurs[moteurgraphique_.map[(int)positionsAlliees[i].X, (int)positionsAlliees[i].Y].pointeurArmee].bataillon[moteurgraphique_.map[(int)positionsAlliees[i].X, (int)positionsAlliees[i].Y].pointeurUnite].typeUnite == e_typeUnite.Elite)
                                        {
                                            unitesAlliees.RemoveAt(i + 1);
                                            positionsAlliees.RemoveAt(i + 1);
                                            distanceAvecAlliees.RemoveAt(i + 1);
                                        }
                                        else if (gameplay_.listeDesJoueurs[moteurgraphique_.map[(int)positionsAlliees[i + 1].X, (int)positionsAlliees[i + 1].Y].pointeurArmee].bataillon[moteurgraphique_.map[(int)positionsAlliees[i + 1].X, (int)positionsAlliees[i + 1].Y].pointeurUnite].typeUnite == e_typeUnite.Elite)
                                        {
                                            unitesAlliees.RemoveAt(i);
                                            positionsAlliees.RemoveAt(i);
                                            distanceAvecAlliees.RemoveAt(i);
                                        }
                                        else
                                        {
                                            unitesAlliees.RemoveAt(i);
                                            positionsAlliees.RemoveAt(i);
                                            distanceAvecAlliees.RemoveAt(i);
                                        }
                                    }
                                }
                            }
                            #endregion

                            #endregion

                            #region deplacementVersAllieLePlusPratique

                            if (distanceAvecAlliees.Count > 0)
                            {
                                for (int i = 0; i < porteesDeMeilleuresPrecisionsPouvoir.Count; i++)
                                {
                                    for (int j = 0; j <= porteesDeMeilleuresPrecisionsPouvoir[i] - 1; j++)
                                    {
                                        if (ilABouger == false && dejaBienPlace == false)
                                        {
                                            if (porteesDeMeilleuresPrecisionsPouvoir[i] == distanceAvecAlliees[0])
                                            {
                                                dejaBienPlace = true;
                                                moi_.SHORYUKEN.UtiliserPouvoir(moi_, moteurgraphique_, gameplay_, unitesAlliees[0].i, unitesAlliees[0].j, ref gameplay_.mood, hud_);
                                            }
                                            else
                                            {
                                                if ((int)positionsAlliees[0].X + j >= 0 && (int)positionsAlliees[0].X + j < moteurgraphique_.longueur &&
                                                    (int)positionsAlliees[0].Y + (porteesDeMeilleuresPrecisionsPouvoir[i] - j) >= 0 && (int)positionsAlliees[0].Y + (porteesDeMeilleuresPrecisionsPouvoir[i] - j) < moteurgraphique_.largeur)
                                                {
                                                    if (moteurgraphique_.map[(int)positionsAlliees[0].X + j, (int)positionsAlliees[0].Y + (porteesDeMeilleuresPrecisionsPouvoir[i] - j)].cheminValid)
                                                    {
                                                        ilABouger = true;
                                                        moi_.PathFindingLoohy(moteurgraphique_, (int)positionsAlliees[0].X + j, (int)positionsAlliees[0].Y + (porteesDeMeilleuresPrecisionsPouvoir[i] - j));
                                                    }
                                                    else if ((int)positionsAlliees[0].X - j >= 0 && (int)positionsAlliees[0].X - j < moteurgraphique_.longueur &&
                                                             (int)positionsAlliees[0].Y - (porteesDeMeilleuresPrecisionsPouvoir[i] - j) >= 0 && (int)positionsAlliees[0].Y - (porteesDeMeilleuresPrecisionsPouvoir[i] - j) < moteurgraphique_.largeur)
                                                    {
                                                        if (moteurgraphique_.map[(int)positionsAlliees[0].X - j, (int)positionsAlliees[0].Y - (porteesDeMeilleuresPrecisionsPouvoir[i] - j)].cheminValid)
                                                        {
                                                            ilABouger = true;
                                                            moi_.PathFindingLoohy(moteurgraphique_, (int)positionsAlliees[0].X - j, (int)positionsAlliees[0].Y - (porteesDeMeilleuresPrecisionsPouvoir[i] - j));
                                                        }
                                                        else if ((int)positionsAlliees[0].X + (porteesDeMeilleuresPrecisionsPouvoir[i] - j) >= 0 && (int)positionsAlliees[0].X + (porteesDeMeilleuresPrecisionsPouvoir[i] - j) < moteurgraphique_.longueur &&
                                                                 (int)positionsAlliees[0].Y - j >= 0 && (int)positionsAlliees[0].Y - j < moteurgraphique_.largeur)
                                                        {
                                                            if (moteurgraphique_.map[(int)positionsAlliees[0].X + (porteesDeMeilleuresPrecisionsPouvoir[i] - j), (int)positionsAlliees[0].Y - j].cheminValid)
                                                            {
                                                                ilABouger = true;
                                                                moi_.PathFindingLoohy(moteurgraphique_, (int)positionsAlliees[0].X + (porteesDeMeilleuresPrecisionsPouvoir[i] - j), (int)positionsAlliees[0].Y - j);
                                                            }
                                                            else if ((int)positionsAlliees[0].X - (porteesDeMeilleuresPrecisionsPouvoir[i] - j) >= 0 && (int)positionsAlliees[0].X - (porteesDeMeilleuresPrecisionsPouvoir[i] - j) < moteurgraphique_.longueur &&
                                                                     (int)positionsAlliees[0].Y + j >= 0 && (int)positionsAlliees[0].Y + j < moteurgraphique_.largeur)
                                                            {
                                                                if (moteurgraphique_.map[(int)positionsAlliees[0].X - (porteesDeMeilleuresPrecisionsPouvoir[i] - j), (int)positionsAlliees[0].Y + j].cheminValid)
                                                                {
                                                                    ilABouger = true;
                                                                    moi_.PathFindingLoohy(moteurgraphique_, (int)positionsAlliees[0].X - (porteesDeMeilleuresPrecisionsPouvoir[i] - j), (int)positionsAlliees[0].Y + j);
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            #endregion
                        }
                        else
                        {
                            deplacementMoyenJoute(moteurgraphique_, gameplay_, moi_, armee_, hud_);
                        }
                    }
                }

                if (moi_.pvactuel < moi_.pvmax * (3 / 10) && !ilABouger && !dejaBienPlace)
                {
                    #region battreEnRetraite

                    for (int distanceQG = 0; distanceQG < 32; distanceQG++)
                    {
                        for (int k = 0; k <= distanceQG; k++)
                        {
                            if (ilABouger == false)
                            {
                                if ((int)gameplay_.listeDesJoueurs[moi_.numeroArmee].QG.X + k >= 0 && (int)gameplay_.listeDesJoueurs[moi_.numeroArmee].QG.X + k < moteurgraphique_.longueur &&
                                    (int)gameplay_.listeDesJoueurs[moi_.numeroArmee].QG.Y + (distanceQG - k) >= 0 && (int)gameplay_.listeDesJoueurs[moi_.numeroArmee].QG.Y + (distanceQG - k) < moteurgraphique_.largeur)
                                {
                                    if (moteurgraphique_.map[(int)gameplay_.listeDesJoueurs[moi_.numeroArmee].QG.X + k, (int)gameplay_.listeDesJoueurs[moi_.numeroArmee].QG.Y + (distanceQG - k)].cheminValid)
                                    {
                                        ilABouger = true;
                                        moi_.PathFindingLoohy(moteurgraphique_, (int)gameplay_.listeDesJoueurs[moi_.numeroArmee].QG.X + k, (int)gameplay_.listeDesJoueurs[moi_.numeroArmee].QG.Y + (distanceQG - k));
                                    }
                                    else if ((int)gameplay_.listeDesJoueurs[moi_.numeroArmee].QG.X - k >= 0 && (int)gameplay_.listeDesJoueurs[moi_.numeroArmee].QG.X - k < moteurgraphique_.longueur &&
                                             (int)gameplay_.listeDesJoueurs[moi_.numeroArmee].QG.Y - (distanceQG - k) >= 0 && (int)gameplay_.listeDesJoueurs[moi_.numeroArmee].QG.Y - (distanceQG - k) < moteurgraphique_.largeur)
                                    {
                                        if (moteurgraphique_.map[(int)gameplay_.listeDesJoueurs[moi_.numeroArmee].QG.X - k, (int)gameplay_.listeDesJoueurs[moi_.numeroArmee].QG.Y - (distanceQG - k)].cheminValid)
                                        {
                                            ilABouger = true;
                                            moi_.PathFindingLoohy(moteurgraphique_, (int)gameplay_.listeDesJoueurs[moi_.numeroArmee].QG.X - k, (int)gameplay_.listeDesJoueurs[moi_.numeroArmee].QG.Y - (distanceQG - k));
                                        }
                                        else if ((int)gameplay_.listeDesJoueurs[moi_.numeroArmee].QG.X + (distanceQG - k) >= 0 && (int)gameplay_.listeDesJoueurs[moi_.numeroArmee].QG.X + (distanceQG - k) < moteurgraphique_.longueur &&
                                                 (int)gameplay_.listeDesJoueurs[moi_.numeroArmee].QG.Y - k >= 0 && (int)gameplay_.listeDesJoueurs[moi_.numeroArmee].QG.Y - k < moteurgraphique_.largeur)
                                        {
                                            if (moteurgraphique_.map[(int)gameplay_.listeDesJoueurs[moi_.numeroArmee].QG.X + (distanceQG - k), (int)gameplay_.listeDesJoueurs[moi_.numeroArmee].QG.Y - k].cheminValid)
                                            {
                                                ilABouger = true;
                                                moi_.PathFindingLoohy(moteurgraphique_, (int)gameplay_.listeDesJoueurs[moi_.numeroArmee].QG.X + (distanceQG - k), (int)gameplay_.listeDesJoueurs[moi_.numeroArmee].QG.Y - k);
                                            }
                                            else if ((int)gameplay_.listeDesJoueurs[moi_.numeroArmee].QG.X - (distanceQG - k) >= 0 && (int)gameplay_.listeDesJoueurs[moi_.numeroArmee].QG.X - (distanceQG - k) < moteurgraphique_.longueur &&
                                                 (int)gameplay_.listeDesJoueurs[moi_.numeroArmee].QG.Y + k >= 0 && (int)gameplay_.listeDesJoueurs[moi_.numeroArmee].QG.Y + k < moteurgraphique_.largeur)
                                            {
                                                if (moteurgraphique_.map[(int)gameplay_.listeDesJoueurs[moi_.numeroArmee].QG.X - (distanceQG - k), (int)gameplay_.listeDesJoueurs[moi_.numeroArmee].QG.Y + k].cheminValid)
                                                {
                                                    ilABouger = true;
                                                    moi_.PathFindingLoohy(moteurgraphique_, (int)gameplay_.listeDesJoueurs[moi_.numeroArmee].QG.X - (distanceQG - k), (int)gameplay_.listeDesJoueurs[moi_.numeroArmee].QG.Y + k);
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    #endregion
                }

                else
                {
                    if (ilABouger == false)
                    {
                        deplacementMoyenJoute(moteurgraphique_, gameplay_, moi_, armee_, hud_);
                    }
                }
            }
        }