Build 0.21.6.0

2023-01-31 18:01:29 +02:00
parent 697ec52120
commit 25fa5a9552
145 changed files with 2317 additions and 1145 deletions
@@ -351,21 +351,6 @@ namespace Barotrauma
            }
        }

-        public static bool IsOnFriendlyTeam(CharacterTeamType myTeam, CharacterTeamType otherTeam)
-        {
-            if (myTeam == otherTeam) { return true; }
-            return myTeam switch
-            {
-                // NPCs are friendly to the same team and the friendly NPCs
-                CharacterTeamType.None or CharacterTeamType.Team1 or CharacterTeamType.Team2 => otherTeam == CharacterTeamType.FriendlyNPC,
-                // Friendly NPCs are friendly to both player teams
-                CharacterTeamType.FriendlyNPC => otherTeam == CharacterTeamType.Team1 || otherTeam == CharacterTeamType.Team2,
-                _ => true
-            };
-        }
-
-        public static bool IsOnFriendlyTeam(Character me, Character other) => IsOnFriendlyTeam(me.TeamID, other.TeamID);
-
        public void ReequipUnequipped()
        {
            foreach (var item in unequippedItems)
@@ -206,13 +206,19 @@ namespace Barotrauma
            private set;
        } = new HashSet<Submarine>();

-        public bool IsTargetingPlayerTeam => IsTargetInPlayerTeam(SelectedAiTarget);
        public static bool IsTargetBeingChasedBy(Character target, Character character)
            => character?.AIController is EnemyAIController enemyAI && enemyAI.SelectedAiTarget?.Entity == target && (enemyAI.State == AIState.Attack || enemyAI.State == AIState.Aggressive);
        public bool IsBeingChasedBy(Character c) => IsTargetBeingChasedBy(Character, c);
        private bool IsBeingChased => IsBeingChasedBy(SelectedAiTarget?.Entity as Character);

-        private bool IsTargetInPlayerTeam(AITarget target) => target?.Entity?.Submarine != null && target.Entity.Submarine.Info.IsPlayer || target?.Entity is Character targetCharacter && targetCharacter.IsOnPlayerTeam;
+        private static bool IsTargetInPlayerTeam(AITarget target) => target?.Entity?.Submarine != null && target.Entity.Submarine.Info.IsPlayer || target?.Entity is Character targetCharacter && targetCharacter.IsOnPlayerTeam;
+
+        private bool IsAttackingOwner(Character other) =>
+            PetBehavior != null && PetBehavior.Owner != null &&
+            !other.IsUnconscious && !other.IsArrested &&
+            other.AIController is HumanAIController humanAI &&
+            humanAI.ObjectiveManager.CurrentObjective is AIObjectiveCombat combat &&
+            combat.Enemy != null && combat.Enemy == PetBehavior.Owner;

        private bool reverse;
        public bool Reverse 
@@ -355,7 +361,7 @@ namespace Barotrauma
                { 
                    targetingTag = "owner";
                }
-                else if (targetCharacter.AIController is HumanAIController && !IsOnFriendlyTeam(Character, targetCharacter))
+                else if (PetBehavior != null && (!Character.IsOnFriendlyTeam(targetCharacter) || IsAttackingOwner(targetCharacter)))
                {
                    targetingTag = "hostile";
                }
@@ -681,19 +687,22 @@ namespace Barotrauma
                    {
                        if (SelectedAiTarget.Entity is Character targetCharacter)
                        {
-                            bool IsValid(Character.Attacker a)
+                            bool ShouldRetaliate(Character.Attacker a)
                            {
                                Character c = a.Character;
-                                if (c.IsDead || c.Removed) { return false; }
-                                if (!Character.IsFriendly(c)) { return true; }
-                                if (!c.IsPlayer) { return false; }
-                                // Only apply the threshold to players
-                                return a.Damage >= selectedTargetingParams.Threshold;
+                                if (c == null || c.IsUnconscious || c.Removed) { return false; }
+                                // Can't target characters of same species/group because that would make us hostile to all friendly characters in the same species/group.
+                                if (Character.IsSameSpeciesOrGroup(c)) { return false; }
+                                if (targetCharacter.IsSameSpeciesOrGroup(c)) { return false; }
+                                if (c.IsPlayer || Character.IsOnFriendlyTeam(c))
+                                {
+                                    return a.Damage >= selectedTargetingParams.Threshold;
+                                }
+                                return true;
                            }
-                            Character attacker = targetCharacter.LastAttackers.LastOrDefault(IsValid)?.Character;
-                            if (attacker?.AiTarget != null && !Character.IsSameSpeciesOrGroup(attacker) && !targetCharacter.IsSameSpeciesOrGroup(attacker))
+                            Character attacker = targetCharacter.LastAttackers.LastOrDefault(ShouldRetaliate)?.Character;
+                            if (attacker?.AiTarget != null)
                            {
-                                // Can't retaliate on characters of same species or group because that would make us hostile to all friendly characters in the same group.
                                ChangeTargetState(attacker, AIState.Attack, selectedTargetingParams.Priority * 2);
                                SelectTarget(attacker.AiTarget);
                                State = AIState.Attack;
@@ -1502,7 +1511,7 @@ namespace Barotrauma
                                    {
                                        hitTarget = limb.character;
                                    }
-                                    if (hitTarget != null && !hitTarget.IsDead && Character.IsFriendly(hitTarget))
+                                    if (hitTarget != null && !hitTarget.IsDead && Character.IsFriendly(hitTarget) && !IsAttackingOwner(hitTarget))
                                    {
                                        return true;
                                    }
@@ -2316,7 +2325,7 @@ namespace Barotrauma
                    {
                        t = limb.character;
                    }
-                    if (t != null && (t == target || !Character.IsFriendly(t)))
+                    if (t != null && (t == target || (!Character.IsFriendly(t) || IsAttackingOwner(t))))
                    {
                        return true;
                    }
@@ -310,7 +310,7 @@ namespace Barotrauma
                UseIndoorSteeringOutside = false;
            }
            
-            if (Character.Submarine == null || Character.IsOnPlayerTeam && !Character.IsEscorted && !IsOnFriendlyTeam(Character.TeamID, Character.Submarine.TeamID))
+            if (Character.Submarine == null || Character.IsOnPlayerTeam && !Character.IsEscorted && !Character.IsOnFriendlyTeam(Character.Submarine.TeamID))
            {
                // Spot enemies while staying outside or inside an enemy ship.
                // does not apply for escorted characters, such as prisoners or terrorists who have their own behavior
@@ -541,7 +541,7 @@ namespace Barotrauma
            if (Character.LockHands) { return; }
            if (ObjectiveManager.CurrentObjective == null) { return; }
            if (Character.CurrentHull == null) { return; }
-            bool oxygenLow = !Character.AnimController.HeadInWater && Character.OxygenAvailable < CharacterHealth.LowOxygenThreshold && Character.NeedsOxygen;
+            bool shouldActOnSuffocation = Character.IsLowInOxygen && !Character.AnimController.HeadInWater && HasDivingSuit(Character, requireOxygenTank: false) && !HasItem(Character, AIObjectiveFindDivingGear.OXYGEN_SOURCE, out _, conditionPercentage: 1);
            bool isCarrying = ObjectiveManager.HasActiveObjective<AIObjectiveContainItem>() || ObjectiveManager.HasActiveObjective<AIObjectiveDecontainItem>();

            bool NeedsDivingGearOnPath(AIObjectiveGoTo gotoObjective)
@@ -566,17 +566,17 @@ namespace Barotrauma
                        gotoObjective.Abandon = true;
                    }
                }
-                if (!oxygenLow)
+                if (!shouldActOnSuffocation)
                {
                    return;
                }
            }

            // Diving gear
