package system.character;

import java.math.BigDecimal;

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

/**
 * Define-se aqui nesta classe os traços dos personagens, tais como o hp, mp, ataque e etc.<br>
 * Cada objeto que deseja alterar ou operar com as variáveis deve possuir uma instância desta classe.
 * */
public class CharacterTraits implements Jogada {

	/**
	 * Serve pra não dar merda na serialização de objetos.
	 */
	private static final long serialVersionUID = 7027080714859210083L;

	/**
	 * Valor máximo tanto positivo quanto negativo dos parâmetros
	 * */
	public static final int MAX_PARAMETER_VALUE = 999999;
	
	// -------------------------------------------
	// Constantes de resistência
	// -------------------------------------------
	/**
	 * Constante que determina o quão fraco ou forte tal traço é. DRAIN = -100%.
	 * */
	public static final double DRAIN = -1.0;
	/**
	 * Constante que determina o quão fraco ou forte tal traço é. NULL = 0%.
	 * */
	public static final double NULL = 0.0;
	/**
	 * Constante que determina o quão fraco ou forte tal traço é. RESISTANT = 50%.
	 * */
	public static final double RESISTANT = 0.5;
	/**
	 * Constante que determina o quão fraco ou forte tal traço é. STRONG = 75%.
	 * */
	public static final double STRONG = 0.75;
	/**
	 * Constante que determina o quão fraco ou forte tal traço é. NORMAL = 100%.
	 * */
	public static final double NEUTRAL = 1.0;
	/**
	 * Constante que determina o quão fraco ou forte tal traço é. WEAK = 125%.
	 * */
	public static final double WEAK = 1.25;
	/**
	 * Constante que determina o quão fraco ou forte tal traço é. AVERSE = 150%.
	 * */
	public static final double AVERSE = 1.5;

	/**
	 * Define a quantidade de parâmetros principais.
	 * */
	private int mainParametersQuantity = 7;
	/**
	 * Define a quantidade de parâmetros secundários. Deixe no mínimo 1.
	 * */
	private int secondaryParametersQuantity = 5;
	/**
	 * Define a quantidade de elementos. Deixe no mínimo 1.
	 * */
	private int elementsQuantity = 8;
	/**
	 * Define a quantidade de status negativos.
	 */
	private int afflictionQuantity = 9;
	
	// -------------------------------------------
	// Parâmetros principais
	// -------------------------------------------
	/**
	 * Matriz de parâmetros principais base. As posições equivalem respectivamente aos seguintes parâmetros:<P>
	 * [0] - hp<br>
	 * [1] - maxhp<br>
	 * [2] - mp<br>
	 * [3] - maxMp<br>
	 * [4] - attack<br>
	 * [5] - defense<br>
	 * [6] - speed
	 * */
	private int[] mainParameters = new int[mainParametersQuantity];
	/**
	 * Matriz de parâmetros principais adicionais. Ela serve para controlar os valores adicionais dos seus
	 * respectivos parâmetros.
	 * */
	private int[] mainParametersPlus = new int[mainParametersQuantity];
	/**
	 * Matriz de modificadores dos parâmetros principais base.
	 * */
	private double[] mainParametersModifiers = new double[mainParametersQuantity];
	
	// -------------------------------------------
	// Parâmetros secundários
	// -------------------------------------------
	/**
	 *  Matriz de parâmetros secundários base. As posições equivalem respectivamente aos seguintes parâmetros:<P>
	 * [0] - accuracy<br>
	 * [1] - evasion<br>
	 * [2] - physicalCritical<br>
	 * [3] - hpRegenRate<br>
	 * [4] - mpRegenRate
	 * */
	private double[] secondaryParameters = new double[secondaryParametersQuantity];
	/**
	 * Matriz de parâmetros secundários adicionais. Ela serve para controlar os valores adicionais dos seus
	 * respectivos parâmetros.
	 * */
	private double[] secondaryParametersPlus = new double[secondaryParametersQuantity];
	/**
	 * Matriz de modificadores dos parâmetros secundários base.
	 * */
	private double[] secondaryParametersModifiers = new double[secondaryParametersQuantity];
	
