/**
* pre: post: retourne le nombre de pion qui peuvent encore être placé par ce joueur et ce pion.
*/
public int checkNumberOfPion(String pionPath, boolean Tour) {
int count = 0;
int nbrPion;
int min;
int max;
Pion pion = getTypePion(pionPath, true);
nbrPion = pion.getNombre();
if (Tour) {
min = 6;
max = 9;
} else {
min = 0;
max = 3;
}
for (int i = min; i <= max; i++) {
for (int j = 0; j < 10; j++) {
if (map.getPion(i, j) != null && pionPath.contains(map.getPion(i, j).getName())) {
count++;
}
}
}
return nbrPion - count;
}
/**
* @param name
* @return renvoit le pion et le retir de la liste des pions si il y en a encore un, renvoit null
* sinon, et ne touche pas à la liste des pions.
*/
protected Pion getPion(ArrayList<Pion> listPion, String name) {
for (Pion i : listPion) {
if (i.getName().equals(name)) {
listPion.remove(i);
return i;
}
}
return null;
}
/**
* @param Pion1 et Pion2
* @return implémentation d'un combat entre pions sur la carte. renvoit 0 si les deux pions meurt
* renvoit 1 si le pion attaquant meurt ou renvoit 2 si le pion defenseur meurt.
*/
public int fight(Pion P1, Pion P2) {
int result = Fight.fightResult[P1.getForce()][P2.getForce()];
if (result == 0) {
if (P1.getTeam()) {
LostTrue.add(P1);
LostFalse.add(P2);
} else {
LostTrue.add(P2);
LostFalse.add(P1);
}
}
if (result == 1 && P1.getTeam()) {
LostTrue.add(P1);
}
if (result == 2 && P2.getTeam()) {
LostTrue.add(P2);
}
if (result == 1 && P2.getTeam()) {
LostFalse.add(P1);
}
if (result == 2 && P1.getTeam()) {
LostFalse.add(P2);
}
return result;
}
/**
* initialise la liste des pions à placer sur le terrain de jeu.
*
* @param team
* @param isAnIA
* @return
*/
public ArrayList<Pion> initializePions(boolean team, boolean isAnIA) {
int i;
ArrayList<Pion> listPion = new ArrayList<Pion>();
Joueur J;
if (team) J = J1;
else J = J2;
listPion.add(new Drapeau(team, J));
for (i = 1; i < 7; i++) {
listPion.add(new Bombe(team, J));
}
listPion.add(new Espion(team, J));
for (i = 8; i < 16; i++) {
listPion.add(new Eclaireur(team, J));
}
for (i = 16; i < 21; i++) {
listPion.add(new Demineur(team, J));
}
for (i = 21; i < 25; i++) {
listPion.add(new Sergent(team, J));
}
for (i = 25; i < 29; i++) {
listPion.add(new Lieutenant(team, J));
}
for (i = 29; i < 33; i++) {
listPion.add(new Capitaine(team, J));
}
for (i = 33; i < 36; i++) {
listPion.add(new Commandant(team, J));
}
for (i = 36; i < 38; i++) {
listPion.add(new Colonel(team, J));
}
listPion.add(new General(team, J));
listPion.add(new Marechal(team, J));
if (!team && isAnIA) {
for (Pion pion : listPion) {
pion.setVisibleByIA(true);
}
}
return listPion;
}
/**
* @param oldX, oldY, x, y, joueur
* @return renvoit true si le pion de la case (oldX,oldY) peut être déplacer sur la case (x,y)
* Attention: Si la case sur laquelle on souhaite déplacer son pion est occupée par un pion
* adverse, cette methode renvoit true.
*/
public boolean canMoveOnNewCase(int oldX, int oldY, int x, int y, boolean joueur) {
Pion attaquant = map.getPion(oldX, oldY);
if (attaquant == null) // verification "inutile", mais on est jamais trop prudent.
{
return false;
}
// Si on tente de déplacer un pion qui ne nous appartient pas.
else if (attaquant.getTeam() != joueur) {
return false;
} else {
byte nbrPas = attaquant.getNbrDePas();
// Soit un déplacement verticale (donc les x)
if (logicalXOR(
((0 < oldX - x && oldX - x <= nbrPas) || (0 < x - oldX && x - oldX <= nbrPas)),
// Soit un déplacement horizontale (donc les y)
((0 < oldY - y && oldY - y <= nbrPas) || (0 < y - oldY && y - oldY <= nbrPas)))) {
if (oldX != x && oldY != y) {
return false;
}
// Verifie s'il il n'y as pas de pion sur le trajet, lorsque la distance parcourue est
// différente de 1.
if (nbrPas != 1 && checkObstacleOnWay(oldX, oldY, x, y, nbrPas)) {
return false;
}
Pion defenseur = map.getPion(x, y);
if (defenseur == null) {
return true;
}
// si blackout
if (defenseur.getName().equals("blackout")) {
return false;
}
// deplacer un pion sur un pion adverse.
else if (defenseur.getTeam() != attaquant.getTeam()) {
return true;
}
// tenter de deplacer un pion sur un autre pion qui nous appartient, ou sur une case
// interdite.
else {
return false;
}
} else return false;
}
}
