(61d00a474) v0.9.7.1

Barotrauma/BarotraumaShared/SharedSource/Characters/Health/Afflictions/Affliction.cs

@@ -0,0 +1,208 @@
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml.Linq;
+
+namespace Barotrauma
+{
+    class Affliction : ISerializableEntity
+    {
+        public readonly AfflictionPrefab Prefab;
+
+        public string Name => ToString();
+
+        public Dictionary<string, SerializableProperty> SerializableProperties { get; set; }
+
+        [Serialize(0f, true), Editable]
+        public float Strength { get; set; }
+
+        [Serialize("", true), Editable]
+        public string Identifier { get; private set; }
+
+        [Serialize(1.0f, true, description: "The probability for the affliction to be applied."), Editable(minValue: 0f, maxValue: 1f)]
+        public float Probability { get; private set; } = 1.0f;
+
+        public float DamagePerSecond;
+        public float DamagePerSecondTimer;
+        public float PreviousVitalityDecrease;
+
+        public float StrengthDiminishMultiplier = 1.0f;
+        public Affliction MultiplierSource;
+
+        /// <summary>
+        /// Which character gave this affliction
+        /// </summary>
+        public Character Source;
+
+        public Affliction(AfflictionPrefab prefab, float strength)
+        {
+            Prefab = prefab;
+            Strength = strength;
+            Identifier = prefab?.Identifier;
+        }
+
+        public void Serialize(XElement element)
+        {
+            SerializableProperty.SerializeProperties(this, element);
+        }
+
+        public void Deserialize(XElement element)
+        {
+            SerializableProperties = SerializableProperty.DeserializeProperties(this, element);
+        }
+
+        public Affliction CreateMultiplied(float multiplier)
+        {
+            return Prefab.Instantiate(Strength * multiplier, Source);
+        }
+
+        public override string ToString() => Prefab == null ? "Affliction (Invalid)" : $"Affliction ({Prefab.Name})";
+
+        public float GetVitalityDecrease(CharacterHealth characterHealth)
+        {
+            if (Strength < Prefab.ActivationThreshold) return 0.0f;
+            AfflictionPrefab.Effect currentEffect = Prefab.GetActiveEffect(Strength);
+            if (currentEffect == null) return 0.0f;
+            if (currentEffect.MaxStrength - currentEffect.MinStrength <= 0.0f) return 0.0f;
+
+            float currVitalityDecrease = MathHelper.Lerp(
+                currentEffect.MinVitalityDecrease, 
+                currentEffect.MaxVitalityDecrease, 
+                (Strength - currentEffect.MinStrength) / (currentEffect.MaxStrength - currentEffect.MinStrength));
+
+            if (currentEffect.MultiplyByMaxVitality) currVitalityDecrease *= characterHealth == null ? 100.0f : characterHealth.MaxVitality;
+
+            return currVitalityDecrease;
+        }
+
+        public float GetScreenDistortStrength()
+        {
+            if (Strength < Prefab.ActivationThreshold) return 0.0f;
+            AfflictionPrefab.Effect currentEffect = Prefab.GetActiveEffect(Strength);
+            if (currentEffect == null) return 0.0f;
+            if (currentEffect.MaxScreenDistortStrength - currentEffect.MinScreenDistortStrength <= 0.0f) return 0.0f;
+
+            return MathHelper.Lerp(
+                currentEffect.MinScreenDistortStrength,
+                currentEffect.MaxScreenDistortStrength,
+                (Strength - currentEffect.MinStrength) / (currentEffect.MaxStrength - currentEffect.MinStrength));
+        }
+
+        public float GetRadialDistortStrength()
+        {
+            if (Strength < Prefab.ActivationThreshold) return 0.0f;
+            AfflictionPrefab.Effect currentEffect = Prefab.GetActiveEffect(Strength);
+            if (currentEffect == null) return 0.0f;
+            if (currentEffect.MaxRadialDistortStrength - currentEffect.MinRadialDistortStrength <= 0.0f) return 0.0f;
+
+            return MathHelper.Lerp(
+                currentEffect.MinRadialDistortStrength,
+                currentEffect.MaxRadialDistortStrength,
+                (Strength - currentEffect.MinStrength) / (currentEffect.MaxStrength - currentEffect.MinStrength));
+        }
+
+        public float GetChromaticAberrationStrength()
+        {
+            if (Strength < Prefab.ActivationThreshold) return 0.0f;
+            AfflictionPrefab.Effect currentEffect = Prefab.GetActiveEffect(Strength);
+            if (currentEffect == null) return 0.0f;
+            if (currentEffect.MaxChromaticAberrationStrength - currentEffect.MinChromaticAberrationStrength <= 0.0f) return 0.0f;
+
+            return MathHelper.Lerp(
+                currentEffect.MinChromaticAberrationStrength,
+                currentEffect.MaxChromaticAberrationStrength,
+                (Strength - currentEffect.MinStrength) / (currentEffect.MaxStrength - currentEffect.MinStrength));
+        }
+
+        public float GetScreenBlurStrength()
+        {
+            if (Strength < Prefab.ActivationThreshold) return 0.0f;
+            AfflictionPrefab.Effect currentEffect = Prefab.GetActiveEffect(Strength);
+            if (currentEffect == null) return 0.0f;
+            if (currentEffect.MaxScreenBlurStrength - currentEffect.MinScreenBlurStrength <= 0.0f) return 0.0f;
+
+            return MathHelper.Lerp(
+                currentEffect.MinScreenBlurStrength,
+                currentEffect.MaxScreenBlurStrength,
+                (Strength - currentEffect.MinStrength) / (currentEffect.MaxStrength - currentEffect.MinStrength));
+        }
+
+        public void CalculateDamagePerSecond(float currentVitalityDecrease)
+        {
+            DamagePerSecond = Math.Max(DamagePerSecond, currentVitalityDecrease - PreviousVitalityDecrease);
+            if (DamagePerSecondTimer >= 1.0f)
+            {
+                DamagePerSecond = currentVitalityDecrease - PreviousVitalityDecrease;
+                PreviousVitalityDecrease = currentVitalityDecrease;
+                DamagePerSecondTimer = 0.0f;
+            }
+        }
+
+        public float GetResistance(string afflictionId)
+        {
+            if (Strength < Prefab.ActivationThreshold) return 0.0f;
+            AfflictionPrefab.Effect currentEffect = Prefab.GetActiveEffect(Strength);
+            if (currentEffect == null) return 0.0f;
+            if (currentEffect.MaxResistance - currentEffect.MinResistance <= 0.0f) return 0.0f;
+            if (afflictionId != null && afflictionId != currentEffect.ResistanceFor) return 0.0f;
+
+            return MathHelper.Lerp(
+                currentEffect.MinResistance,
+                currentEffect.MaxResistance,
+                (Strength - currentEffect.MinStrength) / (currentEffect.MaxStrength - currentEffect.MinStrength));
+        }    
+
+        public float GetSpeedMultiplier()
+        {
+            if (Strength < Prefab.ActivationThreshold) return 1.0f;
+            AfflictionPrefab.Effect currentEffect = Prefab.GetActiveEffect(Strength);
+            if (currentEffect == null) return 1.0f;
+            if (currentEffect.MaxSpeedMultiplier - currentEffect.MinSpeedMultiplier <= 0.0f) return 1.0f;
+
+            return MathHelper.Lerp(
+                currentEffect.MinSpeedMultiplier,
+                currentEffect.MaxSpeedMultiplier,
+                (Strength - currentEffect.MinStrength) / (currentEffect.MaxStrength - currentEffect.MinStrength));
+        }
+
+        public virtual void Update(CharacterHealth characterHealth, Limb targetLimb, float deltaTime)
+        {
+            AfflictionPrefab.Effect currentEffect = Prefab.GetActiveEffect(Strength);
+            if (currentEffect == null) return;
+
+            if (currentEffect.StrengthChange < 0) // Reduce diminishing of buffs if boosted
+            {
+                Strength += currentEffect.StrengthChange * deltaTime * StrengthDiminishMultiplier;
+            }
+            else // Reduce strengthening of afflictions if resistant
+            {
+                Strength += currentEffect.StrengthChange * deltaTime * (1f - characterHealth.GetResistance(Prefab.Identifier));
+            }
+
+            foreach (StatusEffect statusEffect in currentEffect.StatusEffects)
+            {
+                statusEffect.SetUser(Source);
+                if (statusEffect.HasTargetType(StatusEffect.TargetType.Character))
+                {
+                    statusEffect.Apply(ActionType.OnActive, deltaTime, characterHealth.Character, characterHealth.Character);
+                }
+                if (targetLimb != null && statusEffect.HasTargetType(StatusEffect.TargetType.Limb))
+                {
+                    statusEffect.Apply(ActionType.OnActive, deltaTime, characterHealth.Character, targetLimb);
+                }
+                if (targetLimb != null && statusEffect.HasTargetType(StatusEffect.TargetType.AllLimbs))
+                {
+                    statusEffect.Apply(ActionType.OnActive, deltaTime, targetLimb.character, targetLimb.character.AnimController.Limbs.Cast<ISerializableEntity>().ToList());
+                }
+                if (statusEffect.HasTargetType(StatusEffect.TargetType.NearbyItems) || 
+                    statusEffect.HasTargetType(StatusEffect.TargetType.NearbyCharacters))
+                {
+                    var targets = new List<ISerializableEntity>();
+                    statusEffect.GetNearbyTargets(characterHealth.Character.WorldPosition, targets);
+                    statusEffect.Apply(ActionType.OnActive, deltaTime, targetLimb.character, targets);
+                }
+            }
+        }
+    }
+}

Barotrauma/BarotraumaShared/SharedSource/Characters/Health/Afflictions/AfflictionBleeding.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Barotrauma
+{
+    class AfflictionBleeding : Affliction
+    {
+        public AfflictionBleeding(AfflictionPrefab prefab, float strength) : 
+            base(prefab, strength)
+        {
+        }
+
+        public override void Update(CharacterHealth characterHealth, Limb targetLimb, float deltaTime)
+        {
+            base.Update(characterHealth, targetLimb, deltaTime);
+            characterHealth.BloodlossAmount += Strength * (1.0f / 60.0f) * deltaTime;
+        }
+    }
+}

Barotrauma/BarotraumaShared/SharedSource/Characters/Health/Afflictions/AfflictionHusk.cs

