Пример #1
0
  /**
   * Renvoie la console correspondant a la reference RMI donnee.
   *
   * @param refRMI reference RMI
   * @return console correspondante
   * @throws RemoteException
   */
  protected IConsole consoleFromRef(int refRMI) throws RemoteException {
    int p = port + refRMI;
    String ip = null;
    String adr = null;
    IConsole console = null;

    try {
      ip = personnages.get(refRMI).getAdresseIp();
      adr = Constantes.nomRMI(ip, p, "Console" + refRMI);
      console = (IConsole) Naming.lookup(adr);

    } catch (MalformedURLException e) {
      console = null;
      logger.severe(Constantes.nomClasse(this), "Erreur : acces a " + adr + "\n" + e.toString());
      e.printStackTrace();

    } catch (NotBoundException e) {
      console = null;
      logger.severe(Constantes.nomClasse(this), "Erreur : acces a " + adr + "\n" + e.toString());
      e.printStackTrace();

    } catch (NullPointerException e) {
      console = null;
    }

    return console;
  }
Пример #2
0
  @Override
  public synchronized boolean connecte(
      int refRMI, String ipConsole, Personnage personnage, int nbTours, Point position)
      throws RemoteException {

    // assignation d'un port unique a chaque personnage
    int portConsole = port + refRMI;
    String adr = Constantes.nomRMI(ipConsole, portConsole, "Console" + refRMI);

    boolean res = true;

    try {
      logger.info(Constantes.nomClasse(this), "Demande de connexion (" + adr + ")");

      // ajout du personnage a la liste
      personnages.put(refRMI, new VuePersonnage(ipConsole, personnage, nbTours, position, refRMI));

      logger.info(Constantes.nomClasse(this), "Connexion acceptee (" + adr + ")");
      logElements();

    } catch (Exception e) {
      logger.severe(Constantes.nomClasse(this), "Echec de connexion (" + adr + ")");
      e.printStackTrace();

      ejectePersonnage(refRMI);

      res = false;
    }

    return res;
  }
Пример #3
0
  /**
   * Ajoute l'increment donne a la caracteristique donne de l'element correspondant a la vue donnee.
   * L'increment peut etre positif ou negatif.
   *
   * @param vuePersonnage client a mettre a jour
   * @param carac caracteristique a mettre a jour
   * @param increment increment a ajouter a la valeur de la caracteristique courante
   * @throws RemoteException
   */
  public void incrementeCaractElement(
      VuePersonnage vuePersonnage, Caracteristique carac, int increment) throws RemoteException {

    int refRMI = vuePersonnage.getRefRMI();
    IConsole console = consoleFromRef(refRMI);
    Personnage pers = vuePersonnage.getElement();

    if (carac == Caracteristique.VIE && increment < 0) {
      increment = (increment * (100 - pers.getCaract(Caracteristique.ARMURE))) / 100;
    }

    // increment de la caracteristique
    pers.incrementeCaract(carac, increment);

    if (pers.estVivant()) {
      if (increment < 0) {
        console.log(
            Level.INFO,
            Constantes.nomClasse(this),
            "J'ai perdu " + -increment + " points de " + carac);

        if (carac == Caracteristique.VIE) {
          setPhrase(refRMI, "Ouch, j'ai perdu " + increment + " points de vie.");
        }

      } else {
        console.log(
            Level.INFO,
            Constantes.nomClasse(this),
            "J'ai gagne " + increment + " points de " + carac);
      }
    }
  }
Пример #4
0
  /**
   * Teste si un personnage doit etre connecte : il est mort, il triche, ou son temps sur l'arene
   * est ecoule. Si oui, le deconnecte.
   *
   * @param refRMI reference du personnage
   * @return vrai si le personnage a ete deconnecte, faux sinon
   * @throws RemoteException
   */
  private boolean verifieDeconnexion(int refRMI) throws RemoteException {
    boolean res = true;
    Personnage personnage = (Personnage) elementFromRef(refRMI);

    if (!personnage.estVivant()) {
      // on teste si le client est vivant
      logger.info(
          Constantes.nomClasse(this), nomRaccourciClient(refRMI) + " est mort... Client ejecte");
      deconnecte(refRMI, "Vous etes mort...", "mort naturelle");

    } else if (!verifieCaracts(personnage)) {
      // on teste la triche
      logger.info(
          Constantes.nomClasse(this),
          nomRaccourciClient(refRMI) + " est un tricheur... Client ejecte");

      deconnecte(refRMI, "Vous etes mort pour cause de triche...", "SHAME!");

    } else if (!personnages.get(refRMI).resteTours()) {
      // on teste le nombre de tours
      logger.info(
          Constantes.nomClasse(this),
          "Fin du nombre de tours de " + nomRaccourciClient(refRMI) + "... Client ejecte");

      deconnecte(refRMI, "Temps autorise dans l'arene ecoule, vous etes elimine !", "temps ecoule");

    } else {
      res = false;
    }

    return res;
  }
