Exemple #1
0
 public Unite()
 {
     pointsAttaque = 2;
     pointsDefense = 1;
     pointsDepl = 1;
     pointsVie = 2;
     pointsVieMax = pointsVie;
     coord = new Coordonnees();
     strategySuggestion = new Suggestion();
 }
        public void TestDistance()
        {
            Coordonnees coord1 = new Coordonnees(0, 1);
            Coordonnees coord2 = new Coordonnees(0, 1);
            Coordonnees coord3 = new Coordonnees(0, 2);

            Assert.AreEqual(0.0, coord1.distance(coord1));
            Assert.AreEqual(0.0, coord1.distance(coord2));
            Assert.AreEqual(1.0, coord1.distance(coord3));
        }
        public void TestCoordonneesEgalOperator()
        {
            Coordonnees coord1 = new Coordonnees(0, 1);
            Coordonnees coord2 = new Coordonnees(0, 1);
            Coordonnees coord3 = new Coordonnees(2, 1);

            Assert.AreEqual(new Coordonnees(0, 1), new Coordonnees(0, 1));
            Assert.AreEqual(coord1, coord1);
            Assert.AreEqual(coord1, coord2);
            Assert.AreNotEqual(coord2, coord3);
            Assert.AreNotEqual(new Coordonnees(0, 1), new Coordonnees(0, 2));

            Assert.IsTrue(coord1 == coord2);
            Assert.IsTrue(coord1 != coord3);
            Assert.IsFalse(coord3 == coord1);
            Assert.IsFalse(coord1 != coord2);
        }
Exemple #4
0
 private void testDeplacementApresCombat(Unite unit, SuggMap sugg, ref Coordonnees coordApres, ref int deplMax, Coordonnees tmp)
 {
     if (caseAccessible(tmp, unit, sugg) && sugg[tmp].Depl > deplMax)
     {
         deplMax = sugg[tmp].Depl;
         coordApres = tmp;
     }
 }
Exemple #5
0
 /// <summary>
 /// Rapproche l'unité au plus pret de la destination
 /// </summary>
 /// <param name="unit">l'unité a déplacé</param>
 /// <param name="destCoord">la case de déstination</param>
 /// <param name="sugg">Les suggestions</param>
 private void rapprocheAuPlusPret(Unite unit, Coordonnees destCoord, SuggMap sugg)
 {
     Coordonnees coordApres = null;
     int deplMax = int.MinValue;
     //OUEST
     Coordonnees tmp = new Coordonnees(destCoord.X - 1, destCoord.Y);
     testDeplacementApresCombat(unit, sugg, ref coordApres, ref deplMax, tmp);
     //EST
     tmp = new Coordonnees(destCoord.X + 1, destCoord.Y);
     testDeplacementApresCombat(unit, sugg, ref coordApres, ref deplMax, tmp);
     //NORD
     tmp = new Coordonnees(destCoord.X, destCoord.Y - 1);
     testDeplacementApresCombat(unit, sugg, ref coordApres, ref deplMax, tmp);
     //SUD
     tmp = new Coordonnees(destCoord.X, destCoord.Y + 1);
     testDeplacementApresCombat(unit, sugg, ref coordApres, ref deplMax, tmp);
     unit.Coord = coordApres;
 }
Exemple #6
0
 /// <summary>
 /// Teste si deux cases sont adjacentes
 /// </summary>
 /// <param name="a">la 1er coordonnees d'une case</param>
 /// <param name="b">la 2eme cordonnees d'une case</param>
 /// <returns>return vrai si les cases sont adjacentes, faux sinon</returns>
 private bool estAdjacent(Coordonnees a, Coordonnees b)
 {
     return Math.Abs(Math.Abs(a.X - b.X) - Math.Abs(a.Y - b.Y))==1;
 }
Exemple #7
0
 /// <summary>
 /// Test si la coordonnees est bien contenu dans la map
 /// </summary>
 /// <param name="c"></param>
 /// <returns></returns>
 private bool coordInBound(Coordonnees c)
 {
     return c.X >= 0 && c.X < Largeur && c.Y >= 0 && c.Y < Hauteur;
 }
Exemple #8
0
        /// <summary>
        /// Fait combattre 2 unités, et fait les déplacements appropriés en cas de victoire de l'attaquant.
        /// </summary>
        /// <param name="unit"></param>
        /// <param name="unitDef"></param>
        /// <param name="destCoord"></param>
        /// <param name="sugg"></param>
        private void combat(Unite unit, Unite unitDef, Coordonnees destCoord, SuggMap sugg)
        {
            unit.attaquer(unitDef);

            if (!unit.estEnVie())
            {
                unites.Remove(unit);
            }
            if (!unitDef.estEnVie())
            {
                unites.Remove(unitDef);
                if (getUniteFromCoord(destCoord).Count == 0)
                {
                    unit.Coord = destCoord;
                }
                else
                {
                    if (!estAdjacent(destCoord, unit.Coord)) // si l'unité n'est pas sur une case adjacente à l'adversaire, on rapproche l'unité
                    {
                        rapprocheAuPlusPret(unit, destCoord, sugg);
                    }
                }
                unit.PointsDepl = sugg[destCoord].Depl;
            }
        }