-            if (oxygenLow || findItemState != FindItemState.OtherItem)
+            if (shouldActOnSuffocation || findItemState != FindItemState.OtherItem)
            {
                bool needsGear = NeedsDivingGear(Character.CurrentHull, out _);
-                if (!needsGear || oxygenLow)
+                if (!needsGear || shouldActOnSuffocation)
                {
                    bool isCurrentObjectiveFindSafety = ObjectiveManager.IsCurrentObjective<AIObjectiveFindSafety>();
                    bool shouldKeepTheGearOn =
@@ -591,14 +591,14 @@ namespace Barotrauma
                        Character.CurrentHull.IsWetRoom;
                    bool IsOrderedToWait() => Character.IsOnPlayerTeam && ObjectiveManager.CurrentOrder is AIObjectiveGoTo goTo && goTo.Target == Character;
                    bool removeDivingSuit = !shouldKeepTheGearOn && !IsOrderedToWait();
-                    if (oxygenLow && Character.CurrentHull.Oxygen > 0 && (!isCurrentObjectiveFindSafety || Character.OxygenAvailable < 1))
+                    if (shouldActOnSuffocation && Character.CurrentHull.Oxygen > 0 && (!isCurrentObjectiveFindSafety || Character.OxygenAvailable < 1))
                    {
                        shouldKeepTheGearOn = false;
                        // Remove the suit before we pass out
                        removeDivingSuit = true;
                    }
                    bool takeMaskOff = !shouldKeepTheGearOn;
-                    if (!shouldKeepTheGearOn && !oxygenLow)
+                    if (!shouldKeepTheGearOn && !shouldActOnSuffocation)
                    {
                        if (ObjectiveManager.IsCurrentObjective<AIObjectiveIdle>())
                        {
@@ -647,7 +647,7 @@ namespace Barotrauma
                        var divingSuit = Character.Inventory.FindItemByTag(AIObjectiveFindDivingGear.HEAVY_DIVING_GEAR);
                        if (divingSuit != null && !divingSuit.HasTag(AIObjectiveFindDivingGear.DIVING_GEAR_WEARABLE_INDOORS))
                        {
-                            if (oxygenLow || Character.Submarine?.TeamID != Character.TeamID || ObjectiveManager.GetCurrentPriority() >= AIObjectiveManager.RunPriority)
+                            if (shouldActOnSuffocation || Character.Submarine?.TeamID != Character.TeamID || ObjectiveManager.GetCurrentPriority() >= AIObjectiveManager.RunPriority)
                            {
                                divingSuit.Drop(Character);
                                HandleRelocation(divingSuit);
@@ -982,7 +982,7 @@ namespace Barotrauma
                                if (target.CurrentHull != hull) { continue; }
                                if (AIObjectiveRescueAll.IsValidTarget(target, Character))
                                {
-                                    if (AddTargets<AIObjectiveRescueAll, Character>(Character, target) && newOrder == null && !ObjectiveManager.HasActiveObjective<AIObjectiveRescue>())
+                                    if (AddTargets<AIObjectiveRescueAll, Character>(Character, target) && newOrder == null && (!Character.IsMedic || Character == target) && !ObjectiveManager.HasActiveObjective<AIObjectiveRescue>())
                                    {
                                        var orderPrefab = OrderPrefab.Prefabs["requestfirstaid"];
                                        newOrder = new Order(orderPrefab, hull, null, orderGiver: Character);
@@ -1161,7 +1161,7 @@ namespace Barotrauma
                    freezeAI = true;
                }
            }
-            if (attacker == null || attacker.IsDead || attacker.Removed)
+            if (attacker == null || attacker.IsUnconscious || attacker.Removed)
            {
                // Don't react to the damage if there's no attacker.
                // We might consider launching the retreat combat objective in some cases, so that the bot does not just stand somewhere getting damaged and dying.
@@ -1199,7 +1199,7 @@ namespace Barotrauma
                    return;
                }
                float cumulativeDamage = realDamage + Character.GetDamageDoneByAttacker(attacker);
-                bool isAccidental = attacker.IsBot && !IsMentallyUnstable && !attacker.AIController.IsMentallyUnstable && Character.CombatAction == null;
+                bool isAccidental = attacker.IsBot && !IsMentallyUnstable && !attacker.AIController.IsMentallyUnstable && attacker.CombatAction == null;
                if (isAccidental)
                {
                    if (!Character.IsSecurity && cumulativeDamage > minorDamageThreshold)
@@ -1279,7 +1279,7 @@ namespace Barotrauma
                    if (otherCharacter.Submarine != attacker.Submarine) { continue; }
                    if (otherCharacter.Info?.Job == null || otherCharacter.IsInstigator) { continue; }
                    if (otherCharacter.IsPlayer) { continue; }
-                    if (!(otherCharacter.AIController is HumanAIController otherHumanAI)) { continue; }
+                    if (otherCharacter.AIController is not HumanAIController otherHumanAI) { continue; }
                    if (!otherHumanAI.IsFriendly(Character)) { continue; }
                    bool isWitnessing = otherHumanAI.VisibleHulls.Contains(Character.CurrentHull) || otherHumanAI.VisibleHulls.Contains(attacker.CurrentHull);
                    if (!isWitnessing) 
@@ -1299,7 +1299,7 @@ namespace Barotrauma

            AIObjectiveCombat.CombatMode DetermineCombatMode(Character c, float cumulativeDamage = 0, bool isWitnessing = false)
            {
-                if (!(c.AIController is HumanAIController humanAI)) { return AIObjectiveCombat.CombatMode.None; }
+                if (c.AIController is not HumanAIController humanAI) { return AIObjectiveCombat.CombatMode.None; }
                if (!IsFriendly(attacker))
                {
                    if (c.Submarine == null)
@@ -1327,7 +1327,7 @@ namespace Barotrauma
                    }
                    if (attacker.IsPlayer && c.TeamID == attacker.TeamID)
                    {
-                        if (GameMain.IsSingleplayer || Character.TeamID != attacker.TeamID)
+                        if (GameMain.IsSingleplayer || c.TeamID != attacker.TeamID)
                        {
                            // Bots in the player team never act aggressively in single player when attacked by the player
                            // In multiplayer, they react only to players attacking them or other crew members
@@ -1345,11 +1345,11 @@ namespace Barotrauma
                        isAttackerFightingEnemy = true;
                        return AIObjectiveCombat.CombatMode.None;
                    }
-                    if (isWitnessing && Character.CombatAction != null && !c.IsSecurity)
+                    if (isWitnessing && c.CombatAction != null && !c.IsSecurity)
                    {
-                        return Character.CombatAction.WitnessReaction;
+                        return c.CombatAction.WitnessReaction;
                    }
-                    if (attacker.IsPlayer && FindInstigator() is Character instigator)
+                    if (!attacker.IsInstigator && c.IsOnFriendlyTeam(attacker) && FindInstigator() is Character instigator)
                    {
                        // The guards don't react to player's aggressions when there's an instigator around
                        isAttackerFightingEnemy = true;
@@ -1359,11 +1359,11 @@ namespace Barotrauma
                    {
                        if (c.IsSecurity)
                        {
-                            return Character.CombatAction != null ? Character.CombatAction.GuardReaction : AIObjectiveCombat.CombatMode.None;
+                            return attacker.CombatAction != null ? attacker.CombatAction.GuardReaction : AIObjectiveCombat.CombatMode.Offensive;
                        }
                        else
                        {
-                            return Character.CombatAction != null ? Character.CombatAction.WitnessReaction : AIObjectiveCombat.CombatMode.None;
+                            return attacker.CombatAction != null ? attacker.CombatAction.WitnessReaction : AIObjectiveCombat.CombatMode.Retreat;
                        }
                    }
                    else
@@ -1567,20 +1567,20 @@ namespace Barotrauma
            return false;
        }

-        public static bool HasDivingGear(Character character, float conditionPercentage = 0) => HasDivingSuit(character, conditionPercentage) || HasDivingMask(character, conditionPercentage);
+        public static bool HasDivingGear(Character character, float conditionPercentage = 0, bool requireOxygenTank = true) => HasDivingSuit(character, conditionPercentage, requireOxygenTank) || HasDivingMask(character, conditionPercentage, requireOxygenTank);

        /// <summary>
        /// Check whether the character has a diving suit in usable condition plus some oxygen.
        /// </summary>
-        public static bool HasDivingSuit(Character character, float conditionPercentage = 0) 
-            => HasItem(character, AIObjectiveFindDivingGear.HEAVY_DIVING_GEAR, out _, AIObjectiveFindDivingGear.OXYGEN_SOURCE, conditionPercentage, requireEquipped: true,
+        public static bool HasDivingSuit(Character character, float conditionPercentage = 0, bool requireOxygenTank = true) 
+            => HasItem(character, AIObjectiveFindDivingGear.HEAVY_DIVING_GEAR, out _, requireOxygenTank ? AIObjectiveFindDivingGear.OXYGEN_SOURCE : Identifier.Empty, conditionPercentage, requireEquipped: true,
                predicate: (Item item) => character.HasEquippedItem(item, InvSlotType.OuterClothes));

        /// <summary>
        /// Check whether the character has a diving mask in usable condition plus some oxygen.
        /// </summary>
-        public static bool HasDivingMask(Character character, float conditionPercentage = 0) 
-            => HasItem(character, AIObjectiveFindDivingGear.LIGHT_DIVING_GEAR, out _, AIObjectiveFindDivingGear.OXYGEN_SOURCE, conditionPercentage, requireEquipped: true);
+        public static bool HasDivingMask(Character character, float conditionPercentage = 0, bool requireOxygenTank = true) 
+            => HasItem(character, AIObjectiveFindDivingGear.LIGHT_DIVING_GEAR, out _, requireOxygenTank ? AIObjectiveFindDivingGear.OXYGEN_SOURCE : Identifier.Empty, conditionPercentage, requireEquipped: true);

        private static List<Item> matchingItems = new List<Item>();

@@ -2045,7 +2045,7 @@ namespace Barotrauma
        public static bool IsFriendly(Character me, Character other, bool onlySameTeam = false)
        {
            bool sameTeam = me.TeamID == other.TeamID;
-            bool teamGood = sameTeam || !onlySameTeam && IsOnFriendlyTeam(me, other);
+            bool teamGood = sameTeam || !onlySameTeam && me.IsOnFriendlyTeam(other);
            if (!teamGood) { return false; }
            if (!me.IsSameSpeciesOrGroup(other)) { return false; }
            if (me.TeamID == CharacterTeamType.FriendlyNPC && other.TeamID == CharacterTeamType.Team1 && GameMain.GameSession?.GameMode is CampaignMode campaign)
@@ -352,7 +352,7 @@ namespace Barotrauma
                        Weapon = null;
                        continue;
                    }
-                    if (WeaponComponent.IsLoaded(character))
+                    if (WeaponComponent.IsNotEmpty(character))
                    {
                        // All good, the weapon is loaded
                        break;
@@ -470,7 +470,7 @@ namespace Barotrauma
                    // Not in the inventory anymore or cannot find the weapon component
                    return false;
                }
-                if (!WeaponComponent.IsLoaded(character))
+                if (!WeaponComponent.IsNotEmpty(character))
                {
                    // Try reloading (and seek ammo)
                    if (!Reload(seekAmmo))
@@ -541,7 +541,7 @@ namespace Barotrauma
                        priority /= 2;
                    }
                }
-                if (!weapon.IsLoaded(character))
+                if (!weapon.IsNotEmpty(character))
                {
                    if (weapon is RangedWeapon && !isAllowedToSeekWeapons)
                    {
@@ -554,7 +554,15 @@ namespace Barotrauma
                        priority /= 2;
                    }
                }
-                if (Enemy.IsKnockedDown)
+
+                if (Enemy.Params.Health.StunImmunity)
+                {
+                    if (weapon.Item.HasTag("stunner"))
+                    {
+                        priority /= 2;
+                    }
+                }
+                else if (Enemy.IsKnockedDown)
                {
                    // Enemy is stunned, reduce the priority of stunner weapons.
                    Attack attack = GetAttackDefinition(weapon);
@@ -244,7 +244,8 @@ namespace Barotrauma

        public bool IsInTargetSlot(Item item)
        {
-            if (container?.Inventory is ItemInventory inventory && TargetSlot is not null)
+            if (TargetSlot == null) { return true; }
+            if (container?.Inventory is ItemInventory inventory)
            {
                return inventory.IsInSlot(item, (int)TargetSlot);
            }
@@ -63,15 +63,16 @@ namespace Barotrauma
            }
            else
            {
-                if (HumanAIController.NeedsDivingGear(character.CurrentHull, out bool needsSuit) && 
+                if ((character.IsLowInOxygen && !character.AnimController.HeadInWater && HumanAIController.HasDivingSuit(character, requireOxygenTank: false)) ||
+                    (HumanAIController.NeedsDivingGear(character.CurrentHull, out bool needsSuit) && 
                    (needsSuit ? 
                    !HumanAIController.HasDivingSuit(character, conditionPercentage: AIObjectiveFindDivingGear.GetMinOxygen(character)) : 
-                    !HumanAIController.HasDivingGear(character, conditionPercentage: AIObjectiveFindDivingGear.GetMinOxygen(character))))
+                    !HumanAIController.HasDivingGear(character, conditionPercentage: AIObjectiveFindDivingGear.GetMinOxygen(character)))))
                {
                    Priority = 100;
                }
                else if ((objectiveManager.IsCurrentOrder<AIObjectiveGoTo>() || objectiveManager.IsCurrentOrder<AIObjectiveReturn>()) &&
-                         character.Submarine != null && !AIController.IsOnFriendlyTeam(character.TeamID, character.Submarine.TeamID))
+                         character.Submarine != null && !character.IsOnFriendlyTeam(character.Submarine.TeamID))
                {
                    // Ordered to follow, hold position, or return back to main sub inside a hostile sub
                    // -> ignore find safety unless we need to find a diving gear
@@ -137,12 +138,14 @@ namespace Barotrauma
        private float retryTimer;
        protected override void Act(float deltaTime)
        {
+            if (resetPriority) { return; }
            var currentHull = character.CurrentHull;
+            bool shouldActOnSuffocation = character.IsLowInOxygen && !character.AnimController.HeadInWater && HumanAIController.HasDivingSuit(character, requireOxygenTank: false);
            bool dangerousPressure = currentHull == null || currentHull.LethalPressure > 0 && character.PressureProtection <= 0;
-            if (!character.LockHands && (!dangerousPressure || cannotFindSafeHull))
+            if (!character.LockHands && (!dangerousPressure || shouldActOnSuffocation || cannotFindSafeHull))
            {
                bool needsDivingGear = HumanAIController.NeedsDivingGear(currentHull, out bool needsDivingSuit);
-                bool needsEquipment = false;
+                bool needsEquipment = shouldActOnSuffocation;
                if (needsDivingSuit)
                {
                    needsEquipment = !HumanAIController.HasDivingSuit(character, AIObjectiveFindDivingGear.GetMinOxygen(character));
@@ -178,7 +178,7 @@ namespace Barotrauma
                    requiredCondition = () => 
                        Leak.Submarine == character.Submarine &&
                        Leak.linkedTo.Any(e => e is Hull h && (character.CurrentHull == h || h.linkedTo.Contains(character.CurrentHull))),
-                    endNodeFilter = n => n.Waypoint.CurrentHull != null && Leak.linkedTo.Any(e => e is Hull h && h == n.Waypoint.CurrentHull),
+                    endNodeFilter = IsSuitableEndNode,
                    // The Go To objective can be abandoned if the leak is fixed (in which case we don't want to use the dialogue)
                    SpeakCannotReachCondition = () => !CheckObjectiveSpecific()
                },
@@ -197,6 +197,14 @@ namespace Barotrauma
                    }
                },
                onCompleted: () => RemoveSubObjective(ref gotoObjective));
+
+                bool IsSuitableEndNode(PathNode n)
+                {
+                    if (n.Waypoint.CurrentHull is null) { return false; }
+                    if (n.Waypoint.CurrentHull.ConnectedGaps.Contains(Leak)) { return true; }
+                    // Accept also nodes located in the linked hulls (multi-hull rooms)
+                    return Leak.linkedTo.Any(e => e is Hull h && h.linkedTo.Contains(n.Waypoint.CurrentHull));
+                }
            }
        }

@@ -54,7 +54,7 @@ namespace Barotrauma
        public bool AllowVariants { get; set; }
        public bool Equip { get; set; }
        public bool Wear { get; set; }
-        public bool RequireLoaded { get; set; }
+        public bool RequireNonEmpty { get; set; }
        public bool EvaluateCombatPriority { get; set; }
        public bool CheckPathForEachItem { get; set; }
        public bool SpeakIfFails { get; set; }
@@ -391,10 +391,10 @@ namespace Barotrauma
                {
                    if (!itemInventory.Container.HasRequiredItems(character, addMessage: false)) { continue; }
                }
-                float itemPriority = 1;
+                float itemPriority = item.Prefab.BotPriority;
                if (GetItemPriority != null)
                {
-                    itemPriority = GetItemPriority(item);
+                    itemPriority *= GetItemPriority(item);
                }
                Entity rootInventoryOwner = item.GetRootInventoryOwner();
                if (rootInventoryOwner is Item ownerItem)
@@ -513,7 +513,7 @@ namespace Barotrauma
            float lowestCost = float.MaxValue;
            foreach (MapEntityPrefab prefab in MapEntityPrefab.List)
            {
-                if (!(prefab is ItemPrefab itemPrefab)) { continue; }
+                if (prefab is not ItemPrefab itemPrefab) { continue; }
                if (IdentifiersOrTags.Any(id => id == prefab.Identifier || prefab.Tags.Contains(id)))
                {
                    float cost = itemPrefab.DefaultPrice != null && itemPrefab.CanBeBought ?
@@ -561,7 +561,7 @@ namespace Barotrauma
            if (ignoredIdentifiersOrTags != null && CheckItemIdentifiersOrTags(item, ignoredIdentifiersOrTags)) { return false; }
            if (item.Condition < TargetCondition) { return false; }
            if (ItemFilter != null && !ItemFilter(item)) { return false; }
-            if (RequireLoaded && item.Components.Any(i => !i.IsLoaded(character))) { return false; }
+            if (RequireNonEmpty && item.Components.Any(i => !i.IsNotEmpty(character))) { return false; }
            return CheckItemIdentifiersOrTags(item, IdentifiersOrTags) || (AllowVariants && !item.Prefab.VariantOf.IsEmpty && IdentifiersOrTags.Contains(item.Prefab.VariantOf));
        }

@@ -21,7 +21,7 @@ namespace Barotrauma
        public bool CheckInventory { get; set; }
        public bool EvaluateCombatPriority { get; set; }
        public bool CheckPathForEachItem { get; set; }
-        public bool RequireLoaded { get; set; }
+        public bool RequireNonEmpty { get; set; }
        public bool RequireAllItems { get; set; }

        private readonly ImmutableArray<Identifier> gearTags;
@@ -61,7 +61,7 @@ namespace Barotrauma
                            AllowStealing = AllowStealing,
                            ignoredIdentifiersOrTags = ignoredTags,
                            CheckPathForEachItem = CheckPathForEachItem,
-                            RequireLoaded = RequireLoaded,
+                            RequireNonEmpty = RequireNonEmpty,
                            ItemCount = count,
                            SpeakIfFails = RequireAllItems
                        },
@@ -364,8 +364,7 @@ namespace Barotrauma
                    CurrentOrders.RemoveAt(i);
                    continue;
                }
-                var currentOrderInfo = character.GetCurrentOrder(currentOrder);
-                if (currentOrderInfo is Order)
+                if (character.GetCurrentOrder(currentOrder) is Order currentOrderInfo)
                {
                    int currentPriority = currentOrderInfo.ManualPriority;
                    if (currentOrder.ManualPriority != currentPriority)
@@ -539,7 +538,8 @@ namespace Barotrauma
                        KeepActiveWhenReady = true,
                        CheckInventory = true,
                        Equip = false,
-                        FindAllItems = true
+                        FindAllItems = true,
+                        RequireNonEmpty = false
                    };
                    break;
                case "findweapon":
@@ -555,7 +555,8 @@ namespace Barotrauma
                            KeepActiveWhenReady = false,
                            CheckInventory = false,
                            EvaluateCombatPriority = true,
-                            FindAllItems = false
+                            FindAllItems = false,
+                            RequireNonEmpty = true
                        };
                    }
                    prepareObjective.KeepActiveWhenReady = false;
@@ -600,9 +601,9 @@ namespace Barotrauma

            Order dismissOrder = currentOrder.GetDismissal();
 #if CLIENT
-            if (GameMain.GameSession?.CrewManager != null && GameMain.GameSession.CrewManager.IsSinglePlayer)
+            if (GameMain.GameSession?.CrewManager is CrewManager cm && cm.IsSinglePlayer)
            {
-                GameMain.GameSession.CrewManager.SetCharacterOrder(character, dismissOrder);
+                character.SetOrder(dismissOrder, isNewOrder: true, speak: false);
            }
 #else
            GameMain.Server?.SendOrderChatMessage(new OrderChatMessage(dismissOrder, character, character));
@@ -27,6 +27,7 @@ namespace Barotrauma
        public bool FindAllItems { get; set; }
        public bool Equip { get; set; }
        public bool EvaluateCombatPriority { get; set; }
+        public bool RequireNonEmpty { get; set; }

        private AIObjective GetSubObjective()
        {
@@ -74,7 +75,7 @@ namespace Barotrauma
                    Abandon = true;

                }
-                else if (items.Any(i => i.Components.Any(i => !i.IsLoaded(character))))
+                else if (items.Any(i => i.Components.Any(i => !i.IsNotEmpty(character))))
                {
                    Reset();
                }
@@ -106,7 +107,7 @@ namespace Barotrauma
                            CheckInventory = CheckInventory,
                            Equip = Equip,
                            EvaluateCombatPriority = EvaluateCombatPriority,
-                            RequireLoaded = true,
+                            RequireNonEmpty = RequireNonEmpty,
                            RequireAllItems = requireAll
                        },
                        onCompleted: () =>
@@ -157,7 +158,7 @@ namespace Barotrauma
                        {
                            EvaluateCombatPriority = EvaluateCombatPriority,
                            SpeakIfFails = true,
-                            RequireLoaded = true
+                            RequireNonEmpty = RequireNonEmpty
                        };
                    }
                    if (!TryAddSubObjective(ref getSingleItemObjective, getItemConstructor,
@@ -320,10 +320,10 @@ namespace Barotrauma
                    foreach (KeyValuePair<Identifier, float> treatmentSuitability in currentTreatmentSuitabilities)
                    {
                        if (treatmentSuitability.Value <= cprSuitability) { continue; }
-                        if (MapEntityPrefab.Find(null, treatmentSuitability.Key, showErrorMessages: false) is ItemPrefab itemPrefab)
+                        if (ItemPrefab.Prefabs.TryGet(treatmentSuitability.Key, out ItemPrefab itemPrefab))
                        {
-                            if (!Item.ItemList.Any(it => ((MapEntity)it).Prefab.Identifier == treatmentSuitability.Key)) { continue; }
-                            suitableItemIdentifiers.Add(treatmentSuitability.Key);
+                            if (Item.ItemList.None(it => it.Prefab.Identifier == treatmentSuitability.Key)) { continue; }
+                            suitableItemIdentifiers.Add(itemPrefab.Identifier);
                            //only list the first 4 items
                            if (itemNameList.Count < 4)
                            {
@@ -482,18 +482,6 @@ namespace Barotrauma

        public static IEnumerable<Affliction> GetSortedAfflictions(Character character, bool excludeBuffs = true) => CharacterHealth.SortAfflictionsBySeverity(character.CharacterHealth.GetAllAfflictions(), excludeBuffs);

-        public static IEnumerable<Affliction> GetTreatableAfflictions(Character character)
-        {
-            var allAfflictions = character.CharacterHealth.GetAllAfflictions();
-            foreach (Affliction affliction in allAfflictions)
-            {
-                if (affliction.Prefab.IsBuff || affliction.Strength < affliction.Prefab.TreatmentThreshold) { continue; }
-                if (!affliction.Prefab.TreatmentSuitability.Any(kvp => kvp.Value > 0)) { continue; }
-                if (allAfflictions.Any(otherAffliction => affliction.Prefab.IgnoreTreatmentIfAfflictedBy.Contains(otherAffliction.Identifier))) { continue; }
-                yield return affliction;
-            }
-        }
-
        public override void Reset()
        {
            base.Reset();
@@ -26,7 +26,7 @@ namespace Barotrauma
                // When targeting player characters, always treat them when ordered, else use the threshold so that minor/non-severe damage is ignored.
                // If we ignore any damage when the player orders a bot to do healings, it's observed to cause confusion among the players.
                // On the other hand, if the bots too eagerly heal characters when it's not necessary, it's inefficient and can feel frustrating, because it can't be controlled.
-                return character == target || manager.HasOrder<AIObjectiveRescueAll>() ? (target.IsPlayer ? 100 : vitalityThresholdForOrders) : vitalityThreshold;
+                return character == target || manager.HasOrder<AIObjectiveRescueAll>() ? (target.IsPlayer && target.HealthPercentage < 100 ? 100 : vitalityThresholdForOrders) : vitalityThreshold;
            }
        }
        
@@ -67,15 +67,34 @@ namespace Barotrauma
            float vitality = 100;
            vitality -= character.Bleeding * 2;
            vitality += Math.Min(character.Oxygen, 0);
-            vitality -= character.CharacterHealth.GetAfflictionStrength("paralysis");
-            foreach (Affliction affliction in AIObjectiveRescue.GetTreatableAfflictions(character))
+            foreach (Affliction affliction in GetTreatableAfflictions(character))
            {
                float strength = character.CharacterHealth.GetPredictedStrength(affliction, predictFutureDuration: 10.0f);
                vitality -= affliction.GetVitalityDecrease(character.CharacterHealth, strength) / character.MaxVitality * 100;
+                if (affliction.Prefab.AfflictionType == "paralysis")
+                {
+                    vitality -= affliction.Strength;
+                }
+                else if (affliction.Prefab.AfflictionType == "poison")
+                {
+                    vitality -= affliction.Strength;
+                }
            }
            return Math.Clamp(vitality, 0, 100);
        }

+        public static IEnumerable<Affliction> GetTreatableAfflictions(Character character)
+        {
+            var allAfflictions = character.CharacterHealth.GetAllAfflictions();
+            foreach (Affliction affliction in allAfflictions)
+            {
+                if (affliction.Prefab.IsBuff || affliction.Strength < affliction.Prefab.TreatmentThreshold) { continue; }
+                if (affliction.Prefab.TreatmentSuitability.None(kvp => kvp.Value > 0)) { continue; }
+                if (allAfflictions.Any(otherAffliction => affliction.Prefab.IgnoreTreatmentIfAfflictedBy.Contains(otherAffliction.Identifier))) { continue; }
+                yield return affliction;
+            }
+        }
+
        protected override AIObjective ObjectiveConstructor(Character target)
            => new AIObjectiveRescue(character, target, objectiveManager, PriorityModifier);

@@ -454,7 +454,7 @@ namespace Barotrauma
            aiming = false;
            wasAimingMelee = aimingMelee;
            aimingMelee = false;
-            IsHanging = false;
+            IsHanging = IsHanging && character.IsRagdolled;
        }

        void UpdateStanding()
@@ -489,7 +489,7 @@ namespace Barotrauma
                LocalizedString displayName = Params.DisplayName;
                if (displayName.IsNullOrWhiteSpace())
                {
-                    if (string.IsNullOrWhiteSpace(Params.SpeciesTranslationOverride))
+                    if (Params.SpeciesTranslationOverride.IsEmpty)
                    {
                        displayName = TextManager.Get($"Character.{SpeciesName}");
                    }
@@ -752,7 +752,7 @@ namespace Barotrauma
            get
            {
                if (IsUnconscious) { return true; }
-                return CharacterHealth.GetAllAfflictions().Any(a => a.Prefab.AfflictionType == "paralysis" && a.Strength >= a.Prefab.MaxStrength);
+                return CharacterHealth.GetAllAfflictions().Any(a => a.Prefab.Identifier == "paralysis" && a.Strength >= a.Prefab.MaxStrength);
            }
        }

@@ -822,6 +822,7 @@ namespace Barotrauma
        public AIState AIState => AIController is EnemyAIController enemyAI ? enemyAI.State : AIState.Idle;
        public bool IsLatched => AIController is EnemyAIController enemyAI && enemyAI.LatchOntoAI != null && enemyAI.LatchOntoAI.IsAttached;
        public float EmpVulnerability => Params.Health.EmpVulnerability;
+        public float PoisonVulnerability => Params.Health.PoisonVulnerability;

        public float Bloodloss
        {
@@ -1040,6 +1041,8 @@ namespace Barotrauma

        public bool InWater => AnimController is AnimController { InWater: true };

+        public bool IsLowInOxygen => NeedsOxygen && OxygenAvailable < CharacterHealth.LowOxygenThreshold;
+
        public bool GodMode = false;

        public CampaignMode.InteractionType CampaignInteractionType;
@@ -2871,6 +2874,23 @@ namespace Barotrauma
                }
                else
                {
+#if CLIENT
+                    if (Controlled == this)
+                    {
+                        HealingCooldown.PutOnCooldown();
+                    }
+#elif SERVER
+                    if (GameMain.Server?.ConnectedClients is { } clients)
+                    {
+                        foreach (Client c in clients)
+                        {
+                            if (c.Character != this) { continue; }
+
+                            HealingCooldown.SetCooldown(c);
+                            break;
+                        }
+                    }
+#endif
                    SelectCharacter(FocusedCharacter);
 #if CLIENT
                    if (Controlled == this)
@@ -3791,9 +3811,10 @@ namespace Barotrauma
                message.SendDelay -= deltaTime;
                if (message.SendDelay > 0.0f) { continue; }

+                bool canUseRadio = ChatMessage.CanUseRadio(this, out WifiComponent radio);
                if (message.MessageType == null)
                {
-                    message.MessageType = ChatMessage.CanUseRadio(this) ? ChatMessageType.Radio : ChatMessageType.Default;
+                    message.MessageType = canUseRadio ? ChatMessageType.Radio : ChatMessageType.Default;
                }
 #if CLIENT
                if (GameMain.GameSession?.CrewManager != null && GameMain.GameSession.CrewManager.IsSinglePlayer)
@@ -3803,6 +3824,11 @@ namespace Barotrauma
                    {
                        GameMain.GameSession.CrewManager.AddSinglePlayerChatMessage(Name, modifiedMessage, message.MessageType.Value, this);
                    }
+                    if (canUseRadio)
+                    {
+                        Signal s = new Signal(modifiedMessage, sender: this, source: radio.Item);
+                        radio.TransmitSignal(s, sentFromChat: true);
+                    }
                }
 #endif
 #if SERVER
@@ -4122,13 +4148,13 @@ namespace Barotrauma
                OnAttackedProjSpecific(attacker, attackResult, stun);
                if (!wasDead)
                {
-                    TryAdjustAttackerSkill(attacker, CharacterHealth.Vitality - prevVitality);
+                    TryAdjustAttackerSkill(attacker, attackResult);
                }
-            };
+            }
            if (attackResult.Damage > 0)
            {
                LastDamage = attackResult;
-                if (attacker != null)
+                if (attacker != null && attacker != this && !attacker.Removed)
                {
                    AddAttacker(attacker, attackResult.Damage);
                    AddEncounter(attacker);
@@ -4143,26 +4169,84 @@ namespace Barotrauma

        partial void OnAttackedProjSpecific(Character attacker, AttackResult attackResult, float stun);

-        public void TryAdjustAttackerSkill(Character attacker, float healthChange)
+        public void TryAdjustAttackerSkill(Character attacker, AttackResult attackResult)
        {
            if (attacker == null) { return; }
-            
+            if (!attacker.IsOnPlayerTeam) { return; }
            bool isEnemy = AIController is EnemyAIController || TeamID != attacker.TeamID;
-            if (isEnemy)
+            if (!isEnemy) { return; }
+            float weaponDamage = 0;
+            float medicalDamage = 0;
+            foreach (var affliction in attackResult.Afflictions)
            {
-                if (healthChange < 0.0f)
+                if (affliction.Prefab.IsBuff) { continue; }
+                if (Params.IsMachine && !affliction.Prefab.AffectMachines) { continue; }
+                if (affliction.Prefab.AfflictionType == "poison" || affliction.Prefab.AfflictionType == "paralysis")
                {
-                    float attackerSkillLevel = attacker.GetSkillLevel("weapons");
-                    attacker.Info?.IncreaseSkillLevel("weapons".ToIdentifier(),
-                        -healthChange * SkillSettings.Current.SkillIncreasePerHostileDamage / Math.Max(attackerSkillLevel, 1.0f));
+                    if (!Params.Health.PoisonImmunity)
+                    {
+                        float relativeVitality = MaxVitality / 100f;
+                        // Undo the applied modifiers to get the base value. Poison damage is multiplied by max vitality when it's applied.
+                        float dmg = affliction.Strength;
+                        if (relativeVitality > 0)
+                        {
+                            dmg /= relativeVitality;
+                        }
+                        if (PoisonVulnerability > 0)
+                        {
+                            dmg /= PoisonVulnerability;
+                        }
+                        float strength = MaxVitality;
+                        if (Params.AI != null)
+                        {
+                            strength = Params.AI.CombatStrength;
+                        }
+                        // Adjust the skill gain by the strength of the target. Combat strength >= 1000 gives 2x bonus, combat strength < 333 less than 1x.
+                        float vitalityFactor = MathHelper.Lerp(0.5f, 2f, MathUtils.InverseLerp(0, 1000, strength));
+                        dmg *= vitalityFactor;
+                        medicalDamage += dmg * affliction.Prefab.MedicalSkillGain;
+                    }
                }
+                else
+                {
+                    medicalDamage += affliction.GetVitalityDecrease(null) * affliction.Prefab.MedicalSkillGain;
+                }
+                weaponDamage += affliction.GetVitalityDecrease(null) * affliction.Prefab.WeaponsSkillGain;
            }
-            else if (healthChange > 0.0f)
+            if (medicalDamage > 0)
            {
-                float attackerSkillLevel = attacker.GetSkillLevel("medical");
-                attacker.Info?.IncreaseSkillLevel("medical".ToIdentifier(),
-                    healthChange * SkillSettings.Current.SkillIncreasePerFriendlyHealed / Math.Max(attackerSkillLevel, 1.0f));
+                IncreaseSkillLevel("medical".ToIdentifier(), medicalDamage);
            }
+            if (weaponDamage > 0)
+            {
+                IncreaseSkillLevel("weapons".ToIdentifier(), weaponDamage);
+            }
+
+            void IncreaseSkillLevel(Identifier skill, float damage)
+            {
+                float attackerSkillLevel = attacker.GetSkillLevel(skill);
+                // The formula is too generous on low skill levels, hence the minimum divider.
+                float minSkillDivider = 15f;
+                attacker.Info?.IncreaseSkillLevel(skill, damage * SkillSettings.Current.SkillIncreasePerHostileDamage / Math.Max(attackerSkillLevel, minSkillDivider));
+            }
+        }
+
+        public void TryAdjustHealerSkill(Character healer, float healthChange = 0, Affliction affliction = null)
+        {
+            if (healer == null) { return; }
+            bool isEnemy = AIController is EnemyAIController || TeamID != healer.TeamID;
+            if (isEnemy) { return; }
+            float medicalGain = healthChange;
+            if (affliction?.Prefab is { IsBuff: true } && (!Params.IsMachine || affliction.Prefab.AffectMachines))
+            {
+                medicalGain += affliction.Strength * affliction.Prefab.MedicalSkillGain;
+            }
+            if (medicalGain <= 0) { return; }
+            Identifier skill = new Identifier("medical");
+            float attackerSkillLevel = healer.GetSkillLevel(skill);
+            // The formula is too generous on low skill levels, hence the minimum divider.
+            float minSkillDivider = 15f;
+            healer.Info?.IncreaseSkillLevel(skill, medicalGain * SkillSettings.Current.SkillIncreasePerFriendlyHealed / Math.Max(attackerSkillLevel, minSkillDivider));
        }

        /// <summary>
@@ -5240,7 +5324,24 @@ namespace Barotrauma

        public bool IsFriendly(Character other) => IsFriendly(this, other);

-        public static bool IsFriendly(Character me, Character other) => AIController.IsOnFriendlyTeam(me, other) && IsSameSpeciesOrGroup(me, other);
+        public static bool IsFriendly(Character me, Character other) => IsOnFriendlyTeam(me, other) && IsSameSpeciesOrGroup(me, other);
+
+        public static bool IsOnFriendlyTeam(CharacterTeamType myTeam, CharacterTeamType otherTeam)
+        {
+            if (myTeam == otherTeam) { return true; }
+            return myTeam switch
+            {
+                // NPCs are friendly to the same team and the friendly NPCs
+                CharacterTeamType.None or CharacterTeamType.Team1 or CharacterTeamType.Team2 => otherTeam == CharacterTeamType.FriendlyNPC,
+                // Friendly NPCs are friendly to both player teams
+                CharacterTeamType.FriendlyNPC => otherTeam == CharacterTeamType.Team1 || otherTeam == CharacterTeamType.Team2,
+                _ => true
+            };
+        }
+
+        public static bool IsOnFriendlyTeam(Character me, Character other) => IsOnFriendlyTeam(me.TeamID, other.TeamID);
+        public bool IsOnFriendlyTeam(Character other) => IsOnFriendlyTeam(TeamID, other.TeamID);
+        public bool IsOnFriendlyTeam(CharacterTeamType otherTeam) => IsOnFriendlyTeam(TeamID, otherTeam);

        public bool IsSameSpeciesOrGroup(Character other) => IsSameSpeciesOrGroup(this, other);

@@ -321,6 +321,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)
            {
@@ -335,8 +336,10 @@ 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);
                }
            }
        }
