Faction Test v1.0.1.0

2023-02-16 15:01:28 +02:00
parent caa5a2f762
commit 2c5a7923b0
309 changed files with 7502 additions and 4335 deletions
@@ -19,6 +19,10 @@ namespace Barotrauma

        private float fluctuationTimer;

+        private AfflictionPrefab.Effect activeEffect;
+        private float prevActiveEffectStrength;
+        protected bool activeEffectDirty = true;
+
        protected float _strength;

        [Serialize(0f, IsPropertySaveable.Yes), Editable]
@@ -46,6 +50,7 @@ namespace Barotrauma
                    Duration = Prefab.Duration;
                }
                _strength = newValue;
+                activeEffectDirty = true;
            }
        }

@@ -147,7 +152,16 @@ namespace Barotrauma
                MathHelper.Clamp((int)Math.Floor(strength / maxStrength * strengthTexts.Length), 0, strengthTexts.Length - 1)];
        }

-        public AfflictionPrefab.Effect GetActiveEffect() => Prefab.GetActiveEffect(Strength);
+        public AfflictionPrefab.Effect GetActiveEffect()
+        {
+            if (activeEffectDirty)
+            {
+                activeEffect = Prefab.GetActiveEffect(_strength);
+                prevActiveEffectStrength = _strength;
+                activeEffectDirty = false;
+            }
+            return activeEffect;
+        }

        public float GetVitalityDecrease(CharacterHealth characterHealth)
        {
@@ -158,7 +172,7 @@ namespace Barotrauma
        {
            if (strength < Prefab.ActivationThreshold) { return 0.0f; }
            strength = MathHelper.Clamp(strength, 0.0f, Prefab.MaxStrength);
-            AfflictionPrefab.Effect currentEffect = Prefab.GetActiveEffect(strength);
+            AfflictionPrefab.Effect currentEffect = GetActiveEffect();
            if (currentEffect == null) { return 0.0f; }
            if (currentEffect.MaxStrength - currentEffect.MinStrength <= 0.0f) { return 0.0f; }

@@ -349,7 +363,7 @@ namespace Barotrauma

        public float GetStatValue(StatTypes statType)
        {
-            if (!(GetViableEffect() is AfflictionPrefab.Effect currentEffect)) { return 0.0f; }
+            if (GetViableEffect() is not AfflictionPrefab.Effect currentEffect) { return 0.0f; }

            if (currentEffect.AfflictionStatValues.TryGetValue(statType, out var value))
            {
@@ -363,7 +377,7 @@ namespace Barotrauma

        public bool HasFlag(AbilityFlags flagType)
        {
-            if (!(GetViableEffect() is AfflictionPrefab.Effect currentEffect)) { return false; }
+            if (GetViableEffect() is not AfflictionPrefab.Effect currentEffect) { return false; }
            return currentEffect.AfflictionAbilityFlags.HasFlag(flagType);
        }

@@ -415,6 +429,7 @@ namespace Barotrauma
            }
            // Don't use the property, because it's virtual and some afflictions like husk overload it for external use.
            _strength = MathHelper.Clamp(_strength, 0.0f, Prefab.MaxStrength);
+            activeEffectDirty |= !MathUtils.NearlyEqual(prevActiveEffectStrength, _strength);

            foreach (StatusEffect statusEffect in currentEffect.StatusEffects)
            {
@@ -442,7 +457,10 @@ namespace Barotrauma
            var currentEffect = GetActiveEffect();
            if (currentEffect != null)
            {
-                currentEffect.StatusEffects.ForEach(se => ApplyStatusEffect(type, se, deltaTime, characterHealth, targetLimb));
+                foreach (var statusEffect in currentEffect.StatusEffects)
+                {
+                    ApplyStatusEffect(type, statusEffect, deltaTime, characterHealth, targetLimb);
+                }
            }
        }

@@ -481,6 +499,7 @@ namespace Barotrauma
        {
            _nonClampedStrength = strength;
            _strength = _nonClampedStrength;
+            activeEffectDirty |= !MathUtils.NearlyEqual(_strength, prevActiveEffectStrength);
        }

        public bool ShouldShowIcon(Character afflictedCharacter)
@@ -43,6 +43,7 @@ namespace Barotrauma
                    DeactivateHusk();
                    highestStrength = 0;
                }
+                activeEffectDirty = true;
            }
        }
        private float highestStrength;