	/**
	 * Matriz de modificadores de dano dos elementos. As posições equivalem respectivamente aos seguintes
	 * elementos:<p>
	 * [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>
	 * */
	private double[] elementalResistance = new double[elementsQuantity];
	
	/**
	 * Condições negativas presentes no personagem.
	 */
	private Affliction[] afflictions = new Affliction[afflictionQuantity];

	/**
	 * Define se o personagem está ativo ou não
	 * */
	private boolean active;
	/**
	 * Define se o personagem pode agir
	 * */
	private boolean restricted;
	/**
	 * Define se o jogador pode atribuir uma ação ao personagem. False = pode.
	 * */
	private boolean autoBattle;
	
	/**
	 * Inicializa uma instância de Traços.
	 * Utilize os métodos a seguir para inicializar uns parâmetros chatos:<br>
	 * clearParametersModifier()<br>
	 * clearSecondaryParametersModifier()<br>
	 * clearElementalDefenses()
	 * */
	public CharacterTraits() {	}
	
	/**
	 * Adiciona os parâmetros principais e secundários deste objeto Traços com os de outro.
	 * @param traits - os CharacterTraits a serem somados neste objeto.
	 * @return this.Traits + traits.
	 * */
	public CharacterTraits addTraits(CharacterTraits traits) {
		for (int i = 0; i < mainParameters.length; i++) {
			this.mainParameters[i] += traits.getMainParameters()[i];
		}
		
		for (int i = 0; i < mainParametersPlus.length; i++) {
			this.mainParametersPlus[i] += traits.getMainParametersPlus()[i];
		}
		
		for (int i = 0; i < mainParametersModifiers.length; i++) {
			this.mainParametersModifiers[i] += traits.getMainParametersModifiers()[i];
		}
		
		for (int i = 0; i < secondaryParameters.length; i++) {
			this.secondaryParameters[i] += traits.getSecondaryParameters()[i];
		}
		
		for (int i = 0; i < secondaryParametersPlus.length; i++) {
			this.secondaryParametersPlus[i] += traits.getSecondaryParametersPlus()[i];
		}
		
		for (int i = 0; i < secondaryParametersModifiers.length; i++) {
			this.secondaryParametersModifiers[i] += traits.getSecondaryParametersModifiers()[i];
		}
		
		return this;
	}
	
	/**
	 * Subtrai os parâmetros principais e secundários deste objeto Traços com os de outro.
	 * @param traits - os CharacterTraits a serem subtraídos deste objeto.
	 * @return this.Traits - traits.
	 * */
	public CharacterTraits substractTraits(CharacterTraits traits) {
		for (int i = 0; i < mainParameters.length; i++) {
			this.mainParameters[i] -= traits.getMainParameters()[i];
		}
		
		for (int i = 0; i < mainParametersPlus.length; i++) {
			this.mainParametersPlus[i] -= traits.getMainParametersPlus()[i];
		}
		
		for (int i = 0; i < mainParametersModifiers.length; i++) {
			this.mainParametersModifiers[i] -= traits.getMainParametersModifiers()[i];
		}
		
		for (int i = 0; i < secondaryParameters.length; i++) {
			this.secondaryParameters[i] -= traits.getSecondaryParameters()[i];
		}
		
		for (int i = 0; i < secondaryParametersPlus.length; i++) {
			this.secondaryParametersPlus[i] -= traits.getSecondaryParametersPlus()[i];
		}
		
		for (int i = 0; i < secondaryParametersModifiers.length; i++) {
			this.secondaryParametersModifiers[i] -= traits.getSecondaryParametersModifiers()[i];
		}
		
		return this;
	}
	
