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)); }