@@ -319,6 +319,7 @@ namespace Barotrauma
        {
            public readonly List<StatusEffect> StatusEffects = new List<StatusEffect>();
            public readonly float MinInterval, MaxInterval;
+            public readonly float MinStrength, MaxStrength;

            public PeriodicEffect(ContentXElement element, string parentDebugName)
            {
@@ -333,23 +334,38 @@ namespace Barotrauma
                }
                else
                {
-                    MinInterval = Math.Max(element.GetAttributeFloat("mininterval", 1.0f), 1.0f);
-                    MaxInterval = Math.Max(element.GetAttributeFloat("maxinterval", 1.0f), MinInterval);
+                    MinInterval = Math.Max(element.GetAttributeFloat(nameof(MinInterval), 1.0f), 1.0f);
+                    MaxInterval = Math.Max(element.GetAttributeFloat(nameof(MaxInterval), 1.0f), MinInterval);
+                    MinStrength = Math.Max(element.GetAttributeFloat(nameof(MinStrength), 0f), 0f);
+                    MaxStrength = Math.Max(element.GetAttributeFloat(nameof(MaxStrength), MinStrength), MinStrength);
                }
            }
        }

+        public static readonly Identifier DamageType = "damage".ToIdentifier();
+        public static readonly Identifier BurnType = "burn".ToIdentifier();
+        public static readonly Identifier BleedingType = "bleeding".ToIdentifier();
+        public static readonly Identifier ParalysisType = "paralysis".ToIdentifier();
+        public static readonly Identifier PoisonType = "poison".ToIdentifier();
+        public static readonly Identifier StunType = "stun".ToIdentifier();
+        public static readonly Identifier EMPType = "emp".ToIdentifier();
+        public static readonly Identifier SpaceHerpesType = "spaceherpes".ToIdentifier();
+        public static readonly Identifier AlienInfectedType = "alieninfected".ToIdentifier();
+        public static readonly Identifier InvertControlsType = "invertcontrols".ToIdentifier();
+        public static readonly Identifier HuskInfectionType = "huskinfection".ToIdentifier();
+
        public static AfflictionPrefab InternalDamage => Prefabs["internaldamage"];
        public static AfflictionPrefab BiteWounds => Prefabs["bitewounds"];
        public static AfflictionPrefab ImpactDamage => Prefabs["blunttrauma"];
-        public static AfflictionPrefab Bleeding => Prefabs["bleeding"];
-        public static AfflictionPrefab Burn => Prefabs["burn"];
+        public static AfflictionPrefab Bleeding => Prefabs[BleedingType];
+        public static AfflictionPrefab Burn => Prefabs[BurnType];
        public static AfflictionPrefab OxygenLow => Prefabs["oxygenlow"];
        public static AfflictionPrefab Bloodloss => Prefabs["bloodloss"];
        public static AfflictionPrefab Pressure => Prefabs["pressure"];
-        public static AfflictionPrefab Stun => Prefabs["stun"];
+        public static AfflictionPrefab Stun => Prefabs[StunType];
        public static AfflictionPrefab RadiationSickness => Prefabs["radiationsickness"];

+
        public static readonly PrefabCollection<AfflictionPrefab> Prefabs = new PrefabCollection<AfflictionPrefab>();

        public override void Dispose() { }
@@ -413,8 +429,8 @@ namespace Barotrauma
        //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;
+        public readonly float BurnOverlayAlpha;
+        public readonly float DamageOverlayAlpha;

        //steam achievement given when the affliction is removed from the controlled character
        public readonly Identifier AchievementOnRemoved;
@@ -425,6 +441,20 @@ namespace Barotrauma
        public readonly Sprite AfflictionOverlay;
        public readonly bool AfflictionOverlayAlphaIsLinear;

+        public readonly bool DamageParticles;
+
+        /// <summary>
+        /// An arbitrary modifier that affects how much medical skill is increased when you apply the affliction on a target. 
+        /// If the affliction causes damage or is of type poison or paralysis, the skill is increased only when the target is hostile. 
+        /// If the affliction is of type buff, the skill is increased only when the target is friendly.
+        /// </summary>
+        public readonly float MedicalSkillGain;
+        /// <summary>
+        /// An arbitrary modifier that affects how much weapons skill is increased when you apply the affliction on a target. 
+        /// The skill is increased only when the target is hostile. 
+        /// </summary>
+        public readonly float WeaponsSkillGain;
+
        private readonly List<Effect> effects = new List<Effect>();
        private readonly List<PeriodicEffect> periodicEffects = new List<PeriodicEffect>();

