AfflictionPrefab.cs

using Barotrauma.Abilities;
using Microsoft.Xna.Framework;
using System;
using System.Collections.Generic;
using System.Reflection;
using System.Xml.Linq;
using Barotrauma.Extensions;
using System.Collections.Immutable;
using Barotrauma.Items.Components;
using System.Linq;
 
namespace Barotrauma
{
    class CPRSettings : Prefab
    {
        public readonly static PrefabSelector<CPRSettings> Prefabs = new PrefabSelector<CPRSettings>();
        public static CPRSettings Active => Prefabs.ActivePrefab;
 
        public readonly float ReviveChancePerSkill;
        public readonly float ReviveChanceExponent;
        public readonly float ReviveChanceMin;
        public readonly float ReviveChanceMax;
        public readonly float StabilizationPerSkill;
        public readonly float StabilizationMin;
        public readonly float StabilizationMax;
        public readonly float DamageSkillThreshold;
        public readonly float DamageSkillMultiplier;
 
        private readonly string insufficientSkillAfflictionIdentifier;
        public AfflictionPrefab InsufficientSkillAffliction
        {
            get
            {
                return
                    AfflictionPrefab.Prefabs.ContainsKey(insufficientSkillAfflictionIdentifier) ?
                    AfflictionPrefab.Prefabs[insufficientSkillAfflictionIdentifier] :
                    AfflictionPrefab.InternalDamage;
            }
        }
 
        public CPRSettings(XElement element, AfflictionsFile file) : base(file, file.Path.Value.ToIdentifier())
        {
            ReviveChancePerSkill = Math.Max(element.GetAttributeFloat("revivechanceperskill", 0.01f), 0.0f);
            ReviveChanceExponent = Math.Max(element.GetAttributeFloat("revivechanceexponent", 2.0f), 0.0f);
            ReviveChanceMin = MathHelper.Clamp(element.GetAttributeFloat("revivechancemin", 0.05f), 0.0f, 1.0f);
            ReviveChanceMax = MathHelper.Clamp(element.GetAttributeFloat("revivechancemax", 0.9f), ReviveChanceMin, 1.0f);
 
            StabilizationPerSkill = Math.Max(element.GetAttributeFloat("stabilizationperskill", 0.01f), 0.0f);
            StabilizationMin = MathHelper.Max(element.GetAttributeFloat("stabilizationmin", 0.05f), 0.0f);
            StabilizationMax = MathHelper.Max(element.GetAttributeFloat("stabilizationmax", 2.0f), StabilizationMin);
 
            DamageSkillThreshold = MathHelper.Clamp(element.GetAttributeFloat("damageskillthreshold", 40.0f), 0.0f, 100.0f);
            DamageSkillMultiplier = MathHelper.Clamp(element.GetAttributeFloat("damageskillmultiplier", 0.1f), 0.0f, 100.0f);
 
            insufficientSkillAfflictionIdentifier = element.GetAttributeString("insufficientskillaffliction", "");
        }
 
        public override void Dispose() { }
    }
 
    class AfflictionPrefabHusk : AfflictionPrefab
    {
        // Use any of these to define which limb the appendage is attached to.
        // If multiple are defined, the order of preference is: id, name, type.
        public readonly int AttachLimbId;
        public readonly string AttachLimbName;
        public readonly LimbType AttachLimbType;
 
        public readonly float DormantThreshold;
 
        public readonly float ActiveThreshold;
 
        public readonly float TransitionThreshold;
 
        public readonly float TransformThresholdOnDeath;
 
        public readonly Identifier HuskedSpeciesName;
 
        public readonly bool TransferBuffs;
 
        public readonly bool SendMessages;
 
        public readonly bool CauseSpeechImpediment;
 
        public readonly bool NeedsAir;
 
        public readonly bool ControlHusk;
 
