package system.item;

import br.ufsc.inf.leobr.cliente.Jogada;
import system.item.skill.Affliction;

/**
 * Classe cheia de booleanos que definem o que uma Skill pode afetar e de qual maneira é afetado.<br>
 * Seu uso primário é definir para onde os valores de dano vão (Hp, Mp, os dois ou nenhum), qual <br>
 * o elemento da Skill, quais Affliction ela causa e buffs/debuffs nos atributos do personagem ao acertar.
 */
public class Effect implements Jogada {
	
	/**
	 * Serve pra não dar merda na serialização de objetos.
	 */
	private static final long serialVersionUID = -2202300194433401823L;
	
	/**
	 * Ignora alvos da equipe inimiga.
	 */
	private boolean ignoreHostiles;
	/**
	 * Permite a possibilidade de acertar aliados.
	 */
	private boolean friendlyFire;
	/**
	 * Revive os alvos.
	 */
	private boolean revive;
	/**
	 * Pode ter acerto crítico.
	 */
	private boolean canCritical;
	/**
	 * A Skill tem como alvo o próprio usuário.
	 */
	private boolean selfTargeted;
	/**
	 * O valor causado em dano é convertido para seu respectivo atributo.<br>
	 * Hp para Hp, Mp para Mp.
	 */
	private boolean drain;
	/**
	 * A Skill afeta o Hp dos alvos.
	 */
	private boolean affectHp;
	/**
	 * A Skill afeta o Mp dos alvos.
	 */
	private boolean affectMp;
	/**
	 * A Skill não pode errar.
	 */
	private boolean cannotMiss;
	/**
	 * Quais elementos estão presentes na Skill.
	 */
	private boolean[] elementalAttack;
	
	/**
	 * Quais status negativos ela pode causar.
	 */
	private Affliction[] afflictions;

	/**
	 * Inicializa um novo efeito para a habilidade.
	 * @param ignoreHostiles - ignora alvos da equipe inimiga
	 * @param friendlyFire - permite alvos aliados
	 * @param revive - revive os alvos afetados
	 * @param canCritical - pode ter acerto crítico
	 * @param selfTargeted - o alvo é o próprio usuário
	 * @param drain - o valor causado em dano é convertido para seu respectivo atributo. Hp para Hp, Mp para Mp.
	 * @param affectHp - afeta o Hp dos alvos
	 * @param affectMp - afeta o Mp dos alvos
	 * @param cannotMiss - a skill não pode errar
	 * @param elementalAttack - quais elementos estão presentes na Skill:<br>
	 * [0] - Melee (Corpo a corpo)<br>
	 * [1] - Ranged (Á distância)<br>
	 * [2] - NonElemental (Não elemental)<br>
	 * [3] - Fire (Fogo)<br>
	 * [4] - Ice (Gelo)<br>
	 * [5] - Thunder (Trovão)<br>
	 * [6] - Wind (Vento)<br>
	 * [7] - Dragon (Dragão)<br>
	 * @param afflictions - quais status negativos ela pode causar:<br>
	 * [0] - KO (morto, nocauteado)<br>
	 * [1] - Poisoned (DoT)<br>
	 * [2] - Burned (DoT mais forte por menos tempo)<br>
	 * [3] - Confused (perde o controle do personagem)<br>
	 * [4] - Sleeping (não age, regenera hp e mp, não esquiva, leva mais dano)<br>
	 * [5] - Frozen (nao age, não esquiva)<br>
	 * [6] - Shocked (não esquiva)<br>
	 * [7] - Paralyzed (não age, não esquiva)<br>
	 * [8] - Blind (reduz a precisão)
	 */
	public Effect(boolean ignoreHostiles, boolean friendlyFire, boolean revive, boolean canCritical,
			boolean selfTargeted, boolean drain, boolean affectHp, boolean affectMp, boolean cannotMiss,
			boolean[] elementalAttack, Affliction[] afflictions) {
		this.ignoreHostiles = ignoreHostiles;
		this.friendlyFire = friendlyFire;
		this.revive = revive;
		this.canCritical = canCritical;
		this.selfTargeted = selfTargeted;
		this.drain = drain;
		this.affectHp = affectHp;
		this.affectMp = affectMp;
		this.cannotMiss = cannotMiss;
		this.elementalAttack = elementalAttack;
		this.afflictions = afflictions;
	}
	
	// --------------------------------------------------------------------------------------------
	// Getters e setters
	// --------------------------------------------------------------------------------------------
	
	public boolean isIgnoreHostiles() {
		return ignoreHostiles;
	}

	public boolean isFriendlyFire() {
		return friendlyFire;
	}
	
	public boolean isRevive() {
		return revive;
	}
	
	public boolean isCanCritical() {
		return canCritical;
	}
	
	public boolean isSelfTargeted() {
		return selfTargeted;
	}
	
	public boolean isDrain() {
		return drain;
	}

	public boolean isAffectHp() {
		return affectHp;
	}

	public boolean isAffectMp() {
		return affectMp;
	}

	public boolean isCannotMiss() {
		return cannotMiss;
	}

	public boolean isElementMelee() {
		return elementalAttack[0];
	}
	
	public boolean isElementRanged() {
		return elementalAttack[1];
	}
	
	public boolean isElementNonElemental() {
		return elementalAttack[2];
	}
	
	public boolean isElementFire() {
		return elementalAttack[3];
	}
	
	public boolean isElementIce() {
		return elementalAttack[4];
	}
	
	public boolean isElementThunder() {
		return elementalAttack[5];
	}
	
	public boolean isElementWind() {
		return elementalAttack[6];
	}
	
	public boolean isElementDragon() {
		return elementalAttack[7];
	}
	
	public Affliction[] getAfflictions() {
		return afflictions;
	}
}
