2f107db...5202af9

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

@@ -0,0 +1,187 @@
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Barotrauma
+{
+    class Affliction
+    {
+        public readonly AfflictionPrefab Prefab;
+        
+        public float Strength;
+
+        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;
+        }
+
+        public Affliction CreateMultiplied(float multiplier)
+        {
+            return Prefab.Instantiate(Strength * multiplier, Source);
+        }
+
+        public override string ToString()
+        {
+            return "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 != 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)
+            {
+                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/Source/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/Source/Characters/Health/Afflictions/AfflictionHusk.cs

@@ -1,7 +1,4 @@
-#if CLIENT
-using Microsoft.Xna.Framework;
-#endif
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Xml.Linq;
@@ -19,7 +16,7 @@ namespace Barotrauma
 
         private InfectionState state;
 
-        private Limb huskAppendage;
+        private List<Limb> huskAppendage;
         
         public InfectionState State
         {
@@ -59,30 +56,7 @@ namespace Barotrauma
             }
         }
 
-        private void UpdateMessages(float prevStrength, Character character)
-        {
-#if CLIENT
-            if (Strength < Prefab.MaxStrength * 0.5f)
-            {
-                if (prevStrength % 10.0f > 0.05f && Strength % 10.0f < 0.05f)
-                {
-                    GUI.AddMessage(TextManager.Get("HuskDormant"), Color.Red);
-                }
-            }
-            else if (Strength < Prefab.MaxStrength)
-            {
-                if (state == InfectionState.Dormant && Character.Controlled == character)
-                {
-                    GUI.AddMessage(TextManager.Get("HuskCantSpeak"), Color.Red);
-                }
-            }
-            else if (state != InfectionState.Active && Character.Controlled == character)
-            {
-                GUI.AddMessage(TextManager.Get("HuskActivate").Replace("[Attack]", GameMain.Config.KeyBind(InputType.Attack).ToString()), 
-                    Color.Red);
-            }
-#endif
-        }
+        partial void UpdateMessages(float prevStrength, Character character);
 
         private void UpdateDormantState(float deltaTime, Character character)
         {
@@ -125,45 +99,44 @@ namespace Barotrauma
         private void ActivateHusk(Character character)
         {
             character.NeedsAir = false;
-            AttachHuskAppendage(character);
+            if (huskAppendage == null)
+            {
+                huskAppendage = AttachHuskAppendage(character);
+                character.SetStun(0.5f);
+            }
         }
 
-        private void AttachHuskAppendage(Character character)
+        public static List<Limb> AttachHuskAppendage(Character character, Ragdoll ragdoll = null)
         {
-            //husk appendage already created, don't do anything
-            if (huskAppendage != null) return;
-
-            XDocument doc = XMLExtensions.TryLoadXml(Path.Combine("Content", "Characters", "Human", "Huskappendage.xml"));
-            if (doc == null || doc.Root == null) return;
-
-            var limbElement = doc.Root.Element("limb");
-            if (limbElement == null)
+            var huskDoc = XMLExtensions.TryLoadXml(Character.GetConfigFile("humanhusk"));
+            string pathToAppendage = huskDoc.Root.Element("huskappendage").GetAttributeString("path", string.Empty);
+            XDocument doc = XMLExtensions.TryLoadXml(pathToAppendage);
+            if (doc == null || doc.Root == null) { return null; }
+            if (ragdoll == null)
             {
-                DebugConsole.ThrowError("Error in huskappendage.xml - limb element not found");
-                return;
+                ragdoll = character.AnimController;
             }
-
-            var jointElement = doc.Root.Element("joint");
-            if (jointElement == null)
+            if (ragdoll.Dir < 1.0f)
             {
-                DebugConsole.ThrowError("Error in huskappendage.xml - joint element not found");
-                return;
+                ragdoll.Flip();
             }
-
-            character.SetStun(0.5f);
-            if (character.AnimController.Dir < 1.0f)
+            var huskAppendages = new List<Limb>();
+            var limbElements = doc.Root.Elements("limb").ToDictionary(e => e.GetAttributeString("id", null), e => e);
+            foreach (var jointElement in doc.Root.Elements("joint"))
             {
-                character.AnimController.Flip();
+                if (limbElements.TryGetValue(jointElement.GetAttributeString("limb2", null), out XElement limbElement))
+                {
+                    JointParams jointParams = new JointParams(jointElement, ragdoll.RagdollParams);
+                    Limb attachLimb = ragdoll.Limbs[jointParams.Limb1];
+                    Limb huskAppendage = new Limb(ragdoll, character, new LimbParams(limbElement, ragdoll.RagdollParams));
+                    huskAppendage.body.Submarine = character.Submarine;
+                    huskAppendage.body.SetTransform(attachLimb.SimPosition, attachLimb.Rotation);
+                    ragdoll.AddLimb(huskAppendage);
+                    ragdoll.AddJoint(jointParams);
+                    huskAppendages.Add(huskAppendage);
+                }
             }
-
-            var torso = character.AnimController.GetLimb(LimbType.Torso);
-            
-            huskAppendage = new Limb(character.AnimController, character, new LimbParams(limbElement, character.AnimController.RagdollParams));
-            huskAppendage.body.Submarine = character.Submarine;
-            huskAppendage.body.SetTransform(torso.SimPosition, torso.Rotation);
-
-            character.AnimController.AddLimb(huskAppendage);
-            character.AnimController.AddJoint(jointElement);
+            return huskAppendages;
         }
 
         private void DeactivateHusk(Character character)
@@ -175,8 +148,7 @@ namespace Barotrauma
         private void RemoveHuskAppendage(Character character)
         {
             if (huskAppendage == null) return;
-
-            character.AnimController.RemoveLimb(huskAppendage);
+            huskAppendage.ForEach(l => character.AnimController.RemoveLimb(l));
             huskAppendage = null;
         }
 
@@ -189,7 +161,7 @@ namespace Barotrauma
 
         private void CharacterDead(Character character, CauseOfDeath causeOfDeath)
         {
-            if (GameMain.Client != null) { return; }
+            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
@@ -210,25 +182,24 @@ namespace Barotrauma
             character.Enabled = false;
             Entity.Spawner.AddToRemoveQueue(character);
 
-            var characterFiles = GameMain.Instance.GetFilesOfType(ContentType.Character);
-            var configFile = characterFiles.FirstOrDefault(f => Path.GetFileNameWithoutExtension(f)?.ToLowerInvariant() == "humanhusk");
+            var configFile = Character.GetConfigFile("humanhusk");
 
             if (string.IsNullOrEmpty(configFile))
             {
-                DebugConsole.ThrowError("Failed to turn character \"" + character.Name + "\" into a husk - humanhusk config file not found.");
+                DebugConsole.ThrowError("Failed to turn character \"" + character.Name + "\" into a husk - husk config file not found.");
                 yield return CoroutineStatus.Success;
             }
 
-            XDocument doc = XMLExtensions.TryLoadXml(configFile);
-            if (doc?.Root == null)
-            {
-                DebugConsole.ThrowError("Failed to turn character \"" + character.Name + "\" into a husk - humanhusk config file ("+configFile+") could not be read.");
-                yield return CoroutineStatus.Success;
-            }
+            //XDocument doc = XMLExtensions.TryLoadXml(configFile);
+            //if (doc?.Root == null)
+            //{
+            //    DebugConsole.ThrowError("Failed to turn character \"" + character.Name + "\" into a husk - husk config file ("+configFile+") could not be read.");
+            //    yield return CoroutineStatus.Success;
+            //}
             
-            character.Info.Ragdoll = null;
-            character.Info.SourceElement = doc.Root;
-            var husk = Character.Create(configFile, character.WorldPosition, character.Info.Name, character.Info, false, true);
+            //character.Info.Ragdoll = null;
+            //character.Info.SourceElement = doc.Root;
+            var husk = Character.Create(configFile, character.WorldPosition, character.Info.Name, character.Info, isRemotePlayer: false, hasAi: true);
 
             foreach (Limb limb in husk.AnimController.Limbs)
             {

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

@@ -0,0 +1,355 @@
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Xml.Linq;
+
+namespace Barotrauma
+{
+    public static class CPRSettings
+    {
+        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; }
+
+        public static void Load(XElement element)
+        {
+            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);
+        }
+    }
+
+    class AfflictionPrefab
+    {
+        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("minmultiplier", 1.0f);
+                MaxBuffMultiplier = element.GetAttributeFloat("maxmultiplier", 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 AfflictionPrefab Husk;
+
+        public static List<AfflictionPrefab> List = new List<AfflictionPrefab>();
+
+        //Arbitrary string that is used to identify the type of the affliction.
+        //Afflictions with the same type stack up, and items may be configured to cure specific types of afflictions.
+        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 readonly string Identifier;
+
+        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.0f;
+        public readonly float MaxStrength = 100.0f;
+        
+        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 IconColor;
+
+        private List<Effect> effects = new List<Effect>();
+
+        private Dictionary<string, float> treatmentSuitability = new Dictionary<string, float>();
+
+        private readonly string typeName;
+
+        private readonly ConstructorInfo constructor;
+
+        public Dictionary<string, float> TreatmentSuitability
+        {
+            get { return treatmentSuitability; }
+        }
+
+        public static void LoadAll(IEnumerable<string> filePaths)
+        {
+            foreach (string filePath in filePaths)
+            {
+                XDocument doc = XMLExtensions.TryLoadXml(filePath);
+                if (doc == null || doc.Root == null) continue;
+
+                foreach (XElement element in doc.Root.Elements())
+                {
+                    switch (element.Name.ToString().ToLowerInvariant())
+                    {
+                        case "internaldamage":
+                            List.Add(InternalDamage = new AfflictionPrefab(element, typeof(Affliction)));
+                            break;
+                        case "bleeding":
+                            List.Add(Bleeding = new AfflictionPrefab(element, typeof(AfflictionBleeding)));
+                            break;
+                        case "burn":
+                            List.Add(Burn = new AfflictionPrefab(element, typeof(Affliction)));
+                            break;
+                        case "oxygenlow":
+                            List.Add(OxygenLow = new AfflictionPrefab(element, typeof(Affliction)));
+                            break;
+                        case "bloodloss":
+                            List.Add(Bloodloss = new AfflictionPrefab(element, typeof(Affliction)));
+                            break;
+                        case "pressure":
+                            List.Add(Pressure = new AfflictionPrefab(element, typeof(Affliction)));
+                            break;
+                        case "stun":
+                            List.Add(Stun = new AfflictionPrefab(element, typeof(Affliction)));
+                            break;
+                        case "husk":
+                        case "afflictionhusk":
+                            List.Add(Husk = new AfflictionPrefab(element, typeof(AfflictionHusk)));
+                            break;
+                        case "cprsettings":
+                            CPRSettings.Load(element);
+                            break;
+                        default:
+                            List.Add(new AfflictionPrefab(element));
+                            break;
+                    }
+                }
+            }
+
+            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.");
+            if (Husk == null) DebugConsole.ThrowError("Affliction \"Husk\" not defined in the affliction prefabs.");
+        }
+
+        public AfflictionPrefab(XElement element, Type type = null)
+        {
+            typeName = type == null ? element.Name.ToString() : type.Name;
+
+            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", ActivationThreshold);
+            MaxStrength         = element.GetAttributeFloat("maxstrength", 100.0f);
+
+            DamageOverlayAlpha  = element.GetAttributeFloat("damageoverlayalpha", 0.0f);
+            BurnOverlayAlpha    = element.GetAttributeFloat("burnoverlayalpha", 0.0f);
+
+            CauseOfDeathDescription     = TextManager.Get("AfflictionCauseOfDeath." + Identifier, true) ?? element.GetAttributeString("causeofdeathdescription", "");
+            SelfCauseOfDeathDescription = TextManager.Get("AfflictionCauseOfDeathSelf." + Identifier, true) ?? element.GetAttributeString("selfcauseofdeathdescription", "");
+
+            AchievementOnRemoved = element.GetAttributeString("achievementonremoved", "");
+            
+            foreach (XElement subElement in element.Elements())
+            {
+                switch (subElement.Name.ToString().ToLowerInvariant())
+                {
+                    case "icon":
+                        Icon = new Sprite(subElement);
+                        IconColor = subElement.GetAttributeColor("color", Color.White);
+                        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 + "\".");
+                return;
+            }
+
+            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 || !treatmentSuitability.ContainsKey(item.Prefab.Identifier.ToLowerInvariant()))
+            {
+                return 0.0f;
+            }
+            return treatmentSuitability[item.Prefab.Identifier.ToLowerInvariant()];
+        }
+    }
+}

Barotrauma/BarotraumaShared/Source/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/Source/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/Source/Characters/Health/CharacterHealth.cs

@@ -74,7 +74,7 @@ namespace Barotrauma
             {
                 return Afflictions.FindAll(a => a.Prefab.AfflictionType == afflictionType);
             }
-        }
+        }       
 
         const float InsufficientOxygenThreshold = 30.0f;
         const float LowOxygenThreshold = 50.0f;
@@ -339,7 +339,20 @@ namespace Barotrauma
             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;
         }
 
         public void ReduceAffliction(Limb targetLimb, string affliction, float amount)
