@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;
}
@Override
public HashMap<Integer, Point> getVoisins(int refRMI) throws RemoteException {
HashMap<Integer, Point> res = new HashMap<Integer, Point>();
VuePersonnage courant = personnages.get(refRMI);
VuePersonnage tempPers;
// personnages
for (int refVoisin : personnages.keySet()) {
tempPers = personnages.get(refVoisin);
if (estVoisin(courant, tempPers)) {
res.put(refVoisin, tempPers.getPosition());
}
}
VuePotion tempPot;
// potions
for (int refVoisin : potions.keySet()) {
tempPot = potions.get(refVoisin);
if (estVoisin(courant, tempPot)) {
res.put(refVoisin, tempPot.getPosition());
}
}
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);
}
}
}
@Override
public boolean Fuite(int refRMI, int refRMIaFuir) throws RemoteException {
boolean res = false;
VuePersonnage client = personnages.get(refRMI);
if (client.isActionExecutee()) {
// si une action a deja ete executee
logActionDejaExecutee(refRMI);
} else {
Point pMoi = this.getPosition(refRMI);
Point pAFuir = this.getPosition(refRMIaFuir);
Point objectif = pMoi;
if (pMoi.getX() - pAFuir.getX() > 0) objectif.x++;
else objectif.x--;
if (pMoi.getY() - pAFuir.getY() > 0) objectif.y++;
else objectif.y--;
// sinon, on tente de jouer l'interaction
new Deplacement(client, getVoisins(refRMI)).seDirigeVers(objectif);
client.executeAction();
res = true;
}
return res;
}
/** 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);
}
/**
* Verifie que les deux elements sont voisins, l'element courant etant un personnage. Pour etre un
* voisin : ils doivent etre differents, ils doivent etre a une distance inferieure ou egale a la
* vision, il doivent etre actifs.
*
* @param courant personnage courant
* @param voisin element voisin
* @return vrai si l'element donne est bien un voisin
*/
private boolean estVoisin(VuePersonnage courant, VueElement<?> voisin) throws RemoteException {
boolean res =
courant.getElement().estVivant()
&& Calculs.distanceChebyshev(voisin.getPosition(), courant.getPosition())
<= Constantes.VISION;
if (voisin instanceof VuePersonnage) { // potion
res =
res
&& ((VuePersonnage) voisin).getElement().estVivant()
&& voisin.getRefRMI() != courant.getRefRMI();
}
return res;
}
@Override
public boolean deplaceRapidement(int refRMI, Point objectif) throws RemoteException {
boolean res = false;
VuePersonnage client = personnages.get(refRMI);
if (client.isActionExecutee()) {
// si une action a deja ete executee
logActionDejaExecutee(refRMI);
} else {
// sinon, on tente de jouer l'interaction
new DeplacementRapide(client, getVoisins(refRMI)).seDirigeVers(objectif);
client.executeAction();
res = true;
}
return res;
}
@Override
public boolean invoquer(int refRMI, int nbSbires) throws RemoteException {
// TODO Auto-generated method stub
boolean res = false;
VuePersonnage invoqueur = personnages.get(refRMI);
if (invoqueur.isActionExecutee()) {
// si une action a deja ete executee
logActionDejaExecutee(refRMI);
} else {
// sinon, on tente de jouer l'interaction
new Invocation(this, invoqueur, nbSbires).invoquerSbires();
invoqueur.executeAction();
res = true;
}
return res;
}
/**
* Renvoie la liste des references triees par ordre de passage en fonction de l'initiative.
*
* @return liste de toutes les references des personnages de la partie, ordonnee par initiative
* (decroissante)
*/
private List<Integer> getSortedRefs() {
// on cree une priority queue de paires reference RMI/initiative du
// personnage
// en ajoutant des paires dans la queue, elles automatiquement seront
// classees en suivant leur methode compareTo
Queue<PaireRefRMIIntitiative> queueRefsInitiative = new PriorityQueue<PaireRefRMIIntitiative>();
for (VuePersonnage client : personnages.values()) {
queueRefsInitiative.offer(
new PaireRefRMIIntitiative(
client.getRefRMI(), client.getElement().getCaract(Caracteristique.INITIATIVE)));
}
// on recupere juste les references
List<Integer> listeRefsTriees = new ArrayList<Integer>();
while (!queueRefsInitiative.isEmpty()) {
listeRefsTriees.add(queueRefsInitiative.poll().getRef());
}
return listeRefsTriees;
}
@Override
public void deconnecte(int refRMI, String cause, String phrase) throws RemoteException {
// enregistrement des infos de la console lors de sa deconnexion,
// le but etant de garder des informations sur les deconnectes
VuePersonnage vuePersonnage = personnages.get(refRMI);
vuePersonnage.getElement().tue(); // au cas ou ce ne serait pas une mort "naturelle"
vuePersonnage.setTourMort(tour);
setPhrase(refRMI, "MORT >_< (" + phrase + ")");
// ajout a la liste des morts
personnagesMorts.add(vuePersonnage);
try {
// fermeture de la console en donnant la raison
consoleFromRef(refRMI).deconnecte(cause);
} catch (UnmarshalException e) {
e.printStackTrace();
}
// suppression de la liste des vivants
ejectePersonnage(refRMI);
}