Пример #5
0
  @Override
  public boolean ramassePotion(int refRMI, int refPotion) throws RemoteException {
    boolean res = false;

    VuePersonnage vuePersonnage = personnages.get(refRMI);
    VuePotion vuePotion = potions.get(refPotion);

    if (vuePersonnage.isActionExecutee()) {
      // si une action a deja ete executee
      logActionDejaExecutee(refRMI);

    } else {
      // sinon, on tente de jouer l'interaction
      int distance =
          Calculs.distanceChebyshev(vuePersonnage.getPosition(), vuePotion.getPosition());

      // on teste la distance entre le personnage et la potion
      if (distance <= Constantes.DISTANCE_MIN_INTERACTION) {
        new Ramassage(this, vuePersonnage, vuePotion).interagit();
        personnages.get(refRMI).executeAction();

        res = true;
      } else {
        logger.warning(
            Constantes.nomClasse(this),
            nomRaccourciClient(refRMI)
                + " a tente d'interagir avec "
                + vuePotion.getElement().getNom()
                + ", alors qu'il est trop eloigne !\nDistance = "
                + distance);
      }
    }

    return res;
  }
Пример #6
0
  /**
   * Ajoute les logs dans le cas ou le personnage correspondant a la console donnee a tenter
   * d'executer plusieurs fois une action dans le meme tour.
   *
   * @param refRMI console
   * @throws RemoteException
   */
  private void logActionDejaExecutee(int refRMI) throws RemoteException {
    consoleFromRef(refRMI)
        .log(Level.WARNING, "AVERTISSEMENT ARENE", "Une action a deja ete executee ce tour-ci !");

    logger.warning(
        Constantes.nomClasse(this),
        nomRaccourciClient(refRMI) + " a tente de jouer plusieurs actions dans le meme tour");
  }
Пример #7
0
  @Override
  public boolean ajouteArmure(int refRMI, int armure) throws RemoteException {

    VuePersonnage pCible = personnages.get(refRMI);
    IConsole console = consoleFromRef(refRMI);
    console.log(Level.INFO, Constantes.nomClasse(this), "Je gagne " + armure + " armure ");
    this.incrementeCaractElement(pCible, Caracteristique.ARMURE, armure);

    return true;
  }
Пример #8
0
  @Override
  public boolean regenerationMana(int refRMI, int mana) throws RemoteException {

    VuePersonnage pCible = personnages.get(refRMI);
    IConsole console = consoleFromRef(refRMI);
    console.log(Level.INFO, Constantes.nomClasse(this), "Je regagne " + mana + " Mana ");
    new RegenerationMana(this, pCible).regenMana(mana);

    return true;
  }
Пример #9
0
  @Override
  public boolean soin(int refRMI, int mana, int pv) throws RemoteException {
    // TODO Auto-generated method stub

    VuePersonnage pASoigner = personnages.get(refRMI);
    IConsole console = consoleFromRef(refRMI);
    console.log(
        Level.INFO, Constantes.nomClasse(this), "Je me soigne de " + pv + " contre " + mana);
    new Soin(this, pASoigner).soigner(mana, pv);

    return true;
  }
Пример #10
0
  /** Affiche le classement de la partie dans le logger. */
  private void logClassement() {
    List<VuePersonnage> classement = getPersonnagesClassement();

    String msg = "";
    int i = 1;

    for (VuePersonnage vue : classement) {
      msg += "\n" + i + " : " + vue.getElement().getNomGroupe() + " " + vue.getPhrase();
      i++;
    }

    logger.info(Constantes.nomClasse(this), "Classement :" + msg);
  }