Exemple #9
0
 /// <summary>
 /// Teste si la cases est accessible à une unité. C-a-d que la case est vide ou qu'elle contient des unités du même joueur
 /// et que les suggestions le permettent
 /// </summary>
 /// <param name="c">la coordonnees de destination</param>
 /// <param name="u">l'unité qui doit se déplacer</param>
 /// <returns>vrai si la case est accessible, faux sinon</returns>
 private bool caseAccessible(Coordonnees c, Unite u, SuggMap sugg)
 {
     List<Unite> listUniteCase = getUniteFromCoord(c);
     return coordInBound(c) && sugg[c].Sugg > 0 && listUniteCase.Count == 0 || (listUniteCase.Count > 0 && listUniteCase[0].IdProprietaire == u.IdProprietaire);
 }
Exemple #10
0
 /// <summary>
 /// Place les unités sur la carte à la coordonnees indiqué
 /// </summary>
 /// <param name="list">la liste des unités à placées</param>
 /// <param name="c">la coordonnees où placer les unités</param>
 public void placeUnite(List<Unite> list, Coordonnees c)
 {
     foreach (Unite u in list)
     {
         u.Coord = c;
         unites.Add(u);
     }
 }
Exemple #11
0
 /// <summary>
 /// Récupère les unités d'une case et d'un joueur précis
 /// </summary>
 /// <param name="coord">la coordonnée de la case</param>
 /// <param name="j">le joueur</param>
 /// <returns>la liste des unités d'une case et d'un joueur précis</returns>
 public List<Unite> getUniteFromCoordAndJoueur(Coordonnees coord, Joueur j)
 {
     return unites.Where(u => u.Coord == coord && u.IdProprietaire == j.Id).ToList();
 }
Exemple #12
0
 /// <summary>
 /// Récupère les unités d'une case
 /// </summary>
 /// <param name="coord">la coordonnées de la case</param>
 /// <returns>la liste des unités de la case</returns>
 public List<Unite> getUniteFromCoord(Coordonnees coord)
 {
     return unites.Where(u => u.Coord == coord).ToList();
 }
Exemple #13
0
 /// <summary>
 /// Déplace la liste d'unités
 /// </summary>
 /// <param name="u"></param>
 /// <param name="destCoord"></param>
 /// <param name="sugg"></param>
 public void deplaceUnites(List<Unite> u, Coordonnees destCoord, SuggMap sugg)
 {
     foreach(Unite unit in u)
     {
         deplaceUnite(unit, destCoord, sugg);
     }
 }
Exemple #14
0
 /// <summary>
 /// Déplace un unité sur la case de destination.
 /// Attaque les unités ennemis présentes sur la case et se déplace après le combat si la case est vide
 /// </summary>
 /// <param name="unit">l'unité à déplacé</param>
 /// <param name="destCoord">coordonnees de la case de destination</param>
 /// <param name="sugg">les suggesions de deplacement</param>
 public void deplaceUnite(Unite unit, Coordonnees destCoord, SuggMap sugg)
 {
     if (sugg.Keys.Contains(destCoord) && sugg[destCoord].Sugg > 0)
     {
         List<Unite> dest = getUniteFromCoord(destCoord);
         if (unites.Contains(unit))
         {
             if (caseAccessible(destCoord, unit,sugg)) // si case vide ou case avec alliés
             {
                 unit.Coord = destCoord;
                 unit.PointsDepl = sugg[destCoord].Depl;
             }
             else // sinon combat
             {
                 Unite unitDef = getMeilleurUniteDef(dest);
                 combat(unit, unitDef, destCoord, sugg);
             }
         }
     }
 }
 private void Rectangle_MouseDown(object sender, MouseButtonEventArgs e)
 {
     var rect = sender as Tile;
     int column = (int)Canvas.GetLeft(rect) / 50;
     int row = (int)Canvas.GetTop(rect) / 50;
     monteur.Carte.setCase(column, row, monteur.Carte.FabriqueCase.getCase(terrain));
     actualiseCase(column, row);
     release = false;
     saved = false;
     souris = new Coordonnees(column, row);
     e.Handled = true;
 }
 /// <summary>
 /// Calcul la distance entre deux coordonnées
 /// </summary>
 /// <param name="b"></param>
 /// <returns></returns>
 public double distance(Coordonnees b)
 {
     return Math.Sqrt(Math.Pow(this.X - b.X, 2) + Math.Pow(this.Y - b.Y, 2));
 }