@@ -459,7 +472,7 @@ namespace Barotrauma
             {
                 if (newAffliction.Prefab == affliction.Prefab)
                 {
-                    affliction.Strength = Math.Min(affliction.Prefab.MaxStrength, affliction.Strength + newAffliction.Strength * (100.0f / MaxVitality));
+                    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();
@@ -469,11 +482,12 @@ namespace Barotrauma
 
             //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)),
+                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();
@@ -486,11 +500,13 @@ namespace Barotrauma
         {
             if (!DoesBleed && newAffliction is AfflictionBleeding) return;
             if (!Character.NeedsAir && newAffliction.Prefab == AfflictionPrefab.OxygenLow) return;
+            // Currently only human can get the husk infection.
+            if (newAffliction.Prefab == AfflictionPrefab.Husk && Character.SpeciesName.ToLowerInvariant() != "human") { 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));
+                    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;
@@ -503,13 +519,17 @@ namespace Barotrauma
             //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)),
+                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 UpdateLimbAfflictionOverlays();
+
         public void Update(float deltaTime)
         {
             UpdateOxygen(deltaTime);
@@ -533,39 +553,29 @@ namespace Barotrauma
                     {
                         UpdateBleedingProjSpecific((AfflictionBleeding)affliction, targetLimb, deltaTime);
                     }
+                    Character.SpeedMultiplier = affliction.GetSpeedMultiplier();
                 }
             }
             
             for (int i = afflictions.Count - 1; i >= 0; i--)
             {
-                if (irremovableAfflictions.Contains(afflictions[i])) continue;
-                if (afflictions[i].Strength <= 0.0f)
+                var affliction = afflictions[i];
+                if (irremovableAfflictions.Contains(affliction)) continue;
+                if (affliction.Strength <= 0.0f)
                 {
-                    SteamAchievementManager.OnAfflictionRemoved(afflictions[i], Character);
+                    SteamAchievementManager.OnAfflictionRemoved(affliction, Character);
                     afflictions.RemoveAt(i);
                 }
             }
             for (int i = 0; i < afflictions.Count; i++)
             {
-                afflictions[i].Update(this, null, deltaTime);
-                afflictions[i].DamagePerSecondTimer += deltaTime;
+                var affliction = afflictions[i];
+                affliction.Update(this, null, deltaTime);
+                affliction.DamagePerSecondTimer += deltaTime;
+                Character.SpeedMultiplier = affliction.GetSpeedMultiplier();
             }
-
-#if CLIENT
-            foreach (Limb limb in Character.AnimController.Limbs)
-            {            
-                limb.BurnOverlayStrength = 0.0f;
-                limb.DamageOverlayStrength = 0.0f;
-                if (limbHealths[limb.HealthIndex].Afflictions.Count == 0) continue;
-                foreach (Affliction a in limbHealths[limb.HealthIndex].Afflictions)
-                {
-                    limb.BurnOverlayStrength += a.Strength / a.Prefab.MaxStrength * a.Prefab.BurnOverlayAlpha;
-                    limb.DamageOverlayStrength +=  a.Strength / a.Prefab.MaxStrength * a.Prefab.DamageOverlayAlpha;
-                }
-                limb.BurnOverlayStrength /= limbHealths[limb.HealthIndex].Afflictions.Count;
-                limb.DamageOverlayStrength /= limbHealths[limb.HealthIndex].Afflictions.Count;
-            }
-#endif
+            
+            UpdateLimbAfflictionOverlays();
 
             CalculateVitality();
             if (Vitality <= MinVitality) Kill();
@@ -598,6 +608,8 @@ namespace Barotrauma
             Vitality = MaxVitality;
             if (Unkillable) { return; }
 
+            float damageResistanceMultiplier = 1f - GetResistance("damage");
+
             foreach (LimbHealth limbHealth in limbHealths)
             {
                 foreach (Affliction affliction in limbHealth.Afflictions)
@@ -611,6 +623,7 @@ namespace Barotrauma
                     {
                         vitalityDecrease *= limbHealth.VitalityTypeMultipliers[affliction.Prefab.AfflictionType.ToLowerInvariant()];
                     }
+                    vitalityDecrease *= damageResistanceMultiplier;
                     Vitality -= vitalityDecrease;
                     affliction.CalculateDamagePerSecond(vitalityDecrease);
                 }
@@ -619,6 +632,7 @@ namespace Barotrauma
             foreach (Affliction affliction in afflictions)
             {
                 float vitalityDecrease = affliction.GetVitalityDecrease(this);
+                vitalityDecrease *= damageResistanceMultiplier;
                 Vitality -= vitalityDecrease;
                 affliction.CalculateDamagePerSecond(vitalityDecrease);
             }
@@ -627,6 +641,7 @@ namespace Barotrauma
         private void Kill()
         {
             if (Unkillable) { return; }
+            
             var causeOfDeath = GetCauseOfDeath();
             Character.Kill(causeOfDeath.First, causeOfDeath.Second);
         }
@@ -697,7 +712,9 @@ namespace Barotrauma
             foreach (Affliction affliction in activeAfflictions)
             {
                 msg.WriteRangedInteger(0, AfflictionPrefab.List.Count - 1, AfflictionPrefab.List.IndexOf(affliction.Prefab));
-                msg.Write(affliction.Strength);
+                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>>();
@@ -715,7 +732,9 @@ namespace Barotrauma
             {
                 msg.WriteRangedInteger(0, limbHealths.Count - 1, limbHealths.IndexOf(limbAffliction.First));
                 msg.WriteRangedInteger(0, AfflictionPrefab.List.Count - 1, AfflictionPrefab.List.IndexOf(limbAffliction.Second.Prefab));
-                msg.Write(limbAffliction.Second.Strength);
+                msg.WriteRangedSingle(
+                    MathHelper.Clamp(limbAffliction.Second.Strength, 0.0f, limbAffliction.Second.Prefab.MaxStrength), 
+                    0.0f, limbAffliction.Second.Prefab.MaxStrength, 8);
             }
         }
 

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

@@ -3,7 +3,7 @@ using System.Xml.Linq;
 
 namespace Barotrauma
 {
-    class DamageModifier
+    partial class DamageModifier
     {
         [Serialize(1.0f, false)]
         public float DamageMultiplier
@@ -11,7 +11,7 @@ namespace Barotrauma
             get;
             private set;
         }
-        
+
         [Serialize("0.0,360", false)]
         public Vector2 ArmorSector
         {
@@ -45,17 +45,6 @@ namespace Barotrauma
             private set;
         }
 
-
-
-#if CLIENT
-        [Serialize("", false)]
-        public string DamageSound
-        {
-            get;
-            private set;
-        }
-#endif
-
         public DamageModifier(XElement element, string parentDebugName)
         {
             SerializableProperty.DeserializeProperties(this, element);