public float BattlerDamageOther(Battler _attacker, AttackDamageProperties _skill, Battler _defender)
    {
        float damageDone = 1;

        if (_skill.power > 0)
        {
            //Check Crit & Hit
            if (!CheckHit(_attacker, _skill, _defender))
            {
                SpawnDamageText(_defender.transform.position, "Miss", Color.grey);
                return(0);
            }
            bool crit = CheckCrit(_attacker, _skill, _defender);

            //Damage
            damageDone = Mathf.Floor(Calculator.DamageCalc(_attacker, _skill, _defender, crit));
            if (_defender.defending)
            {
                damageDone = Mathf.Floor(damageDone * 0.25f);
            }
            _defender.GetComponent <SpriteAnimator>().Play(_defender.anims.Hurt, true);
            _defender.HP -= damageDone;
            if (!crit)
            {
                SpawnDamageText(_defender.transform.position, damageDone.ToString(), Color.white);
            }
            else
            {
                SpawnDamageText(_defender.transform.position, "" + (damageDone).ToString(), Color.yellow);
            }
            //_other.aura.Add(_skill.element, damageDone);
        }
        return(damageDone);
    }
    public bool CheckCrit(Battler _attacker, AttackDamageProperties _skill, Battler _defender)
    {
        float random       = Random.Range(0.0f, 1.0f);
        float chanceToCrit = ((_attacker.Stats.Accuracy * _skill.accuracyMod) / _defender.Stats.Evade) - 1;

        if (chanceToCrit > 0)
        {
            if (random < chanceToCrit)
            {
                //Crit
                return(true);
            }
        }
        return(false);
    }
    public bool CheckHit(Battler _attacker, AttackDamageProperties _skill, Battler _defender)
    {
        float random      = Random.Range(0.0f, 1.0f);
        float chanceToHit = (_attacker.Stats.Accuracy * _skill.accuracyMod) / _defender.Stats.Evade;

        if (chanceToHit < 1)
        {
            if (random > chanceToHit)
            {
                //Miss
                return(false);
            }
        }
        return(true);
    }
    /*public static float DamageCalc(Battler _attacker, AttackDamageProperties _attack, Battler _defender, bool _critical, List<float> _addedMods = null)
     * {
     *  float finalDamage = 0;
     *
     *  //float levelPower = _attacker.profile.level / 25;
     *  float levelPower = 1;
     *
     *  float attackPower = _attack.power;
     *  float matchup = 1;
     *  switch (_attack.type)
     *  {
     *      case DamageType.Physical:
     *          matchup = _attacker.Stats.Attack / _defender.Stats.Defence;
     *          break;
     *      case DamageType.Magic:
     *          matchup = _attacker.Stats.MagAttack / _defender.Stats.MagDefence;
     *          break;
     *      default:
     *          matchup = 1;
     *          break;
     *  }
     *
     *  float criticalMod = 1;
     *  if (_critical)
     *  {
     *      criticalMod = 1.5f;
     *  }
     *
     *  float addedMods = 1;
     *  if (_addedMods != null)
     *  {
     *      foreach (float i in _addedMods)
     *      {
     *          addedMods *= i;
     *      }
     *  }
     *
     *  finalDamage = attackPower * levelPower * matchup * criticalMod * addedMods;
     *  //_defender.BurnChill -= effect;
     *  Debug.Log(_attacker.name + " > " + _defender.name + "  Damage " + attackPower + ", matchup " + matchup + ", Crit! " + criticalMod + "  = " + finalDamage);
     *
     *  //return Mathf.Floor(finalDamage);
     *  return finalDamage;
     * }*/

    public static float DamageCalc(Battler _attacker, AttackDamageProperties _attack, Battler _defender, bool _critical)
    {
        // Attack Power vs. Defence Power
        float matchup = 0;

        switch (_attack.type)
        {
        case DamageType.Physical:
            matchup = _attacker.Stats.Attack - (_defender.Stats.Defence / 2);
            break;

        case DamageType.Magic:
            matchup = _attacker.Stats.MagAttack - (_defender.Stats.MagDefence / 2);
            break;

        case DamageType.Pierce:
        default:
            matchup = 0;
            break;
        }
        // Element Aura
        float auraMod = 1;

        float critMod = 1;

        if (_critical)
        {
            critMod = 1.5f;
        }

        float finalDamage = Mathf.Floor((_attack.power + matchup) * auraMod * critMod);

        Debug.Log(_attacker.name + _defender.name + "  Damage " + _attack.power + ", matchup " + matchup + ", auraMod " + auraMod + ", Crit! " + critMod + "  = " + finalDamage);

        return(Mathf.Max(1, finalDamage));
    }