public void AttrSpeedPlus(ActiveAbility ability, AbilityAttribute attr)
{
var degree = (float)attr.FindParameter("degree").value;
var duration = (float)attr.FindParameter("duration").value;
FindTarget().GetComponent <StatusEffectHost>().AddStatusEffect("speed+", duration, degree, good: true);
}
private static string BoostStatDescription(Ability ability, AbilityAttribute attribute)
{
switch ((string)attribute.FindParameter("stat").value)
{
case "strength":
return("Increases Strength by " + attribute.FindParameter("degree").value.ToString() + ".\n");
case "dexterity":
return("Increases Dexterity by " + attribute.FindParameter("degree").value.ToString() + ".\n");
case "constitution":
return("Increases Constitution by " + attribute.FindParameter("degree").value.ToString() + ".\n");
case "intelligence":
return("Increases Intelligence by " + attribute.FindParameter("degree").value.ToString() + ".\n");
case "wisdom":
return("Increases Wisdom by " + attribute.FindParameter("degree").value.ToString() + ".\n");
case "luck":
return("Increases Luck by " + attribute.FindParameter("degree").value.ToString() + ".\n");
default:
return("Increases UNKNOWN ATTRIBUTE by " + attribute.FindParameter("degree").value.ToString() + ".\n");
}
}
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);
}
public void AttrHealAll(ActiveAbility ability, AbilityAttribute attr)
{
float factor = 10;
if (GetComponent <PlayerCharacter>() != null)
{
factor *= GetComponent <PlayerCharacter>().weapon.attackPower;
}
else
{
factor *= GetComponent <Monster>().attackFactor;
}
int level = 1;
if (GetComponent <ExperienceGainer>() != null)
{
level = GetComponent <ExperienceGainer>().level;
}
else
{
level = GetComponent <MonsterScaler>().level;
}
//factor *= SecondaryStatUtility.CalcHealingMultiplier(GetComponent<Character>().wisdom, level);
factor *= CharacterAttribute.attributes["healingMultiplier"].instances[GetComponent <Character>()].TotalValue / 100f;
//var healingAmount = (int)((float)attr.FindParameter("degree").value * factor * FindTarget().GetComponent<Health>().healingMultiplier);
var healingAmount = (int)((float)attr.FindParameter("degree").value *factor *CharacterAttribute.attributes["receivedHealing"].instances[FindTarget()].TotalValue / 100f);
//foreach (var monster in Monster.monsters) if (monster.GetComponent<MonsterCombatant>().InCombat()) monster.GetComponent<Health>().Heal(healingAmount);
foreach (var monster in Monster.monsters)
{
monster.GetComponent <Health>().Heal(healingAmount); // temp
}
GetComponent <AudioGenerator>().PlaySoundByName("sfx_magic_heal2");
}
private static string SpeedMinusDescription(AttackAbility ability, AbilityAttribute attribute)
{
var degree = (int)(((float)attribute.FindParameter("degree").value) * 100f);
var duration = (float)attribute.FindParameter("duration").value;
return("Slow target's movement by " + degree.ToString() + "% for " + Mathf.FloorToInt(duration).ToString() + " seconds.\n");
}
public static void SpeedMinus(Character target, AbilityAttribute attr)
{
var degree = (float)attr.FindParameter("degree").value;
var duration = (float)attr.FindParameter("duration").value;
target.GetComponent <StatusEffectHost>().AddStatusEffect("speed-", duration, degree);
}
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);
}
public void AttrParalyze(ActiveAbility ability, AbilityAttribute attr)
{
if (!(ability is UtilityAbility))
{
return;
}
var duration = (float)attr.FindParameter("duration").value;
float radius = 0;
if (attr.FindParameter("radius") != null)
{
radius = (float)attr.FindParameter("radius").value * 3;
}
var utilityAbility = (UtilityAbility)ability;
List <StatusEffectHost> targets = new List <StatusEffectHost>();
if (utilityAbility.targetType == "none" && radius > 0)
{
targets = GetTargetsWithinRadiusOfPoint(transform.position, radius);
}
else if (utilityAbility.targetType == "point" && radius > 0 && GetMouseCursorTargetLocation() != Vector3.positiveInfinity)
{
targets = GetTargetsWithinRadiusOfPoint(GetMouseCursorTargetLocation(), radius);
}
else if (utilityAbility.targetType == "point" && radius == 0 && GetMouseCursorTargetCharacter() != null)
{
targets.Add(GetMouseCursorTargetCharacter());
}
foreach (var target in targets)
{
target.AddStatusEffect("paralysis", (float)attr.FindParameter("duration").value, inflicter: GetComponent <Character>(), good: false, ability: ability);
}
}
public void AttrSelfDestruct(ActiveAbility ability, AbilityAttribute attr)
{
var damage = GetComponent <Attacker>().CalculateAttackDamage((AttackAbility)ability) * ((AttackAbility)ability).damage;
Damage.CreateAoe(GetComponent <Character>(), gameObject, (AttackAbility)ability, ability.attributes, (int)damage, 4, "Enemy");
Destroy(gameObject, 0.2f);
}
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);
}
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);
}
private static float GetSpeedMinus(AttackAbility ability, AbilityAttribute attribute)
{
var degree = (float)attribute.FindParameter("degree").value;
var duration = (float)attribute.FindParameter("duration").value;
return(ability.points * degree / 10f * duration);
}
public static void Knockback(Character attacker, Character target, AbilityAttribute attr)
{
float degree = (float)attr.FindParameter("degree").value;
var obj = target.gameObject.AddComponent <PushingEffect>();
obj.Initialize(target.transform.position + attacker.transform.forward * degree, 0.25f);
target.GetComponent <AbilityUser>().AddPushingEffect(target.transform.position + attacker.transform.forward * degree, 0.25f);
}
public void AttrTimestop(ActiveAbility ability, AbilityAttribute attr)
{
var duration = (float)attr.FindParameter("duration").value;
var radius = ability.radius;
string tag = GetComponent <Character>().oppositeFaction;
AddStatusEffectToAllWithTag(tag, "paralysis", duration, distance: radius);
}
private string GetDotText(AbilityAttribute attribute, int baseAttributeScore)
{
var text = GetDotDamage(attribute, baseAttributeScore).ToString();
text += " over ";
text += GetDotSeconds(attribute).ToString() + " s";
return(text);
}
public static void Lifeleech(Character attacker, Character target, float damage, AbilityAttribute attr)
{
var amount = damage * (float)attr.FindParameter("degree").value;
attacker.GetComponent <Health>().Heal(amount);
GameObject obj = GameObject.Instantiate(attacker.GetComponent <CacheGrabber>().spellEffects[0]);
var script = obj.GetComponent <LifeleechScript>();
script.vampire = attacker.transform;
script.victim = target.transform;
}
public static void Blind(Character attacker, Character target, AbilityAttribute attr)
{
target.GetComponent <StatusEffectHost>().AddStatusEffect("blind", (float)attr.FindParameter("duration").value, inflicter: attacker);
var name = target.gameObject.name;
if (name == "kittenCharacter(Clone)")
{
name = "Player";
}
target.GetComponent <ObjectSpawner>().CreateFloatingStatusText("Blinded!", name + " has been blinded!");
}
public static void JumpBack(Character attacker, Character target, AbilityAttribute attr)
{
if (attr.FindParameter("degree") == null)
{
return;
}
var degree = (float)attr.FindParameter("degree").value;
var obj = attacker.gameObject.AddComponent <PushingEffect>();
obj.Initialize(attacker.transform.position - attacker.transform.forward * degree, 0.5f);
attacker.GetComponent <AbilityUser>().RpcAddPushingEffect(target.transform.position - attacker.transform.forward * degree, 0.5f);
}
public static SavedAbilityAttribute ConvertFrom(AbilityAttribute attribute)
{
var obj = new SavedAbilityAttribute {
type = attribute.type,
points = attribute.points,
priority = attribute.priority
};
foreach (var parameter in attribute.parameters)
{
obj.parameters.Add(SavedAbilityParameter.ConvertFrom(parameter));
}
return(obj);
}
public static void PullTowards(Character attacker, Character target, AbilityAttribute attr)
{
if (attr.FindParameter("degree") == null)
{
return;
}
float distance = (float)attr.FindParameter("degree").value;
if (distance >= 1 && distance <= 10)
{
var obj = target.gameObject.AddComponent <PushingEffect>();
obj.Initialize(target.transform.position - attacker.transform.forward * (distance - 1), 0.5f);
target.GetComponent <AbilityUser>().RpcAddPushingEffect(target.transform.position - attacker.transform.forward * (distance - 1), 0.5f);
}
}
public AbilityAttribute Copy()
{
var newAttribute = new AbilityAttribute {
type = type,
points = points,
priority = priority,
parameters = new List <AbilityAttributeParameter>()
};
foreach (var parameter in parameters)
{
newAttribute.parameters.Add(parameter.Copy());
}
return(newAttribute);
}
public static float Appraise(PassiveAbility ability, AbilityAttribute attribute)
{
if (simplePassiveValues.ContainsKey(attribute.type))
{
return(simplePassiveValues[attribute.type]);
}
else if (simplePassiveMultipliers.ContainsKey(attribute.type))
{
return(simplePassiveMultipliers[attribute.type] * ability.points);
}
else if (complexPassiveMethods.ContainsKey(attribute.type))
{
return(complexPassiveMethods[attribute.type](ability, attribute));
}
return(1000000000);
}
private static float GetInflictVulnerability(AttackAbility ability, AbilityAttribute attribute)
{
var degree = (float)attribute.FindParameter("degree").value;
if (degree == 100)
{
return(ability.points * 0.75f);
}
else if (degree == 50)
{
return(ability.points * 0.5f);
}
else
{
return(ability.points * 0.25f);
}
}
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);
}
}
private static float GetElementalDamageBuff(AttackAbility ability, AbilityAttribute attribute)
{
var damageBoost = (float)attribute.FindParameter("degree").value;
if (damageBoost == 100)
{
return(ability.points * 0.06f);
}
else if (damageBoost == 50)
{
return(ability.points * 0.03f);
}
else
{
return(ability.points * 0.01f);
}
}
private static string ParalyzeDescription(Ability ability, AbilityAttribute attribute)
{
var utilityAbility = ability as UtilityAbility;
if (utilityAbility.targetType == "none")
{
return("Paralyze all enemies within radius " + Mathf.FloorToInt((float)attribute.FindParameter("radius").value).ToString() + " for " + Mathf.FloorToInt((float)attribute.FindParameter("duration").value).ToString() + " seconds.\n");
}
else if (utilityAbility.targetType == "point" && attribute.FindParameter("radius") != null)
{
return("Paralyze all enemies within radius " + Mathf.FloorToInt((float)attribute.FindParameter("radius").value).ToString() + " of targeted point for " + Mathf.FloorToInt((float)attribute.FindParameter("duration").value).ToString() + " seconds.\n");
}
else
{
return("Paralyze targeted enemy for " + Mathf.FloorToInt((float)attribute.FindParameter("duration").value).ToString() + " seconds.\n");
}
}
private static string SpeedMinusDescription(Ability ability, AbilityAttribute attribute)
{
var utilityAbility = ability as UtilityAbility;
if (utilityAbility.targetType == "none")
{
return("Slows all enemies within radius " + Mathf.FloorToInt((float)(attribute.FindParameter("radius").value)).ToString() + " by " + Mathf.FloorToInt((float)attribute.FindParameter("degree").value * 100f).ToString() + "% for " + Mathf.FloorToInt((float)attribute.FindParameter("duration").value).ToString() + " seconds.\n");
}
else if (utilityAbility.targetType == "point" && attribute.FindParameter("radius") != null)
{
return("Slows all enemies within radius " + Mathf.FloorToInt((float)attribute.FindParameter("radius").value).ToString() + " of targeted point by " + Mathf.FloorToInt((float)attribute.FindParameter("degree").value * 100f).ToString() + "% for " + Mathf.FloorToInt((float)attribute.FindParameter("duration").value).ToString() + " seconds.\n");
}
else
{
return("Slows targeted enemy by " + Mathf.FloorToInt((float)attribute.FindParameter("degree").value * 100f).ToString() + "% for " + Mathf.FloorToInt((float)attribute.FindParameter("duration").value).ToString() + " seconds.\n");
}
}
private static AbilityAttribute SquashAttributes(AbilityAttribute attr1, AbilityAttribute attr2)
{
var attr1Copy = attr1.Copy();
var attr2Copy = attr2.Copy();
attr1Copy.points = ((attr1Copy.points + attr2Copy.points) / 2) * Mathf.Pow(1.05f, 3);
attr1Copy.priority = attr1Copy.points + attr2Copy.points;
foreach (var param in attr1Copy.parameters)
{
var param2 = attr2Copy.FindParameter(param.name);
if (param.value is float)
{
param.value = ((float)param.value + (float)param2.value) / 2f;
}
else if (param.value is int)
{
param.value = ((int)param.value + (int)param2.value) / 2;
}
}
return(attr1Copy);
}
private static int BoostStatIcon(AbilityAttribute attribute)
{
var stat = attribute.FindParameter("stat").value as string;
var statTable = new Dictionary <string, int> {
["strength"] = 74,
["dexterity"] = 5,
["constitution"] = 48,
["intelligence"] = 55,
["wisdom"] = 75,
["luck"] = 76
};
if (statTable.ContainsKey(stat))
{
return(statTable[stat]);
}
else
{
return(0);
}
}
