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);
}
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;
}
}
/// <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;
}
/// <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;
}
/// <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;
}
/// <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;
}
}
/// <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);
}
/// <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);
}
}
/// <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();
}
/// <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();
}
/// <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);
}
}
/// <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));
}