@@ -0,0 +1,301 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Xml.Linq;
+
+namespace Barotrauma
+{
+    partial class AfflictionHusk : Affliction
+    {
+        public enum InfectionState
+        {
+            Dormant, Transition, Active
+        }
+
+        private bool subscribedToDeathEvent;
+
+        private InfectionState state;
+
+        private List<Limb> huskAppendage;
+        
+        public InfectionState State
+        {
+            get { return state; }
+        }
+
+        public AfflictionHusk(AfflictionPrefab prefab, float strength) : 
+            base(prefab, strength)
+        {
+        }
+
+        public override void Update(CharacterHealth characterHealth, Limb targetLimb, float deltaTime)
+        {
+            float prevStrength = Strength;
+            base.Update(characterHealth, targetLimb, deltaTime);
+
+            if (!subscribedToDeathEvent)
+            {
+                characterHealth.Character.OnDeath += CharacterDead;
+                subscribedToDeathEvent = true;
+            }
+
+            if (characterHealth.Character == Character.Controlled) UpdateMessages(prevStrength, characterHealth.Character);
+            if (Strength < Prefab.MaxStrength * 0.5f)
+            {
+                UpdateDormantState(deltaTime, characterHealth.Character);
+            }
+            else if (Strength < Prefab.MaxStrength)
+            {
+                characterHealth.Character.SpeechImpediment = 100.0f;
+                UpdateTransitionState(deltaTime, characterHealth.Character);
+            }
+            else
+            {
+                characterHealth.Character.SpeechImpediment = 100.0f;
+                UpdateActiveState(deltaTime, characterHealth.Character);
+            }
+        }
+
+        partial void UpdateMessages(float prevStrength, Character character);
+
+        private void UpdateDormantState(float deltaTime, Character character)
+        {
+            if (state != InfectionState.Dormant)
+            {
+                DeactivateHusk(character);
+            }
+            
+            state = InfectionState.Dormant;
+        }
+
+        private void UpdateTransitionState(float deltaTime, Character character)
+        {
+            if (state != InfectionState.Transition)
+            {
+                DeactivateHusk(character);                
+            }
+
+            state = InfectionState.Transition;
+        }
+
+        private void UpdateActiveState(float deltaTime, Character character)
+        {
+            if (state != InfectionState.Active)
+            {
+                ActivateHusk(character);
+                state = InfectionState.Active;
+            }
+
+            foreach (Limb limb in character.AnimController.Limbs)
+            {
+                character.LastDamageSource = null;
+                character.DamageLimb(
+                    limb.WorldPosition, limb,
+                    new List<Affliction>() { AfflictionPrefab.InternalDamage.Instantiate(0.5f * deltaTime / character.AnimController.Limbs.Length) },
+                    0.0f, false, 0.0f);
+            }
+        }
+
+        public void ActivateHusk(Character character)
+        {
+            if (huskAppendage == null)
+            {
+                huskAppendage = AttachHuskAppendage(character, Prefab.Identifier);
+                if (huskAppendage != null)
+                {
+                    character.NeedsAir = false;
+                    character.SetStun(0.5f);
+                }
+#if CLIENT
+                character.AnimController.GetLimb(LimbType.Head).EnableHuskSprite = true;
+#endif
+            }
+        }
+
+        private void DeactivateHusk(Character character)
+        {
+            character.NeedsAir = character.Params.MainElement.GetAttributeBool("needsair", false);
+            if (huskAppendage != null)
+            {
+                huskAppendage.ForEach(l => character.AnimController.RemoveLimb(l));
+                huskAppendage = null;
+#if CLIENT
+                character.AnimController.GetLimb(LimbType.Head).EnableHuskSprite = false;
+#endif
+            }
+        }
+
+        public void Remove(Character character)
+        {
+            DeactivateHusk(character);
+            if (character != null) character.OnDeath -= CharacterDead;
+            subscribedToDeathEvent = false;
+        }
+
+        private void CharacterDead(Character character, CauseOfDeath causeOfDeath)
+        {
+            if (GameMain.NetworkMember != null && GameMain.NetworkMember.IsClient) { return; }
+            if (Strength < Prefab.MaxStrength * 0.5f || character.Removed) { return; }
+
+            //don't turn the character into a husk if any of its limbs are severed
+            if (character.AnimController?.LimbJoints != null)
+            {
+                foreach (var limbJoint in character.AnimController.LimbJoints)
+                {
+                    if (limbJoint.IsSevered) return;
+                }
+            }
+
+            //create the AI husk in a coroutine to ensure that we don't modify the character list while enumerating it
+            CoroutineManager.StartCoroutine(CreateAIHusk(character));
+        }
+
+        private IEnumerable<object> CreateAIHusk(Character character)
+        {
+            character.Enabled = false;
+            Entity.Spawner.AddToRemoveQueue(character);
+
+            string speciesName = GetHuskedSpeciesName(character.SpeciesName, Prefab as AfflictionPrefabHusk);
+            CharacterPrefab prefab = CharacterPrefab.FindBySpeciesName(speciesName);
+
+            if (prefab == null)
+            {
+                DebugConsole.ThrowError("Failed to turn character \"" + character.Name + "\" into a husk - husk config file not found.");
+                yield return CoroutineStatus.Success;
+            }
+
+            var husk = Character.Create(speciesName, character.WorldPosition, character.Info.Name, character.Info, isRemotePlayer: false, hasAi: true, ragdoll: character.AnimController.RagdollParams);
+
+            foreach (Limb limb in husk.AnimController.Limbs)
+            {
+                if (limb.type == LimbType.None)
+                {
+                    limb.body.SetTransform(character.SimPosition, 0.0f);
+                    continue;
+                }
+
+                var matchingLimb = character.AnimController.GetLimb(limb.type);
+                if (matchingLimb?.body != null)
+                {
+                    limb.body.SetTransform(matchingLimb.SimPosition, matchingLimb.Rotation);
+                    limb.body.LinearVelocity = matchingLimb.LinearVelocity;
+                    limb.body.AngularVelocity = matchingLimb.body.AngularVelocity;
+                }
+            }
+
+            if (character.Inventory.Items.Length != husk.Inventory.Items.Length)
+            {
+                string errorMsg = "Failed to move items from the source character's inventory into a husk's inventory (inventory sizes don't match)";
+                DebugConsole.ThrowError(errorMsg);
+                GameAnalyticsManager.AddErrorEventOnce("AfflictionHusk.CreateAIHusk:InventoryMismatch", GameAnalyticsSDK.Net.EGAErrorSeverity.Error, errorMsg);
+                yield return CoroutineStatus.Success;
+            }
+
+            for (int i = 0; i < character.Inventory.Items.Length && i < husk.Inventory.Items.Length; i++)
+            {
+                if (character.Inventory.Items[i] == null) continue;
+                husk.Inventory.TryPutItem(character.Inventory.Items[i], i, true, false, null);
+            }
+
+            yield return CoroutineStatus.Success;
+        }
+
+        public static List<Limb> AttachHuskAppendage(Character character, string afflictionIdentifier, XElement appendageDefinition = null, Ragdoll ragdoll = null)
+        {
+            var appendage = new List<Limb>();
+            if (!(AfflictionPrefab.List.FirstOrDefault(ap => ap.Identifier == afflictionIdentifier) is AfflictionPrefabHusk matchingAffliction))
+            {
+                DebugConsole.ThrowError($"Could not find an affliction of type 'huskinfection' that matches the affliction '{afflictionIdentifier}'!");
+                return appendage;
+            }
+            string nonhuskedSpeciesName = GetNonHuskedSpeciesName(character.SpeciesName, matchingAffliction);
+            string huskedSpeciesName = GetHuskedSpeciesName(nonhuskedSpeciesName, matchingAffliction);
+            CharacterPrefab huskPrefab = CharacterPrefab.FindBySpeciesName(huskedSpeciesName);
+            if (huskPrefab?.XDocument == null)
+            {
+                DebugConsole.ThrowError($"Failed to find the config file for the husk infected species with the species name '{huskedSpeciesName}'!");
+                return appendage;
+            }
+            var mainElement = huskPrefab.XDocument.Root.IsOverride() ? huskPrefab.XDocument.Root.FirstElement() : huskPrefab.XDocument.Root;
+            var element = appendageDefinition;
+            if (element == null)
+            {
+                element = mainElement.GetChildElements("huskappendage").FirstOrDefault(e => e.GetAttributeString("affliction", string.Empty).Equals(afflictionIdentifier, System.StringComparison.OrdinalIgnoreCase));
+            }
+            if (element == null)
+            {
+                DebugConsole.ThrowError($"Error in '{huskPrefab.FilePath}': Failed to find a huskappendage that matches the affliction with an identifier '{afflictionIdentifier}'!");
+                return appendage;
+            }
+            string pathToAppendage = element.GetAttributeString("path", string.Empty);
+            XDocument doc = XMLExtensions.TryLoadXml(pathToAppendage);
+            if (doc == null) { return appendage; }
+            if (ragdoll == null)
+            {
+                ragdoll = character.AnimController;
+            }
+            if (ragdoll.Dir < 1.0f)
+            {
+                ragdoll.Flip();
+            }
+            var limbElements = doc.Root.Elements("limb").ToDictionary(e => e.GetAttributeString("id", null), e => e);
+            foreach (var jointElement in doc.Root.Elements("joint"))
+            {
+                if (limbElements.TryGetValue(jointElement.GetAttributeString("limb2", null), out XElement limbElement))
+                {
+                    var jointParams = new RagdollParams.JointParams(jointElement, ragdoll.RagdollParams);
+                    Limb attachLimb = null;
+                    if (matchingAffliction.AttachLimbId > -1)
+                    {
+                        attachLimb = ragdoll.Limbs.FirstOrDefault(l => l.Params.ID == matchingAffliction.AttachLimbId);
+                    }
+                    else if (matchingAffliction.AttachLimbName != null)
+                    {
+                        attachLimb = ragdoll.Limbs.FirstOrDefault(l => l.Name == matchingAffliction.AttachLimbName);
+                    }
+                    else if (matchingAffliction.AttachLimbType != LimbType.None)
+                    {
+                        attachLimb = ragdoll.Limbs.FirstOrDefault(l => l.type == matchingAffliction.AttachLimbType);
+                    }
+                    if (attachLimb == null)
+                    {
+                        DebugConsole.Log("Attachment limb not defined in the affliction prefab or no matching limb could be found. Using the appendage definition as it is.");
+                        attachLimb = ragdoll.Limbs.FirstOrDefault(l => l.Params.ID == jointParams.Limb1);
+                    }
+                    if (attachLimb != null)
+                    {
+                        jointParams.Limb1 = attachLimb.Params.ID;
+                        var appendageLimbParams = new RagdollParams.LimbParams(limbElement, ragdoll.RagdollParams)
+                        {
+                            // Ensure that we have a valid id for the new limb
+                            ID = ragdoll.Limbs.Length
+                        };
+                        jointParams.Limb2 = appendageLimbParams.ID;
+                        Limb huskAppendage = new Limb(ragdoll, character, appendageLimbParams);
+                        huskAppendage.body.Submarine = character.Submarine;
+                        huskAppendage.body.SetTransform(attachLimb.SimPosition, attachLimb.Rotation);
+                        ragdoll.AddLimb(huskAppendage);
+                        ragdoll.AddJoint(jointParams);
+                        appendage.Add(huskAppendage);
+                    }
+                    else
+                    {
+                        DebugConsole.ThrowError("Attachment limb not found!");
+                    }
+                }
+            }
+            return appendage;
+        }
+
+        public static string GetHuskedSpeciesName(string speciesName, AfflictionPrefabHusk prefab)
+        {
+            return prefab.HuskedSpeciesName.Replace(AfflictionPrefabHusk.Tag, speciesName);
+        }
+
+        public static string GetNonHuskedSpeciesName(string huskedSpeciesName, AfflictionPrefabHusk prefab)
+        {
+            string nonTag = prefab.HuskedSpeciesName.Remove(AfflictionPrefabHusk.Tag);
+            return huskedSpeciesName.ToLowerInvariant().Remove(nonTag);
+        }
+    }
+}

Barotrauma/BarotraumaShared/SharedSource/Characters/Health/Afflictions/AfflictionPrefab.cs