Пример #11
0
  @Override
  public synchronized void ajoutePotion(Potion potion, Point position) throws RemoteException {
    int refRMI = alloueRefRMI();
    VuePotion vuePotion = new VuePotion(potion, position, refRMI);

    // ajout de la potion a la liste
    potions.put(refRMI, vuePotion);

    logger.info(
        Constantes.nomClasse(this),
        "Ajout de la potion " + Constantes.nomCompletClient(vuePotion) + " (" + refRMI + ")");

    logElements();
  }
Пример #12
0
  /** Ferme le serveur a la fin de la partie. */
  private void fermerServeur() {
    // afficher le classement dans le log
    logClassement();

    // a la fin de la partie, on ferme la "porte" RMI
    try {
      // deconnection des clients
      List<Integer> listRef = getSortedRefs();

      for (int refRMI : listRef) {
        deconnecte(refRMI, "Fermeture du serveur", "");
      }

      logger.info(Constantes.nomClasse(this), "Fin de la partie ! Fermeture du serveur");

      unexportObject(this, true);

      logger.info(Constantes.nomClasse(this), "Serveur ferme");

    } catch (RemoteException e) {
      e.printStackTrace();
      System.exit(1);
    }
  }
Пример #13
0
  /**
   * Constructeur de l'arene.
   *
   * @param port le port de connexion
   * @param adresseIP nom de la machine qui heberge l'arene
   * @param nbTours duree de vue du serveur en nombre de tours de jeu (si negatif, duree illimitee)
   * @param logger gestionnaire de log
   * @throws RemoteException
   * @throws MalformedURLException
   */
  public Arene(int port, String adresseIP, int nbTours, LoggerProjet logger)
      throws RemoteException, MalformedURLException {

    super();
    this.port = port;
    this.adresseIP = adresseIP;
    this.NB_TOURS = nbTours;

    personnages = new Hashtable<Integer, VuePersonnage>();
    potions = new Hashtable<Integer, VuePotion>();
    personnagesMorts = new ArrayList<VuePersonnage>();

    this.logger = logger;

    // ajout de l'arene au registre RMI
    Naming.rebind(adrToString(), this);

    logger.info(Constantes.nomClasse(this), "Arene cree a l'adresse " + adrToString());

    new Thread(this).start();
  }
Пример #14
0
  public boolean Vampirise(int refRMI, int refRMIAdv) throws RemoteException {
    boolean res = false;

    VuePersonnage client = personnages.get(refRMI);
    VuePersonnage clientAdv = personnages.get(refRMIAdv);

    if (personnages.get(refRMI).isActionExecutee()) {
      // si une action a deja ete executee
      logActionDejaExecutee(refRMI);

    } else {
      // sinon, on tente de jouer l'interaction
      IConsole console = consoleFromRef(refRMI);
      IConsole consoleAdv = consoleFromRef(refRMIAdv);

      int distance =
          Calculs.distanceChebyshev(
              personnages.get(refRMI).getPosition(), personnages.get(refRMIAdv).getPosition());

      // on teste la distance entre les personnages
      if (distance <= Constantes.DISTANCE_MIN_INTERACTION) {
        Personnage pers = (Personnage) elementFromRef(refRMI);
        Personnage persAdv = (Personnage) elementFromRef(refRMIAdv);

        // on teste que les deux personnages soient en vie
        if (pers.estVivant() && persAdv.estVivant()) {
          console.log(
              Level.INFO,
              Constantes.nomClasse(this),
              "Je decoupe " + nomRaccourciClient(refRMIAdv));
          consoleAdv.log(
              Level.INFO,
              Constantes.nomClasse(this),
              "Je me fait massacrer par " + nomRaccourciClient(refRMI));

          logger.info(
              Constantes.nomClasse(this),
              nomRaccourciClient(refRMI)
                  + " attaque "
                  + nomRaccourciClient(consoleAdv.getRefRMI()));

          new Vampirise(this, client, clientAdv).interagit();
          personnages.get(refRMI).executeAction();

          // si l'adversaire est mort
          if (!persAdv.estVivant()) {
            setPhrase(refRMI, "Je tue " + nomRaccourciClient(consoleAdv.getRefRMI()));
            console.log(
                Level.INFO, Constantes.nomClasse(this), "Je tue " + nomRaccourciClient(refRMI));

            logger.info(
                Constantes.nomClasse(this),
                nomRaccourciClient(refRMI) + " tue " + nomRaccourciClient(consoleAdv.getRefRMI()));
          }

          res = true;
        } else {
          logger.warning(
              Constantes.nomClasse(this),
              nomRaccourciClient(refRMI)
                  + " a tente d'interagir avec "
                  + nomRaccourciClient(refRMIAdv)
                  + ", alors qu'il est mort...");

          console.log(
              Level.WARNING,
              Constantes.nomClasse(this),
              nomRaccourciClient(refRMIAdv) + " est deja mort !");
        }
      } else {
        logger.warning(
            Constantes.nomClasse(this),
            nomRaccourciClient(refRMI)
                + " a tente d'interagir avec "
                + nomRaccourciClient(refRMIAdv)
                + ", alors qu'il est trop eloigne... Distance de chebyshev = "
                + distance);

        console.log(
            Level.WARNING,
            "AVERTISSEMENT ARENE",
            nomRaccourciClient(refRMIAdv) + " est trop eloigne !\nDistance = " + distance);
      }
    }

    return res;
  }
