unsafe public bool **getMapSuggestion()
{
int type = 0;
if (unitSelect is DwarfUnit)
{
type = 1;
}
else if (unitSelect is ElfUnit)
{
type = 2;
}
else if (unitSelect is OrcUnit)
{
type = 3;
}
else if (unitSelect is HumanUnit)
{
type = 4;
}
int[][] mapElement = buildMapElement(this.game.getMap().getSize());
WrapperAlgo wp = new WrapperAlgo();
bool **mapMove = wp.possible(this.game.getMap().getSize(), this.Xselect, this.Yselect, type, mapElement, unitSelect.getMovePts());
return(mapMove);
}
/// <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);
}
public MainWindow()
{
InitializeComponent();
int n = 0;
int xJ1, yJ1, xJ2, yJ2;
xJ1 = 0;
yJ1 = 0;
xJ2 = 0;
yJ2 = 0;
n = 5;
int i, j;
WrapperAlgo wa = new WrapperAlgo(n);
unsafe
{
int **cases;
cases = wa.remplirCarte();
wa.positionJoueur(xJ1, yJ1, xJ2, yJ2);
System.Windows.Rect dc = new Rect();
for (i = 0; i < n; i++)
{
for (j = 0; j < n; j++)
{
switch (cases[i][j])
{
case (int)TypeCase.MONTAGNE:
OnRender(dc);
break;
case (int)TypeCase.PLAINE:
break;
case (int)TypeCase.DESERT:
break;
case (int)TypeCase.EAU:
break;
case (int)TypeCase.FORET:
break;
default:
break;
}
}
}
}
}
unsafe public Window3()
{
InitializeComponent();
taille = 10;
WrapperAlgo wa = new WrapperAlgo(taille);
int **tabCarte = wa.remplirCarte();
int xJ1 = 0;
int yJ1 = 0;
int xJ2 = 0;
int yJ2 = 0;
wa.positionJoueur(&xJ1, &yJ1, &xJ2, &yJ2);
}
//Monteur Partie
unsafe public IGame buildGame(string pseudo1, IFaction faction1, string pseudo2, IFaction faction2)
{
IPlayer Player1 = new Player(faction1, this.nbUnits, pseudo1);
IPlayer Player2 = new Player(faction2, this.nbUnits, pseudo2);
WrapperAlgo wp = new WrapperAlgo();
int * posPlayer = wp.placingPlayer(this.map.getSize());
for (int i = 0; i < this.nbUnits; i++)
{
IUnit u = Player1.getUnit(i);
this.map.getTile(posPlayer[0], posPlayer[1]).addUnit(u);
IUnit v = Player2.getUnit(i);
this.map.getTile(posPlayer[2], posPlayer[3]).addUnit(v);
}
return(new Game(this.nbRounds, Player1, Player2, this.map));
}
//Créer une map de taille t
unsafe public Map(int size)
{
this.size = size;
this.map = new ITile[size, size];
this.factory = new ITileFactory();
WrapperAlgo wp = new WrapperAlgo();
int ** typeTile = wp.buildMap(size);
int i, j;
for (i = 0; i < size; i++)
{
for (j = 0; j < size; j++)
{
this.map[i, j] = factory.makeTile(typeTile[i][j]);
}
}
}
/// <summary>
/// Création d'une carte à 3 parametres, les 2 joueurs qui vont s'affronter et la strategie de la partie qui sera utilisée
/// </summary>
/// <param name="j1"> le joueur 1 </param>
/// <param name="j2"> le joueur 2 </param>
/// <param name="st"> la strategie de la partie </param>
unsafe public Partie(Joueur j1, Joueur j2, StrategieCarte st)
{
pvMaxUnite = 2;
joueur1 = j1;
joueur2 = j2;
LaCarte = new Carte(st.tailleCarte());
strat = st;
nbToursRestants = strat.nombreDeTour();
int j1x, j1y, j2x, j2y;
WrapperAlgo.positionJoueurParTaille(getCarte().getLongueurCote(), &j1x, &j1y, &j2x, &j2y);
joueur1.setx0(j1x);
joueur1.sety0(j1y);
joueur2.setx0(j2x);
joueur2.sety0(j2y);
LaCarte.InitialisationDeLaCarte(joueur1, joueur2, strat.nombreUniteParPeuple());
Joueur1ALaMain = true;
selectOp = new SelectionOperateur();
}
/// <summary>
/// Création d'une carte, les cases de la carte sont initialisées en fonction de la carte que le wrapperalgo a déjà généré
/// </summary>
/// <param name="taille"> la taille de la carte </param>
unsafe public Carte(int taille)
{
ListeDesCases = new List <Case>();
WrapperAlgo wa = new WrapperAlgo(taille);
int ** tabCarte = wa.remplirCarte();
longueurCote = taille;
int i, j;
for (i = 0; i < taille; i++)
{
for (j = 0; j < taille; j++)
{
int type = tabCarte[i][j];
Case c;
switch (type)
{
case 0:
c = new Montagne();
break;
case 1:
c = new Plaine();
break;
case 2:
c = new Desert();
break;
case 3:
c = new Eau();
break;
default:
c = new Foret();
break;
}
ListeDesCases.Add(c);
}
}
}
/// <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);
}
unsafe public MainWindow()
{
//InitializeComponent();
WrapperAlgo wrapper = new WrapperAlgo();
int ** t = wrapper.tabMap();
wrapper.affiche();
System.Console.ReadLine();
// GamePlay engine;
// Map map;
////
////Rectangle selectedVisual;
///// <summary>
///// Construction de la fenetre (référencé dans le App.xaml)
///// </summary>
//public MainWithEvents()
//{
// InitializeComponent();
// engine = new Game.Gameplay.NewGamePlayImpl();
//}
///// <summary>
///// Réaction à l'evt "la fenetre est construite" (référencé dans le MainWithEvents.xaml)
///// </summary>
///// <param name="sender">la fenetre </param>
///// <param name="e"> l'evt : la fentere est construite</param>
//private void Window_Loaded(object sender, RoutedEventArgs e)
//{
// // on initialise la Grid (mapGrid défini dans le xaml) à partir de la map du modèle (engine)
// map = engine._Map;
//}
}
/// <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);
}
public int go(int x)
{
WrapperAlgo w = new WrapperAlgo();
return w.computeFoo(x);
}
