コード例 #1
0
    public static UtilityAbility ScaleUtilityAbility(float points, float cooldown, float mp, float baseMp, string targetType, List <AbilityAttribute> abilityAttributes, AbilitySkillTree skillTree)
    {
        var startingPoints = points;
        var newAbility     = new UtilityAbility {
            points      = points,
            cooldown    = cooldown,
            mpUsage     = mp,
            baseMpUsage = baseMp,
            targetType  = targetType,
            level       = AbilityCalculator.GetLevelFromPoints(startingPoints),
            skillTree   = skillTree
        };

        ModifyUtilityAbilityPointsForQualities(newAbility);
        foreach (var attribute in abilityAttributes)
        {
            var pointCost = AbilityAttributeAppraiser.Appraise(newAbility, attribute);
            points -= pointCost;
            if (points >= 0)
            {
                newAbility.attributes.Add(attribute);
                newAbility.points -= pointCost;
            }
            else
            {
                points += pointCost;
            }
        }
        newAbility.name        = AbilityNamer.Name(newAbility);
        newAbility.description = AbilityDescriber.Describe(newAbility);
        newAbility.xp          = GetXpFromLevel(newAbility.level);
        SetMpUsage(newAbility);
        return(newAbility);
    }
コード例 #2
0
 public static AbilityAttribute Generate(AttackAbility ability, string attributeType)
 {
     for (int i = 0; i < 10000; i++)
     {
         AbilityAttribute attribute;
         if (simpleAttributes.Contains(attributeType))
         {
             attribute = new AbilityAttribute {
                 type = attributeType
             };
             attribute.priority = UnityEngine.Random.Range(12.5f, 100f);
             attribute.points   = AbilityAttributeAppraiser.Appraise(ability, attribute);
             if (negativeAttributes.Contains(attribute.type) && attribute.priority < 50)
             {
                 continue;
             }
             return(attribute);
         }
         attribute = attributes[attributeType](ability);
         if (attribute != null)
         {
             attribute.priority = UnityEngine.Random.Range(12.5f, 100f);
             attribute.points   = AbilityAttributeAppraiser.Appraise(ability, attribute);
             if (negativeAttributes.Contains(attribute.type) && attribute.priority < 50)
             {
                 continue;
             }
             return(attribute);
         }
     }
     Debug.Log("FAILED TO FIND VALID ATTRIBUTE FOR ABILITY!");
     return(null);
 }
コード例 #3
0
 public static AbilityAttribute Generate(PassiveAbility ability, string attributeType)
 {
     for (int i = 0; i < 10000; i++)
     {
         AbilityAttribute attribute;
         if (simpleAttributes.Contains(attributeType))
         {
             attribute = new AbilityAttribute {
                 type = attributeType
             };
             attribute.priority = RNG.Float(12.5f, 100f);
             attribute.points   = AbilityAttributeAppraiser.Appraise(ability, attribute);
             return(attribute);
         }
         attribute = attributes[attributeType](ability);
         if (attribute != null)
         {
             attribute.priority = RNG.Float(12.5f, 100f);
             attribute.points   = AbilityAttributeAppraiser.Appraise(ability, attribute);
             return(attribute);
         }
     }
     Debug.Log("FAILED TO FIND VALID ATTRIBUTE FOR ABILITY!");
     return(null);
 }
コード例 #4
0
 public static AbilityAttribute Generate(UtilityAbility ability)
 {
     for (int i = 0; i < 10000; i++)
     {
         string           roll = TableRoller.Roll("UtilityAttributes_" + ability.targetType);
         AbilityAttribute attribute;
         if (simpleAttributes.Contains(roll))
         {
             attribute = new AbilityAttribute {
                 type = roll
             };
             attribute.priority = UnityEngine.Random.Range(12.5f, 100f);
             attribute.points   = AbilityAttributeAppraiser.Appraise(ability, attribute);
             if (negativeAttributes.Contains(attribute.type) && attribute.priority < 50)
             {
                 continue;
             }
             return(attribute);
         }
         attribute = attributes[roll](ability);
         if (attribute != null)
         {
             attribute.priority = UnityEngine.Random.Range(12.5f, 100f);
             attribute.points   = AbilityAttributeAppraiser.Appraise(ability, attribute);
             if (negativeAttributes.Contains(attribute.type) && attribute.priority < 50)
             {
                 continue;
             }
             return(attribute);
         }
     }
     Debug.Log("FAILED TO FIND VALID ATTRIBUTE FOR ABILITY!");
     return(null);
 }