@@ -0,0 +1,623 @@
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Xml.Linq;
+using System.Linq;
+using System.Security.Cryptography;
+
+namespace Barotrauma
+{
+    static class CPRSettings
+    {
+        public static string FilePath { get; private set; }
+        public static bool IsLoaded { get; private set; }
+        public static float ReviveChancePerSkill { get; private set; }
+        public static float ReviveChanceExponent { get; private set; }
+        public static float ReviveChanceMin { get; private set; }
+        public static float ReviveChanceMax { get; private set; }
+        public static float StabilizationPerSkill { get; private set; }
+        public static float StabilizationMin { get; private set; }
+        public static float StabilizationMax { get; private set; }
+        public static float DamageSkillThreshold { get; private set; }
+        public static float DamageSkillMultiplier { get; private set; }
+
+        private static string insufficientSkillAfflictionIdentifier { get; set; }
+        public static AfflictionPrefab InsufficientSkillAffliction
+        {
+            get
+            {
+                return
+                    AfflictionPrefab.Prefabs.ContainsKey(insufficientSkillAfflictionIdentifier) ?
+                    AfflictionPrefab.Prefabs[insufficientSkillAfflictionIdentifier] :
+                    AfflictionPrefab.InternalDamage;
+            }
+        }
+
+        public static void Load(XElement element, string filePath)
+        {
+            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", "");
+
+            IsLoaded = true;
+            FilePath = filePath;
+        }
+
+        public static void Unload()
+        {
+            IsLoaded = false;
+            FilePath = null;
+        }
+    }
+
+    class AfflictionPrefabHusk : AfflictionPrefab
+    {
+        public AfflictionPrefabHusk(XElement element, string filePath, Type type = null) : base(element, filePath, type)
+        {
+            HuskedSpeciesName = element.GetAttributeString("huskedspeciesname", null).ToLowerInvariant();
+            if (HuskedSpeciesName == null)
+            {
+                DebugConsole.NewMessage($"No 'huskedspeciesname' defined for the husk affliction ({Identifier}) in {element.ToString()}", Color.Orange);
+                HuskedSpeciesName = "[speciesname]husk";
+            }
+            TargetSpecies = element.GetAttributeStringArray("targets", new string[0] { }, trim: true, convertToLowerInvariant: true);
+            if (TargetSpecies.Length == 0)
+            {
+                DebugConsole.NewMessage($"No 'targets' defined for the husk affliction ({Identifier}) in {element.ToString()}", Color.Orange);
+                TargetSpecies = new string[] { "human" };
+            }
+            var attachElement = element.GetChildElement("attachlimb");
+            if (attachElement != null)
+            {
+                AttachLimbId = attachElement.GetAttributeInt("id", -1);
+                AttachLimbName = attachElement.GetAttributeString("name", null);
+                AttachLimbType = Enum.TryParse(attachElement.GetAttributeString("type", "none"), true, out LimbType limbType) ? limbType : LimbType.None;
+            }
+            else
+            {
+                AttachLimbId = -1;
+                AttachLimbName = null;
+                AttachLimbType = LimbType.None;
+            }
+        }
+
+        // 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 string HuskedSpeciesName;
+        public readonly string[] TargetSpecies;
+        public const string Tag = "[speciesname]";
+    }
+
+    class AfflictionPrefab : IPrefab, IDisposable
+    {
+        public class Effect
+        {
+            //this effect is applied when the strength is within this range
+            public float MinStrength, MaxStrength;
+
+            public readonly float MinVitalityDecrease = 0.0f;
+            public readonly float MaxVitalityDecrease = 0.0f;
+            
+            //how much the strength of the affliction changes per second
+            public readonly float StrengthChange = 0.0f;
+
+            public readonly bool MultiplyByMaxVitality;
+
+            public float MinScreenBlurStrength, MaxScreenBlurStrength;
+            public float MinScreenDistortStrength, MaxScreenDistortStrength;
+            public float MinRadialDistortStrength, MaxRadialDistortStrength;
+            public float MinChromaticAberrationStrength, MaxChromaticAberrationStrength;
+            public float MinSpeedMultiplier, MaxSpeedMultiplier;
+            public float MinBuffMultiplier, MaxBuffMultiplier;
+
+            public float MinResistance, MaxResistance;
+            public string ResistanceFor;
+            public string DialogFlag;
+
+            //statuseffects applied on the character when the affliction is active
+            public readonly List<StatusEffect> StatusEffects = new List<StatusEffect>();
+
+            public Effect(XElement element, string parentDebugName)
+            {
+                MinStrength =  element.GetAttributeFloat("minstrength", 0);
+                MaxStrength =  element.GetAttributeFloat("maxstrength", 0);
+
+                MultiplyByMaxVitality = element.GetAttributeBool("multiplybymaxvitality", false);
+
+                MinVitalityDecrease = element.GetAttributeFloat("minvitalitydecrease", 0.0f);
+                MaxVitalityDecrease = element.GetAttributeFloat("maxvitalitydecrease", 0.0f);
+                MaxVitalityDecrease = Math.Max(MinVitalityDecrease, MaxVitalityDecrease);
+
+                MinScreenDistortStrength = element.GetAttributeFloat("minscreendistort", 0.0f);
+                MaxScreenDistortStrength = element.GetAttributeFloat("maxscreendistort", 0.0f);
+                MaxScreenDistortStrength = Math.Max(MinScreenDistortStrength, MaxScreenDistortStrength);
+
+                MinRadialDistortStrength = element.GetAttributeFloat("minradialdistort", 0.0f);
+                MaxRadialDistortStrength = element.GetAttributeFloat("maxradialdistort", 0.0f);
+                MaxRadialDistortStrength = Math.Max(MinRadialDistortStrength, MaxRadialDistortStrength);
+
+                MinChromaticAberrationStrength = element.GetAttributeFloat("minchromaticaberration", 0.0f);
+                MaxChromaticAberrationStrength = element.GetAttributeFloat("maxchromaticaberration", 0.0f);
+                MaxChromaticAberrationStrength = Math.Max(MinChromaticAberrationStrength, MaxChromaticAberrationStrength);
+
+                MinScreenBlurStrength = element.GetAttributeFloat("minscreenblur", 0.0f);
+                MaxScreenBlurStrength = element.GetAttributeFloat("maxscreenblur", 0.0f);
+                MaxScreenBlurStrength = Math.Max(MinScreenBlurStrength, MaxScreenBlurStrength);
+
+                ResistanceFor = element.GetAttributeString("resistancefor", "");
+                MinResistance = element.GetAttributeFloat("minresistance", 0.0f);
+                MaxResistance = element.GetAttributeFloat("maxresistance", 0.0f);
+                MaxResistance = Math.Max(MinResistance, MaxResistance);
+
+                MinSpeedMultiplier = element.GetAttributeFloat("minspeedmultiplier", 1.0f);
+                MaxSpeedMultiplier = element.GetAttributeFloat("maxspeedmultiplier", 1.0f);
+                MaxSpeedMultiplier = Math.Max(MinSpeedMultiplier, MaxSpeedMultiplier);
+
+                MinBuffMultiplier = element.GetAttributeFloat("minbuffmultiplier", 1.0f);
+                MaxBuffMultiplier = element.GetAttributeFloat("maxbuffmultiplier", 1.0f);
+                MaxBuffMultiplier = Math.Max(MinBuffMultiplier, MaxBuffMultiplier);
+
+                DialogFlag = element.GetAttributeString("dialogflag", "");
+
+                StrengthChange = element.GetAttributeFloat("strengthchange", 0.0f);
+
+                foreach (XElement subElement in element.Elements())
+                {
+                    switch (subElement.Name.ToString().ToLowerInvariant())
+                    {
+                        case "statuseffect":
+                            StatusEffects.Add(StatusEffect.Load(subElement, parentDebugName));
+                            break;
+                    }
+                }
+            }
+        }
+
+        public static AfflictionPrefab InternalDamage;
+        public static AfflictionPrefab Bleeding;
+        public static AfflictionPrefab Burn;
+        public static AfflictionPrefab OxygenLow;
+        public static AfflictionPrefab Bloodloss;
+        public static AfflictionPrefab Pressure;
+        public static AfflictionPrefab Stun;
+
+        public static readonly PrefabCollection<AfflictionPrefab> Prefabs = new PrefabCollection<AfflictionPrefab>();
+
+        private bool disposed = false;
+        public void Dispose()
+        {
+            if (disposed) { return; }
+            disposed = true;
+            Prefabs.Remove(this);
+        }
+
+        public static IEnumerable<AfflictionPrefab> List
+        {
+            get
+            {
+                foreach (var prefab in Prefabs)
+                {
+                    yield return prefab;
+                }
+            }
+        }
+
+        public string FilePath { get; private set; }
+
+        /// <summary>
+        /// Unique identifier that's generated by hashing the prefab's string identifier. 
+        /// Used to reduce the amount of bytes needed to write affliction data into network messages in multiplayer.
+        /// </summary>
+        public uint UIntIdentifier;
+
+        // Arbitrary string that is used to identify the type of the affliction.
+        public readonly string AfflictionType;
+
+        //Does the affliction affect a specific limb or the whole character
+        public readonly bool LimbSpecific;
+
+        //If not a limb-specific affliction, which limb is the indicator shown on in the health menu
+        //(e.g. mental health problems on head, lack of oxygen on torso...)
+        public readonly LimbType IndicatorLimb;
+
+        public string Identifier { get; private set; }
+        public string OriginalName { get { return Identifier; } }
+        public ContentPackage ContentPackage { get; private set; }
+
+        public readonly string Name, Description;
+        public readonly bool IsBuff;
+
+        public readonly string CauseOfDeathDescription, SelfCauseOfDeathDescription;
+
+        //how high the strength has to be for the affliction to take affect
+        public readonly float ActivationThreshold = 0.0f;
+        //how high the strength has to be for the affliction icon to be shown in the UI
+        public readonly float ShowIconThreshold = 0.05f;
+        public readonly float MaxStrength = 100.0f;
+
+        //how high the strength has to be for the affliction icon to be shown with a health scanner
+        public readonly float ShowInHealthScannerThreshold = 0.05f;
+
+        //how much karma changes when a player applies this affliction to someone (per strength of the affliction)
+        public float KarmaChangeOnApplied;
+
+        public float BurnOverlayAlpha;
+        public float DamageOverlayAlpha;
+
+        //steam achievement given when the affliction is removed from the controlled character
+        public readonly string AchievementOnRemoved;
+
+        public readonly Sprite Icon;
+        public readonly Color[] IconColors;
+
+        private List<Effect> effects = new List<Effect>();
+
+        private readonly string typeName;
+
+        private readonly ConstructorInfo constructor;
+
+        public IEnumerable<KeyValuePair<string, float>> TreatmentSuitability
+        {
+            get
+            {
+                foreach (var itemPrefab in ItemPrefab.Prefabs)
+                {
+                    float suitability = Math.Max(itemPrefab.GetTreatmentSuitability(Identifier), itemPrefab.GetTreatmentSuitability(AfflictionType));
+                    if (suitability > 0.0f)
+                    {
+                        yield return new KeyValuePair<string, float>(itemPrefab.Identifier, suitability);
+                    }
+                }
+            }
+        }
+
+        public static void LoadAll(IEnumerable<ContentFile> files)
+        {
+            CPRSettings.Unload();
+            InternalDamage = null;
+            Bleeding = null;
+            Burn = null;
+            OxygenLow = null;
+            Bloodloss = null;
+            Pressure = null;
+            Stun = null;
+#if CLIENT
+            CharacterHealth.DamageOverlay?.Remove();
+            CharacterHealth.DamageOverlay = null;
+            CharacterHealth.DamageOverlayFile = string.Empty;
+#endif
+            var prevPrefabs = Prefabs.ToList();
+            foreach (var prefab in prevPrefabs)
+            {
+                prefab.Dispose();
+            }
+            System.Diagnostics.Debug.Assert(Prefabs.Count() == 0, "All previous AfflictionPrefabs were not removed in AfflictionPrefab.LoadAll");
+
+            foreach (ContentFile file in files)
+            {
+                LoadFromFile(file);
+            }
+
+            if (InternalDamage == null) { DebugConsole.ThrowError("Affliction \"Internal Damage\" not defined in the affliction prefabs."); }
+            if (Bleeding == null) { DebugConsole.ThrowError("Affliction \"Bleeding\" not defined in the affliction prefabs."); }
+            if (Burn == null) { DebugConsole.ThrowError("Affliction \"Burn\" not defined in the affliction prefabs."); }
+            if (OxygenLow == null) { DebugConsole.ThrowError("Affliction \"OxygenLow\" not defined in the affliction prefabs."); }
+            if (Bloodloss == null) { DebugConsole.ThrowError("Affliction \"Bloodloss\" not defined in the affliction prefabs."); }
+            if (Pressure == null) { DebugConsole.ThrowError("Affliction \"Pressure\" not defined in the affliction prefabs."); }
+            if (Stun == null) { DebugConsole.ThrowError("Affliction \"Stun\" not defined in the affliction prefabs."); }
+        }
+
+        public static void LoadFromFile(ContentFile file)
+        {
+            XDocument doc = XMLExtensions.TryLoadXml(file.Path);
+            if (doc == null) { return; }
+            var mainElement = doc.Root.IsOverride() ? doc.Root.FirstElement() : doc.Root;
+            if (doc.Root.IsOverride())
+            {
+                DebugConsole.ThrowError("Cannot override all afflictions, because many of them are required by the main game! Please try overriding them one by one.");
+            }
+            foreach (XElement element in mainElement.Elements())
+            {
+                bool isOverride = element.IsOverride();
+                XElement sourceElement = isOverride ? element.FirstElement() : element;
+                string elementName = sourceElement.Name.ToString().ToLowerInvariant();
+                string identifier = sourceElement.GetAttributeString("identifier", null);
+                if (!elementName.Equals("cprsettings", StringComparison.OrdinalIgnoreCase) &&
+                    !elementName.Equals("damageoverlay", StringComparison.OrdinalIgnoreCase))
+                {
+                    if (string.IsNullOrWhiteSpace(identifier))
+                    {
+                        DebugConsole.ThrowError($"No identifier defined for the affliction '{elementName}' in file '{file.Path}'");
+                        continue;
+                    }
+                    if (Prefabs.ContainsKey(identifier))
+                    {
+                        if (isOverride)
+                        {
+                            DebugConsole.NewMessage($"Overriding an affliction or a buff with the identifier '{identifier}' using the file '{file.Path}'", Color.Yellow);
+                        }
+                        else
+                        {
+                            DebugConsole.ThrowError($"Duplicate affliction: '{identifier}' defined in {elementName} of '{file.Path}'");
+                            continue;
+                        }
+                    }
+                }
+                string type = sourceElement.GetAttributeString("type", "");
+                switch (sourceElement.Name.ToString().ToLowerInvariant())
+                {
+                    case "cprsettings":
+                        type = "cprsettings";
+                        break;
+                    case "damageoverlay":
+                        type = "damageoverlay";
+                        break;
+                }
+
+                AfflictionPrefab prefab = null;
+                switch (type)
+                {
+                    case "damageoverlay":
+#if CLIENT
+                        if (CharacterHealth.DamageOverlay != null)
+                        {
+                            if (isOverride)
+                            {
+                                DebugConsole.NewMessage($"Overriding damage overlay with '{file.Path}'", Color.Yellow);
+                            }
+                            else
+                            {
+                                DebugConsole.ThrowError($"Error in '{file.Path}': damage overlay already loaded. Add <override></override> tags as the parent of the custom damage overlay sprite to allow overriding the vanilla one.");
+                                break;
+                            }
+                        }
+                        CharacterHealth.DamageOverlay?.Remove();
+                        CharacterHealth.DamageOverlay = new Sprite(element);
+                        CharacterHealth.DamageOverlayFile = file.Path;
+#endif
+                        break;
+                    case "bleeding":
+                        prefab = new AfflictionPrefab(sourceElement, file.Path, typeof(AfflictionBleeding));
+                        break;
+                    case "huskinfection":
+                        prefab = new AfflictionPrefabHusk(sourceElement, file.Path, typeof(AfflictionHusk));
+                        break;
+                    case "cprsettings":
+                        if (CPRSettings.IsLoaded)
+                        {
+                            if (isOverride)
+                            {
+                                DebugConsole.NewMessage($"Overriding the CPR settings with '{file.Path}'", Color.Yellow);
+                            }
+                            else
+                            {
+                                DebugConsole.ThrowError($"Error in '{file.Path}': CPR settings already loaded. Add <override></override> tags as the parent of the custom CPRSettings to allow overriding the vanilla values.");
+                                break;
+                            }
+                        }
+                        CPRSettings.Load(sourceElement, file.Path);
+                        break;
+                    case "damage":
+                    case "burn":
+                    case "oxygenlow":
+                    case "bloodloss":
+                    case "stun":
+                    case "pressure":
+                    case "internaldamage":
+                        prefab = new AfflictionPrefab(sourceElement, file.Path, typeof(Affliction))
+                        {
+                            ContentPackage = file.ContentPackage
+                        };
+                        break;
+                    default:
+                        prefab = new AfflictionPrefab(sourceElement, file.Path)
+                        {
+                            ContentPackage = file.ContentPackage
+                        };
+                        break;
+                }
+                switch (identifier)
+                {
+                    case "internaldamage":
+                        InternalDamage = prefab;
+                        break;
+                    case "bleeding":
+                        Bleeding = prefab;
+                        break;
+                    case "burn":
+                        Burn = prefab;
+                        break;
+                    case "oxygenlow":
+                        OxygenLow = prefab;
+                        break;
+                    case "bloodloss":
+                        Bloodloss = prefab;
+                        break;
+                    case "pressure":
+                        Pressure = prefab;
+                        break;
+                    case "stun":
+                        Stun = prefab;
+                        break;
+                }
+                if (prefab != null)
+                {
+                    Prefabs.Add(prefab, isOverride);
+                }
+            }
+
+            using MD5 md5 = MD5.Create();
+            foreach (AfflictionPrefab prefab in Prefabs)
+            {
+                prefab.UIntIdentifier = ToolBox.StringToUInt32Hash(prefab.Identifier, md5);
+
+                //it's theoretically possible for two different values to generate the same hash, but the probability is astronomically small
+                var collision = Prefabs.Find(p => p != prefab && p.UIntIdentifier == prefab.UIntIdentifier);
+                if (collision != null)
+                {
+                    DebugConsole.ThrowError("Hashing collision when generating uint identifiers for Afflictions: " + prefab.Identifier + " has the same identifier as " + collision.Identifier + " (" + prefab.UIntIdentifier + ")");
+                    collision.UIntIdentifier++;
+                }
+            }
+        }
+
+        public static void RemoveByFile(string filePath)
+        {
+            if (CPRSettings.FilePath == filePath) { CPRSettings.Unload(); }
+#if CLIENT
+            if (CharacterHealth.DamageOverlayFile == filePath)
+            {
+                CharacterHealth.DamageOverlay?.Remove();
+                CharacterHealth.DamageOverlay = null;
+            }
+#endif
+
+            Prefabs.RemoveByFile(filePath);
+        }
+
+        public AfflictionPrefab(XElement element, string filePath, Type type = null)
+        {
+            FilePath = filePath;
+
+            typeName = type == null ? element.Name.ToString() : type.Name;
+            if (typeName == "InternalDamage" && type == null)
+            {
+                type = typeof(Affliction);
+            }
+
+            Identifier = element.GetAttributeString("identifier", "");
+
+            AfflictionType = element.GetAttributeString("type", "");
+            Name = TextManager.Get("AfflictionName." + Identifier, true) ?? element.GetAttributeString("name", "");
+            Description = TextManager.Get("AfflictionDescription." + Identifier, true) ?? element.GetAttributeString("description", "");
+            IsBuff = element.GetAttributeBool("isbuff", false);
+
+            LimbSpecific = element.GetAttributeBool("limbspecific", false);
+            if (!LimbSpecific)
+            {
+                string indicatorLimbName = element.GetAttributeString("indicatorlimb", "Torso");
+                if (!Enum.TryParse(indicatorLimbName, out IndicatorLimb))
+                {
+                    DebugConsole.ThrowError("Error in affliction prefab " + Name + " - limb type \"" + indicatorLimbName + "\" not found.");
+                }
+            }
+
+            ActivationThreshold = element.GetAttributeFloat("activationthreshold", 0.0f);
+            ShowIconThreshold   = element.GetAttributeFloat("showiconthreshold", Math.Max(ActivationThreshold, 0.05f));
+            MaxStrength         = element.GetAttributeFloat("maxstrength", 100.0f);
+
+            ShowInHealthScannerThreshold = element.GetAttributeFloat("showinhealthscannerthreshold", Math.Max(ActivationThreshold, 0.05f));
+
+            DamageOverlayAlpha  = element.GetAttributeFloat("damageoverlayalpha", 0.0f);
+            BurnOverlayAlpha    = element.GetAttributeFloat("burnoverlayalpha", 0.0f);
+
+            KarmaChangeOnApplied = element.GetAttributeFloat("karmachangeonapplied", 0.0f);
+
+            CauseOfDeathDescription     = TextManager.Get("AfflictionCauseOfDeath." + Identifier, true) ?? element.GetAttributeString("causeofdeathdescription", "");
+            SelfCauseOfDeathDescription = TextManager.Get("AfflictionCauseOfDeathSelf." + Identifier, true) ?? element.GetAttributeString("selfcauseofdeathdescription", "");
+
+            IconColors = element.GetAttributeColorArray("iconcolors", null);
+            AchievementOnRemoved = element.GetAttributeString("achievementonremoved", "");
+            
+            foreach (XElement subElement in element.Elements())
+            {
+                switch (subElement.Name.ToString().ToLowerInvariant())
+                {
+                    case "icon":
+                        Icon = new Sprite(subElement);
+                        break;
+                    case "effect":
+                        effects.Add(new Effect(subElement, Name));
+                        break;
+                }
+            }
+
+            try
+            {
+                if (type == null)
+                {
+                    type = Type.GetType("Barotrauma." + typeName, true, true);
+                    if (type == null)
+                    {
+                        DebugConsole.ThrowError("Could not find an affliction class of the type \"" + typeName + "\".");
+                        return;
+                    }
+                }
+            }
+            catch
+            {
+                DebugConsole.ThrowError("Could not find an affliction class of the type \"" + typeName + "\".");
+                type = typeof(Affliction);
+            }
+
+            constructor = type.GetConstructor(new[] { typeof(AfflictionPrefab), typeof(float) });
+        }
+
+        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));
+        }
+    }
+}

