public int distance(Coordonnee coords)
{
int newX = Math.Abs(coords.X - X);
int newY = Math.Abs(coords.Y - Y);
return newX + newY;
}
public bool bordEau(Coordonnee coords)
{
return ((coords.getX() > 1 && getCase(coords.decaler(-1, 0)).getTypeCase() == TypeCases.EAU) ||
(coords.getY() > 1 && getCase(coords.decaler(0, -1)).getTypeCase() == TypeCases.EAU) ||
(coords.getX() < taille && getCase(coords.decaler(1, 0)).getTypeCase() == TypeCases.EAU) ||
(coords.getY() < taille && getCase(coords.decaler(0, 1)).getTypeCase() == TypeCases.EAU));
}
public void TestDeplacementNain()
{
Coordonnee destination;
f = new FabriqueNain();
c = new Coordonnee(1, 2); //Desert
// - Vers case basique
destination = new Coordonnee(1, 1); //Montagne
u = f.fabriquerUnite(c);
u.deplacement(destination);
Assert.AreEqual(u.mouvement, 0);
Assert.IsTrue(u.coordonnees.Equals(destination));
// - Vers case eau
destination = new Coordonnee(1, 3); //Eau
u = f.fabriquerUnite(c);
u.deplacement(destination);
Assert.AreEqual(u.mouvement, 1);
Assert.IsTrue(u.coordonnees.Equals(c));
// - Montagne -> Montagne
c = new Coordonnee(1, 1); //Montagne
destination = new Coordonnee(3, 3); //Montagne
u = f.fabriquerUnite(c);
u.deplacement(destination);
Assert.AreEqual(u.mouvement, 0);
Assert.IsTrue(u.coordonnees.Equals(destination));
}
public override bool deplacementPossible(Coordonnee coords)
{
if (this.coordonnees.Equals(coords))
return false;
int distance = coordonnees.distance(coords);
if (distance > 1) return false;
return (mouvement >= 1);
}
public override resultatCombat deplacement(Coordonnee coords)
{
if (!deplacementPossible(coords)) return resultatCombat.DEPLACEMENT_IMPOSSIBLE;
resultatCombat retour = verifUniteCase(coords);
mouvement -= 1.0;
makeResultatCombat(retour, coords);
return retour;
}
public Unite(Coordonnee coords)
{
coordonnees = new Coordonnee();
logDernierCombat = new Log();
attaque = ATTAQUE_MAX;
defense = DEFENSE_MAX;
vie = VIE_MAX;
mouvement = MOUVEMENT_MAX;
coordonnees.clone(coords);
}
public override bool deplacementPossible(Coordonnee coords)
{
if (this.coordonnees.Equals(coords))
return false;
Case c = SmallWorld.Instance.carte.getCase(coords);
int distance = coordonnees.distance(coords);
if (distance > 1 || c.getTypeCase() == TypeCases.EAU) return false;
if (c.getTypeCase() == TypeCases.PLAINE && mouvement >= 0.5) return true;
return (mouvement >= 1);
}
public override resultatCombat deplacement(Coordonnee coords)
{
if (!deplacementPossible(coords)) return resultatCombat.DEPLACEMENT_IMPOSSIBLE;
resultatCombat retour = verifUniteCase(coords);
Case c = SmallWorld.Instance.carte.getCase(coords);
if (c.getTypeCase() == TypeCases.PLAINE) mouvement -= 0.5;
else mouvement -= 1.0;
makeResultatCombat(retour, coords);
return retour;
}
public override bool deplacementPossible(Coordonnee coords)
{
if (this.coordonnees.Equals(coords))
return false;
int distance = coordonnees.distance(coords);
Case c = SmallWorld.Instance.carte.getCase(coords);
if (c.getTypeCase() == TypeCases.EAU) return false;
Case currentCase = SmallWorld.Instance.carte.getCase(coordonnees);
if (currentCase.getTypeCase() == TypeCases.MONTAGNE && c.getTypeCase() == TypeCases.MONTAGNE && mouvement >= 1
&& !SmallWorld.Instance.carte.presenceUniteEnnemie(coords, this)) return true;
if (distance > 1) return false;
return (mouvement >= 1);
}
public int getNombreUnites(Coordonnee coord)
{
int nb = 0;
foreach (Joueur j in SmallWorld.Instance.joueurs)
{
foreach (Unite u in j.getUnites())
{
if(u.coordonnees.Equals(coord))
nb++;
}
}
return nb;
}
public Viking(Coordonnee coords)
: base(coords)
{
}
public Nain(Coordonnee coords)
: base(coords)
{
}
public bool presenceUniteEnnemie(Coordonnee coord, Unite amie)
{
foreach (Joueur j in SmallWorld.Instance.joueurs)
{
if (j.Peuple != amie.getPeuple())
{
foreach (Unite u in j.getUnites())
{
if (u.coordonnees.Equals(coord))
return true;
}
}
}
return false;
}
private void drawBack(DrawingContext dc)
{
int taille = SmallWorld.Instance.carte.taille;
for (int x = 1; x <= taille; x++)
{
for (int y = 1; y <= taille; y++)
{
Coordonnee coords = new Coordonnee(x, y);
switch (SmallWorld.Instance.carte.getCase(coords).getTypeCase())
{
case TypeCases.DESERT:
dc.DrawImage(desert, new Rect((x - 1) * imgSize, (y - 1) * imgSize, imgSize, imgSize));
break;
case TypeCases.PLAINE:
dc.DrawImage(plaine, new Rect((x - 1) * imgSize, (y - 1) * imgSize, imgSize, imgSize));
break;
case TypeCases.MONTAGNE:
dc.DrawImage(montagne, new Rect((x - 1) * imgSize, (y - 1) * imgSize, imgSize, imgSize));
break;
case TypeCases.EAU:
dc.DrawImage(eau, new Rect((x - 1) * imgSize, (y - 1) * imgSize, imgSize, imgSize));
break;
case TypeCases.FORET:
dc.DrawImage(foret, new Rect((x - 1) * imgSize, (y - 1) * imgSize, imgSize, imgSize));
break;
case TypeCases.VORTEX:
dc.DrawImage(vortex, new Rect((x - 1) * imgSize, (y - 1) * imgSize, imgSize, imgSize));
break;
}
}
}
SolidColorBrush scb = Brushes.Black;
Pen p = new Pen(scb, 3);
dc.DrawLine(p, new Point(0,0), new Point(0,taille*imgSize));
dc.DrawLine(p, new Point(taille*imgSize, 0), new Point(0,0));
for (int x = 1; x <= taille; x++)
{
dc.DrawLine(p, new Point(x*imgSize, 0), new Point(x*imgSize, taille*imgSize));
}
for (int y = 1; y <= taille; y++)
{
dc.DrawLine(p, new Point(0, y * imgSize), new Point(taille * imgSize, y * imgSize));
}
}
protected override void OnMouseLeave(MouseEventArgs e)
{
if (checkPreventRefresh())
return;
lastCaseSurvolee = null;
this.InvalidateVisual();
}
private void drawDeplacement(DrawingContext dc)
{
if (caseSurvolee != null) {
drawCase(caseSurvolee, Brushes.Blue.Clone(), 0.35, dc);
caseSurvolee = null;
}
}
/**
* Vérifie si une ou plusieurs unité ennemies sont présentes sur la case
* Le cas échéant, lance une attaque contre l'unité ayant le plus de défense
* Sinon, déplace l'unité voulant se déplacer
*/
protected resultatCombat verifUniteCase(Coordonnee coords)
{
int defMax = 0;
int choisie = -1;
Joueur ennemi = null;
bool uniteSeule = true;
foreach (Joueur j in SmallWorld.Instance.joueurs)
{
if (j != SmallWorld.Instance.getJoueurCourant())
{
for (int i = 0; i < j.getUnites().Count; i++)
{
Unite u = j.getUnites()[i];
if (u.coordonnees.Equals(coords))
{
if (choisie != -1) uniteSeule = false;
if (u.defense > defMax)
{
choisie = i;
defMax = u.defense;
ennemi = j;
}
}
}
}
}
if (choisie != -1)
{
return combattre(choisie, uniteSeule, ennemi);
}
else
{
return resultatCombat.DEPLACEMENT_SIMPLE;
}
}
protected void makeResultatCombat(resultatCombat result, Coordonnee coords)
{
switch (result)
{
case resultatCombat.ATTAQUANT_MORT:
case resultatCombat.DEUX_MORTS:
SmallWorld.Instance.getJoueurCourant().getUnites().Remove(this);
break;
case resultatCombat.DEPLACEMENT_BATAILLE:
case resultatCombat.DEPLACEMENT_SIMPLE:
coordonnees = coords;
break;
}
}
public abstract bool deplacementPossible(Coordonnee coords);
/// <summary> /// Regarde en fonction de la case si l'unité peut se déplacer ou pas /// </summary> public abstract resultatCombat deplacement(Coordonnee coords);
public Unite fabriquerUnite(Coordonnee coords)
{
return new Nain(coords);
}
public Dictionary<Unite, int> getUnites(Coordonnee coord)
{
Dictionary<Unite, int> listeUnite = new Dictionary<Unite, int>();
bool joueurTrouve = false; // Optimisation de la boucle
foreach (Joueur j in SmallWorld.Instance.joueurs)
{
int i = 0; // ID dans le tableau des unitées
foreach (Unite u in j.getUnites())
{
if (u.coordonnees.Equals(coord))
{
listeUnite.Add(u, i);
joueurTrouve = true;
}
i++;
}
if (joueurTrouve)
break;
}
return listeUnite;
}
protected override void OnMouseDown(MouseButtonEventArgs e)
{
Point click = e.GetPosition(this);
if (e.LeftButton == MouseButtonState.Pressed) {
verifierActionSelectionUnite(click);
}
else if (e.RightButton == MouseButtonState.Pressed)
{
if (s.Visibility == System.Windows.Visibility.Hidden)
{
verifierActionDeplacement(click);
lastCaseSurvolee = null; // Permet de refresh l'interface
MouseEventArgs mouse1 = new MouseEventArgs(Mouse.PrimaryDevice, 0) { RoutedEvent = Mouse.MouseMoveEvent };
this.RaiseEvent(mouse1);
}
else // Si jamais le menu est ouvert on le ferme juste et on déplace pas
{
s.Visibility = System.Windows.Visibility.Hidden;
this.InvalidateVisual();
}
}
}
/**
* Retourne des suggestions de déplacement pour l'unité courante
* Return List<Coordonnee> liste de coordonnées de cases suggérées
*/
public unsafe List<Coordonnee> getSuggestions()
{
int x = SmallWorld.Instance.getUniteCourante().coordonnees.getX();
int y = SmallWorld.Instance.getUniteCourante().coordonnees.getY();
int** suggestions = wrapper.suggestions((int) SmallWorld.Instance.getJoueurCourant().Peuple, x, y);
List<Coordonnee> retour = new List<Coordonnee>();
for (int i = 0; i < 3; i++)//3 suggestions. TODO: Changement automatique en fonction du nombre reçu
{
int suggx = suggestions[i][0];
int suggy = suggestions[i][1];
if (suggx != 0 && suggy != 0)
{
Coordonnee suggestion = new Coordonnee(suggx, suggy);
retour.Add(suggestion);
}
}
return retour;
}
protected override void OnMouseMove(MouseEventArgs e)
{
if (checkPreventRefresh())
return;
Point click = e.GetPosition(this);
Coordonnee tempCaseSurvol = pointToCoordonne(click);
Unite uCourrante = SmallWorld.Instance.getUniteCourante();
if (lastCaseSurvolee == null || (!(tempCaseSurvol.Equals(lastCaseSurvolee))))
{
// Affichage d'une case déplacable
if (uCourrante.deplacementPossible(tempCaseSurvol))
{
caseSurvolee = tempCaseSurvol;
}
else
{
caseSurvolee = null;
}
// Survol d'une unité
Dictionary<Unite, int> d = SmallWorld.Instance.carte.getUnites(tempCaseSurvol);
if (d.Count == 1)
{
if (fenetreParent != null)
fenetreParent.setInfoUniteSurvole(d.Keys.First(), d.Values.First());
}
else if (d.Count > 1)
{
if (fenetreParent != null)
// TODO : A virer
fenetreParent.setInfoUniteSurvole(d.Count);
}
else
{
if (fenetreParent != null)
fenetreParent.hideInfoUniteSurvole();
}
lastCaseSurvolee = tempCaseSurvol;
this.InvalidateVisual();
}
}
public bool Equals(Coordonnee obj)
{
return (X == obj.X && Y == obj.Y);
}
private void drawCase(Coordonnee c, Brush couleur, double opacity, DrawingContext dc)
{
int x = c.getX();
int y = c.getY();
Brush sugg = couleur;
sugg.Opacity = opacity;
dc.DrawRectangle(sugg, null, new Rect((x - 1) * imgSize, (y - 1) * imgSize, imgSize, imgSize));
}
public void initialiseVortexs()
{
for (int i = 0; i < taille; i++)
{
for (int j = 0; j < taille; j++)
{
int typeCase = grid[i, j];
if (typeCase == (int)TypeCases.VORTEX)
{
Coordonnee c = new Coordonnee(i + 1, j + 1);
vortexs.Add(c);
}
}
}
}
/**
* Demande à une unité de se déplacer sur la case visée
* Return true si fin du jeu
*/
public bool deplacement(Coordonnee c)
{
resultatCombat result = getUniteCourante().deplacement(c);
if (result == resultatCombat.ATTAQUANT_MORT || getUniteCourante().mouvement < 1)
{
int nextUnite = getJoueurCourant().getFirstMovementAbleUnit();
if (nextUnite == -1)
passerTour();
else
instance.uniteCourante = nextUnite;
}
return checkFinJeu();
}
public void clone(Coordonnee coords)
{
X = coords.getX();
Y = coords.getY();
}
