Ejemplo n.º 1
1
  /**
   * 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;
  }
Ejemplo n.º 2
0
 /**
  * @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;
 }
Ejemplo n.º 3
0
  /**
   * @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;
  }
Ejemplo n.º 4
0
  /**
   * 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;
  }
Ejemplo n.º 5
0
  /**
   * @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;
    }
  }