        public AfflictionPrefabHusk(ContentXElement element, AfflictionsFile file, Type type = null) : base(element, file, type)
        {
            HuskedSpeciesName = element.GetAttributeIdentifier("huskedspeciesname", Identifier.Empty);
            if (HuskedSpeciesName.IsEmpty)
            {
                DebugConsole.NewMessage($"No 'huskedspeciesname' defined for the husk affliction ({Identifier}) in {element}", Color.Orange);
                HuskedSpeciesName = "husk".ToIdentifier();
            }
            // Remove "[speciesname]" for backward support (we don't use it anymore)
            HuskedSpeciesName = HuskedSpeciesName.Remove("[speciesname]").ToIdentifier();
            if (TargetSpecies.Length == 0)
            {
                DebugConsole.NewMessage($"No 'targets' defined for the husk affliction ({Identifier}) in {element}", Color.Orange);
                TargetSpecies = new Identifier[] { CharacterPrefab.HumanSpeciesName };
            }
            var attachElement = element.GetChildElement("attachlimb");
            if (attachElement != null)
            {
                AttachLimbId = attachElement.GetAttributeInt("id", -1);
                AttachLimbName = attachElement.GetAttributeString("name", null);
                AttachLimbType = attachElement.GetAttributeEnum("type", LimbType.None);
            }
            else
            {
                AttachLimbId = -1;
                AttachLimbName = null;
                AttachLimbType = LimbType.None;
            }
 
            TransferBuffs = element.GetAttributeBool("transferbuffs", true);
            SendMessages = element.GetAttributeBool("sendmessages", true);
            CauseSpeechImpediment = element.GetAttributeBool("causespeechimpediment", true);
            NeedsAir = element.GetAttributeBool("needsair", false);
            ControlHusk = element.GetAttributeBool("controlhusk", false);
 
            DormantThreshold = element.GetAttributeFloat("dormantthreshold", MaxStrength * 0.5f);
            ActiveThreshold = element.GetAttributeFloat("activethreshold", MaxStrength * 0.75f);
            TransitionThreshold = element.GetAttributeFloat("transitionthreshold", MaxStrength);
 
            if (DormantThreshold > ActiveThreshold)
            {
                DebugConsole.ThrowError($"Error in \"{Identifier}\": {nameof(DormantThreshold)} is greater than {nameof(ActiveThreshold)} ({DormantThreshold} > {ActiveThreshold})",
                            contentPackage: element.ContentPackage);
            }
            if (ActiveThreshold > TransitionThreshold)
            {
                DebugConsole.ThrowError($"Error in \"{Identifier}\": {nameof(ActiveThreshold)} is greater than {nameof(TransitionThreshold)} ({ActiveThreshold} > {TransitionThreshold})",
                            contentPackage: element.ContentPackage);
            }
 
            TransformThresholdOnDeath = element.GetAttributeFloat("transformthresholdondeath", ActiveThreshold);
        }
    }
 
    class AfflictionPrefab : PrefabWithUintIdentifier
    {
        public sealed class Effect
        {
            //this effect is applied when the strength is within this range
            [Serialize(0.0f, IsPropertySaveable.No, description: "Minimum affliction strength required for this effect to be active.")]
            public float MinStrength { get; private set; }
 
            [Serialize(0.0f, IsPropertySaveable.No, description: "Maximum affliction strength for which this effect will be active.")]
            public float MaxStrength { get; private set; }
 
            [Serialize(0.0f, IsPropertySaveable.No, description: "The amount of vitality that is lost at this effect's lowest strength.")]
            public float MinVitalityDecrease { get; private set; }
 
            [Serialize(0.0f, IsPropertySaveable.No, description: "The amount of vitality that is lost at this effect's highest strength.")]
            public float MaxVitalityDecrease { get; private set; }
 
            [Serialize(0.0f, IsPropertySaveable.No, description: "How much the affliction's strength changes every second while this effect is active.")]
            public float StrengthChange { get; private set; }
 
            [Serialize(false, IsPropertySaveable.No, description:
                "If set to true, MinVitalityDecrease and MaxVitalityDecrease represent a fraction of the affected character's maximum " +
                "vitality, with 1 meaning 100%, instead of the same amount for all species.")]
            public bool MultiplyByMaxVitality { get; private set; }
 
            [Serialize(0.0f, IsPropertySaveable.No, description: "Blur effect strength at this effect's lowest strength.")]
            public float MinScreenBlur { get; private set; }
 
            [Serialize(0.0f, IsPropertySaveable.No, description: "Blur effect strength at this effect's highest strength.")]
            public float MaxScreenBlur { get; private set; }
 
            [Serialize(0.0f, IsPropertySaveable.No, description: "Generic distortion effect strength at this effect's lowest strength.")]
            public float MinScreenDistort { get; private set; }
 
            [Serialize(0.0f, IsPropertySaveable.No, description: "Generic distortion effect strength at this effect's highest strength.")]
            public float MaxScreenDistort { get; private set; }
 
            [Serialize(0.0f, IsPropertySaveable.No, description: "Radial distortion effect strength at this effect's lowest strength.")]
            public float MinRadialDistort { get; private set; }
 
            [Serialize(0.0f, IsPropertySaveable.No, description: "Radial distortion effect strength at this effect's highest strength.")]
            public float MaxRadialDistort { get; private set; }
 
            [Serialize(0.0f, IsPropertySaveable.No, description: "Chromatic aberration effect strength at this effect's lowest strength.")]
            public float MinChromaticAberration { get; private set; }
 