	/**
	 * Retorna o percentual da relação [mainParameters[0]]/[mainParameters[1]] em até 3 dígitos decimais
	 * */
	public double hpRatio() {
		return new BigDecimal(new Double(mainParameters[0]) / new Double(mainParameters[1])).setScale(3, BigDecimal.ROUND_HALF_UP).doubleValue();
	}
	
	/**
	 * Retorna o percentual da relação [mainParameters[2]]/[mainParameters[3]] em até 3 dígitos decimais
	 * */
	public double mpRatio() {
		return new BigDecimal(new Double(mainParameters[2]) / new Double(mainParameters[3])).setScale(3, BigDecimal.ROUND_HALF_UP).doubleValue();
	}
	
	/**
	 * Retorna um valor inteiro do [hp] com base no percentual [percantageOfCurrentHp].<P>
	 * Ex: hp =  100, percentageOfCurrentHp = 0.2, valorQueSeraRetornado = 20.
	 * @deprecated
	 * */
	public int percentageOfCurrentHp(double percentageOfCurrentHp) {
		return new BigDecimal(getHp() * percentageOfCurrentHp).setScale(3, BigDecimal.ROUND_HALF_UP).intValue();
	}
	
	/**
	 * Retorna um valor inteiro do [maxHp] com base no percentual [percantageOfMaxHp].<P>
	 * Ex: maxHp =  1000, percentageOfMaxHp = 0.2, valorQueSeraRetornado = 200.
	 * */
	public int percentageOfMaxHp(double percentageOfMaxHp) {
		return new BigDecimal(totalMainParameter(1) * percentageOfMaxHp).setScale(3, BigDecimal.ROUND_HALF_UP).intValue();
	}
	
	/**
	 * Retorna um valor inteiro do [mp] com base no percentual [percentageOfCurrentMp].<P>
	 * Ex: mp =  10, percentageOfCurrentMp = 0.2, valorQueSeraRetornado = 2.
	 * @deprecated
	 * */
	public int percentageOfCurrentMp(double percentageOfCurrentMp) {
		return new BigDecimal(getMp() * percentageOfCurrentMp).setScale(3, BigDecimal.ROUND_HALF_UP).intValue();
	}
	
	/**
	 * Retorna um valor inteiro do [maxMp] com base no percentual [percentageOfMaxMp].<P>
	 * Ex: maxMp =  100, percentageOfMaxMp = 0.2, valorQueSeraRetornado = 20.
	 * */
	public int percentageOfMaxMp(double percentageOfMaxMp) {
		return new BigDecimal(totalMainParameter(3) * percentageOfMaxMp).setScale(3, BigDecimal.ROUND_HALF_UP).intValue();
	}
	
	/**	
	 * Retorna o valor total do parâmetro indicado por mainParameterIndex.<br>
	 * As posições equivalem respectivamente aos seguintes parâmetros:<P>
	 * [0] - hp<br>
	 * [1] - maxhp<br>
	 * [2] - mp<br>
	 * [3] - maxMp<br>
	 * [4] - attack<br>
	 * [5] - defense<br>
	 * [6] - speed
	 * @param mainParameterIndex - o índice do parâmetro a ser retornado
	 * @return (int) (sumOfMainParameter(mainParameterIndex) * mainParametersModifiers[mainParameterIndex])
	 * */
	public int totalMainParameter(int mainParameterIndex) {
		int totalMainParameterInteger = (int) (sumOfMainParameter(mainParameterIndex) * mainParametersModifiers[mainParameterIndex]);
		
		if (totalMainParameterInteger <= MAX_PARAMETER_VALUE && totalMainParameterInteger >= -MAX_PARAMETER_VALUE) {
			return totalMainParameterInteger;
		}else {
			return MAX_PARAMETER_VALUE;
		}
	}
	