Barotrauma/BarotraumaShared/SharedSource/Characters/Health/Afflictions/AfflictionPsychosis.cs

@@ -0,0 +1,27 @@
+using Microsoft.Xna.Framework;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using Barotrauma.Extensions;
+using System.Xml.Linq;
+using System;
+
+namespace Barotrauma
+{
+    partial class AfflictionPsychosis : Affliction
+    {
+
+        public AfflictionPsychosis(AfflictionPrefab prefab, float strength) : base(prefab, strength)
+        {
+
+        }
+
+        public override void Update(CharacterHealth characterHealth, Limb targetLimb, float deltaTime)
+        {
+            base.Update(characterHealth, targetLimb, deltaTime);
+            UpdateProjSpecific(characterHealth, targetLimb, deltaTime);
+        }
+
+        partial void UpdateProjSpecific(CharacterHealth characterHealth, Limb targetLimb, float deltaTime);
+    }
+}

Barotrauma/BarotraumaShared/SharedSource/Characters/Health/Afflictions/AfflictionSpaceHerpes.cs

@@ -0,0 +1,71 @@
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Barotrauma
+{
+    class AfflictionSpaceHerpes : Affliction
+    {
+        private float invertControlsCooldown = 60.0f;
+        private float stunCoolDown = 60.0f;
+        private float invertControlsTimer;
+
+        private float invertControlsToggleTimer;
+
+        public AfflictionSpaceHerpes(AfflictionPrefab prefab, float strength) : base(prefab, strength)
+        {
+        }
+
+        public override void Update(CharacterHealth characterHealth, Limb targetLimb, float deltaTime)
+        {
+            base.Update(characterHealth, targetLimb, deltaTime);
+
+            if (GameMain.NetworkMember != null && GameMain.NetworkMember.IsClient) { return; }
+
+            invertControlsCooldown -= deltaTime;
+            if (invertControlsCooldown <= 0.0f)
+            {
+                //invert controls every 126-234 seconds when strength is close to 0
+                //every 56-104 seconds when strength is close to 100
+                invertControlsCooldown = (180.0f - Strength) * Rand.Range(0.7f, 1.3f);
+                invertControlsTimer = MathHelper.Lerp(10.0f, 60.0f, Strength / 100.0f) * Rand.Range(0.7f, 1.3f);
+            }
+            else if (invertControlsTimer > 0.0f)
+            {
+                //randomly toggle inverted controls on/off every 5 seconds
+                invertControlsToggleTimer -= deltaTime;
+                if (invertControlsToggleTimer <= 0.0f)
+                {
+                    invertControlsToggleTimer = 5.0f;
+                    if (Rand.Range(0.0f, 1.0f) < 0.5f)
+                    {
+                        characterHealth.ReduceAffliction(null, "invertcontrols", 100);
+                    }
+                    else
+                    {
+                        var invertControlsAffliction = AfflictionPrefab.List.FirstOrDefault(ap => ap.Identifier == "invertcontrols");
+                        characterHealth.ApplyAffliction(null, new Affliction(invertControlsAffliction, 5.0f));
+                    }
+                }
+
+                invertControlsTimer -= deltaTime;
+            }
+
+
+            if (Strength > 50.0f)
+            {
+                stunCoolDown -= deltaTime;
+                if (stunCoolDown <= 0.0f)
+                {
+                    //stun every 126-234 seconds when strength is close to 0
+                    //stun 56-104 seconds when strength is close to 100
+                    stunCoolDown = (180.0f - Strength) * Rand.Range(0.7f, 1.3f);
+                    float stunDuration = MathHelper.Lerp(3.0f, 10.0f, Strength / 100.0f) * Rand.Range(0.7f, 1.3f);
+                    characterHealth.Character.SetStun(stunDuration);
+                }
+            }
+        }
+    }
+}

