コード例 #1
0
        public float GetRandomDamage(float minDamage, SchoolOfDamage school = SchoolOfDamage.Other)
        {
            minDamage *= level;
            switch (school)
            {
            case SchoolOfDamage.Air:
                minDamage += currentCharacteristic.MagicPowerOfAir;
                break;

            case SchoolOfDamage.Darkness:
                minDamage += currentCharacteristic.MagicPowerOfDarkness;
                break;

            case SchoolOfDamage.Earth:
                minDamage += currentCharacteristic.MagicPowerOfEarth;
                break;

            case SchoolOfDamage.Fire:
                minDamage += currentCharacteristic.MagicPowerOfFire;
                break;

            case SchoolOfDamage.Light:
                minDamage += currentCharacteristic.MagicPowerOfLight;
                break;

            case SchoolOfDamage.Nature:
                minDamage += currentCharacteristic.MagicPowerOfNature;
                break;

            case SchoolOfDamage.Water:
                minDamage += currentCharacteristic.MagicPowerOfWater;
                break;

            case SchoolOfDamage.Physic:
                minDamage += currentCharacteristic.PhysicalAttackPower;
                break;
            }
            return(minDamage * UnityEngine.Random.Range(1 + currentCharacteristic.CriticalChance, 100 + currentCharacteristic.CriticalEffect));
        }
コード例 #2
0
        public DamageResult AddDamage(TypeOfResources resource, float damage, SchoolOfDamage school = SchoolOfDamage.Other)
        {
            if (damage == 0f || resource == TypeOfResources.Nothing)
            {
                return(DamageResult.NoDamage);
            }
            switch (resource)
            {
            case TypeOfResources.Energy:
                currentEnergy -= damage;
                return(damage > 0 ? DamageResult.AddEnergy : DamageResult.SubEnergy);

            case TypeOfResources.Mana:
                currentMana -= damage;
                return(damage > 0 ? DamageResult.AddMana : DamageResult.SubMana);

            case TypeOfResources.Health:
                if (damage > 0)
                {
                    var finalDamage = 0f;
                    switch (school)
                    {
                    case SchoolOfDamage.Air:
                        finalDamage = damage - currentCharacteristic.MagicDefenceOfAir;
                        break;

                    case SchoolOfDamage.Darkness:
                        finalDamage = damage - currentCharacteristic.MagicDefenceOfDarkness;
                        break;

                    case SchoolOfDamage.Earth:
                        finalDamage = damage - currentCharacteristic.MagicDefenceOfEarth;
                        break;

                    case SchoolOfDamage.Fire:
                        finalDamage = damage - currentCharacteristic.MagicDefenceOfFire;
                        break;

                    case SchoolOfDamage.Light:
                        finalDamage = damage - currentCharacteristic.MagicDefenceOfLight;
                        break;

                    case SchoolOfDamage.Nature:
                        finalDamage = damage - currentCharacteristic.MagicDefenceOfNature;
                        break;

                    case SchoolOfDamage.Water:
                        finalDamage = damage - currentCharacteristic.MagicDefenceOfWater;
                        break;

                    case SchoolOfDamage.Physic:
                        if (currentCharacteristic.ChanceOfParrying > UnityEngine.Random.Range(1, 100))
                        {
                            return(DamageResult.Parrying);
                        }
                        if (currentCharacteristic.ChanceOfBlocking > UnityEngine.Random.Range(1, 100))
                        {
                            return(DamageResult.Blocked);
                        }
                        finalDamage = damage - currentCharacteristic.PhysicalDefencePower;
                        break;

                    default:
                        finalDamage = damage;
                        break;
                    }
                    if (finalDamage > 0f)
                    {
                        currentHealth -= finalDamage;
                        return(DamageResult.SubHealth);
                    }
                    return(DamageResult.Absorb);
                }
                else
                {
                    currentHealth -= damage;
                }
                break;
            }
            return(DamageResult.AddHealth);
        }