	/**
	 * Soma o determinado parâmetro principal com seu adicional.
	 * @param mainParameterIndex - o índice do parâmetro a ser examinado
	 * @return a soma de [mainParameters[mainParameterIndex]] com mainParametersPlus[mainParameterIndex]
	 * */
	public int sumOfMainParameter(int mainParameterIndex) {
		return mainParameters[mainParameterIndex] + mainParametersPlus[mainParameterIndex];
	}
	
	/**
	 * Retorna o valor total do parâmetro indicado por secondaryParameterIndex.<br>
	 * As posições equivalem respectivamente aos seguintes parâmetros:<P>
	 * [0] - accuracy<br>
	 * [1] - evasion<br>
	 * [2] - physicalCritical<br>
	 * [3] - hpRegenRate<br>
	 * [4] - mpRegenRate
	 * @param secondaryParameterIndex - o índice do parâmetro a ser retornado
	 * @return sumOfSecondaryParameter(secondaryParameterIndex) * secondaryParametersModifiers[secondaryParameterIndex]
	 * */
	public double totalSecondaryParameter(int secondaryParameterIndex) {
		return sumOfSecondaryParameter(secondaryParameterIndex) * secondaryParametersModifiers[secondaryParameterIndex];
	}
	
	/**
	 * Soma o determinado parâmetro principal com seu adicional.
	 * @param secondaryParameterIndex - o índice do parâmetro a ser examinado
	 * @return a soma de [secondaryParameters[secondaryParameterIndex]] com [secondaryParametersPlus[secondaryParameterIndex]]
	 * */
	public double sumOfSecondaryParameter(int secondaryParameterIndex) {
		return secondaryParameters[secondaryParameterIndex] + secondaryParametersPlus[secondaryParameterIndex];
	}
		
	/**
	 * Reseta os modificadores dos parâmetros de volta ao valor original (100%)
	 * */
	public void clearParametersModifier() {
		for (int i = 0; i < mainParametersModifiers.length; i++) {
			mainParametersModifiers[i] = 1;
		}
	}
	
	/**
	 * Reseta os modificadores dos parâmetros de volta ao valor original (100%)
	 * */
	public void clearSecondaryParametersModifier() {
		for (int i = 0; i < secondaryParametersModifiers.length; i++) {
			secondaryParametersModifiers[i] = 1;
		}
	}
	
	/**
	 * Inicializa todas as defesas elementais como NEUTRAL.
	 * */
	public void clearElementalDefenses() {
		for (int i = 0; i < elementalResistance.length; i++) {
			elementalResistance[i] = NEUTRAL;
		}
	}
	
	/**
	 * Adiciona um status negativo conforme seu id.<p>
	 * [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)
	 * @param id - id do status negativo a ser adicionado.
	 */
	public void addAffliction(int id) {
		afflictions[id] = (Affliction) DatabaseLoader.loadDatabaseElement("afflictions", id);
	}
	
	/**
	 * Remove um status negativo conforme seu id.
	 * @param id - id do status negativo a ser removido.
	 */
	public void removeAffliction(int id) {
		afflictions[id] = null;
	}
	
	/**
	 * Retorna verdadeiro se há o status negativo id no personagem.
	 * @param id - o índice do status negativo
	 * @return - true se houver, false caso contrário
	 */
	public boolean hasAffliction(int id) {
		if (afflictions[id] != null) {
			return true;
		} else {
			return false;
		}
	}
	
	/**
	 * Limpa a lista de Status negativos de elementos.
	 */
	public void clearAllAfflictions() {
		for (int i = 0; i < afflictions.length; i++) {
			afflictions[i] = null;
		}
	}
	
	/**
	 * Soma os parâmetros dos efeitos negativos dos estados.
	 */
	public void applyAfflictions() {
		for (int i = 1; i < afflictions.length; i++) {
			if (afflictions[i] != null) {
				addTraits(afflictions[i].getTraits());				
			}
		}
	}
	