@@ -519,8 +549,14 @@ namespace Barotrauma

            KarmaChangeOnApplied = element.GetAttributeFloat(nameof(KarmaChangeOnApplied), 0.0f);

-            CauseOfDeathDescription     = TextManager.Get($"AfflictionCauseOfDeath.{TranslationIdentifier}").Fallback(element.GetAttributeString("causeofdeathdescription", ""));
-            SelfCauseOfDeathDescription = TextManager.Get($"AfflictionCauseOfDeathSelf.{TranslationIdentifier}").Fallback(element.GetAttributeString("selfcauseofdeathdescription", ""));
+            CauseOfDeathDescription     = 
+                TextManager.Get($"AfflictionCauseOfDeath.{TranslationIdentifier}")
+                .Fallback(TextManager.Get(element.GetAttributeString("causeofdeathdescription", "")))
+                .Fallback(element.GetAttributeString("causeofdeathdescription", ""));
+            SelfCauseOfDeathDescription = 
+                TextManager.Get($"AfflictionCauseOfDeathSelf.{TranslationIdentifier}")
+                .Fallback(TextManager.Get(element.GetAttributeString("selfcauseofdeathdescription", "")))
+                .Fallback(element.GetAttributeString("selfcauseofdeathdescription", ""));

            IconColors = element.GetAttributeColorArray(nameof(IconColors), null);
            AfflictionOverlayAlphaIsLinear = element.GetAttributeBool(nameof(AfflictionOverlayAlphaIsLinear), false);
@@ -530,6 +566,10 @@ namespace Barotrauma

            ResetBetweenRounds = element.GetAttributeBool("resetbetweenrounds", false);

+            DamageParticles = element.GetAttributeBool(nameof(DamageParticles), true);
+            WeaponsSkillGain = element.GetAttributeFloat(nameof(WeaponsSkillGain), 0.0f);
+            MedicalSkillGain = element.GetAttributeFloat(nameof(MedicalSkillGain), 0.0f);
+
            List<Description> descriptions = new List<Description>();
            foreach (var subElement in element.Elements())
            {
@@ -604,6 +644,18 @@ namespace Barotrauma
                        break;
                }
            }
+            for (int i = 0; i < effects.Count; i++)
+            {
+                for (int j = i + 1; j < effects.Count; j++)
+                {
+                    var a = effects[i];
+                    var b = effects[j];
+                    if (a.MinStrength < b.MaxStrength && b.MinStrength < a.MaxStrength)
+                    {
+                        DebugConsole.AddWarning($"Affliction \"{Identifier}\" contains effects with overlapping strength ranges. Only one effect can be active at a time, meaning one of the effects won't work.");
+                    }
+                }
+            }
        }

        public void ClearEffects()
@@ -230,6 +230,11 @@ namespace Barotrauma

        public float StunTimer { get; private set; }

+        /// <summary>
+        /// Was the character in full health at the beginning of the frame?
+        /// </summary>
+        public bool WasInFullHealth { get; private set; }
+
        public Affliction PressureAffliction
        {
            get { return pressureAffliction; }
@@ -334,12 +339,12 @@ namespace Barotrauma
            return null;
        }

-        public T GetAffliction<T>(string identifier, bool allowLimbAfflictions = true) where T : Affliction
+        public T GetAffliction<T>(Identifier identifier, bool allowLimbAfflictions = true) where T : Affliction
        {
            return GetAffliction(identifier, allowLimbAfflictions) as T;
        }

