public static Ability AddAbility(this IAbilityContainer obj, AbilityRule rule, params object[] vals)
{
var a = new Ability(obj, rule, null, vals);
obj.Abilities.Add(a);
return(a);
}
protected virtual AbilityResourceImpactData[] ComputeResourcesImpacts(IAbilityContainer container)
{
if (HasStats == false)
{
return(container.Ability.Main.BaseResourcesImpacts);
}
AbilityResourceImpactData[] impacts = new AbilityResourceImpactData[container.Ability.Main.BaseResourcesImpacts.Length];
for (int i = 0; i < impacts.Length; i++)
{
impacts[i] = new AbilityResourceImpactData(
container.Ability.Main.BaseResourcesImpacts[i].ResourceType,
Stats.EvaluateAbilitiesResourcesStat(
container.Ability.Main.BaseResourcesImpacts[i].ResourceType,
container.Ability.Main.BaseResourcesImpacts[i].ResourceChange));
}
if (container is EntityEquipable eq)
{
eq.EquippedAbility.ApplyResourcesInfluencesOnImpacts(impacts);
}
return(impacts);
}
private void AddObscurationAbility(IAbilityContainer obj, int level)
{
var a = new Ability(obj);
obj.Abilities.Add(a);
a.Rule = Mod.Current.AbilityRules.FindByName("Sector - Sight Obscuration");
a.Values.Add(level.ToString());
}
public AbilityCastInfos(IAbilityContainer container)
{
if (container is EntityEquipable eq)
{
_equipable = eq;
}
_ability = container.Ability;
_lastCastTime = Time.time;
}
public float GetAbilityCooldownProgress(IAbilityContainer ability)
{
if (_abilityCastInfos.ContainsKey(ability))
{
return(Mathf.Clamp(Time.time - _abilityCastInfos[ability].LastCastTime / ability.AbilityCooldown, 0f, 1f));
}
else
{
return(1f);
}
}
public AbilityCastData(Entity caster, IAbilityContainer container, float castTime = -1f, int multiCastID = 0)
{
_abilityCast = container.Ability;
_caster = caster;
_castTime = castTime < 0f ? Time.time : castTime;
_multiCastID = multiCastID;
if (container is EntityEquipable eq)
{
_castingEquipable = eq;
}
}
protected IEnumerator TriggerBurstAbilityCoroutine(IAbilityContainer container)
{
int triggerCount = 0;
float counter = container.AbilityTriggerData.BurstPeriod;
while (triggerCount < container.AbilityTriggerData.BurstCount)
{
counter += Time.deltaTime;
while (counter > container.AbilityTriggerData.BurstPeriod)
{
TriggerAbility_Single(container);
counter -= container.AbilityTriggerData.BurstPeriod;
triggerCount++;
}
yield return(null);
}
}
protected void TriggerAbility_Single(IAbilityContainer container)
{
if (container.ContainsAbility == false)
{
return;
}
if (container.AbilityTriggerData.MultiCastCount > 1)
{
for (int i = 0; i < container.AbilityTriggerData.MultiCastCount; i++)
{
CastAbility(container, i);
}
}
else
{
CastAbility(container);
}
}
protected void TriggerAbility(IAbilityContainer container)
{
if (container.ContainsAbility == false)
{
return;
}
switch (container.AbilityTriggerData.TriggerMethod)
{
case AbilityTriggerMethod.Single:
case AbilityTriggerMethod.Automatic:
TriggerAbility_Single(container);
break;
case AbilityTriggerMethod.Burst:
master.StartCoroutine(TriggerBurstAbilityCoroutine(container));
break;
}
}
protected void TryTriggerAbility(IAbilityContainer container)
{
if (container.ContainsAbility == false)
{
return;
}
if (_abilityCastInfos.ContainsKey(container))
{
if (Time.time >= _abilityCastInfos[container].LastCastTime + container.AbilityCooldown)
{
_abilityCastInfos[container].Cast();
TriggerAbility(container);
}
}
else
{
_abilityCastInfos.Add(container, new AbilityCastInfos(container));
TriggerAbility(container);
}
}
protected void CastAbility(IAbilityContainer container, Vector3 castDirection, int multiCastID)
{
if (container.ContainsAbility == false)
{
return;
}
AbilityData ability = container.Ability;
AbilityCastData castData = new AbilityCastData(master, container, -1, multiCastID);
_activeCastData = castData;
castData.FillBase(
ComputeResourcesImpacts(container),
ability.Main.BaseKnockback * (HasStats ? Stats.EvaluateAbilitiesStat(EntityAbilitiesStat.KnockbackInflictedFactor, 1f) : 1f),
ability.Main.BaseRecoil / container.AbilityTriggerData.MultiCastCount);
if (castDirection.sqrMagnitude <= Mathf.Epsilon)
{
castData.FillCastDirection(DetermineCastDirection(castData.AbilityCast, container.AbilityTriggerData));
}
else
{
castData.FillCastDirection(castDirection);
}
if (castData.AbilityCast.Methods.CastOriginTiming == AbilityCastOriginTiming.CastEntrance)
{
castData.FillOrigin(DetermineCastOrigin(castData.AbilityCast));
}
if (castData.AbilityCast.Timing.Instant == true)
{
PerformAbility(castData);
_activeCastData = null;
_abilityCastTimingsCoroutine = null;
}
else
{
master.RestartCoroutine(CastAbilityTimingCoroutine(castData), ref _abilityCastTimingsCoroutine);
}
}
public static Ability AddAbility(this IAbilityContainer obj, string abilityName, params object[] vals)
{
return(obj.AddAbility(Mod.Current.AbilityRules.Single(r => r.Name == abilityName || r.Aliases.Contains(abilityName)), vals));
}
/// <summary>
/// Loads abilities from a record.
/// </summary>
/// <param name="rec"></param>
public static IEnumerable <Ability> Load(string filename, Record rec, IAbilityContainer obj)
{
int count = 0;
int index = -1;
while (true)
{
count++;
var abil = new Ability(obj);
var nfield = rec.FindField(new string[]
{
"Ability " + count + " Type",
"Ability Type"
}, ref index, false, index + 1);
if (nfield == null)
{
break; // no more abilities
}
var abilname = nfield.CreateFormula <string>(abil).Value;
lock (Mod.Current.AbilityRules)
{
var rules = Mod.Current.AbilityRules.Where(r => r.Matches(abilname)).ToArray();
if (rules.Count() > 1)
{
Mod.Errors.Add(new DataParsingException("Ambiguous ability name match for " + abilname + " alias between the following abilities: " + string.Join(", ", rules.Select(r => r.Name).ToArray()) + ".", filename, rec));
continue;
}
else if (rules.Count() == 0)
{
// create an ad hoc ability rule
abil.Rule = new AbilityRule {
Name = abilname
};
Mod.Current.AbilityRules.Add(abil.Rule);
}
else
{
abil.Rule = rules.Single();
}
abil.Description = rec.Get <string>(new string[] { "Ability " + count + " Descr", "Ability Descr" }, obj);
int valnum = 0;
int idx = -1;
while (true)
{
valnum++;
var vfield = rec.FindField(new string[]
{
"Ability " + count + " Val " + valnum,
"Ability " + count + " Val",
"Ability Val " + valnum,
"Ability Val"
}, ref idx, false, idx + 1);
if (vfield == null)
{
break;
}
var val = vfield.CreateFormula <string>(abil);
abil.Values.Add(val);
}
}
yield return(abil);
}
}
protected void CastAbility(IAbilityContainer container) => CastAbility(container, default, default);
protected void CastAbility(IAbilityContainer container, Vector3 castDirection) => CastAbility(container, castDirection, default);
protected void CastAbility(IAbilityContainer container, int multiCastID) => CastAbility(container, default, multiCastID);
