public override ControllState handleInput(BThirdPerson controller, CharacterStats stats)
    {
        if(controller.stateTime > 5.625){

        }
        return this;
    }

        public void mod_SetButtonsAnticlassSpells(CharacterStats stats)
        {
            this.Label = null;
            int num = 0;
            foreach (GenericAbility current in stats.Abilities)
            {
                if (current is GenericSpell)
                {
                    CharacterStats.Class spellClass = ((GenericSpell)current).SpellClass;
                    if (spellClass != stats.CharacterClass || !CharacterStats.IsPlayableClass(spellClass))
                    {

                        if ((stats.CharacterClass == CharacterStats.Class.Wizard ||
                            stats.CharacterClass == CharacterStats.Class.Priest ||
                            stats.CharacterClass == CharacterStats.Class.Druid ||
                            stats.CharacterClass == CharacterStats.Class.Chanter ||
                            stats.CharacterClass == CharacterStats.Class.Cipher) && IEModOptions.HideAnticlassSpells)
                        {

                        }

                        else
                        {
                            this.SetButton(num, current.gameObject, UIAbilityBarButtonSet.AbilityButtonAction.CAST_SPELL_ABILITY, current.Icon);
                            num++;
                        }
                    }
                }
            }
            this.HideButtons(num);
            this.m_DoRefresh = true;
        }

 public virtual void Start()
 {
     characterStats = gameObject.GetCharacterStats();
     inventory = gameObject.GetInventory();
     playerMotor = gameObject.GetPlayerMotor();
     characterStats.Died += characterStats_Died;
 }

 // Use this for initialization
 void Start()
 {
     P1 = GameObject.FindGameObjectWithTag("Player1");
     P2 = GameObject.FindGameObjectWithTag ("Player2");
     playerHealth1 = P1.GetComponent<CharacterStats> ();
     playerHealth2 = P2.GetComponent<CharacterStats> ();
 }

    public override ControllState handleInput(BThirdPerson controller, CharacterStats stats)
    {
        Vector3 mousePoint = Vector3.zero;
        stats.healthRegenerationRate = 0f;
        stats.enduranceRegenerationRate = 0f;

        if(controller.stateTime < 0.1){
            controller.turnToReferenceObject();
            controller.controller.slotRightHand.GetComponent<OWeapon>().enable();
            shot = false;
        }

        if(Random.Range(1,10) < 3){
            shot = true;
        }

        if(controller.stateTime > 0.22f){
            if(shot){
                return ControllerZombie._ZombieATTACKB;
            }
            else{
                controller.controller.slotRightHand.GetComponent<OWeapon>().disable();
                return ControllerZombie._ZombieIDLE;
            }
        }

        return this;
    }

    public static Character Slime()
    {
        var character = new Character();

        var baseStats = new CharacterStats();
        baseStats.SetStat(Const.Stats.MaxHp, 700d);
        baseStats.SetStat(Const.Stats.MaxMp, 150d);
        baseStats.SetStat(Const.Stats.Attack, 300d);
        baseStats.SetStat(Const.Stats.Defense, 150d);
        baseStats.SetStat(Const.Stats.Wisdom, 70d);
        baseStats.SetStat(Const.Stats.Agility, 100d);
        baseStats.SetStat(Const.Stats.Mind, 50d);
        baseStats.SetStat(Const.Stats.Critical, 0.05d);
        baseStats.SetStat(Const.Stats.Accuracy, 0.8d);
        baseStats.SetStat(Const.Stats.Evasion, 0.1d);

        character.Name = "Slime";
        character.BaseStats = baseStats;

        character.PortraitPath = "Characters/Slime/portrait";
        character.ModelPath = "Characters/Slime/model";
        character.AttackDistance = 2.5f;
        character.SizeOffset = 1.5f;
        character.Skills.Add(Skill.MeleeAttack());
        character.Movement = 2;

        character.PatternShape = Pattern.Single();

        return character;
    }

    public override ControllState handleInput(BThirdPerson controller, CharacterStats stats)
    {
        Vector3 mousePoint = Vector3.zero;
        stats.healthRegenerationRate = 0f;
        stats.enduranceRegenerationRate = 0f;

        if(controller.stateTime < 0.1){
            controller.controller.slotRightHand.GetComponent<OWeapon>().enable();
            shot = false;
            Vector2 inputVector = new Vector2(Input.GetAxis("Horizontal"),Input.GetAxis("Vertical"));
            Vector3 inputVectorTransformed = new Vector3(inputVector.x,0,-inputVector.y);
            Vector3 lookTarget = controller.position + (ControllerCamera.hingeUp.transform.rotation*inputVectorTransformed);
            controller.turn(lookTarget);
        }

        if(Input.GetButtonDown("attack") && stats.reduceEndurance(7) && !shot){
            shot = true;
        }

        if(controller.stateTime > 0.22f){
            if(shot){
                return ControllerKnight._KnightATTACKB;
            }
            else{
                controller.controller.slotRightHand.GetComponent<OWeapon>().disable();
                return ControllerKnight._KnightIDLE;
            }
        }

        return this;
    }

 void Awake()
 {
     anim = GetComponent<Animator>();
     cc = this.GetComponent<CharacterController>();
     car = GetComponent<CharacterStats>();
     shot = GetComponent<Shooting>();
 }

        public static bool mod_ShowOnSpellBar(GenericAbility ability, CharacterStats stats, int spellLevel)
        {
            if (ability.Passive)
            {
                return false;
            }
            GenericSpell genericSpell = ability as GenericSpell;
            GenericCipherAbility genericCipherAbility = ability as GenericCipherAbility;
            if (!genericSpell)
            {
                return genericCipherAbility && (spellLevel <= 0 || genericCipherAbility.SpellLevel == spellLevel);
            }

            if (genericSpell.SpellClass != stats.CharacterClass && spellLevel > 0 && genericSpell.SpellLevel == spellLevel && IEModOptions.HideAnticlassSpells)
            {
                return true;
            }

            if (genericSpell.SpellClass != stats.CharacterClass || (spellLevel > 0 && genericSpell.SpellLevel != spellLevel))
            {
                return false;
            }
            if (stats.CharacterClass != CharacterStats.Class.Wizard || !genericSpell.NeedsGrimoire)
            {
                return true;
            }
            Equipment component = stats.GetComponent<Equipment>();
            if (component == null || component.CurrentItems == null || component.CurrentItems.Grimoire == null)
            {
                return false;
            }
            Grimoire component2 = component.CurrentItems.Grimoire.GetComponent<Grimoire>();
            return !(component2 == null) && component2.HasSpell(genericSpell);
        }

 public void SubtractStats(CharacterStats statsToSubtract)
 {
     swagger -= statsToSubtract.swagger;
     strength -= statsToSubtract.strength;
     agility -= statsToSubtract.agility;
     mind -= statsToSubtract.mind;
     health -= statsToSubtract.health;
 }

 public void AddStats(CharacterStats statsToAdd)
 {
     swagger += statsToAdd.swagger;
     strength += statsToAdd.strength;
     agility += statsToAdd.agility;
     mind += statsToAdd.mind;
     health += statsToAdd.health;
 }

    void Start()
    {
        anim = GetComponent<Animator>();
        playerController = GetComponent<PlayerMovementController>();
        characterStats = GetComponent<CharacterStats>();
        colliderr = GetComponent<CapsuleCollider>();

        characterControlInterface = GetComponent<CharacterControlInterface>();
    }

    void Awake()
    {
        stats = GetComponentInParent<CharacterStats>();

        if (stats == null)
        {
            Debug.LogError("Can not found CharacterStats! " + this.gameObject.name);
        }
    }

    Vector3 greenPos; //Position of the health bar relative to the character

    #endregion Fields

    #region Methods

    void Awake()
    {
        //loads enemy health value from healthScript
        healthScript = transform.parent.gameObject.GetComponent<CharacterStats>();
        curHealth = healthScript.health;
        maxHealth = healthScript.maxHealth;

        //stores two health values, will come in later
    }

    void Start()
    {
        characterStats = GetComponent<CharacterStats>();

        characterStats.HPScaler *= hpScale;
        characterStats.MovingSpeedModifier += movingSpeedModifier;

        transform.localScale *= sizeScale;
    }

    //private Text text;
    void Start()
    {
        characterStats = character.GetComponent<CharacterStats>();
        HPBarRectTransform = HPBarImage.GetComponent<RectTransform>();
        originalSize = HPBarRectTransform.sizeDelta;
        originalLocalPosition = HPBarRectTransform.localPosition;

        //text = HPBarText.GetComponent<Text>();
    }

		public float GetCurrentBonusMultiplierNew(CharacterStats stats, GenericAbility abilityOrigin)
		{
			if (stats == null)
			{
				return 1f;
			}
			float bonus = 0f;
			if (IEModOptions.NPCDispositionFix || (GameState.s_playerCharacter != null && stats.gameObject == GameState.s_playerCharacter.gameObject)) // added ((Mod_GameOptions_GameMode)GameState.Mode).NPCDispositionFix || 
			{
				float single = 1f;
				if (abilityOrigin != null)
				{
					single = single * abilityOrigin.GatherAbilityModProduct(AbilityMod.AbilityModType.NegativeReligiousTraitMultiplier);
				}
				if (stats.CharacterClass == CharacterStats.Class.Priest)
				{
					global::Religion.DeityData deityDatum = this.FindDeityData(stats.Deity);
					if (deityDatum != null)
					{
						bonus = bonus + this.GetBonus(deityDatum.PositiveTrait[0], this.PositiveTraitBonus);
						bonus = bonus + this.GetBonus(deityDatum.PositiveTrait[1], this.PositiveTraitBonus);
						bonus = bonus + this.GetBonus(deityDatum.NegativeTrait[0], this.NegativeTraitBonus) * single;
						bonus = bonus + this.GetBonus(deityDatum.NegativeTrait[1], this.NegativeTraitBonus) * single;
					}
				}
				else if (stats.CharacterClass == CharacterStats.Class.Paladin)
				{
					global::Religion.PaladinOrderData paladinOrderDatum = this.FindPaladinOrderData(stats.PaladinOrder);
					if (paladinOrderDatum != null)
					{
						/* patching in dis/favored dispositions for Pallegina's order */
						if (stats.PaladinOrder == PaladinOrder.FrermasMesCancSuolias)
						{
							var favored1 = IEModOptions.PalleginaFavored1;
							var favored2 = IEModOptions.PalleginaFavored2;
							var disfavored1 = IEModOptions.PalleginaDisfavored1;
							var disfavored2 = IEModOptions.PalleginaDisfavored2;

							paladinOrderDatum.PositiveTrait = new Disposition.Axis[2];
							paladinOrderDatum.PositiveTrait[0] = favored1;
							paladinOrderDatum.PositiveTrait[1] = favored2;
							paladinOrderDatum.NegativeTrait = new Disposition.Axis[2];
							paladinOrderDatum.NegativeTrait[0] = disfavored1;
							paladinOrderDatum.NegativeTrait[1] = disfavored2;
						}
						/**************************************************************************************/

						bonus = bonus + this.GetBonus(paladinOrderDatum.PositiveTrait[0], this.PositiveTraitBonus);
						bonus = bonus + this.GetBonus(paladinOrderDatum.PositiveTrait[1], this.PositiveTraitBonus);
						bonus = bonus + this.GetBonus(paladinOrderDatum.NegativeTrait[0], this.NegativeTraitBonus) * single;
						bonus = bonus + this.GetBonus(paladinOrderDatum.NegativeTrait[1], this.NegativeTraitBonus) * single;
					}
				}
			}
			bonus = bonus + 1f;
			return bonus;
		}

 public CharacterStats Clone()
 {
     var clone = new CharacterStats();
     foreach (var key in this._stats.Keys)
     {
         clone._stats[key] = this._stats[key];
     }
     return clone;
 }

	// Use this for initialization

	void Start () {
		ownColor = gameObject.GetComponent<SpriteRenderer>().color;
		_myStats = new CharacterStats(gameObject.tag.ToString());
		if( _myStats.load() ){
			hp = _myStats.getHp();
			exp = _myStats.getExp();
			coin = _myStats.getCoin();
			max_hp = hp;
		}
	}

    void Start()
    {
        if (gameManager == null) {
          gameManager = Camera.main.GetComponent<GameManager>();
        }

        characterStats = GetComponent<CharacterStats>();

        previousHP = characterStats.MaxHP;
    }