	/**
	 * Subtrai os parâmetros dos efeitos negativos dos estados.
	 */
	public void unapplyAfflictions() {
		for (int i = 1; i < afflictions.length; i++) {
			substractTraits(afflictions[i].getTraits());
		}
	}
	
	// --------------------------------------------------------------------------------------------
	// Getters e setters
	// --------------------------------------------------------------------------------------------
	
	public double getHpModifier() {
		return mainParametersModifiers[0];
	}

	public void setHpModifier(double hpModifier) {
		this.mainParametersModifiers[0] = hpModifier;
	}

	public double getMaxHpModifier() {
		return mainParametersModifiers[1];
	}

	public void setMaxHpModifier(double maxHpModifier) {
		this.mainParametersModifiers[1] = maxHpModifier;
	}

	public double getMpModifier() {
		return mainParametersModifiers[2];
	}

	public void setMpModifier(double mpModifier) {
		this.mainParametersModifiers[2] = mpModifier;
	}

	public double getMaxMpModifier() {
		return mainParametersModifiers[3];
	}

	public void setMaxMpModifier(double maxMpModifier) {
		this.mainParametersModifiers[3] = maxMpModifier;
	}

	public double getAttackModifier() {
		return mainParametersModifiers[4];
	}

	public void setAttackModifier(double attackModifier) {
		this.mainParametersModifiers[4] = attackModifier;
	}

	public double getDefenseModifier() {
		return mainParametersModifiers[5];
	}

	public void setDefenseModifier(double defenseModifier) {
		this.mainParametersModifiers[5] = defenseModifier;
	}

	public double getSpeedModifier() {
		return mainParametersModifiers[6];
	}

	public void setSpeedModifier(double speedModifier) {
		this.mainParametersModifiers[6] = speedModifier;
	}

	public double getAccuracy() {
		return secondaryParameters[0];
	}

	public void setAccuracy(double accuracy) {
		this.secondaryParameters[0] = accuracy;
	}

	public double getEvasion() {
		return secondaryParameters[1];
	}

	public void setEvasion(double evasion) {
		this.secondaryParameters[1] = evasion;
	}

	public double getPhysicalCritical() {
		return secondaryParameters[2];
	}

	public void setPhysicalCritical(double physicalCritical) {
		this.secondaryParameters[2] = physicalCritical;
	}

	public double getHpRegenRate() {
		return secondaryParameters[3];
	}

	public void setHpRegenRate(double hpRegenRate) {
		this.secondaryParameters[3] = hpRegenRate;
	}

	public double getMpRegenRate() {
		return secondaryParameters[4];
	}

	public void setMpRegenRate(double mpRegenRate) {
		this.secondaryParameters[4] = mpRegenRate;
	}	

	public int getHp() {
		return mainParameters[0];
	}

	public void setHp(int hp) {
		if (hp <= MAX_PARAMETER_VALUE && hp >= -MAX_PARAMETER_VALUE) {
			this.mainParameters[0] = hp;
		}
	}

	public int getMaxHp() {
		return mainParameters[1];
	}

	public void setMaxHp(int maxHp) {
		if (maxHp <= MAX_PARAMETER_VALUE && maxHp >= -MAX_PARAMETER_VALUE) {
			this.mainParameters[1] = maxHp;
		}
	}

	public int getMp() {
		return mainParameters[2];
	}

	public void setMp(int mp) {
		if (mp <= MAX_PARAMETER_VALUE && mp >= -MAX_PARAMETER_VALUE) {
			this.mainParameters[2] = mp;
		}
	}

	public int getMaxMp() {
		return mainParameters[3];
	}

	public void setMaxMp(int maxMp) {
		if (maxMp <= MAX_PARAMETER_VALUE && maxMp >= -MAX_PARAMETER_VALUE) {
			this.mainParameters[3] = maxMp;
		}
	}
	
