public override SuggMap getSuggestion(Carte carte, Unite unite)
{
SuggMap res = base.getSuggestion(carte, unite);
// on cherche la meilleur case possible la plus éloigné des ennemis
List<Coordonnees> meilleursCases = new List<Coordonnees>();
Dictionary<Coordonnees, double> dictionary = new Dictionary<Coordonnees, double>();
foreach (var pair in res)
{
if (pair.Value.Sugg != 0)
{
double minDist = double.MaxValue;
Coordonnees coordCase = pair.Key;
Coordonnees coord=null;
foreach (Unite u in carte.Unites.Where(z => z.IdProprietaire != unite.IdProprietaire))
{
if (coordCase.distance(u.Coord) < minDist)
{
minDist = coordCase.distance(u.Coord);
coord = u.Coord;
}
}
res[coordCase].Sugg += (int)minDist;
}
}
return res;
}
public void TestPointVie()
{
Unite u = new Unite();
Assert.IsTrue(u.estEnVie());
u.perdPV(1);
Assert.AreEqual(u.PointsVieMax - 1, u.PointsVie);
}
/// <summary>
/// Récupère les suggestions en fonction du peuple de l'unité et de la case
/// </summary>
/// <param name="carte"></param>
/// <param name="unite"></param>
/// <returns></returns>
public override SuggMap getSuggestion(Carte carte, Unite unite)
{
List<int> sugg = new WrapperSuggestion().getSuggestion(carte.toList(), //la carte
getUnitesToList(carte, unite), //l'emplacement des unités ennemis
carte.Largeur,
carte.Hauteur,
unite.Coord.X, //coordonnees x de l'unité
unite.Coord.Y, //coordonnees y de l'unité
unite.PointsDepl, //le nombre de points de déplacement de l'unité
unite.Proprietaire.Peuple.toInt()); //le peuple de l'unité
return listIntToSuggMap(carte, sugg);
}
public GroupeUnite(Unite unit)
{
InitializeComponent();
this.unit = unit;
selected = false;
selectable = false;
grpUnit.Header = unit.ToString() + " " + unit.Proprietaire.Peuple;
PV.Text = unit.PointsVie.ToString()+"/"+unit.PointsVieMax.ToString();
PA.Text = unit.PointsAttaque.ToString();
PDef.Text = unit.PointsDefense.ToString();
PDepl.Text = unit.PointsDepl.ToString();
grpUnit.BorderBrush = (SolidColorBrush)new BrushConverter().ConvertFromString(unit.Proprietaire.Couleur);
}
public void TestDeplacement()
{
Carte c = creerCarteRapide();
Unite unite = new Unite();
unite.Coord = new Coordonnees(0,0);
unite.Proprietaire = new JoueurConcret(new FabriquePeupleGaulois(), "Red", "j");
unite.IdProprietaire = 0;
SuggMap sugg = unite.StrategySuggestion.getSuggestion(c,unite);
c.deplaceUnite(unite,new Coordonnees(0,1),sugg);
Assert.AreEqual<Coordonnees>(unite.Coord, new Coordonnees(0, 1));
}
protected List<int> getUnitesToList(Carte carte, Unite unite)
{
List<int> res = new List<int>();
List<Unite> tmp;
for (int i = 0; i < carte.Largeur; i++)
{
for (int j = 0; j < carte.Hauteur; j++)
{
tmp = carte.getUniteFromCoord(new Coordonnees(i, j));
if (tmp.Count > 0 && tmp[0].IdProprietaire != unite.IdProprietaire)
res.Add(tmp.Count);
else
res.Add(0);
}
}
return res;
}
public override int calculPoints(Carte c, Unite u)
{
int bonus = 0;
Coordonnees coord = u.Coord;
for(int i=0;i<c.Largeur;i++)
{
for(int j=0;j<c.Hauteur;j++)
{
if (coord.X - 1 > 0 && c.Cases[coord.X-1][coord.Y] is CaseEau
|| coord.X + 1 < c.Largeur && c.Cases[coord.X + 1][coord.Y] is CaseEau
|| coord.Y - 1 > 0 && c.Cases[coord.X][coord.Y-1] is CaseEau
|| coord.Y + 1 < c.Hauteur && c.Cases[coord.X][coord.Y+1] is CaseEau)
{
bonus = 1;
}
}
}
return base.calculPoints(c,u) + bonus;
}
public override List<Unite> creerUnite(Joueur j)
{
List<Unite> list = new List<Unite>();
for (int i = 0; i < partie.Carte.NbUniteClassique; i++)
{
Unite unit = new Unite();
unit.Proprietaire = j;
list.Add(unit);
}
for (int i = 0; i < partie.Carte.NbUniteElite; i++)
{
Unite unit = new UniteElite();
unit.Proprietaire = j;
list.Add(unit);
}
for (int i = 0; i < partie.Carte.NbUniteBlindee; i++)
{
Unite unit = new UniteBlindee();
unit.Proprietaire = j;
list.Add(unit);
}
return list;
}
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>
/// 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>
/// 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);
}
}
}
}
public abstract SuggMap getSuggestion(Carte carte, Unite unite);
/// <summary>
/// Calcul les points
/// </summary>
/// <param name="c"></param>
/// <param name="u"></param>
/// <returns></returns>
public virtual int calculPoints(Carte c, Unite u)
{
return c.Cases[u.Coord.X][u.Coord.Y].bonusPoints(this);
}