コード例 #5
0
    public static AttackAbility ScaleAttackAbility(float points, Element element, BaseStat baseStat, float damageRatio, float dotDamageRatio, float dotTime, bool isRanged, float cooldown, float mp, float baseMp, float radius, int icon, int hitEffect, int projectile, int aoe, List <AbilityAttribute> abilityAttributes, AbilitySkillTree skillTree)
    {
        var startingPoints = points;
        List <AbilityAttribute> paralysis = new List <AbilityAttribute>();

        foreach (var attribute in abilityAttributes)
        {
            if (attribute.type == "paralyze")
            {
                paralysis.Add(attribute);
            }
        }
        if (paralysis.Count > 0 && cooldown == 0)
        {
            foreach (var attribute in paralysis)
            {
                abilityAttributes.Remove(attribute);
            }
        }
        var newAbility = new AttackAbility {
            element          = element,
            baseStat         = baseStat,
            dotTime          = dotTime,
            isRanged         = isRanged,
            cooldown         = cooldown,
            mpUsage          = mp,
            baseMpUsage      = baseMp,
            radius           = radius,
            points           = points,
            icon             = icon,
            hitEffect        = hitEffect,
            rangedProjectile = projectile,
            aoe       = aoe,
            level     = AbilityCalculator.GetLevelFromPoints(startingPoints),
            skillTree = skillTree
        };

        ModifyAttackAbilityPointsForQualities(newAbility);
        points = newAbility.points;
        int count = 0;

        foreach (var attribute in abilityAttributes)
        {
            if (attribute.priority >= 50)
            {
                var pointCost = AbilityAttributeAppraiser.Appraise(newAbility, attribute);
                if (count < 4)
                {
                    points -= pointCost;
                }
                if (count < 4 && points >= 0)
                {
                    newAbility.attributes.Add(attribute);
                    newAbility.points -= pointCost;
                }
                else if (count < 4 && points < 0)
                {
                    points += pointCost;
                }
                count++;
            }
            else
            {
                newAbility.attributes.Add(attribute);
            }
        }
        var totalDamage   = AttackAbilityGenerator.CalculateDamage(points);
        var regularDamage = totalDamage * damageRatio / (damageRatio + dotDamageRatio);
        var dotDamage     = totalDamage * dotDamageRatio / (damageRatio + dotDamageRatio);

        newAbility.damage      = regularDamage;
        newAbility.dotDamage   = dotDamage;
        newAbility.name        = AbilityNamer.Name(newAbility);
        newAbility.description = AbilityDescriber.Describe(newAbility);
        newAbility.xp          = GetXpFromLevel(newAbility.level);
        SetMpUsage(newAbility);
        return(newAbility);
    }
コード例 #6
0
    public static AttackAbility Generate(int level = 1, Element element = Element.none)
    {
        for (int i = 0; i < 10000; i++)
        {
            var startingPoints = AbilityCalculator.GetPointsFromLevel(level);
            var isRanged       = RNG.Bool();
            var usesMp         = RNG.Bool();
            var statResults    = GetBaseStatAndPointsMod(isRanged, usesMp);
            var baseStat       = statResults.Item1;
            startingPoints *= statResults.Item2;
            int mp, baseMp;
            if (!usesMp)
            {
                baseMp = 0;
            }
            else
            {
                var mpResult = AbilityCalculator.GetBaseMpCostAndPointsMod();
                baseMp          = mpResult.Item1;
                startingPoints *= mpResult.Item2;
            }
            mp = AbilityCalculator.ScaleMp(baseMp, level);
            if (element == Element.none)
            {
                element = RNG.EnumValue <Element>();
            }
            int hitEffect = 0, projectile = 0;
            if (isRanged)
            {
                projectile = AbilityTables.baseProjectiles[element];
            }
            else
            {
                hitEffect = AbilityTables.baseHitEffects[element];
            }
            var   radiusResults = GetRadiusAndPointsMod();
            float radius        = radiusResults.Item1;
            startingPoints *= radiusResults.Item2;
            int aoe = 0;
            if (radius > 0)
            {
                aoe = AbilityTables.baseAoes[element];
            }
            var dotResults = GetDotStatusAndTimeAndPointsMod();
            var isDot      = dotResults.Item1;
            var dotTime    = dotResults.Item2;
            startingPoints *= dotResults.Item3;
            int numAttributes   = RNG.Int(0, 6);
            var cooldownResults = AbilityCalculator.GetCooldownAndPointsMod();
            var cooldown        = cooldownResults.Item1;
            startingPoints *= cooldownResults.Item2;
            var ability = new AttackAbility {
                element          = element,
                baseStat         = baseStat,
                dotTime          = dotTime,
                isRanged         = isRanged,
                cooldown         = cooldown,
                mpUsage          = mp,
                baseMpUsage      = baseMp,
                radius           = radius,
                hitEffect        = hitEffect,
                rangedProjectile = projectile,
                aoe       = aoe,
                points    = startingPoints,
                level     = level,
                damage    = 0,
                dotDamage = 0
            };
            int count = 0;
            for (int j = 0; j < numAttributes; j++)
            {
                for (int k = 0; k < 10000; k++)
                {
                    count = 0;
                    var attribute = AbilityAttributeGenerator.Generate(ability);
                    if (attribute != null && attribute.points <= ability.points)
                    {
                        ability.attributes.Add(attribute);
                        if (attribute.priority >= 50 && count < 4)
                        {
                            ability.points -= attribute.points;
                            count++;
                        }
                        if (attribute.priority >= 50 && count < 4 && attribute.type == "createDamageZone")
                        {
                            ability.aoe = AbilityTables.baseDamageZones[element];
                        }
                        break;
                    }
                }
            }

            // sort the abilities added and make sure they are processed in the order they will always be processed on future level ups, so that attributes dependent on order for cost will resolve correctly
            ability.SortAttributes();
            ability.points = startingPoints;
            count          = 0;
            foreach (var attribute in ability.attributes)
            {
                if (attribute.priority >= 50)
                {
                    var pointCost = AbilityAttributeAppraiser.Appraise(ability, attribute);
                    if (count < 4)
                    {
                        ability.points -= pointCost;
                    }
                    if (ability.points <= 0)
                    {
                        ability.attributes.Remove(attribute);
                        ability.points += pointCost;
                    }
                    count++;
                }
            }

            var damage = CalculateDamage(ability.points);
            if (isDot)
            {
                ability.dotDamage = damage;
            }
            else
            {
                ability.damage = damage;
            }
            ability.points = AbilityCalculator.GetPointsFromLevel(level);
            ability.SortAttributes();
            ability.icon        = AbilityIconSelector.Select(ability);
            ability.name        = AbilityNamer.Name(ability);
            ability.description = AbilityDescriber.Describe(ability);
            if (ability.IsValid())
            {
                ability.skillTree = new AbilitySkillTree(ability);
                return(ability);
            }
        }
        return(null);
    }