	public int getAttack() {
		int total = (int) (mainParameters[4] * getAttackModifier());
		if (total <= MAX_PARAMETER_VALUE) {
			return total;
		}else {
			return MAX_PARAMETER_VALUE;
		}
	}

	public void setAttack(int attack) {
		if (attack <= MAX_PARAMETER_VALUE && attack >= -MAX_PARAMETER_VALUE) {
			this.mainParameters[4] = attack;
		}
	}

	public int getDefense() {
		int total = (int) (mainParameters[5] * getDefenseModifier());
		if (total <= MAX_PARAMETER_VALUE) {
			return total;
		}else {
			return MAX_PARAMETER_VALUE;
		}
	}

	public void setDefense(int defense) {
		if (defense <= MAX_PARAMETER_VALUE && defense >= -MAX_PARAMETER_VALUE) {
			this.mainParameters[5] = defense;
		}
	}

	public int getSpeed() {
		int total = (int) (mainParameters[6] * getSpeedModifier());
		if (total <= MAX_PARAMETER_VALUE) {
			return total;
		}else {
			return MAX_PARAMETER_VALUE;
		} 
	}

	public void setSpeed(int speed) {
		if (speed <= MAX_PARAMETER_VALUE && speed >= -MAX_PARAMETER_VALUE) {
			this.mainParameters[6] = speed;
		}
	}

	public int getHpPlus() {
		return mainParametersPlus[0];
	}

	public void setHpPlus(int hpPlus) {
		this.mainParametersPlus[0] = hpPlus;
	}

	public int getMaxHpPlus() {
		return mainParametersPlus[1];
	}

	public void setMaxHpPlus(int maxHpPlus) {
		this.mainParametersPlus[1] = maxHpPlus;
	}

	public int getMpPlus() {
		return mainParametersPlus[2];
	}

	public void setMpPlus(int mpPlus) {
		this.mainParametersPlus[2] = mpPlus;
	}

	public int getMaxMpPlus() {
		return mainParametersPlus[3];
	}

	public void setMaxMpPlus(int maxMpPlus) {
		this.mainParametersPlus[3] = maxMpPlus;
	}

	public int getAttackPlus() {
		return mainParametersPlus[4];
	}

	public void setAttackPlus(int attackPlus) {
		this.mainParametersPlus[4] = attackPlus;
	}

	public int getDefensePlus() {
		return mainParametersPlus[5];
	}

	public void setDefensePlus(int defensePlus) {
		this.mainParametersPlus[5] = defensePlus;
	}
	
	public int getSpeedPlus() {
		return mainParametersPlus[6];
	}

	public void setSpeedPlus(int speedPlus) {
		this.mainParametersPlus[6] = speedPlus;
	}

	public double getElementMelee() {
		return elementalResistance[0];
	}

	public void setElementMelee(double elementMelee) {
		this.elementalResistance[0] = elementMelee;
	}

	public double getElementRanged() {
		return elementalResistance[1];
	}

	public void setElementRanged(double elementRanged) {
		this.elementalResistance[1] = elementRanged;
	}

	public double getElementNonElemental() {
		return elementalResistance[2];
	}
	
	public void setElementNonElemental(double elementNonElemental) {
		this.elementalResistance[2] = elementNonElemental;
	}
	
	public double getElementFire() {
		return elementalResistance[3];
	}

	public void setElementFire(double elementFire) {
		this.elementalResistance[3] = elementFire;
	}

	public double getElementIce() {
		return elementalResistance[4];
	}

	public void setElementIce(double elementIce) {
		this.elementalResistance[4] = elementIce;
	}

	public double getElementThunder() {
		return elementalResistance[5];
	}

	public void setElementThunder(double elementThunder) {
		this.elementalResistance[5] = elementThunder;
	}

	public double getElementWind() {
		return elementalResistance[6];
	}

	public void setElementWind(double elementWind) {
		this.elementalResistance[6] = elementWind;
	}

	public double getElementDragon() {
		return elementalResistance[7];
	}