-        public Affliction GetAffliction(string identifier, Limb limb)
+        public Affliction GetAffliction(Identifier identifier, Limb limb)
        {
            if (limb.HealthIndex < 0 || limb.HealthIndex >= limbHealths.Count)
            {
@@ -375,7 +380,7 @@ namespace Barotrauma
        /// <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)
+        public float GetAfflictionStrength(Identifier afflictionType, Limb limb, bool requireLimbSpecific)
        {
            if (requireLimbSpecific && limbHealths.Count == 1) { return 0.0f; }

@@ -396,7 +401,7 @@ namespace Barotrauma
            return strength;
        }

-        public float GetAfflictionStrength(string afflictionType, bool allowLimbAfflictions = true)
+        public float GetAfflictionStrength(Identifier afflictionType, bool allowLimbAfflictions = true)
        {
            float strength = 0.0f;
            foreach (KeyValuePair<Affliction, LimbHealth> kvp in afflictions)
@@ -478,16 +483,19 @@ namespace Barotrauma
            ReduceMatchingAfflictions(amount, treatmentAction);
        }
        
-        public void ReduceAfflictionOnAllLimbs(Identifier affliction, float amount, ActionType? treatmentAction = null)
+        public void ReduceAfflictionOnAllLimbs(Identifier afflictionIdOrType, float amount, ActionType? treatmentAction = null)
        {
-            if (affliction.IsEmpty) { throw new ArgumentException($"{nameof(affliction)} is empty"); }
-            
+            if (afflictionIdOrType.IsEmpty) { throw new ArgumentException($"{nameof(afflictionIdOrType)} is empty"); }
+
            matchingAfflictions.Clear();
-            matchingAfflictions.AddRange(afflictions.Keys);
-            matchingAfflictions.RemoveAll(a =>
-                a.Prefab.Identifier != affliction &&
-                a.Prefab.AfflictionType != affliction);
-            
+            foreach (var affliction in afflictions)
+            {
+                if (affliction.Key.Prefab.Identifier == afflictionIdOrType || affliction.Key.Prefab.AfflictionType == afflictionIdOrType)
+                {
+                    matchingAfflictions.Add(affliction.Key);
+                }
+            }
+
            ReduceMatchingAfflictions(amount, treatmentAction);
        }

@@ -504,18 +512,21 @@ namespace Barotrauma
            ReduceMatchingAfflictions(amount, treatmentAction);
        }
        
-        public void ReduceAfflictionOnLimb(Limb targetLimb, Identifier affliction, float amount, ActionType? treatmentAction = null)
+        public void ReduceAfflictionOnLimb(Limb targetLimb, Identifier afflictionIdOrType, float amount, ActionType? treatmentAction = null)
        {
-            if (affliction.IsEmpty) { throw new ArgumentException($"{nameof(affliction)} is empty"); }
+            if (afflictionIdOrType.IsEmpty) { throw new ArgumentException($"{nameof(afflictionIdOrType)} is empty"); }
            if (targetLimb is null) { throw new ArgumentNullException(nameof(targetLimb)); }
-            
+
            matchingAfflictions.Clear();
-            matchingAfflictions.AddRange(GetAfflictionsForLimb(targetLimb));
-
-            matchingAfflictions.RemoveAll(a =>
-                a.Prefab.Identifier != affliction &&
-                a.Prefab.AfflictionType != affliction);
-
+            var targetLimbHealth = limbHealths[targetLimb.HealthIndex];
+            foreach (var affliction in afflictions)
+            {
+                if ((affliction.Key.Prefab.Identifier == afflictionIdOrType || affliction.Key.Prefab.AfflictionType == afflictionIdOrType) &&
+                    affliction.Value == targetLimbHealth)
+                {
+                    matchingAfflictions.Add(affliction.Key);
+                }
+            }
            ReduceMatchingAfflictions(amount, treatmentAction);
        }

@@ -617,7 +628,7 @@ namespace Barotrauma
            KillIfOutOfVitality();
        }

-        public float GetLimbDamage(Limb limb, string afflictionType = null)
+        public float GetLimbDamage(Limb limb, Identifier afflictionType)
        {
            float damageStrength;
            if (limb.IsSevered)
@@ -630,16 +641,16 @@ namespace Barotrauma
                // Therefore with e.g. 80 health, the max damage per limb would be 40.
                // Having at least 40 damage on both legs would cause maximum limping.
                float max = MaxVitality / 2;
-                if (string.IsNullOrEmpty(afflictionType))
+                if (afflictionType.IsEmpty)
                {
-                    float damage = GetAfflictionStrength("damage", limb, true);
-                    float bleeding = GetAfflictionStrength("bleeding", limb, true);
-                    float burn = GetAfflictionStrength("burn", limb, true);
+                    float damage = GetAfflictionStrength(AfflictionPrefab.DamageType, limb, true);
+                    float bleeding = GetAfflictionStrength(AfflictionPrefab.BleedingType, limb, true);
+                    float burn = GetAfflictionStrength(AfflictionPrefab.BurnType, limb, true);
                    damageStrength = Math.Min(damage + bleeding + burn, max);
                }
                else
                {
-                    damageStrength = Math.Min(GetAfflictionStrength("damage", limb, true), max);
+                    damageStrength = Math.Min(GetAfflictionStrength(afflictionType, limb, true), max);
                }
                return damageStrength / max;
            }