Barotrauma/BarotraumaShared/SharedSource/Characters/Health/Buffs/BuffDurationIncrease.cs

@@ -0,0 +1,53 @@
+using Microsoft.Xna.Framework;
+
+namespace Barotrauma
+{
+    class BuffDurationIncrease : Affliction
+    {
+        public BuffDurationIncrease(AfflictionPrefab prefab, float strength) : base(prefab, strength)
+        {
+
+        }
+
+        public override void Update(CharacterHealth characterHealth, Limb targetLimb, float deltaTime)
+        {
+            base.Update(characterHealth, targetLimb, deltaTime);
+
+            var afflictions = characterHealth.GetAllAfflictions();
+
+            if (Strength <= 0)
+            {
+                foreach (Affliction affliction in afflictions)
+                {
+                    if (!affliction.Prefab.IsBuff || affliction == this || affliction.MultiplierSource != this) continue;
+                    affliction.MultiplierSource = null;
+                    affliction.StrengthDiminishMultiplier = 1f;
+                }
+            }
+            else
+            {
+                foreach (Affliction affliction in afflictions)
+                {
+                    if (!affliction.Prefab.IsBuff || affliction == this || affliction.MultiplierSource == this) continue;
+                    float multiplier = GetDiminishMultiplier();
+                    if (affliction.StrengthDiminishMultiplier < multiplier) continue;
+
+                    affliction.MultiplierSource = this;
+                    affliction.StrengthDiminishMultiplier = multiplier;
+                }
+            }
+        }
+
+        private float GetDiminishMultiplier()
+        {
+            if (Strength < Prefab.ActivationThreshold) return 1.0f;
+            AfflictionPrefab.Effect currentEffect = Prefab.GetActiveEffect(Strength);
+            if (currentEffect == null) return 1.0f;
+
+            return MathHelper.Lerp(
+                currentEffect.MinBuffMultiplier,
+                currentEffect.MaxBuffMultiplier,
+                (Strength - currentEffect.MinStrength) / (currentEffect.MaxStrength - currentEffect.MinStrength));
+        }
+    }
+}

Barotrauma/BarotraumaShared/SharedSource/Characters/Health/CharacterHealth.cs

