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);
}
protected override void LevelUp(int originalLevel, int targetLevel)
{
LevelUp(targetLevel - originalLevel);
float originalPoints = 70f;
float targetPoints = 70f;
for (int i = 1; i < originalLevel; i++)
{
originalPoints *= 1.05f * 1.05f; //double progression speed for passives for now
}
for (int i = 1; i < targetLevel; i++)
{
targetPoints *= 1.05f * 1.05f; //double progression speed for passives for now
}
float ratio = targetPoints / originalPoints;
foreach (var attribute in attributes)
{
foreach (var parameter in attribute.parameters)
{
if (parameter.value is float)
{
parameter.value = (float)parameter.value * ratio;
}
else if (parameter.value is int)
{
parameter.value = Mathf.FloorToInt((int)parameter.value * ratio);
}
}
}
level = targetLevel;
description = AbilityDescriber.Describe(this);
}
public void Activate()
{
foreach (var effect in effects)
{
if (enhancementLookup.ContainsKey(effect.type))
{
enhancementLookup[effect.type](effect);
}
}
ability.description = AbilityDescriber.Describe(ability);
if (PlayerCharacter.localPlayer != null)
{
PlayerCharacter.localPlayer.GetComponent <HotbarUser>().CmdRefreshAbilityInfo();
}
}
protected override void LevelUp(int originalLevel, int targetLevel)
{
LevelUp(targetLevel - originalLevel);
float targetPoints = AbilityCalculator.GetPointsFromLevel(targetLevel);
AbilityScaler.RemoveSkillTreeEnhancements(this);
var newAbility = AbilityScaler.ScaleUtilityAbility(targetPoints, cooldown, mpUsage, baseMpUsage, targetType, attributes, skillTree);
level = targetLevel;
points = targetPoints;
mpUsage = newAbility.mpUsage;
baseMpUsage = newAbility.baseMpUsage;
attributes = newAbility.attributes;
AbilityScaler.AddSkillTreeEnhancements(this);
description = AbilityDescriber.Describe(this);
}
protected override void LevelUp(int originalLevel, int targetLevel)
{
LevelUp(targetLevel - originalLevel);
float targetPoints = AbilityCalculator.GetPointsFromLevel(targetLevel);
AbilityScaler.RemoveSkillTreeEnhancements(this);
var newAbility = AbilityScaler.ScaleAttackAbility((int)targetPoints, element, baseStat, damage, dotDamage, dotTime, isRanged, cooldown, mpUsage, baseMpUsage, radius, icon, hitEffect, rangedProjectile, aoe, attributes, skillTree);
level = targetLevel;
points = targetPoints;
damage = newAbility.damage;
dotDamage = newAbility.dotDamage;
mpUsage = newAbility.mpUsage;
baseMpUsage = newAbility.baseMpUsage;
attributes = newAbility.attributes;
AbilityScaler.AddSkillTreeEnhancements(this);
description = AbilityDescriber.Describe(this);
}
public static PassiveAbility Generate(int level = 1)
{
for (int i = 0; i < 10000; i++)
{
var startingPoints = AbilityCalculator.GetPointsFromLevel(level);
int numAttributes = RNG.Int(1, 5);
var ability = new PassiveAbility {
points = startingPoints,
level = level
};
for (int j = 0; j < numAttributes; j++)
{
for (int k = 0; k < 10000; k++)
{
var attribute = AbilityAttributeGenerator.Generate(ability);
if (attribute != null && attribute.points <= ability.points)
{
ability.attributes.Add(attribute);
ability.points -= attribute.points;
break;
}
}
}
ability.points = startingPoints;
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);
}
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);
}
public static UtilityAbility Generate(int level = 1)
{
for (int i = 0; i < 10000; i++)
{
var startingPoints = AbilityCalculator.GetPointsFromLevel(level);
var usesMpRoll = RNG.Int(0, 3);
bool usesMp = false;
if (usesMpRoll < 2)
{
usesMp = true;
}
int mp, baseMp;
if (!usesMp)
{
baseMp = 0;
}
else
{
var mpResults = AbilityCalculator.GetBaseMpCostAndPointsMod();
baseMp = mpResults.Item1;
startingPoints *= mpResults.Item2;
}
mp = AbilityCalculator.ScaleMp(baseMp, level);
var baseStat = RNG.EnumValue <BaseStat>();
int numAttributes = RNG.Int(1, 5);
var cooldownResults = AbilityCalculator.GetCooldownAndPointsMod();
var cooldown = cooldownResults.Item1;
startingPoints *= cooldownResults.Item2;
var targetType = RNG.List(new List <string> {
"player",
"none",
"point"
});
var ability = new UtilityAbility {
baseStat = baseStat,
cooldown = cooldown,
mpUsage = mp,
baseMpUsage = baseMp,
points = startingPoints,
level = level,
targetType = targetType
};
for (int j = 0; j < numAttributes; j++)
{
for (int k = 0; k < 10000; k++)
{
var attribute = AbilityAttributeGenerator.Generate(ability);
if (attribute != null && attribute.points <= ability.points)
{
ability.attributes.Add(attribute);
ability.points -= attribute.points;
break;
}
}
}
ability.points = startingPoints;
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);
}
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);
}
