public static string Describe(UtilityAbility ability)
{
string description = GetTopDescription(ability);
int count = 0;
foreach (var attribute in ability.attributes)
{
if (attribute.priority < 50 || count > 3)
{
description += "LATENT - ";
}
if (simpleDescriptionTable.ContainsKey(attribute.type))
{
description += simpleDescriptionTable[attribute.type];
}
else if (descriptionTable.ContainsKey(attribute.type))
{
description += descriptionTable[attribute.type](ability, attribute);
}
else
{
description += attribute.type + " - DESCRIPTION NOT FOUND.\n";
}
count++;
}
return(description);
}
public static AbilityAttribute Generate(UtilityAbility 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);
}
private static float GetSpeedPlus(UtilityAbility ability, AbilityAttribute attribute)
{
var degree = (float)attribute.FindParameter("degree").value;
var duration = (float)attribute.FindParameter("duration").value;
return(86f * duration / 5f * degree);
}
private static float GetParalyze(UtilityAbility ability, AbilityAttribute attribute)
{
var duration = (float)attribute.FindParameter("duration").value;
float radius = 0f;
if (attribute.ContainsAttribute("radius"))
{
radius = (float)attribute.FindParameter("radius").value;
}
var pointCost = 280f * duration / 10f;
if (radius == 2)
{
pointCost *= 2f;
}
else if (radius == 4)
{
pointCost *= 8f;
}
else if (radius == 6)
{
pointCost *= 18f;
}
else
{
pointCost *= 32f;
}
return(pointCost);
}
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);
}
private static AbilityAttribute GetElementalDamageBuff(UtilityAbility ability)
{
var roll = UnityEngine.Random.Range(0, 3);
var damageBoostTable = new List <float> {
100, 50, 25
};
var damageBoost = damageBoostTable[roll];
var element = RNG.EnumValue <Element>();
while (element == Element.none)
{
element = RNG.EnumValue <Element>();
}
return(new AbilityAttribute {
type = "elementalDamageBuff",
parameters = new List <AbilityAttributeParameter>
{
new AbilityAttributeParameter {
name = "degree",
value = damageBoost
},
new AbilityAttributeParameter {
name = "duration",
value = 12f
},
new AbilityAttributeParameter {
name = "element",
value = element.ToString()
}
}
});
}
private void GenerateUtilityAbility()
{
UtilityAbility ability = null;
while (ability == null || ability.mpUsage > maxMpAvailable)
{
ability = UtilityAbilityGenerator.Generate();
}
utilityAbilities.Add(ability);
}
private static AbilityAttribute GetDisableDevice(UtilityAbility ability)
{
return(new AbilityAttribute {
type = "disableDevice",
parameters = new List <AbilityAttributeParameter>
{
new AbilityAttributeParameter {
name = "radius",
value = 2f
}
}
});
}
private static AbilityAttribute GetRestoreMp(UtilityAbility ability)
{
return(new AbilityAttribute {
type = "restoreMP",
parameters = new List <AbilityAttributeParameter>
{
new AbilityAttributeParameter {
name = "degree",
value = ability.points * 0.29f
}
}
});
}
private static AbilityAttribute GetHeal(UtilityAbility ability)
{
return(new AbilityAttribute {
type = "heal",
parameters = new List <AbilityAttributeParameter>
{
new AbilityAttributeParameter {
name = "degree",
value = ability.points / 20f
}
}
});
}
private static AbilityAttribute GetImmobilizeSelf(UtilityAbility ability)
{
int duration = RNG.Int(2, 9);
return(new AbilityAttribute {
type = "immobilizeSelf",
parameters = new List <AbilityAttributeParameter> {
new AbilityAttributeParameter {
name = "duration",
value = (float)duration
}
}
});
}
public static float Appraise(UtilityAbility ability, AbilityAttribute attribute)
{
if (simpleUtilityValues.ContainsKey(attribute.type))
{
return(simpleUtilityValues[attribute.type]);
}
else if (simpleUtilityMultipliers.ContainsKey(attribute.type))
{
return(simpleUtilityMultipliers[attribute.type] * ability.points);
}
else if (complexUtilityMethods.ContainsKey(attribute.type))
{
return(complexUtilityMethods[attribute.type](ability, attribute));
}
return(1000000000);
}
private static AbilityAttribute GetShield(UtilityAbility ability)
{
return(new AbilityAttribute {
type = "shield",
parameters = new List <AbilityAttributeParameter>
{
new AbilityAttributeParameter {
name = "degree",
value = ability.points / 40f
},
new AbilityAttributeParameter {
name = "stat",
value = "strength"
}
}
});
}
private static AbilityAttribute GetHot(UtilityAbility ability)
{
return(new AbilityAttribute {
type = "hot",
parameters = new List <AbilityAttributeParameter>
{
new AbilityAttributeParameter {
name = "degree",
value = ability.points / 10f
},
new AbilityAttributeParameter {
name = "duration",
value = 8f
}
}
});
}
private static AbilityAttribute GetMpOverTime(UtilityAbility ability)
{
return(new AbilityAttribute {
type = "mpOverTime",
parameters = new List <AbilityAttributeParameter>
{
new AbilityAttributeParameter {
name = "degree",
value = 80f * ability.points / 70f
},
new AbilityAttributeParameter {
name = "duration",
value = 8f
}
}
});
}
private static float GetElementalDamageBuff(UtilityAbility ability, AbilityAttribute attribute)
{
var damageBoost = (float)attribute.FindParameter("degree").value;
if (damageBoost == 100)
{
return(140f);
}
else if (damageBoost == 50)
{
return(70f);
}
else
{
return(35);
}
}
public virtual ActiveAbility ConvertTo()
{
if (this is SavedAttackAbility)
{
return(((SavedAttackAbility)this).ConvertTo());
}
var obj = new UtilityAbility {
name = name,
description = description,
targetType = targetType,
icon = icon,
cooldown = cooldown,
mpUsage = mpUsage
};
if (baseMpUsage == 0)
{
baseMpUsage = mpUsage;
}
obj.baseMpUsage = baseMpUsage;
obj.radius = radius;
obj.baseStat = baseStat;
if (points == 0)
{
points = 70;
}
obj.points = points;
obj.xp = xp;
obj.level = level;
obj.skillPoints = skillPoints;
obj.skillTree = skillTree.ConvertTo();
foreach (var list in obj.skillTree.nodesByLayer)
{
foreach (var item in list)
{
item.ability = obj;
}
}
foreach (var attribute in attributes)
{
obj.attributes.Add(attribute.ConvertTo());
}
return(obj);
}
public static string Name(UtilityAbility ability)
{
var prefix = "";
var baseName = "";
int count = 0;
foreach (var attribute in ability.attributes)
{
if (attribute.priority < 50 || count > 3)
{
break;
}
if (simplePrefixesTable.ContainsKey(attribute.type))
{
prefix = simplePrefixesTable[attribute.type];
}
else if (prefixesTable.ContainsKey(attribute.type))
{
prefix = prefixesTable[attribute.type](attribute);
}
else if (simpleNamesTable.ContainsKey(attribute.type))
{
baseName = simpleNamesTable[attribute.type];
}
else if (namesTable.ContainsKey(attribute.type))
{
baseName = namesTable[attribute.type](attribute);
}
else
{
baseName = "NAME NOT FOUND";
}
count++;
}
if (prefix == "")
{
return(baseName);
}
else
{
return(prefix + " " + baseName);
}
}
private static string GetTopDescription(UtilityAbility ability)
{
string description = "L" + ability.level.ToString() + " <b>Utility, uses ";
description += "{{baseStat}}</b>\n";
if (ability.mpUsage > 0)
{
description += "<b>MP</b>: " + ((int)ability.mpUsage).ToString() + "\n";
}
if (ability.cooldown >= 60)
{
description += "<b>Cooldown</b>: " + (ability.cooldown / 60).ToString() + "m\n";
}
else if (ability.cooldown > 0)
{
description += "<b>Cooldown</b>: " + ability.cooldown.ToString() + "s\n";
}
return(description);
}
public override Ability Copy()
{
var newAbility = new UtilityAbility {
name = name,
description = description,
baseStat = baseStat,
icon = icon,
cooldown = cooldown,
mpUsage = mpUsage,
baseMpUsage = baseMpUsage,
radius = radius,
points = points
};
foreach (var attribute in attributes)
{
newAbility.attributes.Add(attribute.Copy());
}
return(newAbility);
}
public static int Select(UtilityAbility ability)
{
int count = 0;
foreach (var attribute in ability.attributes)
{
if (attribute.priority < 50 || count > 3)
{
break;
}
if (simpleIconTable.ContainsKey(attribute.type))
{
return(simpleIconTable[attribute.type]);
}
else if (iconTable.ContainsKey(attribute.type))
{
return(iconTable[attribute.type](attribute));
}
count++;
}
return(0);
}
private static AbilityAttribute GetSpeedPlus(UtilityAbility ability)
{
int duration = RNG.Int(2, 11);
int degree = RNG.Int(30, 120);
if (degree > 100)
{
degree = 100;
}
return(new AbilityAttribute {
type = "speed+",
parameters = new List <AbilityAttributeParameter> {
new AbilityAttributeParameter {
name = "duration",
value = (float)duration
},
new AbilityAttributeParameter {
name = "degree",
value = degree / 100f
}
}
});
}
private static AbilityAttribute GetSpeedMinus(UtilityAbility ability)
{
int degreeRoll = UnityEngine.Random.Range(20, 70);
int durationRoll = UnityEngine.Random.Range(2, 9);
float radius = 2f;
bool rollForRadius = false;
if (ability.targetType == "none")
{
rollForRadius = true;
}
else
{
int rollForRoll = UnityEngine.Random.Range(0, 2);
if (rollForRoll == 0)
{
rollForRadius = true;
}
}
if (rollForRadius)
{
int radiusRoll = UnityEngine.Random.Range(0, 30);
if (radiusRoll < 21)
{
radius = 2;
}
else if (radiusRoll < 27)
{
radius = 4;
}
else if (radiusRoll < 29)
{
radius = 6;
}
else
{
radius = 8;
}
}
if (rollForRadius)
{
return new AbilityAttribute {
type = "speed-",
parameters = new List <AbilityAttributeParameter> {
new AbilityAttributeParameter {
name = "degree",
value = degreeRoll / 100f
},
new AbilityAttributeParameter {
name = "duration",
value = (float)durationRoll
},
new AbilityAttributeParameter {
name = "radius",
value = radius
}
}
}
}
;
else
{
return new AbilityAttribute {
type = "speed-",
parameters = new List <AbilityAttributeParameter> {
new AbilityAttributeParameter {
name = "degree",
value = degreeRoll / 100f
},
new AbilityAttributeParameter {
name = "duration",
value = (float)durationRoll
}
}
}
};
}
public static string Describe(UtilityAbility ability)
{
return(UtilityAbilityDescriber.Describe(ability));
}
public static string Name(UtilityAbility ability)
{
return(UtilityAbilityNamer.Name(ability));
}
private static void ModifyUtilityAbilityPointsForQualities(UtilityAbility ability)
{
ability.points *= AbilityCalculator.pointsMultiplierByCooldown[ability.cooldown];
ability.points *= AbilityCalculator.pointsMultiplierByMpUsage[(int)ability.baseMpUsage];
}
private static AbilityAttribute GetParalyze(UtilityAbility ability)
{
int duration = RNG.Int(2, 9);
bool rollForRadius = false;
float radius = 2f;
if (ability.targetType == "none")
{
rollForRadius = true;
}
else
{
rollForRadius = RNG.Bool();
}
if (rollForRadius)
{
int radiusRoll = RNG.Int(0, 30);
if (radiusRoll < 21)
{
radius = 2;
}
else if (radiusRoll < 27)
{
radius = 4;
}
else if (radiusRoll < 29)
{
radius = 6;
}
else
{
radius = 8;
}
}
if (rollForRadius)
{
return new AbilityAttribute {
type = "paralyze",
parameters = new List <AbilityAttributeParameter> {
new AbilityAttributeParameter {
name = "radius",
value = radius
},
new AbilityAttributeParameter {
name = "duration",
value = (float)duration
}
}
}
}
;
else
{
return new AbilityAttribute {
type = "paralyze",
parameters = new List <AbilityAttributeParameter> {
new AbilityAttributeParameter {
name = "duration",
value = (float)duration
}
}
}
};
}
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 AbilityAttribute Generate(UtilityAbility ability, string attributeType)
{
return(UtilityAbilityAttributeGenerator.Generate(ability, attributeType));
}
public static AbilityAttribute Generate(UtilityAbility ability)
{
return(UtilityAbilityAttributeGenerator.Generate(ability));
}
