/**
* 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;
}
@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;
}
/**
* 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);
}
}
}
/**
* 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;
}
@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;
}
/**
* 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");
}
@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;
}
@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;
}
@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;
}
/** 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);
}
@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();
}
/** 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);
}
}
/**
* 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();
}
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;
}
@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();
}
/**
* 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 !");
}
}
/** 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);
}