            [Serialize(0.0f, IsPropertySaveable.No, description: "Chromatic aberration effect strength at this effect's highest strength.")]
            public float MaxChromaticAberration { get; private set; }
 
            [Serialize("255,255,255,255", IsPropertySaveable.No, description: "Radiation grain effect color.")]
            public Color GrainColor { get; private set; }
 
            [Serialize(0.0f, IsPropertySaveable.No, description: "Radiation grain effect strength at this effect's lowest strength.")]
            public float MinGrainStrength { get; private set; }
 
            [Serialize(0.0f, IsPropertySaveable.No, description: "Radiation grain effect strength at this effect's highest strength.")]
            public float MaxGrainStrength { get; private set; }
 
            [Serialize(0.0f, IsPropertySaveable.No, description:
                "The maximum rate of fluctuation to apply to visual effects caused by this affliction effect. " +
                "Effective fluctuation is proportional to the affliction's current strength.")]
            public float ScreenEffectFluctuationFrequency { get; private set; }
            
            [Serialize(1.0f, IsPropertySaveable.No, description:
                "Multiplier for the affliction overlay's opacity at this effect's lowest strength. " +
                "See the list of elements for more details.")]
            public float MinAfflictionOverlayAlphaMultiplier { get; private set; }
 
            [Serialize(1.0f, IsPropertySaveable.No, description:
                "Multiplier for the affliction overlay's opacity at this effect's highest strength. " +
                "See the list of elements for more details.")]
            public float MaxAfflictionOverlayAlphaMultiplier { get; private set; }
 
            [Serialize(1.0f, IsPropertySaveable.No, description:
                "Multiplier for every buff's decay rate at this effect's lowest strength. " +
                "Only applies to afflictions of class BuffDurationIncrease.")]
            public float MinBuffMultiplier { get; private set; }
 
            [Serialize(1.0f, IsPropertySaveable.No, description:
                "Multiplier for every buff's decay rate at this effect's highest strength. " +
                "Only applies to afflictions of class BuffDurationIncrease.")]
            public float MaxBuffMultiplier { get; private set; }
 
            [Serialize(1.0f, IsPropertySaveable.No, description: "Multiplier to apply to the affected character's speed at this effect's lowest strength.")]
            public float MinSpeedMultiplier { get; private set; }
 
            [Serialize(1.0f, IsPropertySaveable.No, description: "Multiplier to apply to the affected character's speed at this effect's highest strength.")]
            public float MaxSpeedMultiplier { get; private set; }
 
            [Serialize(1.0f, IsPropertySaveable.No, description: "Multiplier to apply to all of the affected character's skill levels at this effect's lowest strength.")]
            public float MinSkillMultiplier { get; private set; }
 
            [Serialize(1.0f, IsPropertySaveable.No, description: "Multiplier to apply to all of the affected character's skill levels at this effect's highest strength.")]
            public float MaxSkillMultiplier { get; private set; }
            
            public readonly ImmutableArray<Identifier> ResistanceFor;
 
            public readonly ImmutableArray<LimbType> ResistanceLimbs;
 
            [Serialize(0.0f, IsPropertySaveable.No,
                description: "The amount of resistance to the afflictions specified by ResistanceFor to apply at this effect's lowest strength.")]
            public float MinResistance { get; private set; }
 
            [Serialize(0.0f, IsPropertySaveable.No,
                description: "The amount of resistance to the afflictions specified by ResistanceFor to apply at this effect's highest strength.")]
            public float MaxResistance { get; private set; }
 
            [Serialize("", IsPropertySaveable.No, description: "Identifier used by AI to determine conversation lines to say when this effect is active.")]
            public Identifier DialogFlag { get; private set; }
 
            [Serialize("", IsPropertySaveable.No, description: "Tag that enemy AI may use to target the affected character when this effect is active.")]
            public Identifier Tag { get; private set; }
 
            [Serialize("0,0,0,0", IsPropertySaveable.No,
                description: "Color to tint the affected character's face with at this effect's lowest strength. The alpha channel is used to determine how much to tint the character's face.")]
            public Color MinFaceTint { get; private set; }
 
            [Serialize("0,0,0,0", IsPropertySaveable.No,
                description: "Color to tint the affected character's face with at this effect's highest strength. The alpha channel is used to determine how much to tint the character's face.")]
            public Color MaxFaceTint { get; private set; }
 
            [Serialize("0,0,0,0", IsPropertySaveable.No,
                description: "Color to tint the affected character's entire body with at this effect's lowest strength. The alpha channel is used to determine how much to tint the character.")]
            public Color MinBodyTint { get; private set; }
 
            [Serialize("0,0,0,0", IsPropertySaveable.No,
                description: "Color to tint the affected character's entire body with at this effect's highest strength. The alpha channel is used to determine how much to tint the character.")]
            public Color MaxBodyTint { get; private set; }
 