@@ -415,8 +418,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;
@@ -427,6 +430,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>();

@@ -528,6 +545,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())
            {
@@ -708,7 +708,7 @@ namespace Barotrauma
                    return;
                }
            }
-            if (Character.Params.Health.PoisonImmunity && newAffliction.Prefab.AfflictionType == "poison") { return; }
+            if (Character.Params.Health.PoisonImmunity && (newAffliction.Prefab.AfflictionType == "poison" || newAffliction.Prefab.AfflictionType == "paralysis")) { return; }
            if (Character.EmpVulnerability <= 0 && newAffliction.Prefab.AfflictionType == "emp") { return; }
            if (newAffliction.Prefab is AfflictionPrefabHusk huskPrefab)
            {
@@ -490,13 +490,9 @@ namespace Barotrauma

        public int RefJointIndex => Params.RefJoint;

-        private List<WearableSprite> wearingItems;
-        public List<WearableSprite> WearingItems
-        {
-            get { return wearingItems; }
-        }
+        public readonly List<WearableSprite> WearingItems = new List<WearableSprite>();

-        public List<WearableSprite> OtherWearables { get; private set; } = new List<WearableSprite>();
+        public readonly List<WearableSprite> OtherWearables = new List<WearableSprite>();

        public bool PullJointEnabled
        {
@@ -640,7 +636,6 @@ namespace Barotrauma
            this.ragdoll = ragdoll;
            this.character = character;
            this.Params = limbParams;
-            wearingItems = new List<WearableSprite>();            
            dir = Direction.Right;
            body = new PhysicsBody(limbParams);
            type = limbParams.Type;
@@ -772,7 +767,7 @@ namespace Barotrauma
                        tempModifiers.Add(damageModifier);
                    }
                }
