/// <summary>
/// Fonction qui permet de savoir combien de point rapporte l'occupation d'une case.
/// </summary>
/// <param name="casearr"> la case occupée </param>
/// <param name="nompeuple"> le nom du peuple du joueur qui occupe la case </param>
/// <returns> la valeur des points d'occupation</returns>
public int getPointOccupation(Case casearr, Peuple.NomPeuple nompeuple)
{
switch (nompeuple)
{
case Peuple.NomPeuple.GAULOIS:
if (casearr.getType() == Case.TypeCase.PLAINE)
{
return(2 * casearr.getNbUnitsOnCase());
}
if (casearr.getType() == Case.TypeCase.MONTAGNE)
{
return(0);
}
break;
case Peuple.NomPeuple.NAINS:
if (casearr.getType() == Case.TypeCase.FORET)
{
return(2 * casearr.getNbUnitsOnCase());
}
if (casearr.getType() == Case.TypeCase.PLAINE)
{
return(0);
}
break;
default:
if (casearr.getType() == Case.TypeCase.DESERT)
{
return(0);
}
if (casearr.getType() == Case.TypeCase.EAU)
{
return(0);
}
int total = 0;
foreach (UniteDeBase u in casearr.getUnitsOnCase())
{
if (estAuBordDeLeau(u.getColumn(), u.getRow()))
{
total += 2;
}
else
{
total += 1;
}
}
return(total);
}
return(casearr.getNbUnitsOnCase());
}
/// <summary>
/// Fonction qui permet de connaitre le cout d'un déplacement.
/// </summary>
/// <param name="casearr"> la case d'arrivée </param>
/// <param name="nompeuple"> le nom du peuple du joueur qui pourrait effectuer un déplacement </param>
/// <returns> Le cout</returns>
private float getMoveCost(Case casearr, Peuple.NomPeuple nompeuple)
{
switch (nompeuple)
{
case Peuple.NomPeuple.GAULOIS:
if (casearr.getType() == Case.TypeCase.PLAINE)
{
return(0.5f);
}
break;
default: break;
}
return(1.0f);
}
/// <summary>
/// Fonction qui permet de connaitre la liste des cases sur lesquelles il peut potentiellement y avoir un déplacement
/// </summary>
/// <param name="xdep"> la Colonne correspondant à la case de départ </param>
/// <param name="ydep"> le rang correspondant à la case de départ </param>
/// <param name="casedep"> la case de départ </param>
/// <param name="nompeuple"> le nom du peuple de joueur qui pourrait déplacer une unité </param>
/// <returns> La liste des cases qui peut être jouées.</returns>
public List <int> listeDesCasesPossibles(int xdep, int ydep, Case casedep, Peuple.NomPeuple nompeuple)
{
List <int> res = new List <int>();
int row, column;
for (row = 0; row < longueurCote; row++)
{
for (column = 0; column < longueurCote; column++)
{
if (isMoveAllowed(xdep, ydep, column, row, casedep, getCase(column, row), nompeuple))
{
res.Add(column);
res.Add(row);
}
}
}
return(res);
}
/// <summary>
/// Fonction qui effectue le combat (si celui ci peut avoir lieu).
/// </summary>
/// <param name="xdep"> la colonne de la case de l'attaquant </param>
/// <param name="ydep"> le rang de la case de l'attaquant </param>
/// <param name="xarr"> la colonne de la case du défenseur </param>
/// <param name="yarr"> le rang de la case du défenseur </param>
/// <param name="casedep"> la case de l'attaquant </param>
/// <param name="casearr"> la case du défenseur </param>
/// <param name="nompeuple"> le nom du peuple du joueur qui attaque</param>
/// <param name="j"> le joueur qui veut faire un combat </param>
/// <param name="numJoueur"> le numéro du joueur qui veut faire un combat </param>
/// <returns> Vrai si le combat a été effectué, Faux si le combat ne pouvait pas avoir lieu</returns>
public Boolean fightProcessing(int xdep, int ydep, int xarr, int yarr, Case casedep, Case casearr, Peuple.NomPeuple nompeuple, Joueur joueuratt, Joueur joueurdef)
{
if (!isFightAllowed(xdep, ydep, xarr, yarr, casedep, casearr, nompeuple))
{
return(false);
}
UniteDeBase uattaquante = casedep.UnitsOnCase[0];
UniteDeBase udefensive = casearr.getLUniteDePlusGrandeDefense();
float cost = getMoveCost(casearr, nompeuple);
if (uattaquante.ptDeDepl < cost)
{
return(false);
}
int nbCombat = WrapperAlgo.nbCombat(uattaquante.getPV(), udefensive.getPV());
while (nbCombat > 0 && (uattaquante.getPV() != 0) && (udefensive.getPV() != 0))
{
Boolean LattaquantAPerduUnPV = WrapperAlgo.LattaquantPerdUnPV(uattaquante.getAtt(), udefensive.getDef(), uattaquante.getPourcentagePV(), udefensive.getPourcentagePV());
if (LattaquantAPerduUnPV)
{
int PVinit = (uattaquante.getPV() * 100) / uattaquante.getPourcentagePV();
uattaquante.setPourcentagePV(((uattaquante.getPV() - 1) * 100) / PVinit);
uattaquante.setPV(uattaquante.getPV() - 1);
}
else
{
int PVinit = (udefensive.getPV() * 100) / udefensive.getPourcentagePV();
udefensive.setPourcentagePV(((udefensive.getPV() - 1) * 100) / PVinit);
udefensive.setPV(udefensive.getPV() - 1);
}
nbCombat--;
}
if (udefensive.getPV() == 0)
{
udefensive.meurt();
casearr.UnitsOnCase.Remove(udefensive);
joueurdef.getUnite().Remove(udefensive);
if (casearr.UnitsOnCase.Count == 0)
{
casearr.setEtatOccupation(0);// la case devient libre
return(true);
}
}
if (uattaquante.getPV() == 0)
{
uattaquante.meurt();
casedep.UnitsOnCase.Remove(uattaquante);
joueuratt.getUnite().Remove(uattaquante);
if (casedep.UnitsOnCase.Count == 0)
{
casedep.setEtatOccupation(0);// la case devient libre
}
return(false);
}
return(false);
}
/// <summary>
/// Fonction qui permet de savoir si un combat peut avoir lieu entre des unités de la case d'arrivée(defenseur) et des unités de la case de départ(attaquant). Elle ne tient pas compte du fait qu'u
/// </summary>
/// <param name="xdep"> la Colonne correspondant à la case de départ </param>
/// <param name="ydep"> le rang correspondant à la case de départ </param>
/// <param name="xarr"> la Colonne correspondant à la case d'arrivée </param>
/// <param name="yarr"> le rang correspondant à la case de d'arrivée </param>
/// <param name="casedep"> la case de départ </param>
/// <param name="casearr"> la case d'arrivée </param>
/// <param name="nompeuple"> le nom du peuple de joueur qui tente de provoquer un combat </param>
/// <returns> Rend vrai si le combat est acceptale. Faux sinon.</returns>
private Boolean isFightAllowed(int xdep, int ydep, int xarr, int yarr, Case Casedep, Case casearr, Peuple.NomPeuple nompeuple)
{
switch (nompeuple)
{
case Peuple.NomPeuple.VIKINGS:
if (!WrapperAlgo.isAdjacentCase(xdep, ydep, xarr, yarr))
{
return(false);
}
break;
default: // nains et gaulois
if (!WrapperAlgo.isAdjacentCase(xdep, ydep, xarr, yarr))
{
return(false);
}
if (casearr.getType() == Case.TypeCase.EAU)
{
return(false);
}
break;
}
return(true);
}
/// <summary>
/// Fonction qui effectue le déplacement d'une unité (si celle ci le peut).
/// </summary>
/// <param name="xdep"> la colonne de la case de départ </param>
/// <param name="ydep"> le rang de la case de départ </param>
/// <param name="xarr"> la colonne de la case de d'arrivée </param>
/// <param name="yarr"> le rang de la case d'arrivée </param>
/// <param name="casedep"> la case de départ </param>
/// <param name="casearr"> la case d'arrivée </param>
/// <param name="nompeuple"> le nom du peuple du joueur qui veut faire un déplacement </param>
/// <param name="j"> le joueur qui veut faire un déplacement </param>
/// <param name="numJoueur"> le numéro du joueur qui veut faire un déplacement </param>
/// <returns> Vrai si le déplacement a été effectué, Faux si le déplacement ne pouvait pas avoir lieu</returns>
public Boolean moveProcessing(int xdep, int ydep, int xarr, int yarr, Case casedep, Case casearr, Peuple.NomPeuple nompeuple, Joueur j, int numJoueur)
{
UniteDeBase u = casedep.UnitsOnCase[0];
if (!isMoveAllowed(xdep, ydep, xarr, yarr, casedep, casearr, nompeuple))
{
return(false);
}
float cost = getMoveCost(casearr, nompeuple);
if (u.ptDeDepl < cost)
{
return(false);
}
casedep.UnitsOnCase.Remove(u);
if (casedep.UnitsOnCase.Count == 0)
{
casedep.setEtatOccupation(0); // 0 etant l'etat libre
}
UniteDeBase umodifie = u;
umodifie.ptDeDepl -= cost;
umodifie.setRow(yarr);
umodifie.setColumn(xarr);
casearr.UnitsOnCase.Add(umodifie);
casearr.setEtatOccupation(numJoueur);
return(true);
}
/// <summary>
/// Fonction qui permet de savoir si un déplacement est potentiellement faisable, sans tenir compte des points de déplacement de l'unité qui veut se déplacer.
/// </summary>
/// <param name="xdep"> la Colonne correspondant à la case de départ </param>
/// <param name="ydep"> le rang correspondant à la case de départ </param>
/// <param name="xarr"> la Colonne correspondant à la case d'arrivée </param>
/// <param name="yarr"> le rang correspondant à la case de d'arrivée </param>
/// <param name="casedep"> la case de départ </param>
/// <param name="casearr"> la case d'arrivée </param>
/// <param name="nompeuple"> le nom du peuple de joueur qui tente de déplacer une unité </param>
/// <returns> Rend vrai si le déplacement est acceptale. Faux sinon.</returns>
private Boolean isMoveAllowed(int xdep, int ydep, int xarr, int yarr, Case casedep, Case casearr, Peuple.NomPeuple nompeuple)
{
switch (nompeuple)
{
case Peuple.NomPeuple.GAULOIS:
if (!WrapperAlgo.isAdjacentCase(xdep, ydep, xarr, yarr))
{
return(false);
}
if (casearr.getType() == Case.TypeCase.EAU)
{
return(false);
}
break;
case Peuple.NomPeuple.NAINS:
if ((!WrapperAlgo.isAdjacentCase(xdep, ydep, xarr, yarr)) && casearr.getType() != Case.TypeCase.MONTAGNE)
{
return(false);
}
if ((!WrapperAlgo.isAdjacentCase(xdep, ydep, xarr, yarr)) && (casearr.getType() == Case.TypeCase.MONTAGNE) && (casedep.getType() != Case.TypeCase.MONTAGNE))
{
return(false);
}
if (casearr.getType() == Case.TypeCase.EAU)
{
return(false);
}
break;
default:
if (!WrapperAlgo.isAdjacentCase(xdep, ydep, xarr, yarr))
{
return(false);
}
break;
}
return(true);
}