            [Serialize(0.0f, IsPropertySaveable.No,
                description: "Range of the \"thermal goggles overlay\" enabled by the affliction.")]
            public float ThermalOverlayRange { get; private set; }
 
            [Serialize("255,0,0,255", IsPropertySaveable.No,
                description: $"Color of the \"thermal goggles overlay\" enabled by the affliction. Only has an effect if {nameof(ThermalOverlayRange)} is larger than 0.")]
            public Color ThermalOverlayColor { get; private set; }
 
            public readonly struct AppliedStatValue
            {
                public readonly StatTypes StatType;
 
                public readonly float MinValue;
 
                public readonly float MaxValue;
 
                private readonly float Value;
 
                public AppliedStatValue(ContentXElement element)
                {
                    Value = element.GetAttributeFloat("value", 0.0f);
                    StatType = element.GetAttributeEnum("stattype", StatTypes.None);
                    MinValue = element.GetAttributeFloat("minvalue", Value);
                    MaxValue = element.GetAttributeFloat("maxvalue", Value);
                }
            }
 
            public readonly ImmutableArray<Identifier> BlockTransformation;
 
            public readonly ImmutableDictionary<StatTypes, AppliedStatValue> AfflictionStatValues;
 
            public readonly AbilityFlags AfflictionAbilityFlags;
 
            //statuseffects applied on the character when the affliction is active
            public readonly ImmutableArray<StatusEffect> StatusEffects;
 
            public Effect(ContentXElement element, string parentDebugName)
            {
                SerializableProperty.DeserializeProperties(this, element);
 
                ResistanceFor = element.GetAttributeIdentifierArray("resistancefor", Array.Empty<Identifier>())!.ToImmutableArray();
                ResistanceLimbs = element.GetAttributeEnumArray<LimbType>("resistancelimbs", Array.Empty<LimbType>()).ToImmutableArray();
                
                BlockTransformation = element.GetAttributeIdentifierArray("blocktransformation", Array.Empty<Identifier>())!.ToImmutableArray();
 
                var afflictionStatValues = new Dictionary<StatTypes, AppliedStatValue>();
                var statusEffects = new List<StatusEffect>();
                foreach (var subElement in element.Elements())
                {
                    switch (subElement.Name.ToString().ToLowerInvariant())
                    {
                        case "statuseffect":
                            statusEffects.Add(StatusEffect.Load(subElement, parentDebugName));
                            break;
                        case "statvalue":
                            var newStatValue = new AppliedStatValue(subElement);
                            if (newStatValue.StatType == StatTypes.None || !afflictionStatValues.TryAdd(newStatValue.StatType, newStatValue))
                            {
                                DebugConsole.ThrowError($"Invalid stat value in the affliction \"{parentDebugName}\".", contentPackage: element.ContentPackage);                                
                            }
                            break;
                        case "abilityflag":
                            AbilityFlags flagType = subElement.GetAttributeEnum("flagtype", AbilityFlags.None);
                            if (flagType is AbilityFlags.None)
                            {
                                DebugConsole.ThrowError($"Error in affliction \"{parentDebugName}\" - invalid ability flag type \"{subElement.GetAttributeString("flagtype", "")}\".",
                                    contentPackage: element.ContentPackage);
                                continue;
                            }
                            AfflictionAbilityFlags |= flagType;
                            break;
                        case "affliction":
                            DebugConsole.AddWarning($"Error in affliction \"{parentDebugName}\" - additional afflictions caused by the affliction should be configured inside status effects.",
                                contentPackage: element.ContentPackage);
                            break;
                    }
                }
                AfflictionStatValues = afflictionStatValues.ToImmutableDictionary();
                StatusEffects = statusEffects.ToImmutableArray();
            }
 
            public float GetStrengthFactor(Affliction affliction) => GetStrengthFactor(affliction.Strength);
 
            public float GetStrengthFactor(float strength)
                => MathUtils.InverseLerp(
                    MinStrength,
                    MaxStrength,
                    strength);
        }
 
        public sealed class Description
        {
            public enum TargetType
            {
                Any,
                Self,
                OtherCharacter
            }
 
            public readonly LocalizedString Text;
 
            public readonly Identifier TextTag;
 
            public readonly float MinStrength;
 
            public readonly float MaxStrength;
 
            public readonly TargetType Target;
 