-                foreach (WearableSprite wearable in wearingItems)
+                foreach (WearableSprite wearable in WearingItems)
                {
                    foreach (DamageModifier damageModifier in wearable.WearableComponent.DamageModifiers)
                    {
@@ -791,10 +786,14 @@ namespace Barotrauma
                }
                if (!foundMatchingModifier && random > affliction.Probability) { continue; }
                float finalDamageModifier = damageMultiplier;
-                if (affliction.Prefab.AfflictionType == "emp" && character.EmpVulnerability > 0)
+                if (character.EmpVulnerability > 0 && affliction.Prefab.AfflictionType == "emp")
                {
                    finalDamageModifier *= character.EmpVulnerability;
                }
+                if (!character.Params.Health.PoisonImmunity && (affliction.Prefab.AfflictionType == "poison" || affliction.Prefab.AfflictionType == "paralysis"))
+                {
+                    finalDamageModifier *= character.PoisonVulnerability;
+                }
                foreach (DamageModifier damageModifier in tempModifiers)
                {
                    float damageModifierValue = damageModifier.DamageMultiplier;
@@ -21,7 +21,7 @@ namespace Barotrauma
        public Identifier SpeciesName { get; private set; }

        [Serialize("", IsPropertySaveable.Yes, description: "If the creature is a variant that needs to use a pre-existing translation."), Editable]
-        public string SpeciesTranslationOverride { get; private set; }
+        public Identifier SpeciesTranslationOverride { get; private set; }

        [Serialize("", IsPropertySaveable.Yes, description: "If the display name is not defined, the game first tries to find the translated name. If that is not found, the species name will be used."), Editable]
        public string DisplayName { get; private set; }
@@ -501,6 +501,9 @@ namespace Barotrauma
            [Serialize(false, IsPropertySaveable.Yes), Editable]
            public bool PoisonImmunity { get; set; }

+            [Serialize(1f, IsPropertySaveable.Yes, description: "1 = default, 0 = immune."), Editable(MinValueFloat = 0f, MaxValueFloat = 1000, DecimalCount = 1)]
+            public float PoisonVulnerability { get; set; }
+
            [Serialize(0f, IsPropertySaveable.Yes), Editable]
            public float EmpVulnerability { get; set; }