@@ -696,15 +707,16 @@ namespace Barotrauma
            if (Character.Params.IsMachine && !newAffliction.Prefab.AffectMachines) { return; }
            if (!DoesBleed && newAffliction is AfflictionBleeding) { return; }
            if (!Character.NeedsOxygen && newAffliction.Prefab == AfflictionPrefab.OxygenLow) { return; }
-            if (Character.Params.Health.StunImmunity && newAffliction.Prefab.AfflictionType == "stun")
+            if (Character.Params.Health.StunImmunity && newAffliction.Prefab.AfflictionType == AfflictionPrefab.StunType)
            {
-                if (Character.EmpVulnerability <= 0 || GetAfflictionStrength("emp", allowLimbAfflictions: false) <= 0)
+                if (Character.EmpVulnerability <= 0 || GetAfflictionStrength(AfflictionPrefab.EMPType, allowLimbAfflictions: false) <= 0)
                {
                    return;
                }
            }
-            if (Character.Params.Health.PoisonImmunity && newAffliction.Prefab.AfflictionType == "poison") { return; }
-            if (Character.EmpVulnerability <= 0 && newAffliction.Prefab.AfflictionType == "emp") { return; }
+            if (Character.Params.Health.PoisonImmunity && 
+                (newAffliction.Prefab.AfflictionType == AfflictionPrefab.PoisonType || newAffliction.Prefab.AfflictionType == AfflictionPrefab.ParalysisType)) { return; }
+            if (Character.EmpVulnerability <= 0 && newAffliction.Prefab.AfflictionType == AfflictionPrefab.EMPType) { return; }
            if (newAffliction.Prefab.TargetSpecies.Any() && newAffliction.Prefab.TargetSpecies.None(s => s == Character.SpeciesName)) { return; }

            Affliction existingAffliction = null;
@@ -742,7 +754,8 @@ namespace Barotrauma
                Math.Min(newAffliction.Prefab.MaxStrength, newAffliction.Strength * (100.0f / MaxVitality) * (1f - GetResistance(newAffliction.Prefab))),
                newAffliction.Source);
            afflictions.Add(copyAffliction, limbHealth);
-            
+            MedicalClinic.OnAfflictionCountChanged(Character);
+
            Character.HealthUpdateInterval = 0.0f;

            CalculateVitality();
@@ -766,6 +779,8 @@ namespace Barotrauma

        public void Update(float deltaTime)
        {
+            WasInFullHealth = vitality >= MaxVitality;
+
            UpdateOxygen(deltaTime);

            StunTimer = Stun > 0 ? StunTimer + deltaTime : 0;
@@ -813,10 +828,16 @@ namespace Barotrauma
                    }
                    Character.StackSpeedMultiplier(affliction.GetSpeedMultiplier());
                }
+
                foreach (var affliction in afflictionsToRemove)
                {
                    afflictions.Remove(affliction);
-                }                
+                }
+
+                if (afflictionsToRemove.Count is not 0)
+                {
+                    MedicalClinic.OnAfflictionCountChanged(Character);
+                }
            }

            Character.StackSpeedMultiplier(1f + Character.GetStatValue(StatTypes.MovementSpeed));
@@ -870,6 +891,11 @@ namespace Barotrauma
            }
        }

+        /// <summary>
+        /// 0-1.
+        /// </summary>
+        public float OxygenLowResistance => !Character.NeedsOxygen ? 1 : GetResistance(oxygenLowAffliction.Prefab);
+
        private void UpdateOxygen(float deltaTime)
        {
            if (!Character.NeedsOxygen)
@@ -978,6 +1004,8 @@ namespace Barotrauma
            UpdateLimbAfflictionOverlays();
            UpdateSkinTint();
            Character.Kill(type, affliction);
+
+            WasInFullHealth = false;
 #if CLIENT
            DisplayVitalityDelay = 0.0f;
            DisplayedVitality = Vitality;