            public Description(ContentXElement element, AfflictionPrefab affliction)
            {
                TextTag = element.GetAttributeIdentifier("textidentifier", Identifier.Empty);
                if (!TextTag.IsEmpty)
                {
                    Text = TextManager.Get(TextTag);
                }
                string text = element.GetAttributeString("text", string.Empty);
                if (!text.IsNullOrEmpty())
                {
                    Text = Text?.Fallback(text) ?? text;
                }
                else if (TextTag.IsEmpty)
                {
                    DebugConsole.ThrowError($"Error in affliction \"{affliction.Identifier}\" - no text defined for one of the descriptions.",
                            contentPackage: element.ContentPackage);
                }
 
                MinStrength = element.GetAttributeFloat(nameof(MinStrength), 0.0f);
                MaxStrength = element.GetAttributeFloat(nameof(MaxStrength), 100.0f);
                if (MinStrength >= MaxStrength)
                {
                    DebugConsole.ThrowError($"Error in affliction \"{affliction.Identifier}\" - max strength is not larger than min.",
                            contentPackage: element.ContentPackage);
                }
                Target = element.GetAttributeEnum(nameof(Target), TargetType.Any);
            }
        }
 
        public sealed class PeriodicEffect
        {
            public readonly List<StatusEffect> StatusEffects = new List<StatusEffect>();
            public readonly float MinInterval, MaxInterval;
            public readonly float MinStrength, MaxStrength;
 
            public PeriodicEffect(ContentXElement element, string parentDebugName)
            {
                foreach (var subElement in element.Elements())
                {
                    StatusEffects.Add(StatusEffect.Load(subElement, parentDebugName));
                }
 
                if (element.GetAttribute("interval") != null)
                {
                    MinInterval = MaxInterval = Math.Max(element.GetAttributeFloat("interval", 1.0f), 1.0f);
                }
                else
                {
                    MinInterval = Math.Max(element.GetAttributeFloat(nameof(MinInterval), 1.0f), 0.1f);
                    MaxInterval = Math.Max(element.GetAttributeFloat(nameof(MaxInterval), 1.0f), MinInterval);
                    MinStrength = Math.Max(element.GetAttributeFloat(nameof(MinStrength), 0f), 0f);
                    MaxStrength = Math.Max(element.GetAttributeFloat(nameof(MaxStrength), MinStrength), MinStrength);
                }
            }
        }
 
        public static readonly Identifier DamageType = "damage".ToIdentifier();
        public static readonly Identifier BurnType = "burn".ToIdentifier();
        public static readonly Identifier BleedingType = "bleeding".ToIdentifier();
        public static readonly Identifier ParalysisType = "paralysis".ToIdentifier();
        public static readonly Identifier PoisonType = "poison".ToIdentifier();
        public static readonly Identifier StunType = "stun".ToIdentifier();
        public static readonly Identifier EMPType = "emp".ToIdentifier();
        public static readonly Identifier SpaceHerpesType = "spaceherpes".ToIdentifier();
        public static readonly Identifier AlienInfectedType = "alieninfected".ToIdentifier();
        public static readonly Identifier InvertControlsType = "invertcontrols".ToIdentifier();
        public static readonly Identifier DisguisedAsHuskType = "disguiseashusk".ToIdentifier();
 
        public static AfflictionPrefab InternalDamage => Prefabs["internaldamage"];
        public static AfflictionPrefab BiteWounds => Prefabs["bitewounds"];
        public static AfflictionPrefab ImpactDamage => Prefabs["blunttrauma"];
        public static AfflictionPrefab Bleeding => Prefabs[BleedingType];
        public static AfflictionPrefab Burn => Prefabs[BurnType];
        public static AfflictionPrefab OxygenLow => Prefabs["oxygenlow"];
        public static AfflictionPrefab Bloodloss => Prefabs["bloodloss"];
        public static AfflictionPrefab Pressure => Prefabs["pressure"];
        public static AfflictionPrefab OrganDamage => Prefabs["organdamage"];
        public static AfflictionPrefab Stun => Prefabs[StunType];
        public static AfflictionPrefab RadiationSickness => Prefabs["radiationsickness"];
        public static AfflictionPrefab HuskInfection => Prefabs["huskinfection"];
 
        public static readonly PrefabCollection<AfflictionPrefab> Prefabs = new PrefabCollection<AfflictionPrefab>();
 
        public static IEnumerable<AfflictionPrefab> List => Prefabs;
 
        public override void Dispose() { }
 
        private readonly ContentXElement configElement;
 
        public readonly LocalizedString Name;
        
        public readonly LocalizedString CauseOfDeathDescription, SelfCauseOfDeathDescription;
 
        private readonly LocalizedString defaultDescription;
        public readonly ImmutableList<Description> Descriptions;
 
        public readonly Identifier AfflictionType;
        
        public readonly bool LimbSpecific;
 
        public readonly LimbType IndicatorLimb;
 
        public readonly Identifier TranslationIdentifier;
        
