public static void ClearPosition(this IEffectHolder subject)
{
foreach (var position in subject.GetEffects <Effect>().Where(x => x is IPosition position && position.Subject == subject))
{
position.Remove();
}
}
public static void ClearStatusEffects(this IEffectHolder holder)
{
foreach (var effect in holder.GetEffects <EffectStatusEffect>())
{
effect.Remove();
}
}
public static void AddStatusEffect(this IEffectHolder holder, StatusEffect statusEffect)
{
statusEffect.Creature = holder;
var statusEffects = holder.GetEffects <EffectStatusEffect>();
var combineable = statusEffects.Select(x => x.StatusEffect).Where(x => x.CanCombine(statusEffect)).ToList();
if (combineable.Any())
{
var combined = combineable.SelectMany(x => x.Combine(statusEffect)).Distinct().ToList();
var added = combined.Except(combineable).ToList();
var removed = combineable.Except(combined).ToHashSet();
foreach (var effect in added)
{
effect.Apply();
}
foreach (var effect in statusEffects.Where(x => removed.Contains(x.StatusEffect)))
{
effect.Remove();
}
}
else
{
statusEffect.Apply();
}
}
public static void ClearStatusEffects(this IEffectHolder holder, Func <StatusEffect, bool> match)
{
foreach (var effect in holder.GetEffects <EffectStatusEffect>().Where(effect => match(effect.StatusEffect)))
{
effect.Remove();
}
}
private void CalculateArmor()
{
var equipment = Defender.GetEffects <EffectItemEquipped>();
var mainhand = equipment.FirstOrDefault(x => x.Slot == EquipSlot.Mainhand)?.Item;
var offhand = equipment.FirstOrDefault(x => x.Slot == EquipSlot.Offhand)?.Item;
var body = equipment.FirstOrDefault(x => x.Slot == EquipSlot.Body)?.Item;
List <Item> armors = new List <Item>();
//TODO: Should have some other check to find out if an item is a shield/armor
if (mainhand is ToolPlate)
{
armors.Add(mainhand);
}
if (offhand is ToolPlate)
{
armors.Add(offhand);
}
if (body is ToolPlate)
{
armors.Add(body);
}
if (armors.Any())
{
ExtraEffects.Add(new AttackArmor(armors));
}
}
public static IEnumerable <Wait> PushEvent <T, V>(this IEffectHolder holder, T eventParam) where V : EffectEvent <T>
{
IEnumerable <V> enumerable = holder.GetEffects <V>().Distinct();
foreach (var effect in enumerable)
{
yield return(effect.Trigger(eventParam));
}
}
public static string GetName(this IEffectHolder holder, string defaultName)
{
var effects = holder.GetEffects <EffectName>();
if (effects.Any())
{
return(effects.WithMax(effect => effect.Priority).Name);
}
return(defaultName);
}
public static bool HasFlag(this IEffectHolder holder, Flag flag)
{
var effects = holder.GetEffects <EffectFlag>().Where(effect => effect.Flag == flag);
if (effects.Any())
{
return(effects.WithMax(effect => effect.Priority).Value);
}
return(flag.DefaultValue);
}
public static bool HasFamily(this IEffectHolder holder, Family family)
{
var effects = holder.GetEffects <EffectFamily>().Where(effect => effect.Family == family);
if (effects.Any())
{
return(effects.WithMax(effect => effect.Priority).Value);
}
return(false);
}
public static StatusEffect GetStatusEffect(this IEffectHolder holder, StatusEffect statusEffect)
{
foreach (var checkEffect in holder.GetEffects <EffectStatusEffect>())
{
if (checkEffect.StatusEffect == statusEffect || checkEffect.StatusEffect.CanCombine(statusEffect))
{
return(checkEffect.StatusEffect);
}
}
return(null);
}
public static T GetStatusEffect <T>(this IEffectHolder holder) where T : StatusEffect
{
foreach (var checkEffect in holder.GetEffects <EffectStatusEffect>())
{
if (checkEffect.StatusEffect is T)
{
return((T)checkEffect.StatusEffect);
}
}
return(null);
}
public static void AddName(this IEffectHolder holder, string name)
{
var names = holder.GetEffects <EffectName>();
double priority = 0;
if (names.Any())
{
priority = names.Max(x => x.Priority) + 1;
}
Effect.Apply(new EffectName(holder, name, priority));
}
public static void Heal(this IEffectHolder holder, double heal, PopupHelper popupHelper)
{
var damageEffects = holder.GetEffects <EffectDamage>().ToList();
var totalDamage = damageEffects.Sum(x => x.Amount);
var totalHeal = heal + Math.Max(0, totalDamage - holder.GetStat(Stat.HP));
var healAmounts = Util.ProportionalSplit(damageEffects.Select(x => x.Amount), totalHeal);
int i = 0;
foreach (var damage in damageEffects)
{
damage.Amount -= healAmounts[i];
if (damage.Amount <= 0)
{
damage.Remove();
}
i++;
}
popupHelper?.Add(new MessageHeal(holder, heal));
}
public static MovementTypeResult GetMovementType(this IEffectHolder holder)
{
MovementTypeResult result = new MovementTypeResult();
var effects = holder.GetEffects <EffectMovementType>();
foreach (var movementType in effects.OrderBy(e => e.Priority).Select(e => e.MovementType))
{
if (movementType.GetNeighbors != null)
{
result.GetNeighbors = movementType.GetNeighbors;
}
if (movementType.GetTileCost != null)
{
result.GetTileCost = movementType.GetTileCost;
}
if (movementType.CanTraverse != null)
{
result.CanTraverse = movementType.CanTraverse;
}
}
return(result);
}
public static IEnumerable <IEffectHolder> GetMasters(this IEffectHolder holder)
{
return(holder.GetEffects <EffectSummon>().Where(effect => effect.Slave == holder).Select(effect => effect.Master));
}
public static IEnumerable <Family> GetFamilies(this IEffectHolder holder)
{
var effectGroups = holder.GetEffects <EffectFamily>().GroupBy(effect => effect.Family);
return(effectGroups.Select(group => group.WithMax(effect => effect.Priority)).Where(effect => effect.Value).Select(effect => effect.Family));
}
public static double GetStat(this IEffectHolder holder, Stat stat)
{
return(CalculateStat(holder, holder.GetEffects <Effect>().Where(effect => effect is IStat statEffect && statEffect.Stat == stat), stat.DefaultStat));
}
public static double GetStatDamage(this IEffectHolder holder, Stat stat)
{
return(holder.GetEffects <EffectStatDamage>().Where(x => x.Stat == stat).Sum(x => x.Amount));
}
public static Dictionary <Stat, double> GetStats(this IEffectHolder holder)
{
return(holder.GetEffects <Effect>().OfType <IStat>().GroupBy(stat => stat.Stat, stat => (Effect)stat).ToDictionary(group => group.Key, group => CalculateStat(holder, group, group.Key.DefaultStat)));
}
public static Dictionary <Element, double> GetElements(this IEffectHolder holder)
{
return(holder.GetEffects <EffectElement>().GroupBy(stat => stat.Element, stat => stat).ToDictionary(group => group.Key, group => group.Sum(element => element.Percentage)));
}
public static int GetTrait(this IEffectHolder holder, Trait trait)
{
var effects = holder.GetEffects <EffectTrait>().Where(effect => effect.Trait == trait);
return(Math.Max(0, effects.Sum(x => x.Level)));
}
public static double GetTotalDamage(this IEffectHolder holder)
{
return(holder.GetEffects <EffectDamage>().Sum(x => x.Amount));
}
public static IEnumerable <Item> GetInventory(this IEffectHolder holder)
{
return(holder.GetEffects <EffectItemInventory>().Select(effect => effect.Item));
}
public static IEnumerable <StatusEffect> GetStatusEffects(this IEffectHolder holder)
{
return(holder.GetEffects <EffectStatusEffect>().Select(x => x.StatusEffect));
}
public static double GetDamage(this IEffectHolder holder, Element element)
{
return(holder.GetEffects <EffectDamage>().Where(x => x.Element == element).Sum(x => x.Amount));
}