package game.entity;
import beans.core.GeneralConstant;
import beans.enumeration.Element;
import beans.enumeration.Stat;
import beans.enumeration.Target;
import beans.enumeration.Type;
import beans.enumeration.TypeEquipment;
import beans.serializable.*;
import game.control.StatsController;
import game.model.Emotion;
import game.model.EmotionFactory;
import java.awt.Point;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Observable;
/**
* Fighter sert a representer en combat toutes classes capable de se battre
* (joueur, Monstres...).
*
* Bien que etant dans le modele, il possede un composant obtenable via getImg()
* qui appartient a la vue et lui permet de s'afficher ainsi que ses
* dommages/soin recu.
*
* Il possede egalement un attribut obtenable via getStatReference() qui est un
* composant affichant ses stats, dont sa jauge d'ATB qui est modifiable via
* setJaugeATB(double atb).
*
* De plus on peut lui indiquer sa JList_Combat qu'on lui a associé, pour qu'il
* la supprime lorsqu'il meurt.
*
*
* @author Pierre
* @version Fighter 1.0
* @since Game 1.0
*/
public class Fighter extends Observable {
/**
*
* @since Fighter 1.0
*/
protected boolean allie;
/**
*
* @since Fighter 1.0
*/
protected StatsController statsController;
/**
* Creer le combattant avec les stats indique; Lance une erreur
* d'entree/sortie en cas d'image non trouve.
*
* @param statPerso
* @since Fighter 1.0
*/
public Fighter(final StatsPerso statPerso, final String imagePath) {
allie = false;
this.statsController = new StatsController(statPerso);
initEquipment();
}
/**
* Fais jouer le combattant pour attaquer un ou plusieurs des personnages
* passe en parametre. Actuellement gere juste la recuperation de pm. Peut
* aussi soigner/renforcer leur allies. Peut necessiter une IA ou
* l'intervention du joueur.
*
* @since Fighter 1.0
*/
public void jouer() {
//FIXME : a faire
}
/**
* Modifie les pv du personnages, et le tue eventuellement; Un nombre
* negatif indique que le personnage perds des pv. Les pv ne peuvent
* depasser ceux de depart;
*
* @param nb
* @since Fighter 1.0
*/
public void regainHP(final int nb) {
//FIXME : a faire
}
/**
* Modifie les pm du personnage; Le parametre peut etre negatif.
*
* @param nb
* @since Fighter 1.0
*/
public void regainMP(final int nb) {
//FIXME : a faire
}
/**
* Renvoi une liste des sorts que le personnage peut lancer en fonction du
* cout en pm.
*
* @return
* @since Fighter 1.0
*/
public List<Spell> sortsDispo() {
final List<Spell> spells = statsController.getPermanentStats().getSpells();
final List<Spell> rep = new ArrayList<Spell>(spells.size() + 1);
for (final Spell magie : spells) {
//if (magie.getCout().get(Stat.MP) <= statsPerso.getMP()) {
rep.add(magie);
//}
}
return rep;
}
/**
* Enleve un exemplaire de l'objet indiquer de l'inventaire du personnage.
*
* @param objet
* @since Fighter 1.0
*/
public void useObjet(final Objet objet) {
final Map<Objet, Integer> objets = statsController.getPermanentStats().getObjets();
final int quantity = objets.get(objet);
if (quantity <= 0) {
System.out.println("Le combattant " + statsController.getPermanentStats().getName()
+ " ne peut utiliser l'objet " + objet
+ " car il en possede " + quantity + " exemplaire(s).");
} else if (objet.getTarget() == Target.NONE) {
System.out.println("Le combattant " + statsController.getPermanentStats().getName()
+ " ne peut utiliser l'objet " + objet
+ " car il n'a aucun effet");
}
objets.put(objet, quantity - 1);
if (objets.get(objet) <= 0) {
objets.remove(objet);
}
}
/**
*
* @return @since Fighter 1.0
*/
@Override
public String toString() {
return statsController.getPermanentStats().getName();
}
private void initEmotion() {
final String name = statsController.getPermanentStats().getName();
EmotionFactory.addElement(name, new Emotion(GeneralConstant.PERSO_FACE_PATH, "normal", new Point(0, 0)));
final Emotion emotion = EmotionFactory.getPanelEmotion(name);
emotion.addEmotion("joie", new Point(3, 0));
emotion.addEmotion("triste", new Point(2, 1));
}
/**
* Ajoute un objet à la liste d'objet du joueur
*
* @param objet
* @param newQuantity
* @since Fighter 1.0
*/
public void addObjet(final Objet objet, final int newQuantity) {
final Map<Objet, Integer> objets = statsController.getPermanentStats().getObjets();
final int lastQuantity = objets.get(objet);
objets.put(objet, lastQuantity + newQuantity);
}
/**
*
* @return @since Fighter 1.0
*/
public String getName() {
return statsController.getPermanentStats().getName();
}
/**
*
* @return @since Fighter 1.0
*/
public StatsController getStat() {
return statsController;
}
/**
* Permet de faire gagner de l'expérience du personnage plus tard un monstre
* aura son propre nombre d'Exp gagné
*
* @param expGagne
* @since Fighter 1.0
*/
public void gainExp(int expGagne) {
//FIXME : a faire
}
public void appliqueChangeStatut(final List<ChangeStatut> changeStatuts) {
for (final ChangeStatut statut : changeStatuts) {
final Stat statReference = statut.getStatReference();
int damage = statut.getImpact() * statsController.getTotal(statReference);
final Stat statCible = statut.getStatCible();
switch (statut.getType()) {
case AGRESSIVE:
//FIXME : A voir en fonction des cas, pour l'instant c'est du temporaire
statsController.substract(damage, statCible, false);
break;
case HEAL:
//FIXME : A voir en fonction des cas, pour l'instant c'est du temporaire
statsController.increase(damage, statCible, false);
break;
default:
break;
}
}
}
/**
* Dit si ce combattant est un adversaire du joueur ou un allié.
*
* @return
* <code>true</code> si c'est un adversaire,
* <code>false</code> sinon.
* @since Fighter 1.0
*/
public boolean isPlayerEnemy() {
//TODO: A définir d'urgence.
return false;
}
/**
* Appliquer les changements de statut dues à des coûts
*
* @param cost La liste de coûts
* @since Fighter 1.0
* @see Cost
*/
public void appliqueChangeStatutFromCost(List<Cost> cost) {
// Liste des changements de status
List<ChangeStatut> changes = new ArrayList<ChangeStatut>();
// Pour chaque coût
for (Cost current : cost) {
// Ajouter le changement de statut correspondant au coût
changes.add(current.getChangeStatut());
}
// Appliquer les changements
appliqueChangeStatut(changes);
}
/**
* Retourne les changements de statuts d'une attaque.
*
* @return Les changements de statuts d'une attaque.
* @since Fighter 1.0
* @see ChangeStatut
*/
public List<ChangeStatut> getAttack() {
// Liste des changements de statuts
ArrayList<ChangeStatut> changes = new ArrayList<ChangeStatut>();
// Récupérer les dommages du personnage
changes.add(new ChangeStatut(Type.AGRESSIVE, Element.NONE, getStat().getPhysicalDamages(), Stat.STRENGTH, Stat.HP));
// Renvoyer les changements
return changes;
}
public Map<TypeEquipment, Equipment> getEquipment() {
return statsController.getPermanentStats().getEquipment();
}
public void initEquipment() {
statsController.initEquipment();
}
}