        public readonly bool IsBuff;
        
        public readonly bool AffectMachines;
        
        public readonly bool HealableInMedicalClinic;
        
        public readonly float HealCostMultiplier;
        
        public readonly int BaseHealCost;
        
        public readonly bool ShowBarInHealthMenu;
 
        public readonly bool HideIconAfterDelay;
 
        public readonly float ActivationThreshold = 0.0f;
 
        public readonly float ShowIconThreshold = 0.05f;
 
        public readonly float ShowIconToOthersThreshold = 0.05f;
 
        public readonly float MaxStrength = 100.0f;
 
        public readonly float GrainBurst;
 
        public readonly float ShowInHealthScannerThreshold;
 
        public readonly float TreatmentThreshold;
 
        public ImmutableHashSet<Identifier> IgnoreTreatmentIfAfflictedBy;
 
        public readonly float Duration;
 
        public float KarmaChangeOnApplied;
 
        public readonly float BurnOverlayAlpha;
 
        public readonly float DamageOverlayAlpha;
 
        public readonly Identifier AchievementOnReceived;
 
        public readonly Identifier AchievementOnRemoved;
 
        public readonly Color[] IconColors;
 
        public readonly bool AfflictionOverlayAlphaIsLinear;
 
        public readonly bool ResetBetweenRounds;
 
        public readonly bool DamageParticles;
 
        public readonly float MedicalSkillGain;
 
        public readonly float WeaponsSkillGain;
 
        public Identifier[] TargetSpecies { get; protected set; }
 
        private readonly List<Effect> effects = new List<Effect>();
        
        private readonly List<PeriodicEffect> periodicEffects = new List<PeriodicEffect>();
 
        public IEnumerable<Effect> Effects => effects;
 
        public IList<PeriodicEffect> PeriodicEffects => periodicEffects;
 
        private readonly ConstructorInfo constructor;
 
        public readonly Sprite Icon;
 
        public readonly Sprite AfflictionOverlay;
 
        public ImmutableDictionary<Identifier, float> TreatmentSuitabilities
        {
            get;
            private set;
        } = new Dictionary<Identifier, float>().ToImmutableDictionary();
 
        public bool HasTreatments { get; private set; }
 