Пример #15
0
  @Override
  public void run() {
    // thread executant la strategie de chaque personnage
    ThreadStrategie ts;

    // liste qui va contenir les references RMI des personnages,
    // ordonnees par leur initiative
    List<Integer> listRef;

    while (!partieFinie) {
      // moment de debut du tour
      long begin = System.currentTimeMillis();

      // on verouille le serveur durant un tour de jeu pour ne pas avoir
      // de connexion/deconnexion
      synchronized (this) {
        // tri des references par initiative
        listRef = getSortedRefs();

        // pour chaque personnage, on joue sa strategie
        for (int refRMI : listRef) {
          try {
            // si pas deconnecte
            if (!verifieDeconnexion(refRMI)) {

              // lancement de la strategie (dans un thread separe)
              ts = new ThreadStrategie(consoleFromRef(refRMI));

              // attente de la fin de la strategie (temps d'attente max 1 seconde)
              ts.join(1000);

              // finit le tour pour ce client
              personnages.get(refRMI).termineTour();

              if (ts.isAlive()) {
                // si le thread est toujours vivant apres une
                // seconde (la strategie n'est pas terminee),
                // on l'ejecte
                logger.info(
                    Constantes.nomClasse(this),
                    "Execution de la strategie de "
                        + nomRaccourciClient(refRMI)
                        + " trop longue ! Client ejecte");

                deconnecte(refRMI, "Execution de strategie trop longue. Degage !", "trop lent");

              } else {
                // on reteste apres l'execution de la strategie
                verifieDeconnexion(refRMI);
              }
            }

          } catch (RemoteException e) {
            logger.severe(
                Constantes.nomClasse(this),
                "Erreur dans le run "
                    + "avec la console de reference "
                    + refRMI
                    + "\n"
                    + e.toString());
            e.printStackTrace();
            ejectePersonnage(refRMI);
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
        }
      }

      tour++;
      verifierPartieFinie();

      try {
        long dureeTour = System.currentTimeMillis() - begin;

        // dormir au plus 1 seconde pour permettre
        // la connexion/deconnexion des consoles
        long time = 1000 - dureeTour;

        if (time > 0) {
          Thread.sleep(time);
        }

      } catch (InterruptedException e) {
        logger.severe(Constantes.nomClasse(this), "Erreur : run\n" + e.toString());
        e.printStackTrace();
      }
    }

    fermerServeur();
  }
Пример #16
0
 /**
  * Ejecte un personnage : le retire de la liste des vivants et ajoute une information dans le log.
  *
  * @param refRMI reference du personnage a ejecter
  */
 protected void ejectePersonnage(int refRMI) {
   if (personnages.remove(refRMI) != null) {
     logger.info(Constantes.nomClasse(this), "Console " + refRMI + " ejectee du registre !");
   }
 }
Пример #17
0
 /** Affiche tous les elements present dans l'arene dans le logger. */
 public void logElements() {
   String msg = getPrintElementsMessage();
   logger.info(Constantes.nomClasse(this), "Compte-rendu :" + msg);
 }