@@ -0,0 +1,883 @@
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml.Linq;
+using Barotrauma.Networking;
+using Barotrauma.Extensions;
+
+namespace Barotrauma
+{
+    partial class CharacterHealth
+    {
+        class LimbHealth
+        {
+            public Sprite IndicatorSprite;
+            public Sprite HighlightSprite;
+
+            public Rectangle HighlightArea;
+
+            public readonly string Name;
+                        
+            public readonly List<Affliction> Afflictions = new List<Affliction>();
+
+            public readonly Dictionary<string, float> VitalityMultipliers = new Dictionary<string, float>();
+            public readonly Dictionary<string, float> VitalityTypeMultipliers = new Dictionary<string, float>();
+
+            private readonly CharacterHealth characterHealth;
+
+            public float TotalDamage
+            {
+                get { return Afflictions.Sum(a => a.GetVitalityDecrease(characterHealth)); }
+            }
+
+            public LimbHealth() { }
+
+            public LimbHealth(XElement element, CharacterHealth characterHealth)
+            {
+                Name = TextManager.Get("HealthLimbName." + element.GetAttributeString("name", ""));
+                this.characterHealth = characterHealth;
+                foreach (XElement subElement in element.Elements())
+                {
+                    switch (subElement.Name.ToString().ToLowerInvariant())
+                    {
+                        case "sprite":
+                            IndicatorSprite = new Sprite(subElement);
+                            HighlightArea = subElement.GetAttributeRect("highlightarea", new Rectangle(0, 0, (int)IndicatorSprite.size.X, (int)IndicatorSprite.size.Y));
+                            break;
+                        case "highlightsprite":
+                            HighlightSprite = new Sprite(subElement);
+                            break;
+                        case "vitalitymultiplier":
+                            if (subElement.Attribute("name") != null)
+                            {
+                                DebugConsole.ThrowError("Error in character health config (" + characterHealth.Character.Name + ") - define vitality multipliers using affliction identifiers or types instead of names.");
+                                continue;
+                            }
+
+                            string afflictionIdentifier = subElement.GetAttributeString("identifier", "");
+                            string afflictionType = subElement.GetAttributeString("type", "");
+                            float multiplier = subElement.GetAttributeFloat("multiplier", 1.0f);
+                            if (!string.IsNullOrEmpty(afflictionIdentifier))
+                            {
+                                VitalityMultipliers.Add(afflictionIdentifier.ToLowerInvariant(), multiplier);
+                            }
+                            else
+                            {
+                                VitalityTypeMultipliers.Add(afflictionType.ToLowerInvariant(), multiplier);
+                            }
+                            break;
+                    }
+                }
+            }
+            
+            public List<Affliction> GetActiveAfflictions(AfflictionPrefab prefab)
+            {
+                return Afflictions.FindAll(a => a.Prefab == prefab);
+            }
+            public List<Affliction> GetActiveAfflictions(string afflictionType)
+            {
+                return Afflictions.FindAll(a => a.Prefab.AfflictionType == afflictionType);
+            }
+        }       
+
+        public const float InsufficientOxygenThreshold = 30.0f;
+        public const float LowOxygenThreshold = 50.0f;
+        protected float minVitality;
+
+        protected float maxVitality
+        {
+            get => Character.Params.Health.Vitality;
+            set => Character.Params.Health.Vitality = value;
+        }
+
+        public bool Unkillable;
+
+        public bool DoesBleed
+        {
+            get => Character.Params.Health.DoesBleed;
+            private set => Character.Params.Health.DoesBleed = value;
+        }
+
+        public bool UseHealthWindow
+        {
+            get => Character.Params.Health.UseHealthWindow;
+            set => Character.Params.Health.UseHealthWindow = value;
+        }
+
+        public float CrushDepth
+        {
+            get => Character.Params.Health.CrushDepth;
+            private set => Character.Params.Health.CrushDepth = value;
+        }
+
+        private List<LimbHealth> limbHealths = new List<LimbHealth>();
+        //non-limb-specific afflictions
+        private List<Affliction> afflictions = new List<Affliction>();
+
+        private HashSet<Affliction> irremovableAfflictions = new HashSet<Affliction>();
+        private Affliction bloodlossAffliction;
+        private Affliction oxygenLowAffliction;
+        private Affliction pressureAffliction;
+        private Affliction stunAffliction;
+
+        public bool IsUnconscious
+        {
+            get { return Vitality <= 0.0f; }
+        }
+
+        public float PressureKillDelay { get; private set; } = 5.0f;
+
+        public float Vitality { get; private set; }
+
+        public float HealthPercentage => MathUtils.Percentage(Vitality, MaxVitality);
+
+        public float MaxVitality
+        {
+            get
+            {
+                if (Character?.Info?.Job?.Prefab != null)
+                {
+                    return maxVitality + Character.Info.Job.Prefab.VitalityModifier;
+                }
+                return maxVitality;
+            }
+        }
+
+        public float MinVitality
+        {
+            get
+            {
+                if (Character?.Info?.Job?.Prefab != null)
+                {
+                    return -MaxVitality;
+                }
+                return minVitality;
+            }
+        }
+
+        public float OxygenAmount
+        {
+            get
+            {
+                if (!Character.NeedsAir || Unkillable) return 100.0f;
+                return -oxygenLowAffliction.Strength + 100;
+            }
+            set
+            {
+                if (!Character.NeedsAir || Unkillable) return;
+                oxygenLowAffliction.Strength = MathHelper.Clamp(-value + 100, 0.0f, 200.0f);
+            }
+        }
+
+        public float BloodlossAmount
+        {
+            get { return bloodlossAffliction.Strength; }
+            set { bloodlossAffliction.Strength = MathHelper.Clamp(value, 0.0f, 100.0f); }
+        }
+
+        public float StunTimer
+        {
+            get { return stunAffliction.Strength; }
+            set { stunAffliction.Strength = MathHelper.Clamp(value, 0.0f, stunAffliction.Prefab.MaxStrength); }
+        }
+
+        public Affliction PressureAffliction
+        {
+            get { return pressureAffliction; }
+        }
+
+        public Character Character { get; private set; }
+
+        public CharacterHealth(Character character)
+        {
+            this.Character = character;
+            Vitality = 100.0f;
+
+            DoesBleed = true;
+            UseHealthWindow = false;
+
+            InitIrremovableAfflictions();
+
+            limbHealths.Add(new LimbHealth());
+
+            InitProjSpecific(null, character);
+        }
+
+        public CharacterHealth(XElement element, Character character)
+        {
+            this.Character = character;
+            InitIrremovableAfflictions();
+
+            Vitality    = maxVitality;
+
+            minVitality = character.IsHuman ? -100.0f : 0.0f;
+
+            limbHealths.Clear();
+            foreach (XElement subElement in element.Elements())
+            {
+                if (!subElement.Name.ToString().Equals("limb", StringComparison.OrdinalIgnoreCase)) { continue; }
+                limbHealths.Add(new LimbHealth(subElement, this));
+            }
+            if (limbHealths.Count == 0)
+            {
+                limbHealths.Add(new LimbHealth());
+            }
+
+            InitProjSpecific(element, character);
+        }
+
+        private void InitIrremovableAfflictions()
+        {
+            irremovableAfflictions.Add(bloodlossAffliction = new Affliction(AfflictionPrefab.Bloodloss, 0.0f));
+            irremovableAfflictions.Add(stunAffliction = new Affliction(AfflictionPrefab.Stun, 0.0f));
+            irremovableAfflictions.Add(pressureAffliction = new Affliction(AfflictionPrefab.Pressure, 0.0f));
+            irremovableAfflictions.Add(oxygenLowAffliction = new Affliction(AfflictionPrefab.OxygenLow, 0.0f));
+            foreach (Affliction affliction in irremovableAfflictions)
+            {
+                afflictions.Add(affliction);
+            }
+        }
+
+        partial void InitProjSpecific(XElement element, Character character);
+
+        public IEnumerable<Affliction> GetAllAfflictions(Func<Affliction, bool> limbHealthFilter = null)
+        {
+            return limbHealthFilter == null
+                ? afflictions.Union(limbHealths.SelectMany(lh => lh.Afflictions))
+                : afflictions.Where(limbHealthFilter).Union(limbHealths.SelectMany(lh => lh.Afflictions.Where(limbHealthFilter)));
+        }
+
+        private LimbHealth GetMatchingLimbHealth(Limb limb) => limbHealths[limb.HealthIndex];
+        private LimbHealth GetMatchingLimbHealth(Affliction affliction) => GetMatchingLimbHealth(Character.AnimController.GetLimb(affliction.Prefab.IndicatorLimb));
+
+        /// <summary>
+        /// Returns the limb afflictions and non-limbspecific afflictions that are set to be displayed on this limb.
+        /// </summary>
+        private IEnumerable<Affliction> GetMatchingAfflictions(LimbHealth limb, Func<Affliction, bool> predicate)
+            => limb.Afflictions.Where(predicate).Union(afflictions.Where(a => predicate(a) && GetMatchingLimbHealth(a) == limb));
+
+        public IEnumerable<Affliction> GetAfflictionsByType(string afflictionType, bool allowLimbAfflictions = true)
+        {
+            if (allowLimbAfflictions)
+            {
+                return GetAllAfflictions(a => a.Prefab.AfflictionType == afflictionType);
+            }
+            else
+            {
+                return afflictions.Where(a => a.Prefab.AfflictionType == afflictionType);
+            }
+        }
+
+        public Affliction GetAffliction(string identifier, bool allowLimbAfflictions = true)
+        {
+            foreach (Affliction affliction in afflictions)
+            {
+                if (affliction.Prefab.Identifier == identifier) return affliction;
+            }
+            if (!allowLimbAfflictions) return null;
+
+            foreach (LimbHealth limbHealth in limbHealths)
+            {
+                foreach (Affliction affliction in limbHealth.Afflictions)
+                {
+                    if (affliction.Prefab.Identifier == identifier) return affliction;
+                }
+            }
+
+            return null;
+        }
+
+        public T GetAffliction<T>(string identifier, bool allowLimbAfflictions = true) where T : Affliction
+        {
+            return GetAffliction(identifier, allowLimbAfflictions) as T;
+        }
+
+        public IEnumerable<Affliction> GetAfflictionsByType(string afflictionType, Limb limb)
+        {
+            if (limb.HealthIndex < 0 || limb.HealthIndex >= limbHealths.Count)
+            {
+                DebugConsole.ThrowError("Limb health index out of bounds. Character\"" + Character.Name +
+                    "\" only has health configured for" + limbHealths.Count + " limbs but the limb " + limb.type + " is targeting index " + limb.HealthIndex);
+                return null;
+            }
+            return limbHealths[limb.HealthIndex].Afflictions.Where(a => a.Prefab.AfflictionType == afflictionType);
+        }
+
+        public Affliction GetAffliction(string identifier, Limb limb)
+        {
+            if (limb.HealthIndex < 0 || limb.HealthIndex >= limbHealths.Count)
+            {
+                DebugConsole.ThrowError("Limb health index out of bounds. Character\"" + Character.Name +
+                    "\" only has health configured for" + limbHealths.Count + " limbs but the limb " + limb.type + " is targeting index " + limb.HealthIndex);
+                return null;
+            }
+            foreach (Affliction affliction in limbHealths[limb.HealthIndex].Afflictions)
+            {
+                if (affliction.Prefab.Identifier == identifier) return affliction;
+            }
+            return null;
+        }
+
+        public Limb GetAfflictionLimb(Affliction affliction)
+        {
+            for (int i = 0; i < limbHealths.Count; i++)
+            {
+                if (!limbHealths[i].Afflictions.Contains(affliction)) continue;
+                return Character.AnimController.Limbs.FirstOrDefault(l => l.HealthIndex == i);
+            }
+            return null;
+        }
+
+        /// <summary>
+        /// Get the total strength of the afflictions of a specific type attached to a specific limb
+        /// </summary>
+        /// <param name="afflictionType">Type of the affliction</param>
+        /// <param name="limb">The limb the affliction is attached to</param>
+        /// <param name="requireLimbSpecific">Does the affliction have to be attached to only the specific limb. 
+        /// Most monsters for example don't have separate healths for different limbs, essentially meaning that every affliction is applied to every limb.</param>
+        public float GetAfflictionStrength(string afflictionType, Limb limb, bool requireLimbSpecific)
+        {
+            if (requireLimbSpecific && limbHealths.Count == 1) return 0.0f;
+
+            float strength = 0.0f;
+            foreach (Affliction affliction in limbHealths[limb.HealthIndex].Afflictions)
+            {
+                if (affliction.Strength < affliction.Prefab.ActivationThreshold) continue;
+                if (affliction.Prefab.AfflictionType == afflictionType) strength += affliction.Strength;
+            }
+            return strength;
+        }
+
+        public float GetAfflictionStrength(string afflictionType, bool allowLimbAfflictions = true)
+        {
+            float strength = 0.0f;
+            foreach (Affliction affliction in afflictions)
+            {
+                if (affliction.Strength < affliction.Prefab.ActivationThreshold) continue;
+                if (affliction.Prefab.AfflictionType == afflictionType) strength += affliction.Strength;
+            }
+            if (!allowLimbAfflictions) return strength;
+
+            foreach (LimbHealth limbHealth in limbHealths)
+            {
+                foreach (Affliction affliction in limbHealth.Afflictions)
+                {
+                    if (affliction.Strength < affliction.Prefab.ActivationThreshold) continue;
+                    if (affliction.Prefab.AfflictionType == afflictionType) strength += affliction.Strength;
+                }
+            }
+
+            return strength;
+        }
+
+        public void ApplyAffliction(Limb targetLimb, Affliction affliction)
+        {
+            if (Unkillable) { return; }
+            if (affliction.Prefab.LimbSpecific)
+            {
+                if (targetLimb == null)
+                {
+                    //if a limb-specific affliction is applied to no specific limb, apply to all limbs
+                    foreach (LimbHealth limbHealth in limbHealths)
+                    {
+                        AddLimbAffliction(limbHealth, affliction);
+                    }
+                }
+                else
+                {
+                    AddLimbAffliction(targetLimb, affliction);
+                }
+            }
+            else
+            {
+                AddAffliction(affliction);
+            }
+        }
+
+        public float GetResistance(string resistanceId)
+        {
+            float resistance = 0.0f;
+            for (int i = 0; i < afflictions.Count; i++)
+            {
+                if (!afflictions[i].Prefab.IsBuff) continue;
+                float temp = afflictions[i].GetResistance(resistanceId);
+                if (temp > resistance) resistance = temp;
+            }
+
+            return resistance;
+        }
+
+        private List<Affliction> matchingAfflictions = new List<Affliction>();
+        public void ReduceAffliction(Limb targetLimb, string affliction, float amount)
+        {
+            matchingAfflictions.Clear();
+
+            if (targetLimb != null)
+            {
+                matchingAfflictions.AddRange(limbHealths[targetLimb.HealthIndex].Afflictions);
+            }
+            else
+            {
+                foreach (LimbHealth limbHealth in limbHealths)
+                {
+                    matchingAfflictions.AddRange(limbHealth.Afflictions);
+                }
+            }
+            matchingAfflictions.RemoveAll(a => 
+                !a.Prefab.Identifier.Equals(affliction, StringComparison.OrdinalIgnoreCase) && 
+                !a.Prefab.AfflictionType.Equals(affliction, StringComparison.OrdinalIgnoreCase));
+
+            if (matchingAfflictions.Count == 0) return;
+
+            float reduceAmount = amount / matchingAfflictions.Count;
+            for (int i = matchingAfflictions.Count - 1; i >= 0; i--)
+            {
+                var matchingAffliction = matchingAfflictions[i];
+                if (matchingAffliction.Strength < reduceAmount)
+                {
+                    float surplus = reduceAmount - matchingAffliction.Strength;
+                    amount -= matchingAffliction.Strength;
+                    matchingAffliction.Strength = 0.0f;
+                    matchingAfflictions.RemoveAt(i);
+                    if (i == 0) i = matchingAfflictions.Count;
+                    if (i > 0) reduceAmount += surplus / i;
+                    SteamAchievementManager.OnAfflictionRemoved(matchingAffliction, Character);
+                }
+                else
+                {
+                    matchingAffliction.Strength -= reduceAmount;
+                    amount -= reduceAmount;
+                }
+            }
+            CalculateVitality();
+        }
+
+        public void ApplyDamage(Limb hitLimb, AttackResult attackResult)
+        {
+            if (Unkillable) { return; }
+            if (hitLimb.HealthIndex < 0 || hitLimb.HealthIndex >= limbHealths.Count)
+            {
+                DebugConsole.ThrowError("Limb health index out of bounds. Character\"" + Character.Name +
+                    "\" only has health configured for" + limbHealths.Count + " limbs but the limb " + hitLimb.type + " is targeting index " + hitLimb.HealthIndex);
+                return;
+            }
+
+            foreach (Affliction newAffliction in attackResult.Afflictions)
+            {
+                if (newAffliction.Prefab.LimbSpecific)
+                {
+                    AddLimbAffliction(hitLimb, newAffliction);
+                }
+                else
+                {
+                    AddAffliction(newAffliction);
+                }
+            }            
+        }
+        
+        public void SetAllDamage(float damageAmount, float bleedingDamageAmount, float burnDamageAmount)
+        {
+            if (Unkillable) { return; }
+            foreach (LimbHealth limbHealth in limbHealths)
+            {
+                limbHealth.Afflictions.RemoveAll(a => 
+                    a.Prefab.AfflictionType == AfflictionPrefab.InternalDamage.AfflictionType ||
+                    a.Prefab.AfflictionType == AfflictionPrefab.Burn.AfflictionType ||
+                    a.Prefab.AfflictionType == AfflictionPrefab.Bleeding.AfflictionType);
+
+                if (damageAmount > 0.0f) limbHealth.Afflictions.Add(AfflictionPrefab.InternalDamage.Instantiate(damageAmount));
+                if (bleedingDamageAmount > 0.0f && DoesBleed) limbHealth.Afflictions.Add(AfflictionPrefab.Bleeding.Instantiate(bleedingDamageAmount));
+                if (burnDamageAmount > 0.0f) limbHealth.Afflictions.Add(AfflictionPrefab.Burn.Instantiate(burnDamageAmount));
+            }
+
+            CalculateVitality();
+            if (Vitality <= MinVitality) { Kill(); }
+        }
+
+        public void RemoveAllAfflictions()
+        {
+            foreach (LimbHealth limbHealth in limbHealths)
+            {
+                limbHealth.Afflictions.Clear();
+            }
+
+            afflictions.RemoveAll(a => !irremovableAfflictions.Contains(a));
+            foreach (Affliction affliction in irremovableAfflictions)
+            {
+                affliction.Strength = 0.0f;
+            }
+            CalculateVitality();
+        }
+
+        private void AddLimbAffliction(Limb limb, Affliction newAffliction)
+        {
+            if (!newAffliction.Prefab.LimbSpecific || limb == null) return;
+            if (limb.HealthIndex < 0 || limb.HealthIndex >= limbHealths.Count)
+            {
+                DebugConsole.ThrowError("Limb health index out of bounds. Character\"" + Character.Name +
+                    "\" only has health configured for" + limbHealths.Count + " limbs but the limb " + limb.type + " is targeting index " + limb.HealthIndex);
+                return;
+            }
+            AddLimbAffliction(limbHealths[limb.HealthIndex], newAffliction);
+        }
+
+        private void AddLimbAffliction(LimbHealth limbHealth, Affliction newAffliction)
+        {
+            if (!DoesBleed && newAffliction is AfflictionBleeding) return;
+            if (!Character.NeedsAir && newAffliction.Prefab == AfflictionPrefab.OxygenLow) return;
+
+            foreach (Affliction affliction in limbHealth.Afflictions)
+            {
+                if (newAffliction.Prefab == affliction.Prefab)
+                {
+                    affliction.Strength = Math.Min(affliction.Prefab.MaxStrength, affliction.Strength + (newAffliction.Strength * (100.0f / MaxVitality) * (1f - GetResistance(affliction.Prefab.Identifier))));
+                    affliction.Source = newAffliction.Source;
+                    CalculateVitality();
+                    if (Vitality <= MinVitality) Kill();
+                    return;
+                }
+            }
+
+            //create a new instance of the affliction to make sure we don't use the same instance for multiple characters
+            //or modify the affliction instance of an Attack or a StatusEffect
+            var copyAffliction = newAffliction.Prefab.Instantiate(
+                Math.Min(newAffliction.Prefab.MaxStrength, newAffliction.Strength * (100.0f / MaxVitality) * (1f - GetResistance(newAffliction.Prefab.Identifier))),
+                newAffliction.Source);
+            limbHealth.Afflictions.Add(copyAffliction);
+            
+            Character.HealthUpdateInterval = 0.0f;
+
+            CalculateVitality();
+            if (Vitality <= MinVitality) Kill();
+#if CLIENT
+            selectedLimbIndex = -1;
+#endif
+        }
+
+        private void AddAffliction(Affliction newAffliction)
+        {
+            if (!DoesBleed && newAffliction is AfflictionBleeding) return;
+            if (!Character.NeedsAir && newAffliction.Prefab == AfflictionPrefab.OxygenLow) return;
+            if (newAffliction.Prefab.AfflictionType == "huskinfection")
+            {
+                var huskPrefab = newAffliction.Prefab as AfflictionPrefabHusk;
+                if (huskPrefab.TargetSpecies.None(s => s.Equals(Character.SpeciesName, StringComparison.OrdinalIgnoreCase)))
+                {
+                    return;
+                }
+            }
+            foreach (Affliction affliction in afflictions)
+            {
+                if (newAffliction.Prefab == affliction.Prefab)
+                {
+                    float newStrength = Math.Min(affliction.Prefab.MaxStrength, affliction.Strength + (newAffliction.Strength * (100.0f / MaxVitality) * (1f - GetResistance(affliction.Prefab.Identifier))));
+                    if (affliction == stunAffliction) { Character.SetStun(newStrength, true, true); }
+                    affliction.Strength = newStrength;
+                    affliction.Source = newAffliction.Source;
+                    CalculateVitality();
+                    if (Vitality <= MinVitality) Kill();
+                    return;
+                }
+            }
+
+            //create a new instance of the affliction to make sure we don't use the same instance for multiple characters
+            //or modify the affliction instance of an Attack or a StatusEffect
+            afflictions.Add(newAffliction.Prefab.Instantiate(
+                Math.Min(newAffliction.Prefab.MaxStrength, newAffliction.Strength * (100.0f / MaxVitality) * (1f - GetResistance(newAffliction.Prefab.Identifier))),
+                source: newAffliction.Source));
+
+            Character.HealthUpdateInterval = 0.0f;
+
+            CalculateVitality();
+            if (Vitality <= MinVitality) Kill();
+        }
+
+
+        partial void UpdateProjSpecific(float deltaTime);
+
+        partial void UpdateLimbAfflictionOverlays();
+
+        public void Update(float deltaTime)
+        {
+            UpdateOxygen(deltaTime);
+
+            for (int i = 0; i < limbHealths.Count; i++)
+            {
+                for (int j = limbHealths[i].Afflictions.Count - 1; j >= 0; j--)
+                {
+                    if (limbHealths[i].Afflictions[j].Strength <= 0.0f)
+                    {
+                        SteamAchievementManager.OnAfflictionRemoved(limbHealths[i].Afflictions[j], Character);
+                        limbHealths[i].Afflictions.RemoveAt(j);
+                    }
+                }
+                for (int j = limbHealths[i].Afflictions.Count - 1; j >= 0; j--)
+                {
+                    var affliction = limbHealths[i].Afflictions[j];
+                    Limb targetLimb = Character.AnimController.Limbs.FirstOrDefault(l => l.HealthIndex == i);
+                    affliction.Update(this, targetLimb, deltaTime);
+                    affliction.DamagePerSecondTimer += deltaTime;
+                    if (affliction is AfflictionBleeding)
+                    {
+                        UpdateBleedingProjSpecific((AfflictionBleeding)affliction, targetLimb, deltaTime);
+                    }
+                    Character.StackSpeedMultiplier(affliction.GetSpeedMultiplier());
+                }
+            }
+            
+            for (int i = afflictions.Count - 1; i >= 0; i--)
+            {
+                var affliction = afflictions[i];
+                if (irremovableAfflictions.Contains(affliction)) continue;
+                if (affliction.Strength <= 0.0f)
+                {
+                    SteamAchievementManager.OnAfflictionRemoved(affliction, Character);
+                    afflictions.RemoveAt(i);
+                }
+            }
+            for (int i = 0; i < afflictions.Count; i++)
+            {
+                var affliction = afflictions[i];
+                affliction.Update(this, null, deltaTime);
+                affliction.DamagePerSecondTimer += deltaTime;
+                Character.StackSpeedMultiplier(affliction.GetSpeedMultiplier());
+            }
+            
+            UpdateLimbAfflictionOverlays();
+
+            CalculateVitality();
+            if (Vitality <= MinVitality) Kill();
+        }
+
+        private void UpdateOxygen(float deltaTime)
+        {
+            if (!Character.NeedsAir) return;
+
+            float prevOxygen = OxygenAmount;
+            if (IsUnconscious)
+            {
+                //the character dies of oxygen deprivation in 100 seconds after losing consciousness
+                OxygenAmount = MathHelper.Clamp(OxygenAmount - 1.0f * deltaTime, -100.0f, 100.0f);                
+            }
+            else
+            {
+                OxygenAmount = MathHelper.Clamp(OxygenAmount + deltaTime * (Character.OxygenAvailable < InsufficientOxygenThreshold ? -5.0f : 10.0f), -100.0f, 100.0f);
+            }
+
+            UpdateOxygenProjSpecific(prevOxygen);
+        }
+        
+        partial void UpdateOxygenProjSpecific(float prevOxygen);
+
+        partial void UpdateBleedingProjSpecific(AfflictionBleeding affliction, Limb targetLimb, float deltaTime);
+
+        public void SetVitality(float newVitality)
+        {
+            maxVitality = newVitality;
+            CalculateVitality();
+        }
+
+        public void CalculateVitality()
+        {
+            Vitality = MaxVitality;
+            if (Unkillable) { return; }
+
+            float damageResistanceMultiplier = 1f - GetResistance("damage");
+
+            foreach (LimbHealth limbHealth in limbHealths)
+            {
+                foreach (Affliction affliction in limbHealth.Afflictions)
+                {
+                    float vitalityDecrease = affliction.GetVitalityDecrease(this);
+                    string identifier = affliction.Prefab.Identifier.ToLowerInvariant();
+                    string type = affliction.Prefab.AfflictionType.ToLowerInvariant();
+                    if (limbHealth.VitalityMultipliers.ContainsKey(identifier))
+                    {
+                        vitalityDecrease *= limbHealth.VitalityMultipliers[identifier];
+                    }
+                    if (limbHealth.VitalityTypeMultipliers.ContainsKey(type))
+                    {
+                        vitalityDecrease *= limbHealth.VitalityTypeMultipliers[type];
+                    }
+                    vitalityDecrease *= damageResistanceMultiplier;
+                    Vitality -= vitalityDecrease;
+                    affliction.CalculateDamagePerSecond(vitalityDecrease);
+                }
+            }
+
+            foreach (Affliction affliction in afflictions)
+            {
+                float vitalityDecrease = affliction.GetVitalityDecrease(this);
+                vitalityDecrease *= damageResistanceMultiplier;
+                Vitality -= vitalityDecrease;
+                affliction.CalculateDamagePerSecond(vitalityDecrease);
+            }
+        }
+
+        private void Kill()
+        {
+            if (Unkillable) { return; }
+            
+            var causeOfDeath = GetCauseOfDeath();
+            Character.Kill(causeOfDeath.First, causeOfDeath.Second);
+#if CLIENT
+            DisplayVitalityDelay = 0.0f;
+            DisplayedVitality = Vitality;
+#endif
+        }
+
+        public Pair<CauseOfDeathType, Affliction> GetCauseOfDeath()
+        {
+            List<Affliction> currentAfflictions = GetAllAfflictions(true);
+
+            Affliction strongestAffliction = null;
+            float largestStrength = 0.0f;
+            foreach (Affliction affliction in currentAfflictions)
+            {
+                if (strongestAffliction == null || affliction.GetVitalityDecrease(this) > largestStrength)
+                {
+                    strongestAffliction = affliction;
+                    largestStrength = affliction.GetVitalityDecrease(this);
+                }
+            }
+
+            CauseOfDeathType causeOfDeath = strongestAffliction == null ? CauseOfDeathType.Unknown : CauseOfDeathType.Affliction;
+            if (strongestAffliction == oxygenLowAffliction)
+            {
+                causeOfDeath = Character.AnimController.InWater ? CauseOfDeathType.Drowning : CauseOfDeathType.Suffocation;
+            }
+
+            return new Pair<CauseOfDeathType, Affliction>(causeOfDeath, strongestAffliction);
+        }
+
+        private List<Affliction> GetAllAfflictions(bool mergeSameAfflictions)
+        {
+            List<Affliction> allAfflictions = new List<Affliction>(afflictions);
+            foreach (LimbHealth limbHealth in limbHealths)
+            {
+                allAfflictions.AddRange(limbHealth.Afflictions);
+            }
+
+            if (mergeSameAfflictions)
+            {
+                List<Affliction> mergedAfflictions = new List<Affliction>();
+                foreach (Affliction affliction in allAfflictions)
+                {
+                    var existingAffliction = mergedAfflictions.Find(a => a.Prefab == affliction.Prefab);
+                    if (existingAffliction == null)
+                    {
+                        var newAffliction = affliction.Prefab.Instantiate(affliction.Strength);
+                        if (affliction.Source != null) { newAffliction.Source = affliction.Source; }
+                        newAffliction.DamagePerSecond = affliction.DamagePerSecond;
+                        newAffliction.DamagePerSecondTimer = affliction.DamagePerSecondTimer;
+                        mergedAfflictions.Add(newAffliction);
+                    }
+                    else
+                    {
+                        existingAffliction.DamagePerSecond += affliction.DamagePerSecond;
+                        existingAffliction.Strength += affliction.Strength;
+                    }
+                }
+
+                return mergedAfflictions;
+            }
+
+            return allAfflictions;
+        }
+
+        /// <summary>
+        /// Get the identifiers of the items that can be used to treat the character. Takes into account all the afflictions the character has,
+        /// and negative treatment suitabilities (e.g. a medicine that causes oxygen loss may not be suitable if the character is already suffocating)
+        /// </summary>
+        /// <param name="treatmentSuitability">A dictionary where the key is the identifier of the item and the value the suitability</param>
+        /// <param name="normalize">If true, the suitability values are normalized between 0 and 1. If not, they're arbitrary values defined in the medical item XML, where negative values are unsuitable, and positive ones suitable.</param>
+        /// <param name="randomization">Amount of randomization to apply to the values (0 = the values are accurate, 1 = the values are completely random)</param>        
+        public void GetSuitableTreatments(Dictionary<string, float> treatmentSuitability, bool normalize, float randomization = 0.0f)
+        {
+            //key = item identifier
+            //float = suitability
+            treatmentSuitability.Clear();
+            float minSuitability = -10, maxSuitability = 10;
+            foreach (Affliction affliction in GetAllAfflictions())
+            {
+                foreach (KeyValuePair<string, float> treatment in affliction.Prefab.TreatmentSuitability)
+                {
+                    if (!treatmentSuitability.ContainsKey(treatment.Key))
+                    {
+                        treatmentSuitability[treatment.Key] = treatment.Value * affliction.Strength;
+                    }
+                    else
+                    {
+                        treatmentSuitability[treatment.Key] += treatment.Value * affliction.Strength;
+                    }
+                    minSuitability = Math.Min(treatmentSuitability[treatment.Key], minSuitability);
+                    maxSuitability = Math.Max(treatmentSuitability[treatment.Key], maxSuitability);
+                }
+            }
+            //normalize the suitabilities to a range of 0 to 1
+            if (normalize)
+            {
+                foreach (string treatment in treatmentSuitability.Keys.ToList())
+                {
+                    treatmentSuitability[treatment] = (treatmentSuitability[treatment] - minSuitability) / (maxSuitability - minSuitability);
+                    treatmentSuitability[treatment] = MathHelper.Lerp(treatmentSuitability[treatment], Rand.Range(0.0f, 1.0f), randomization);
+                }
+            }
+            else
+            {
+                foreach (string treatment in treatmentSuitability.Keys.ToList())
+                {
+                    treatmentSuitability[treatment] += Rand.Range(-100.0f, 100.0f) * randomization;
+                }
+            }
+        }
+
+        public void ServerWrite(IWriteMessage msg)
+        {
+            List<Affliction> activeAfflictions = afflictions.FindAll(a => a.Strength > 0.0f && a.Strength >= a.Prefab.ActivationThreshold);
+
+            msg.Write((byte)activeAfflictions.Count);
+            foreach (Affliction affliction in activeAfflictions)
+            {
+                msg.Write(affliction.Prefab.UIntIdentifier);
+                msg.WriteRangedSingle(
+                    MathHelper.Clamp(affliction.Strength, 0.0f, affliction.Prefab.MaxStrength), 
+                    0.0f, affliction.Prefab.MaxStrength, 8);
+            }
+
+            List<Pair<LimbHealth, Affliction>> limbAfflictions = new List<Pair<LimbHealth, Affliction>>();
+            foreach (LimbHealth limbHealth in limbHealths)
+            {
+                foreach (Affliction limbAffliction in limbHealth.Afflictions)
+                {
+                    if (limbAffliction.Strength <= 0.0f || limbAffliction.Strength < limbAffliction.Prefab.ActivationThreshold) continue;
+                    limbAfflictions.Add(new Pair<LimbHealth, Affliction>(limbHealth, limbAffliction));
+                }
+            }
+
+            msg.Write((byte)limbAfflictions.Count);
+            foreach (var limbAffliction in limbAfflictions)
+            {
+                msg.WriteRangedInteger(limbHealths.IndexOf(limbAffliction.First), 0, limbHealths.Count - 1);
+                msg.Write(limbAffliction.Second.Prefab.UIntIdentifier);
+                msg.WriteRangedSingle(
+                    MathHelper.Clamp(limbAffliction.Second.Strength, 0.0f, limbAffliction.Second.Prefab.MaxStrength), 
+                    0.0f, limbAffliction.Second.Prefab.MaxStrength, 8);
+            }
+        }
+
+        public void Remove()
+        {
+            RemoveProjSpecific();
+        }
+
+        partial void RemoveProjSpecific();
+
+        /// <summary>
+        /// Automatically filters out buffs.
+        /// </summary>
+        public static IEnumerable<Affliction> SortAfflictionsBySeverity(IEnumerable<Affliction> afflictions) =>
+            afflictions.Where(a => !a.Prefab.IsBuff).OrderByDescending(a => a.DamagePerSecond).ThenByDescending(a => a.Strength);
+    }
+}