        public AfflictionPrefab(ContentXElement element, AfflictionsFile file, Type type) : base(file, element.GetAttributeIdentifier("identifier", ""))
        {
            configElement = element;
            
            AfflictionType = element.GetAttributeIdentifier("type", "");
            TranslationIdentifier = element.GetAttributeIdentifier("translationoverride", Identifier);
            Name = TextManager.Get($"AfflictionName.{TranslationIdentifier}");
            string fallbackName = element.GetAttributeString("name", "");
            if (!string.IsNullOrEmpty(fallbackName))
            {
                Name = Name.Fallback(fallbackName);
            }
            defaultDescription = TextManager.Get($"AfflictionDescription.{TranslationIdentifier}");
            string fallbackDescription = element.GetAttributeString("description", "");
            if (!string.IsNullOrEmpty(fallbackDescription))
            {
                defaultDescription = defaultDescription.Fallback(fallbackDescription);
            }
            IsBuff = element.GetAttributeBool(nameof(IsBuff), false);
            AffectMachines = element.GetAttributeBool(nameof(AffectMachines), true);
 
            ShowBarInHealthMenu = element.GetAttributeBool("showbarinhealthmenu", true);
 
            HealableInMedicalClinic = element.GetAttributeBool("healableinmedicalclinic", 
                !IsBuff && 
                AfflictionType != "geneticmaterialbuff" && 
                AfflictionType != "geneticmaterialdebuff");
            HealCostMultiplier = element.GetAttributeFloat(nameof(HealCostMultiplier), 1f);
            BaseHealCost = element.GetAttributeInt(nameof(BaseHealCost), 0);
 
            IgnoreTreatmentIfAfflictedBy = element.GetAttributeIdentifierArray(nameof(IgnoreTreatmentIfAfflictedBy), Array.Empty<Identifier>()).ToImmutableHashSet();
 
            Duration = element.GetAttributeFloat(nameof(Duration), 0.0f);
 
            if (element.GetAttribute("nameidentifier") != null)
            {
                string nameIdentifier = element.GetAttributeString("nameidentifier", string.Empty);
                Name = TextManager.Get(nameIdentifier)
                    .Fallback(TextManager.Get($"AfflictionName.{nameIdentifier}"))
                    .Fallback(Name);
            }
 
            LimbSpecific = element.GetAttributeBool("limbspecific", false);
            if (!LimbSpecific)
            {
                string indicatorLimbName = element.GetAttributeString("indicatorlimb", "Torso");
                if (!Enum.TryParse(indicatorLimbName, out IndicatorLimb))
                {
                    DebugConsole.ThrowErrorLocalized("Error in affliction prefab " + Name + " - limb type \"" + indicatorLimbName + "\" not found.");
                }
            }
 
            HideIconAfterDelay = element.GetAttributeBool(nameof(HideIconAfterDelay), false);
 
            ActivationThreshold = element.GetAttributeFloat(nameof(ActivationThreshold), 0.0f);
            ShowIconThreshold   = element.GetAttributeFloat(nameof(ShowIconThreshold), Math.Max(ActivationThreshold, 0.05f));
            ShowIconToOthersThreshold   = element.GetAttributeFloat(nameof(ShowIconToOthersThreshold), ShowIconThreshold);
            MaxStrength         = element.GetAttributeFloat(nameof(MaxStrength), 100.0f);
            GrainBurst          = element.GetAttributeFloat(nameof(GrainBurst), 0.0f);
 
            ShowInHealthScannerThreshold = element.GetAttributeFloat(nameof(ShowInHealthScannerThreshold), 
                Math.Max(ActivationThreshold, AfflictionType == "talentbuff" ? float.MaxValue : ShowIconToOthersThreshold));
            TreatmentThreshold = element.GetAttributeFloat(nameof(TreatmentThreshold), Math.Max(ActivationThreshold, 10.0f));
 
            DamageOverlayAlpha  = element.GetAttributeFloat(nameof(DamageOverlayAlpha), 0.0f);
            BurnOverlayAlpha    = element.GetAttributeFloat(nameof(BurnOverlayAlpha), 0.0f);
 
            KarmaChangeOnApplied = element.GetAttributeFloat(nameof(KarmaChangeOnApplied), 0.0f);
 
            CauseOfDeathDescription     = 
                TextManager.Get($"AfflictionCauseOfDeath.{TranslationIdentifier}")
                .Fallback(TextManager.Get(element.GetAttributeString("causeofdeathdescription", "")))
                .Fallback(element.GetAttributeString("causeofdeathdescription", ""));
            SelfCauseOfDeathDescription = 
                TextManager.Get($"AfflictionCauseOfDeathSelf.{TranslationIdentifier}")
                .Fallback(TextManager.Get(element.GetAttributeString("selfcauseofdeathdescription", "")))
                .Fallback(element.GetAttributeString("selfcauseofdeathdescription", ""));
 
            IconColors = element.GetAttributeColorArray(nameof(IconColors), null);
            AfflictionOverlayAlphaIsLinear = element.GetAttributeBool(nameof(AfflictionOverlayAlphaIsLinear), false);
            AchievementOnReceived = element.GetAttributeIdentifier(nameof(AchievementOnReceived), "");
            AchievementOnRemoved = element.GetAttributeIdentifier(nameof(AchievementOnRemoved), "");
 
            TargetSpecies = element.GetAttributeIdentifierArray("targets", Array.Empty<Identifier>(), trim: true);
 
            ResetBetweenRounds = element.GetAttributeBool("resetbetweenrounds", false);
 
            DamageParticles = element.GetAttributeBool(nameof(DamageParticles), true);
            WeaponsSkillGain = element.GetAttributeFloat(nameof(WeaponsSkillGain), 0.0f);
            MedicalSkillGain = element.GetAttributeFloat(nameof(MedicalSkillGain), 0.0f);
 
            List<Description> descriptions = new List<Description>();
            foreach (var subElement in element.Elements())
            {
                switch (subElement.Name.ToString().ToLowerInvariant())
                {
                    case "icon":
                        Icon = new Sprite(subElement);
                        break;
                    case "afflictionoverlay":
                        AfflictionOverlay = new Sprite(subElement);
                        break;
                    case "statvalue":
                        DebugConsole.ThrowError($"Error in affliction \"{Identifier}\" - stat values should be configured inside the affliction's effects.",
                            contentPackage: element.ContentPackage);
                        break;
                    case "effect":
                    case "periodiceffect":
                        break;
                    case "description":
                        descriptions.Add(new Description(subElement, this));
                        break;
                    default:
                        DebugConsole.AddWarning($"Unrecognized element in affliction \"{Identifier}\" ({subElement.Name})",
                            contentPackage: element.ContentPackage);
                        break;
                }
            }
            Descriptions = descriptions.ToImmutableList();
 
            constructor = type.GetConstructor(new[] { typeof(AfflictionPrefab), typeof(float) });
        }
 