	public void setElementDragon(double elementDragon) {
		this.elementalResistance[7] = elementDragon;
	}

	public int getMainParametersQuantity() {
		return mainParametersQuantity;
	}

	public void setMainParametersQuantity(int mainParametersQuantity) {
		this.mainParametersQuantity = mainParametersQuantity;
	}

	public int getSecondaryParametersQuantity() {
		return secondaryParametersQuantity;
	}

	public void setSecondaryParametersQuantity(int secondaryParametersQuantity) {
		this.secondaryParametersQuantity = secondaryParametersQuantity;
	}

	public int getElementsQuantity() {
		return elementsQuantity;
	}

	public void setElementsQuantity(int elementsQuantity) {
		this.elementsQuantity = elementsQuantity;
	}

	public int[] getMainParameters() {
		return mainParameters;
	}

	public void setMainParameters(int[] mainParameters) {
		this.mainParameters = mainParameters;
	}

	public int[] getMainParametersPlus() {
		return mainParametersPlus;
	}

	public void setMainParametersPlus(int[] mainParametersPlus) {
		this.mainParametersPlus = mainParametersPlus;
	}

	public double[] getMainParametersModifiers() {
		return mainParametersModifiers;
	}

	public void setMainParametersModifiers(double[] mainParametersModifiers) {
		this.mainParametersModifiers = mainParametersModifiers;
	}

	public double[] getSecondaryParameters() {
		return secondaryParameters;
	}

	public void setSecondaryParameters(double[] secondaryParameters) {
		this.secondaryParameters = secondaryParameters;
	}

	public double[] getSecondaryParametersPlus() {
		return secondaryParametersPlus;
	}

	public void setSecondaryParametersPlus(double[] secondaryParametersPlus) {
		this.secondaryParametersPlus = secondaryParametersPlus;
	}

	public double getAccuracyModifier() {
		return secondaryParametersModifiers[0];
	}

	public void setAccuracyModifier(double accuracy) {
		this.secondaryParametersModifiers[0] = accuracy;
	}

	public double getEvasionModifier() {
		return secondaryParametersModifiers[1];
	}

	public void setEvasionModifier(double evasion) {
		this.secondaryParametersModifiers[1] = evasion;
	}

	public double getPhysicalCriticalModifier() {
		return secondaryParametersModifiers[2];
	}

	public void setPhysicalCriticalModifier(double physicalCritical) {
		this.secondaryParametersModifiers[2] = physicalCritical;
	}

	public double getHpRegenRateModifier() {
		return secondaryParametersModifiers[3];
	}

	public void setHpRegenRateModifier(double hpRegenRate) {
		this.secondaryParametersModifiers[3] = hpRegenRate;
	}

	public double getMpRegenRateModifier() {
		return secondaryParametersModifiers[4];
	}

	public void setMpRegenRateModifier(double mpRegenRate) {
		this.secondaryParametersModifiers[4] = mpRegenRate;
	}	

	public double[] getElementalResistance() {
		return elementalResistance;
	}

	public void setElementalResistance(double[] elementalResistance) {
		this.elementalResistance = elementalResistance;
	}

	public static int getMaxParameterValue() {
		return MAX_PARAMETER_VALUE;
	}

	public double[] getSecondaryParametersModifiers() {
		return secondaryParametersModifiers;
	}

	public void setSecondaryParametersModifiers(double[] secondaryParametersModifiers) {
		this.secondaryParametersModifiers = secondaryParametersModifiers;
	}

	public boolean isActive() {
		return active;
	}

	public void setActive(boolean active) {
		this.active = active;
	}

	public boolean isRestricted() {
		return restricted;
	}

	public void setRestricted(boolean restricted) {
		this.restricted = restricted;
	}

	public boolean isAutoBattle() {
		return autoBattle;
	}

	public void setAutoBattle(boolean autoBattle) {
		this.autoBattle = autoBattle;
	}

}