Barotrauma/BarotraumaShared/SharedSource/Characters/Health/DamageModifier.cs

@@ -0,0 +1,139 @@
+using Microsoft.Xna.Framework;
+using System;
+using System.Xml.Linq;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Barotrauma
+{
+    partial class DamageModifier : ISerializableEntity
+    {
+        public string Name => "Damage Modifier";
+
+        public Dictionary<string, SerializableProperty> SerializableProperties { get; private set; }
+
+        [Serialize(1.0f, false), Editable(DecimalCount = 2)]
+        public float DamageMultiplier
+        {
+            get;
+            private set;
+        }
+
+        [Serialize("0.0,360", false), Editable]
+        public Vector2 ArmorSector
+        {
+            get;
+            private set;
+        }
+
+        public Vector2 ArmorSectorInRadians => new Vector2(MathHelper.ToRadians(ArmorSector.X), MathHelper.ToRadians(ArmorSector.Y));
+
+        [Serialize(false, false), Editable]
+        public bool DeflectProjectiles
+        {
+            get;
+            private set;
+        }
+
+        [Serialize("", true), Editable]
+        public string AfflictionIdentifiers
+        {
+            get
+            {
+                return rawAfflictionIdentifierString;
+            }
+            private set
+            {
+                rawAfflictionIdentifierString = value;
+                ParseAfflictionIdentifiers();
+            }
+        }
+
+        [Serialize("", true), Editable]
+        public string AfflictionTypes
+        {
+            get
+            {
+                return rawAfflictionTypeString;
+            }
+            private set
+            {
+                rawAfflictionTypeString = value;
+                ParseAfflictionTypes();
+            }
+        }
+
+        private string rawAfflictionIdentifierString;
+        private string rawAfflictionTypeString;
+        private string[] parsedAfflictionIdentifiers;
+        private string[] parsedAfflictionTypes;
+
+        public DamageModifier(XElement element, string parentDebugName)
+        {
+            Deserialize(element);
+            if (element.Attribute("afflictionnames") != null)
+            {
+                DebugConsole.ThrowError("Error in DamageModifier config (" + parentDebugName + ") - define afflictions using identifiers or types instead of names.");
+            }
+        }
+
+        private void ParseAfflictionTypes()
+        {
+            string[] splitValue = rawAfflictionTypeString.Split(',', '，');
+            for (int i = 0; i < splitValue.Length; i++)
+            {
+                splitValue[i] = splitValue[i].ToLowerInvariant().Trim();
+            }
+            parsedAfflictionTypes = splitValue;
+        }
+
+        private void ParseAfflictionIdentifiers()
+        {
+            string[] splitValue = rawAfflictionIdentifierString.Split(',', '，');
+            for (int i = 0; i < splitValue.Length; i++)
+            {
+                splitValue[i] = splitValue[i].ToLowerInvariant().Trim();
+            }
+            parsedAfflictionIdentifiers = splitValue;
+        }
+
+        public bool MatchesAfflictionIdentifier(string identifier)
+        {
+            //if no identifiers have been defined, the damage modifier affects all afflictions
+            if (AfflictionIdentifiers.Length == 0) { return true; }
+            return parsedAfflictionIdentifiers.Any(id => id.Equals(identifier, StringComparison.OrdinalIgnoreCase));
+        }
+
+        public bool MatchesAfflictionType(string type)
+        {
+            //if no types have been defined, the damage modifier affects all afflictions
+            if (AfflictionTypes.Length == 0) { return true; }
+            return parsedAfflictionTypes.Any(t => t.Equals(type, StringComparison.OrdinalIgnoreCase));
+        }
+
+        /// <summary>
+        /// Returns true if the type or the identifier matches the defined types/identifiers.
+        /// </summary>
+        public bool MatchesAffliction(string identifier, string type)
+        {
+            //if no identifiers or types have been defined, the damage modifier affects all afflictions
+            if (AfflictionIdentifiers.Length == 0 && AfflictionTypes.Length == 0) { return true; }
+            return parsedAfflictionIdentifiers.Any(id => id.Equals(identifier, StringComparison.OrdinalIgnoreCase))
+                || parsedAfflictionTypes.Any(t => t.Equals(type, StringComparison.OrdinalIgnoreCase));
+        }
+
+        public bool MatchesAffliction(Affliction affliction) => MatchesAffliction(affliction.Identifier, affliction.Prefab.AfflictionType);
+
+        public void Serialize(XElement element)
+        {
+            if (element == null) { return; }
+            SerializableProperty.SerializeProperties(this, element);
+        }
+
+        public void Deserialize(XElement element)
+        {
+            if (element == null) { return; }
+            SerializableProperties = SerializableProperty.DeserializeProperties(this, element);
+        }
+    }
+}