        private void RefreshTreatmentSuitabilities()
        {
            var newTreatmentSuitabilities = new Dictionary<Identifier, float>();
 
            foreach (var itemPrefab in ItemPrefab.Prefabs)
            {
                float suitability = itemPrefab.GetTreatmentSuitability(Identifier) + itemPrefab.GetTreatmentSuitability(AfflictionType);
                if (!MathUtils.NearlyEqual(suitability, 0.0f))
                {
                    newTreatmentSuitabilities.TryAdd(itemPrefab.Identifier, suitability);
                }
            }
            HasTreatments = newTreatmentSuitabilities.Any(kvp => kvp.Value > 0);
            TreatmentSuitabilities = newTreatmentSuitabilities.ToImmutableDictionary();
        }
 
        public LocalizedString GetDescription(float strength, Description.TargetType targetType)
        {
            foreach (var description in Descriptions)
            {
                if (strength < description.MinStrength || strength > description.MaxStrength) { continue; }
                switch (targetType)
                {
                    case Description.TargetType.Self:
                        if (description.Target == Description.TargetType.OtherCharacter) { continue; }
                        break;
                    case Description.TargetType.OtherCharacter:
                        if (description.Target == Description.TargetType.Self) { continue; }
                        break;
                }
                return description.Text;
            }
            return defaultDescription;
        }
 
        public static void LoadAllEffectsAndTreatmentSuitabilities()
        {
            foreach (var prefab in Prefabs)
            {
                prefab.RefreshTreatmentSuitabilities();
                prefab.LoadEffects();
            }
        }
 
        public static void ClearAllEffects()
        {
            Prefabs.ForEach(p => p.ClearEffects());
        }
        
        private void LoadEffects()
        {
            ClearEffects();
            foreach (var subElement in configElement.Elements())
            {
                switch (subElement.Name.ToString().ToLowerInvariant())
                {
                    case "effect":
                        effects.Add(new Effect(subElement, Name.Value));
                        break;
                    case "periodiceffect":
                        periodicEffects.Add(new PeriodicEffect(subElement, Name.Value));
                        break;
                }
            }
            for (int i = 0; i < effects.Count; i++)
            {
                for (int j = i + 1; j < effects.Count; j++)
                {
                    var a = effects[i];
                    var b = effects[j];
                    if (a.MinStrength < b.MaxStrength && b.MinStrength < a.MaxStrength)
                    {
                        DebugConsole.AddWarning($"Affliction \"{Identifier}\" contains effects with overlapping strength ranges. Only one effect can be active at a time, meaning one of the effects won't work.",
                            ContentPackage);
                    }
                }
            }
        }
 
        private void ClearEffects()
        {
            effects.Clear();
            periodicEffects.Clear();
        }
 
#if CLIENT
        public void ReloadSoundsIfNeeded()
        {
            foreach (var effect in effects)
            {
                foreach (var statusEffect in effect.StatusEffects)
                {
                    foreach (var sound in statusEffect.Sounds)
                    {
                        if (sound.Sound == null) { RoundSound.Reload(sound); }                       
                    }
                }
            }
            foreach (var periodicEffect in periodicEffects)
            {
                foreach (var statusEffect in periodicEffect.StatusEffects)
                {
                    foreach (var sound in statusEffect.Sounds)
                    {
                        if (sound.Sound == null) { RoundSound.Reload(sound); }
                    }
                }
            }
        }
#endif
 
        public override string ToString()
        {
            return $"AfflictionPrefab ({Name})";
        }
 
        public Affliction Instantiate(float strength, Character source = null)
        {
            object instance = null;
            try
            {
                instance = constructor.Invoke(new object[] { this, strength });
            }
            catch (Exception ex)
            {
                DebugConsole.ThrowError(ex.InnerException != null ? ex.InnerException.ToString() : ex.ToString());
            }
            Affliction affliction = instance as Affliction;
            affliction.Source = source;
            return affliction;
        }
 
        public Effect GetActiveEffect(float currentStrength)
        {
            foreach (Effect effect in effects)
            {
                if (currentStrength > effect.MinStrength && currentStrength <= effect.MaxStrength)
                {
                    return effect;
                }
            }
 
            //if above the strength range of all effects, use the highest strength effect
            Effect strongestEffect = null;
            float largestStrength = currentStrength;
            foreach (Effect effect in effects)
            {
                if (currentStrength > effect.MaxStrength && 
                    (strongestEffect == null || effect.MaxStrength > largestStrength))
                {
                    strongestEffect = effect;
                    largestStrength = effect.MaxStrength;
                }
            }
            return strongestEffect;
        }
 
        public float GetTreatmentSuitability(Item item)
        {
            if (item == null)
            {
                return 0.0f;
            }
            return Math.Max(item.Prefab.GetTreatmentSuitability(Identifier), item.Prefab.GetTreatmentSuitability(AfflictionType));
        }
    }
}