Merge remote-tracking branch 'upstream/master' into develop

Barotrauma/BarotraumaShared/SharedSource/Characters/AI/EnemyAIController.cs

@@ -2628,7 +2628,7 @@ namespace Barotrauma
             float margin = MathHelper.PiOver4 * distanceFactor;
             if (angle < margin || dist < minDistance)
             {
-                var collisionCategories = Physics.CollisionCharacter | Physics.CollisionWall | Physics.CollisionLevel;                
+                var collisionCategories = Physics.CollisionCharacter | Physics.CollisionWall | Physics.CollisionLevel | Physics.CollisionItemBlocking;
                 var pickedBody = Submarine.PickBody(weapon.SimPosition, Character.GetRelativeSimPosition(target), myBodies, collisionCategories, allowInsideFixture: true);
                 if (pickedBody != null)
                 {
@@ -2643,7 +2643,6 @@ namespace Barotrauma
                             return true;
                         }
                     }
-
                     Character t = null;
                     if (pickedBody.UserData is Character c)
                     {
@@ -2657,6 +2656,16 @@ namespace Barotrauma
                     {
                         return true;
                     }
+                    if (pickedBody.UserData is Item item && item.Prefab.DamagedByProjectiles)
+                    {
+                        // Target behind an item -> allow shooting.
+                        return true;
+                    }
+                    if (pickedBody.UserData is Holdable holdable && holdable.Item.Prefab.DamagedByProjectiles)
+                    {
+                        // Target behind a blocking but destructible item -> allow shooting.
+                        return true;
+                    }
                 }
             }
             return false;
@@ -2889,7 +2898,7 @@ namespace Barotrauma
                 if (aiTarget.ShouldBeIgnored()) { continue; }
                 if (ignoredTargets.Contains(aiTarget)) { continue; }
                 if (aiTarget.Type == AITarget.TargetType.HumanOnly) { continue; }
-                if (!TargetOutposts && GameMain.GameSession.GameMode is not TestGameMode)
+                if (!TargetOutposts && GameMain.GameSession?.GameMode is not TestGameMode)
                 {
                     if (aiTarget.Entity.Submarine != null && aiTarget.Entity.Submarine.Info.IsOutpost) { continue; }
                 }
@@ -3918,7 +3927,13 @@ namespace Barotrauma
             return false;
         }
 
+        /// <summary>
+        /// Parameters originally defined in the AI params and modified temporarily.
+        /// </summary>
         private readonly Dictionary<Identifier, IEnumerable<CharacterParams.TargetParams>> modifiedParams = new Dictionary<Identifier, IEnumerable<CharacterParams.TargetParams>>();
+        /// <summary>
+        /// Parameters created temporarily. Not originally defined in the AI params at all.
+        /// </summary>
         private readonly Dictionary<Identifier, CharacterParams.TargetParams> tempParams = new Dictionary<Identifier, CharacterParams.TargetParams>();
         private readonly List<CharacterParams.TargetParams> tempParamsList = new List<CharacterParams.TargetParams>();
 
@@ -3952,11 +3967,6 @@ namespace Barotrauma
                 {
                     if (AIParams.TryAddNewTarget(tag, state, priority ?? minPriority, out CharacterParams.TargetParams targetParams))
                     {
-                        if (state == AIState.Attack)
-                        {
-                            // Only applies to new temp target params. Shouldn't affect any existing definitions (handled below).
-                            targetParams.IgnoreIfNotInSameSub = ignoreAttacksIfNotInSameSub;
-                        }
                         tempParams.Add(tag, targetParams);
                     }
                 }
@@ -3970,6 +3980,15 @@ namespace Barotrauma
                         targetParams.Priority = Math.Max(targetParams.Priority, priority.Value);
                     }
                     targetParams.State = state;
+                    if (state == AIState.Attack)
+                    {
+                        targetParams.IgnoreIfNotInSameSub = ignoreAttacksIfNotInSameSub;
+                        targetParams.IgnoreInside = false;
+                        targetParams.IgnoreOutside = false;
+                        targetParams.IgnoreTargetInside = false;
+                        targetParams.IgnoreTargetOutside = false;
+                        targetParams.IgnoreIncapacitated = false;
+                    }
                 }
                 modifiedParams.TryAdd(tag, existingTargetParams);
             }

Barotrauma/BarotraumaShared/SharedSource/Characters/AI/HumanAIController.cs

@@ -574,7 +574,7 @@ namespace Barotrauma
             foreach (Character c in Character.CharacterList)
             {
                 if (c.Submarine != Character.Submarine) { continue; }
-                if (c.Removed || c.IsDead || c.IsIncapacitated) { continue; }
+                if (c.Removed || c.IsDead || c.IsIncapacitated || c.InDetectable) { continue; }
                 if (IsFriendly(c)) { continue; }
                 Vector2 toTarget = c.WorldPosition - WorldPosition;
                 float dist = toTarget.LengthSquared();
@@ -1045,7 +1045,7 @@ namespace Barotrauma
                 {
                     foreach (Character target in Character.CharacterList)
                     {
-                        if (target.CurrentHull != hull || !target.Enabled) { continue; }
+                        if (target.CurrentHull != hull || !target.Enabled || target.InDetectable) { continue; }
                         if (AIObjectiveFightIntruders.IsValidTarget(target, Character, false))
                         {
                             if (!target.IsHandcuffed && AddTargets<AIObjectiveFightIntruders, Character>(Character, target) && newOrder == null)
@@ -1696,16 +1696,25 @@ namespace Barotrauma
 
         public bool AllowCampaignInteraction()
         {
-            if (Character == null || Character.Removed || Character.IsIncapacitated) { return false; }
+            if (Character == null || Character.Removed) { return false; }
 
-            switch (ObjectiveManager.CurrentObjective)
+            //some events might want to allow talking/examining characters that are incapacitated or in some "emergency" ai state,
+            //so let's ignore those here
+            var type = Character.CampaignInteractionType;
+            if (type != CampaignMode.InteractionType.None &&
+                type != CampaignMode.InteractionType.Talk &&
+                type != CampaignMode.InteractionType.Examine)
             {
-                case AIObjectiveCombat _:
-                case AIObjectiveFindSafety _:
-                case AIObjectiveExtinguishFires _:
-                case AIObjectiveFightIntruders _:
-                case AIObjectiveFixLeaks _:
-                    return false;
+                if (Character.IsIncapacitated) { return false; }
+                switch (ObjectiveManager.CurrentObjective)
+                {
+                    case AIObjectiveCombat _:
+                    case AIObjectiveFindSafety _:
+                    case AIObjectiveExtinguishFires _:
+                    case AIObjectiveFightIntruders _:
+                    case AIObjectiveFixLeaks _:
+                        return false;
+                }
             }
             return true;
         }
@@ -2272,7 +2281,7 @@ namespace Barotrauma
 
         public static bool IsFriendly(Character me, Character other, bool onlySameTeam = false)
         {
-            if (other.IsHusk)
+            if (other.IsHusk && !onlySameTeam)
             {
                 // Disguised as husk
                 return me.IsDisguisedAsHusk;
@@ -2305,16 +2314,15 @@ namespace Barotrauma
             {
                 if (!me.IsSameSpeciesOrGroup(other)) { return false; }
             }
-            if (GameMain.GameSession?.GameMode is CampaignMode)
+            if (GameMain.GameSession?.GameMode is CampaignMode && 
+                //ignore hostile faction if offering services that don't get disabled by faction hostility
+                (me.CampaignInteractionType == CampaignMode.InteractionType.None || CampaignMode.HostileFactionDisablesInteraction(me.CampaignInteractionType)))
             {
                 if ((me.TeamID == CharacterTeamType.FriendlyNPC && other.TeamID == CharacterTeamType.Team1) ||
                     (me.TeamID == CharacterTeamType.Team1 && other.TeamID == CharacterTeamType.FriendlyNPC))
                 {
                     Character npc = me.TeamID == CharacterTeamType.FriendlyNPC ? me : other;
 
-                    //NPCs that allow some campaign interaction are not turned hostile by low reputation
-                    if (npc.CampaignInteractionType != CampaignMode.InteractionType.None) { return true; }
-
                     if (npc.AIController is HumanAIController npcAI)
                     {
                         return !npcAI.IsInHostileFaction();
@@ -2347,7 +2355,7 @@ namespace Barotrauma
             return false;
         }
 
-        public static bool IsActive(Character c) => c != null && c.Enabled && !c.IsUnconscious;
+        public static bool IsActive(Character c) => c is { Enabled: true, IsUnconscious: false };
 
         public static bool IsTrueForAllBotsInTheCrew(Character character, Func<HumanAIController, bool> predicate)
         {
@@ -2359,7 +2367,7 @@ namespace Barotrauma
                 {
                     return false;
                 }
-        }
+            }
             return true;
         }
 
@@ -2468,11 +2476,11 @@ namespace Barotrauma
                     operatingCharacter = c;
                     return true;
                 }
-                if (c.AIController is HumanAIController humanAI && humanAI.ObjectiveManager is AIObjectiveManager objectiveManager)
+                if (c.AIController is HumanAIController { ObjectiveManager: AIObjectiveManager objectiveManager })
                 {
                     foreach (var objective in objectiveManager.Objectives)
                     {
-                        if (!(objective is AIObjectiveOperateItem operateObjective)) { continue; }
+                        if (objective is not AIObjectiveOperateItem operateObjective) { continue; }
                         if (operateObjective.Component?.Item != target.Item) { continue; }
                         if (operateObjective.Priority < highestPriority) { continue; }
                         if (operateObjective.PriorityModifier < highestPriorityModifier) { continue; }
@@ -2485,136 +2493,6 @@ namespace Barotrauma
             return operatingCharacter != null;
         }
 
-        // There's some duplicate logic in the two methods below, but making them use the same code would require some changes in the target classes so that we could use exactly the same checks.
-        // And even then there would be some differences that could end up being confusing (like the exception for steering).
-        public bool IsItemOperatedByAnother(ItemComponent target, out Character other)
-        {
-            other = null;
-            if (target?.Item == null) { return false; }
-            bool isOrder = IsOrderedToOperateTarget(this);
-            foreach (Character c in Character.CharacterList)
-            {
-                if (!IsActive(c)) { continue; }
-                if (c == Character) { continue; }
-                if (c.TeamID != Character.TeamID) { continue; }
-                if (c.IsPlayer)
-                {
-                    if (c.SelectedItem == target.Item)
-                    {
-                        // If the other character is player, don't try to operate
-                        other = c;
-                        break;
-                    }
-                }
-                else if (c.AIController is HumanAIController otherAI)
-                {
-                    if (otherAI.ObjectiveManager.Objectives.None(o => o is AIObjectiveOperateItem operateObjective && operateObjective.Component.Item == target.Item))
-                    {
-                        // Not targeting the same item.
-                        continue;
-                    }
-                    bool isTargetOrdered = IsOrderedToOperateTarget(otherAI);
-                    if (!isOrder && isTargetOrdered)
-                    {
-                        // If the other bot is ordered to operate the item, let him do it, unless we are ordered too
-                        other = c;
-                        break;
-                    }
-                    else
-                    {
-                        if (isOrder && !isTargetOrdered)
-                        {
-                            // We are ordered and the target is not -> allow to operate
-                            continue;
-                        }
-                        else
-                        {
-                            if (!IsOperatingTarget(otherAI))
-                            {
-                                // The other bot is doing something else -> stick to the target.
-                                continue;
-                            }
-                            if (target is Steering)
-                            {
-                                // Steering is hard-coded -> cannot use the required skills collection defined in the xml
-                                if (Character.GetSkillLevel(Tags.HelmSkill) <= c.GetSkillLevel(Tags.HelmSkill))
-                                {
-                                    other = c;
-                                    break;
-                                }
-                            }
-                            else if (target.DegreeOfSuccess(Character) <= target.DegreeOfSuccess(c))
-                            {
-                                other = c;
-                                break;
-                            }
-                        }
-                    }
-                }
-            }
-            return other != null;
-            bool IsOrderedToOperateTarget(HumanAIController ai) => ai.ObjectiveManager.CurrentOrder is AIObjectiveOperateItem operateOrder && operateOrder.Component.Item == target.Item;
-            bool IsOperatingTarget(HumanAIController ai) => ai.ObjectiveManager.CurrentObjective is AIObjectiveOperateItem operateObjective && operateObjective.Component.Item == target.Item;
-        }
-
-        public bool IsItemRepairedByAnother(Item target, out Character other)
-        {
-            other = null;
-            if (Character == null) { return false; }
-            if (target == null) { return false; }
-            bool isOrder = IsOrderedToRepairThis(Character.AIController as HumanAIController);
-            foreach (var c in Character.CharacterList)
-            {
-                if (!IsActive(c)) { continue; }
-                if (c == Character) { continue; }
-                if (c.TeamID != Character.TeamID) { continue; }
-                other = c;
-                if (c.IsPlayer)
-                {
-                    if (target.Repairables.Any(r => r.CurrentFixer == c))
-                    {
-                        // If the other character is player, don't try to repair
-                        return true;
-                    }
-                }
-                else if (c.AIController is HumanAIController operatingAI)
-                {
-                    var repairItemsObjective = operatingAI.ObjectiveManager.GetObjective<AIObjectiveRepairItems>();
-                    if (repairItemsObjective == null) { continue; }
-                    if (repairItemsObjective.SubObjectives.FirstOrDefault(o => o is AIObjectiveRepairItem) is not AIObjectiveRepairItem activeObjective || activeObjective.Item != target)
-                    {
-                        // Not targeting the same item.
-                        continue;
-                    }
-                    bool isTargetOrdered = IsOrderedToRepairThis(operatingAI);
-                    if (!isOrder && isTargetOrdered)
-                    {
-                        // If the other bot is ordered to repair the item, let him do it, unless we are ordered too
-                        return true;
-                    }
-                    else
-                    {
-                        if (isOrder && !isTargetOrdered)
-                        {
-                            // We are ordered and the target is not -> allow to repair
-                            continue;
-                        }
-                        else
-                        {
-                            if (!isTargetOrdered && operatingAI.ObjectiveManager.CurrentOrder != operatingAI.ObjectiveManager.CurrentObjective)
-                            {
-                                // The other bot is ordered to do something else
-                                continue;
-                            }
-                            return target.Repairables.Max(r => r.DegreeOfSuccess(Character)) <= target.Repairables.Max(r => r.DegreeOfSuccess(c));
-                        }
-                    }
-                }
-            }
-            return false;
-            bool IsOrderedToRepairThis(HumanAIController ai) => ai.ObjectiveManager.CurrentOrder is AIObjectiveRepairItems repairOrder && repairOrder.PrioritizedItem == target;
-        }
-
         #region Wrappers
         public bool IsFriendly(Character other, bool onlySameTeam = false) => IsFriendly(Character, other, onlySameTeam);
         public bool IsTrueForAnyBotInTheCrew(Func<HumanAIController, bool> predicate) => IsTrueForAnyBotInTheCrew(Character, predicate);

Barotrauma/BarotraumaShared/SharedSource/Characters/AI/IndoorsSteeringManager.cs

@@ -562,6 +562,7 @@ namespace Barotrauma
                 bool buttonsFound = false;
                 // Check wired controllers (e.g. buttons)
                 // Always run the buttonFilter delegate (inside CanAccessButton method), if defined, because it's used for find a valid controller component that can be used for closing the door, when needed.
+                // TODO: connectionFilter is ignored in the recursive searches, so it does nothing here.
                 foreach (Controller button in door.Item.GetConnectedComponents<Controller>(recursive: true, connectionFilter: c => c.Name is "toggle" or "set_state"))
                 {
                     buttonsFound = true;
@@ -727,12 +728,15 @@ namespace Barotrauma
                         float distance = Vector2.DistanceSquared(button.Item.WorldPosition, character.WorldPosition);
                         //heavily prefer buttons linked to the door, so sub builders can help the bots figure out which button to use by linking them
                         if (door.Item.linkedTo.Contains(button.Item)) { distance *= 0.1f; }
-                        if (closestButton == null || distance < closestDist && character.CanSeeTarget(button.Item))
+                        if (closestButton == null || distance < closestDist)
                         {
-                            closestButton = button;
-                            closestDist = distance;
+                            if (distance < MathUtils.Pow2(button.Item.InteractDistance + GetColliderLength()) && character.CanSeeTarget(button.Item))
+                            {
+                                closestButton = button;
+                                closestDist = distance;
+                            }
                         }
-                        return true;
+                        return closestButton != null;
                     });
                     if (canAccess)
                     {
@@ -755,41 +759,19 @@ namespace Barotrauma
                         }
                         else if (closestButton != null)
                         {
-                            if (closestDist < MathUtils.Pow2(closestButton.Item.InteractDistance + GetColliderLength()))
+                            if (pressButton)
                             {
-                                if (pressButton)
+                                if (closestButton.Item.TryInteract(character, forceSelectKey: true))
                                 {
-                                    if (closestButton.Item.TryInteract(character, forceSelectKey: true))
-                                    {
-                                        lastDoor = (door, shouldBeOpen);
-                                        buttonPressTimer = shouldBeOpen ? ButtonPressCooldown : 0;
-                                    }
-                                    else
-                                    {
-                                        buttonPressTimer = 0;
-                                    }
+                                    lastDoor = (door, shouldBeOpen);
+                                    buttonPressTimer = shouldBeOpen ? ButtonPressCooldown : 0;
                                 }
-                                break;
-                            }
-                            else
-                            {
-                                // Can't reach the button closest to the character.
-                                // It's possible that we could reach another buttons.
-                                // If this becomes an issue, we could go through them here and check if any of them are reachable
-                                // (would have to cache a collection of buttons instead of a single reference in the CanAccess filter method above)
-                                var body = Submarine.PickBody(character.SimPosition, character.GetRelativeSimPosition(closestButton.Item), collisionCategory: Physics.CollisionWall | Physics.CollisionLevel);
-                                if (body != null)
+                                else
                                 {
-                                    if (body.UserData is Item item)
-                                    {
-                                        var d = item.GetComponent<Door>();
-                                        if (d == null || d.IsOpen) { return; }
-                                    }
-                                    // The button is on the wrong side of the door or a wall
-                                    currentPath.Unreachable = true;
+                                    buttonPressTimer = 0;
                                 }
-                                return;
                             }
+                            break;
                         }
                     }
                     else if (shouldBeOpen)
@@ -871,6 +853,16 @@ namespace Barotrauma
                 {
                     if (!CanAccessDoor(door, button =>
                     {
+                        if (Vector2.DistanceSquared(door.Item.WorldPosition, button.Item.WorldPosition) > MathUtils.Pow2(button.Item.InteractDistance + GetColliderLength()))
+                        {
+                            // Too far from the door.
+                            return false;
+                        }
+                        if (!ISpatialEntity.IsTargetVisible(button.Item, door.Item))
+                        {
+                            // Obstructed.
+                            return false;
+                        }
                         // Ignore buttons that are on the wrong side of the door, unless there's a motion sensor connected to the door, which can be triggered by the character.
                         if (door.IsHorizontal)
                         {

Barotrauma/BarotraumaShared/SharedSource/Characters/AI/Objectives/AIObjectiveFightIntruders.cs

@@ -59,7 +59,7 @@ namespace Barotrauma
         public static bool IsValidTarget(Character target, Character character, bool targetCharactersInOtherSubs)
         {
             if (target == null || target.Removed) { return false; }
-            if (target.IsDead) { return false; }
+            if (target.IsDead || target.InDetectable) { return false; }
             if (target.IsUnconscious && target.Params.Health.ConstantHealthRegeneration <= 0.0f) { return false; }
             if (target == character) { return false; }
             if (target.Submarine == null) { return false; }

Barotrauma/BarotraumaShared/SharedSource/Characters/AI/Objectives/AIObjectiveIdle.cs

@@ -387,14 +387,14 @@ namespace Barotrauma
                     chairCheckTimer -= deltaTime;
                     if (chairCheckTimer <= 0.0f && character.SelectedSecondaryItem == null)
                     {
-                        foreach (Item item in Item.ItemList)
+                        foreach (Item chair in Item.ChairItems)
                         {
-                            if (item.CurrentHull != currentHull || !item.HasTag(Tags.ChairItem)) { continue; }
+                            if (chair.CurrentHull != currentHull) { continue; }
                             //not possible in vanilla game, but a mod might have holdable/attachable chairs
-                            if (item.ParentInventory != null || item.body is { Enabled: true }) { continue; } 
-                            var controller = item.GetComponent<Controller>();
+                            if (chair.ParentInventory != null || chair.body is { Enabled: true }) { continue; } 
+                            var controller = chair.GetComponent<Controller>();
                             if (controller == null || controller.User != null) { continue; }
-                            item.TryInteract(character, forceSelectKey: true);
+                            chair.TryInteract(character, forceSelectKey: true);
                         }
                         chairCheckTimer = chairCheckInterval;
                     }

Barotrauma/BarotraumaShared/SharedSource/Characters/AI/Objectives/AIObjectiveOperateItem.cs

@@ -1,4 +1,5 @@
-using Barotrauma.Items.Components;
+using Barotrauma.Extensions;
+using Barotrauma.Items.Components;
 using Microsoft.Xna.Framework;
 using System;
 using System.Collections.Generic;
@@ -15,7 +16,7 @@ namespace Barotrauma
         public override bool AllowMultipleInstances => true;
         protected override bool AllowInAnySub => true;
         protected override bool AllowWhileHandcuffed => false;
-        public override bool PrioritizeIfSubObjectivesActive => component != null && (component is Reactor || component is Turret);
+        public override bool PrioritizeIfSubObjectivesActive => component is Reactor or Turret;
 
         private readonly ItemComponent component, controller;
         private readonly Entity operateTarget;
@@ -88,12 +89,12 @@ namespace Barotrauma
                     Priority = 0;
                     return Priority;
                 }
-                var reactor = component?.Item.GetComponent<Reactor>();
+                var reactor = component.Item.GetComponent<Reactor>();
                 if (reactor != null)
                 {
                     if (!isOrder)
                     {
-                        if (reactor.LastUserWasPlayer && character.TeamID != CharacterTeamType.FriendlyNPC)
+                        if (reactor.LastUserWasPlayer && character.IsOnPlayerTeam)
                         {
                             // The reactor was previously operated by a player -> ignore.
                             Priority = 0;
@@ -126,7 +127,7 @@ namespace Barotrauma
                 }
                 else if (!isOrder)
                 {
-                    var steering = component?.Item.GetComponent<Steering>();
+                    var steering = component.Item.GetComponent<Steering>();
                     if (steering != null && (steering.AutoPilot || HumanAIController.IsTrueForAnyCrewMember(c => c != character && c.IsCaptain, onlyActive: true, onlyConnectedSubs: true)))
                     {
                         // Ignore if already set to autopilot or if there's a captain onboard
@@ -137,7 +138,7 @@ namespace Barotrauma
                 if (targetItem.CurrentHull == null ||
                     targetItem.Submarine != character.Submarine && !isOrder ||
                     targetItem.CurrentHull.FireSources.Any() ||
-                    HumanAIController.IsItemOperatedByAnother(target, out _) ||
+                    IsItemOperatedByAnother(target) ||
                     Character.CharacterList.Any(c => c.CurrentHull == targetItem.CurrentHull && !HumanAIController.IsFriendly(c) && HumanAIController.IsActive(c))
                     || component.Item.IgnoreByAI(character) || useController && controller.Item.IgnoreByAI(character))
                 {
@@ -154,8 +155,8 @@ namespace Barotrauma
                     else if (!OverridePriority.HasValue)
                     {
                         float value = CumulatedDevotion + (AIObjectiveManager.LowestOrderPriority * PriorityModifier);
-                        float max = AIObjectiveManager.LowestOrderPriority - 1;
-                        if (reactor != null && reactor.PowerOn && reactor.FissionRate > 1 && reactor.AutoTemp && Option == "powerup")
+                        const float max = AIObjectiveManager.LowestOrderPriority - 1;
+                        if (reactor is { PowerOn: true, FissionRate: > 1, AutoTemp: true } && Option == "powerup")
                         {
                             // Already on, no need to operate.
                             value = 0;
@@ -171,12 +172,12 @@ namespace Barotrauma
             Entity operateTarget = null, bool useController = false, ItemComponent controller = null, float priorityModifier = 1)
             : base(character, objectiveManager, priorityModifier, option)
         {
-            component = item ?? throw new ArgumentNullException("item", "Attempted to create an AIObjectiveOperateItem with a null target.");
+            component = item ?? throw new ArgumentNullException(nameof(item), "Attempted to create an AIObjectiveOperateItem with a null target.");
             this.requireEquip = requireEquip;
             this.operateTarget = operateTarget;
             this.useController = useController;
-            if (useController) { this.controller = controller ?? component?.Item?.FindController(); }
-            var target = GetTarget();
+            if (useController) { this.controller = controller ?? component.Item?.FindController(); }
+            ItemComponent target = GetTarget();
             if (target == null)
             {
                 Abandon = true;
@@ -320,5 +321,68 @@ namespace Barotrauma
             goToObjective = null;
             getItemObjective = null;
         }
+        
+        private bool IsItemOperatedByAnother(ItemComponent target)
+        {
+            if (target?.Item == null) { return false; }
+            bool isOrdered = IsOrderedToOperateTarget(HumanAIController);
+            foreach (Character c in Character.CharacterList)
+            {
+                if (!HumanAIController.IsActive(c)) { continue; }
+                if (c == character) { continue; }
+                if (c.TeamID != character.TeamID) { continue; }
+                if (c.IsPlayer)
+                {
+                    if (c.SelectedItem == target.Item)
+                    {
+                        // If the other character is player, don't try to operate
+                        return true;
+                    }
+                }
+                else if (c.AIController is HumanAIController otherAI)
+                {
+                    if (otherAI.ObjectiveManager.Objectives.None(o => o is AIObjectiveOperateItem operateObjective && operateObjective.Component.Item == target.Item))
+                    {
+                        // Not targeting the same item.
+                        continue;
+                    }
+                    bool isOtherCharacterOrdered = IsOrderedToOperateTarget(otherAI);
+                    switch (isOrdered)
+                    {
+                        case false when isOtherCharacterOrdered:
+                            // We are not ordered and the target is ordered -> let the other character operate the target item.
+                            return true;
+                        case true when !isOtherCharacterOrdered:
+                            // We are ordered and the other character is not -> allow to us to operate the target item.
+                            continue;
+                        default:
+                        {
+                            // Neither or both are ordered to operate this item.
+                            if (!IsOperatingTarget(otherAI))
+                            {
+                                // The other bot is doing something else -> stick to the target.
+                                continue;
+                            }
+                            if (target is Steering)
+                            {
+                                // Steering is hard-coded -> cannot use the required skills collection defined in the xml
+                                if (character.GetSkillLevel(Tags.HelmSkill) <= c.GetSkillLevel(Tags.HelmSkill))
+                                {
+                                    return true;
+                                }
+                            }
+                            else if (target.DegreeOfSuccess(character) <= target.DegreeOfSuccess(c))
+                            {
+                                return true;
+                            }
+                            break;
+                        }
+                    }
+                }
+            }
+            return false;
+            bool IsOrderedToOperateTarget(HumanAIController ai) => ai.ObjectiveManager.CurrentOrder is AIObjectiveOperateItem operateOrder && operateOrder.Component.Item == target.Item;
+            bool IsOperatingTarget(HumanAIController ai) => ai.ObjectiveManager.CurrentObjective is AIObjectiveOperateItem operateObjective && operateObjective.Component.Item == target.Item;
+        }
     }
 }

Barotrauma/BarotraumaShared/SharedSource/Characters/AI/Objectives/AIObjectiveRepairItem.cs

@@ -50,7 +50,7 @@ namespace Barotrauma
                 }
                 return Priority;
             }
-            if (HumanAIController.IsItemRepairedByAnother(Item, out _))
+            if (AIObjectiveRepairItems.IsItemRepairedByAnother(character, Item))
             {
                 Priority = 0;
                 IsCompleted = true;

Barotrauma/BarotraumaShared/SharedSource/Characters/AI/Objectives/AIObjectiveRepairItems.cs

@@ -76,7 +76,7 @@ namespace Barotrauma
             {
                 if (item.Repairables.None(r => r.RequiredSkills.Any(s => s.Identifier == RelevantSkill))) { return false; }
             }
-            return !HumanAIController.IsItemRepairedByAnother(item, out _);
+            return !IsItemRepairedByAnother(character, item);
         }
 
         public static bool ViableForRepair(Item item, Character character, HumanAIController humanAIController)
@@ -161,5 +161,57 @@ namespace Barotrauma
 
             return true;
         }
+        
+        public static bool IsItemRepairedByAnother(Character character, Item target)
+        {
+            if (target == null) { return false; }
+            bool isOrder = IsOrderedToPrioritizeTarget(character.AIController as HumanAIController);
+            foreach (Character c in Character.CharacterList)
+            {
+                if (!HumanAIController.IsActive(c)) { continue; }
+                if (c == character) { continue; }
+                if (c.TeamID != character.TeamID) { continue; }
+                if (c.IsPlayer)
+                {
+                    if (target.Repairables.Any(r => r.CurrentFixer == c))
+                    {
+                        // If the other character is player, don't try to repair
+                        return true;
+                    }
+                }
+                else if (c.AIController is HumanAIController otherAI)
+                {
+                    var repairItemsObjective = otherAI.ObjectiveManager.GetObjective<AIObjectiveRepairItems>();
+                    if (repairItemsObjective == null) { continue; }
+                    if (repairItemsObjective.SubObjectives.FirstOrDefault(o => o is AIObjectiveRepairItem) is not AIObjectiveRepairItem activeObjective || activeObjective.Item != target)
+                    {
+                        // Not targeting the same item.
+                        continue;
+                    }
+                    bool isTargetOrdered = IsOrderedToPrioritizeTarget(otherAI);
+                    switch (isOrder)
+                    {
+                        case false when isTargetOrdered:
+                            // We are not ordered and the target is ordered -> let the other character repair the target.
+                            return true;
+                        case true when !isTargetOrdered:
+                            // We are ordered and the target is not -> allow us to repair the target.
+                            continue;
+                        default:
+                        {
+                            // Neither or both are ordered to repair this item.
+                            if (otherAI.ObjectiveManager.CurrentObjective is not AIObjectiveRepairItems)
+                            {
+                                // The other bot is doing something else -> stick to the target.
+                                continue;
+                            }
+                            return target.Repairables.Max(r => r.DegreeOfSuccess(character)) <= target.Repairables.Max(r => r.DegreeOfSuccess(c));
+                        }
+                    }
+                }
+            }
+            return false;
+            bool IsOrderedToPrioritizeTarget(HumanAIController ai) => ai.ObjectiveManager.CurrentOrder is AIObjectiveRepairItems repairOrder && repairOrder.PrioritizedItem == target;
+        }
     }
 }

Barotrauma/BarotraumaShared/SharedSource/Characters/AI/Objectives/AIObjectiveRescue.cs

@@ -149,7 +149,7 @@ namespace Barotrauma
                                 if (HumanAIController.VisibleHulls.Contains(Target.CurrentHull) && Target.CurrentHull.DisplayName != null)
                                 {
                                     character.Speak(TextManager.GetWithVariables("DialogFoundUnconsciousTarget",
-                                        ("[targetname]", Target.Name, FormatCapitals.No),
+                                        ("[targetname]", Target.DisplayName, FormatCapitals.No),
                                         ("[roomname]", Target.CurrentHull.DisplayName, FormatCapitals.Yes)).Value,
                                         null, 1.0f, $"foundunconscioustarget{Target.Name}".ToIdentifier(), 60.0f);
                                 }
@@ -239,7 +239,7 @@ namespace Barotrauma
                     if (Target.CurrentHull?.DisplayName != null)
                     {
                         character.Speak(TextManager.GetWithVariables("DialogFoundWoundedTarget",
-                            ("[targetname]", Target.Name, FormatCapitals.No),
+                            ("[targetname]", Target.DisplayName, FormatCapitals.No),
                             ("[roomname]", Target.CurrentHull.DisplayName, FormatCapitals.Yes)).Value,
                             null, 1.0f, $"foundwoundedtarget{Target.Name}".ToIdentifier(), 60.0f);
                     }
@@ -287,6 +287,8 @@ namespace Barotrauma
                     currentTreatmentSuitabilities, 
                     limb: Target.CharacterHealth.GetAfflictionLimb(affliction), 
                     user: character,
+                    checkTreatmentThreshold: true,
+                    checkTreatmentSuggestionThreshold: false,
                     predictFutureDuration: 10.0f);
 
                 foreach (KeyValuePair<Identifier, float> treatmentSuitability in currentTreatmentSuitabilities)
@@ -330,7 +332,10 @@ namespace Barotrauma
             {
                 //get "overall" suitability for no specific limb at this point
                 Target.CharacterHealth.GetSuitableTreatments(
-                    currentTreatmentSuitabilities, user: character, predictFutureDuration: 10.0f);
+                    currentTreatmentSuitabilities, user: character,
+                    checkTreatmentThreshold: true,
+                    checkTreatmentSuggestionThreshold: false,
+                    predictFutureDuration: 10.0f);
                 //didn't have any suitable treatments available, try to find some medical items
                 if (currentTreatmentSuitabilities.Any(s => s.Value > cprSuitability))
                 {
@@ -387,7 +392,7 @@ namespace Barotrauma
                         if (Target != character && character.IsOnPlayerTeam)
                         {
                             character.Speak(TextManager.GetWithVariables("DialogListRequiredTreatments",
-                                ("[targetname]", Target.Name, FormatCapitals.No),
+                                ("[targetname]", Target.DisplayName, FormatCapitals.No),
                                 ("[treatmentlist]", itemListStr, FormatCapitals.Yes)).Value,
                                 null, 2.0f, $"listrequiredtreatments{Target.Name}".ToIdentifier(), 60.0f);
                         }
@@ -483,7 +488,7 @@ namespace Barotrauma
             if (IsCompleted && Target != character && character.IsOnPlayerTeam)
             {
                 string textTag = performedCpr ? "DialogTargetResuscitated" : "DialogTargetHealed";
-                string message = TextManager.GetWithVariable(textTag, "[targetname]", Target.Name)?.Value;
+                string message = TextManager.GetWithVariable(textTag, "[targetname]", Target.DisplayName)?.Value;
                 character.Speak(message, delay: 1.0f, identifier: $"targethealed{Target.Name}".ToIdentifier(), minDurationBetweenSimilar: 60.0f);
             }
             return IsCompleted;

Barotrauma/BarotraumaShared/SharedSource/Characters/AI/Objectives/AIObjectiveRescueAll.cs

@@ -47,9 +47,9 @@ namespace Barotrauma
                         if (objectiveManager.GetFirstActiveObjective<AIObjectiveRescue>() == null)
                         {
                             charactersWithMinorInjuries.Add(target);
-                            character.Speak(TextManager.GetWithVariable("dialogignoreminorinjuries", "[targetname]", target.Name).Value,
+                            character.Speak(TextManager.GetWithVariable("dialogignoreminorinjuries", "[targetname]", target.DisplayName).Value,
                                 delay: 1.0f,
-                                identifier: $"notreatableafflictions{target.Name}".ToIdentifier(),
+                                identifier: $"notreatableafflictions{target.DisplayName}".ToIdentifier(),
                                 minDurationBetweenSimilar: 10.0f);
                         }
                     }

Barotrauma/BarotraumaShared/SharedSource/Characters/AI/ShipCommand/ShipIssueWorker.cs

@@ -50,7 +50,8 @@ namespace Barotrauma
             if (OrderedCharacter.AIController is HumanAIController humanAI && 
                 humanAI.ObjectiveManager.CurrentOrders.None(o => o.MatchesOrder(SuggestedOrder.Identifier, Option) && o.TargetEntity == TargetItem))
             {
-                if (orderedCharacter != CommandingCharacter)
+                bool orderGivenByDifferentCharacter = orderedCharacter != CommandingCharacter;
+                if (orderGivenByDifferentCharacter)
                 {
                     CommandingCharacter.Speak(SuggestedOrder.GetChatMessage(OrderedCharacter.Name, "", givingOrderToSelf: false),
                         minDurationBetweenSimilar: 5,
@@ -62,9 +63,12 @@ namespace Barotrauma
                     .WithOrderGiver(CommandingCharacter)
                     .WithManualPriority(CharacterInfo.HighestManualOrderPriority);
                 OrderedCharacter.SetOrder(CurrentOrder, CommandingCharacter != OrderedCharacter);
-                OrderedCharacter.Speak(TextManager.Get("DialogAffirmative").Value, delay: 1.0f,
-                    minDurationBetweenSimilar: 5,
-                    identifier: ("ReceiveOrder." + SuggestedOrder.Prefab.Identifier).ToIdentifier());
+                if (orderGivenByDifferentCharacter)
+                {
+                    OrderedCharacter.Speak(TextManager.Get("DialogAffirmative").Value, delay: 1.0f,
+                        minDurationBetweenSimilar: 5,
+                        identifier: ("ReceiveOrder." + SuggestedOrder.Prefab.Identifier).ToIdentifier());
+                }
             }
             TimeSinceLastAttempt = 0f;
         }

Barotrauma/BarotraumaShared/SharedSource/Characters/AI/Wreck/WreckAI.cs

@@ -5,6 +5,7 @@ using System.Collections.Generic;
 using Barotrauma.Networking;
 using System.Linq;
 using System;
+using System.Diagnostics;
 
 namespace Barotrauma
 {
@@ -89,12 +90,12 @@ namespace Barotrauma
     {
         public bool IsAlive { get; private set; }
 
-        private readonly List<Item> allItems;
         private readonly List<Item> thalamusItems;
         private readonly List<Structure> thalamusStructures;
         private readonly List<WayPoint> wayPoints = new List<WayPoint>();
         private readonly List<Hull> hulls = new List<Hull>();
         private readonly List<Item> spawnOrgans = new List<Item>();
+        private readonly List<Door> jammedDoors = new List<Door>();
         private readonly Item brain;
 
         private bool initialCellsSpawned;
@@ -105,7 +106,7 @@ namespace Barotrauma
 
         private bool IsThalamus(MapEntityPrefab entityPrefab) => IsThalamus(entityPrefab, Config.Entity);
 
-        private static IEnumerable<T> GetThalamusEntities<T>(Submarine wreck, Identifier tag) where T : MapEntity => GetThalamusEntities(wreck, tag).Where(e => e is T).Select(e => e as T);
+        private static IEnumerable<T> GetThalamusEntities<T>(Submarine wreck, Identifier tag) where T : MapEntity => GetThalamusEntities(wreck, tag).OfType<T>();
 
         private static IEnumerable<MapEntity> GetThalamusEntities(Submarine wreck, Identifier tag) => MapEntity.MapEntityList.Where(e => e.Submarine == wreck && e.Prefab != null && IsThalamus(e.Prefab, tag));
 
@@ -122,93 +123,52 @@ namespace Barotrauma
         {
             GetConfig();
             if (Config == null) { return; }
-            var thalamusPrefabs = ItemPrefab.Prefabs.Where(p => IsThalamus(p));
+            var thalamusPrefabs = ItemPrefab.Prefabs.Where(IsThalamus);
             var brainPrefab = thalamusPrefabs.GetRandom(i => i.Tags.Contains(Config.Brain), Rand.RandSync.ServerAndClient);
             if (brainPrefab == null)
             {
-                DebugConsole.ThrowError($"WreckAI: Could not find any brain prefab with the tag {Config.Brain}! Cannot continue. Failed to create wreck AI.");
+                DebugConsole.ThrowError($"WreckAI {wreck.Info.Name}: Could not find any brain prefab with the tag {Config.Brain}! Cannot continue. Failed to create wreck AI.", contentPackage: Config.ContentPackage);
                 return;
             }
-            allItems = wreck.GetItems(false);
-            thalamusItems = allItems.FindAll(i => IsThalamus(((MapEntity)i).Prefab));
-            hulls.AddRange(wreck.GetHulls(false));
-            var potentialBrainHulls = new List<(Hull hull, float weight)>();
+            thalamusItems = GetThalamusEntities<Item>(wreck, Config.Entity).ToList();
+            hulls.AddRange(wreck.GetHulls(alsoFromConnectedSubs: false));
             brain = new Item(brainPrefab, Vector2.Zero, wreck);
             thalamusItems.Add(brain);
             Point minSize = brain.Rect.Size.Multiply(brain.Scale);
-            // Bigger hulls are allowed, but not preferred more than what's sufficent.
-            Vector2 sufficentSize = new Vector2(minSize.X * 2, minSize.Y * 1.1f);
-            // Shrink the horizontal axis so that the brain is not placed in the left or right side, where we often have curved walls.
-            Rectangle shrinkedBounds = ToolBox.GetWorldBounds(wreck.WorldPosition.ToPoint(), new Point(wreck.Borders.Width - 500, wreck.Borders.Height));
-            foreach (Hull hull in hulls)
-            {
-                float distanceFromCenter = Vector2.Distance(wreck.WorldPosition, hull.WorldPosition);
-                float distanceFactor = MathHelper.Lerp(1.0f, 0.5f, MathUtils.InverseLerp(0, Math.Max(shrinkedBounds.Width, shrinkedBounds.Height) / 2, distanceFromCenter));
-                float horizontalSizeFactor = MathHelper.Lerp(0.5f, 1.0f, MathUtils.InverseLerp(minSize.X, sufficentSize.X, hull.Rect.Width));
-                float verticalSizeFactor = MathHelper.Lerp(0.5f, 1.0f, MathUtils.InverseLerp(minSize.Y, sufficentSize.Y, hull.Rect.Height));
-                float weight = verticalSizeFactor * horizontalSizeFactor * distanceFactor;
-                if (hull.GetLinkedEntities<Hull>().Any())
-                {
-                    // Ignore hulls that have any linked hulls to keep the calculations simple.
-                    continue;
-                }
-                else if (hull.ConnectedGaps.Any(g => g.Open > 0 && (!g.IsRoomToRoom || g.Position.Y < hull.Position.Y)))
-                {
-                    // Ignore hulls that have open gaps to outside or below the center point, because we'll want the room to be full of water and not be accessible without breaking the wall.
-                    continue;
-                }
-                else if (thalamusItems.Any(i => i.CurrentHull == hull))
-                {
-                    // Don't create the brain in a room that already has thalamus items inside it.
-                    continue;
-                }
-                else if (hull.Rect.Width < minSize.X || hull.Rect.Height < minSize.Y)
-                {
-                    // Don't select too small rooms.
-                    continue;
-                }
-                if (weight > 0)
-                {
-                    potentialBrainHulls.Add((hull, weight));
-                }
-            }
+            var potentialBrainHulls = GetPotentialBrainRooms(wreck, Config, minSize, thalamusItems);
             Hull brainHull = ToolBox.SelectWeightedRandom(potentialBrainHulls.Select(pbh => pbh.hull).ToList(), potentialBrainHulls.Select(pbh => pbh.weight).ToList(), Rand.RandSync.ServerAndClient);
             var thalamusStructurePrefabs = StructurePrefab.Prefabs.Where(IsThalamus);
             if (brainHull == null)
             {
-                DebugConsole.AddWarning("Wreck AI: Cannot find a proper room for the brain. Using a random room.");
+                DebugConsole.ThrowError($"Wreck AI {wreck.Info.Name}: Cannot find a suitable room for the Thalamus brain. Using a random room. " +
+                                        $"The wreck should be fixed so that there's at least one room where the following conditions are met: No linked hulls, no open gaps in the floor or to outside the sub, and no other Thalamus items present in the hull.",
+                    contentPackage: Config.ContentPackage);
+                
                 brainHull = hulls.GetRandom(Rand.RandSync.ServerAndClient);
             }
             if (brainHull == null)
             {
-                DebugConsole.ThrowError("Wreck AI: Cannot find any room for the brain! Failed to create the Thalamus.");
+                DebugConsole.ThrowError($"Wreck AI {wreck.Info.Name}: Cannot find any room for the brain! Failed to create the Thalamus.", contentPackage: Config.ContentPackage);
                 return;
             }
+            Debug.WriteLine($"Wreck AI {wreck.Info.Name}: Selected brain room: {brainHull.DisplayName}");
             brainHull.WaterVolume = brainHull.Volume;
             brain.SetTransform(brainHull.SimPosition, rotation: 0, findNewHull: false);
             brain.CurrentHull = brainHull;
+            
+            // Jam the doors, mainly to prevent any mechanisms from opening them. Also makes it a little bit more difficult for the player to breach into the brain room, because they now have to break the door.
+            foreach (Door door in brainHull.ConnectedGaps.Select(g => g.ConnectedDoor))
+            {
+                if (door == null) { continue; }
+                door.IsJammed = true;
+                jammedDoors.Add(door);
+            }
+            
             var backgroundPrefab = thalamusStructurePrefabs.GetRandom(i => i.Tags.Contains(Config.BrainRoomBackground), Rand.RandSync.ServerAndClient);
             if (backgroundPrefab != null)
             {
-                new Structure(brainHull.Rect, backgroundPrefab, wreck);
-            }
-            var horizontalWallPrefab = thalamusStructurePrefabs.GetRandom(p => p.Tags.Contains(Config.BrainRoomHorizontalWall), Rand.RandSync.ServerAndClient);
-            if (horizontalWallPrefab != null)
-            {
-                int height = (int)horizontalWallPrefab.Size.Y;
-                int halfHeight = height / 2;
-                int quarterHeight = halfHeight / 2;
-                new Structure(new Rectangle(brainHull.Rect.Left, brainHull.Rect.Top + quarterHeight, brainHull.Rect.Width, height), horizontalWallPrefab, wreck);
-                new Structure(new Rectangle(brainHull.Rect.Left, brainHull.Rect.Top - brainHull.Rect.Height + halfHeight + quarterHeight, brainHull.Rect.Width, height), horizontalWallPrefab, wreck);
-            }
-            var verticalWallPrefab = thalamusStructurePrefabs.GetRandom(p => p.Tags.Contains(Config.BrainRoomVerticalWall), Rand.RandSync.ServerAndClient);
-            if (verticalWallPrefab != null)
-            {
-                int width = (int)verticalWallPrefab.Size.X;
-                int halfWidth = width / 2;
-                int quarterWidth = halfWidth / 2;
-                new Structure(new Rectangle(brainHull.Rect.Left - quarterWidth, brainHull.Rect.Top, width, brainHull.Rect.Height), verticalWallPrefab, wreck);
-                new Structure(new Rectangle(brainHull.Rect.Right - halfWidth - quarterWidth, brainHull.Rect.Top, width, brainHull.Rect.Height), verticalWallPrefab, wreck);
+                var background = new Structure(brainHull.Rect, backgroundPrefab, wreck);
+                background.SpriteDepth -= 0.01f;
             }
             foreach (Item item in thalamusItems)
             {
@@ -360,6 +320,7 @@ namespace Barotrauma
 
         public void Kill()
         {
+            jammedDoors.ForEach(d => d.IsJammed = false);
             thalamusItems.ForEach(i => i.Condition = 0);
             foreach (var turret in turrets)
             {
@@ -376,27 +337,24 @@ namespace Barotrauma
             protectiveCells.ForEach(c => c.OnDeath -= OnCellDeath);
             if (!IsClient)
             {
-                if (Config != null)
+                if (Config is { KillAgentsWhenEntityDies: true })
                 {
-                    if (Config.KillAgentsWhenEntityDies)
+                    protectiveCells.ForEach(c => c.Kill(CauseOfDeathType.Unknown, null));
+                    if (!string.IsNullOrWhiteSpace(Config.OffensiveAgent))
                     {
-                        protectiveCells.ForEach(c => c.Kill(CauseOfDeathType.Unknown, null));
-                        if (!string.IsNullOrWhiteSpace(Config.OffensiveAgent))
+                        foreach (var character in Character.CharacterList)
                         {
-                            foreach (var character in Character.CharacterList)
+                            // Kills ALL offensive agents that are near the thalamus. Not the ideal solution, 
+                            // but as long as spawning is handled via status effects, I don't know if there is any better way.
+                            // In practice there shouldn't be terminal cells from different thalamus organisms at the same time.
+                            // And if there was, the distance check should prevent killing the agents of a different organism.
+                            if (character.SpeciesName == Config.OffensiveAgent)
                             {
-                                // Kills ALL offensive agents that are near the thalamus. Not the ideal solution, 
-                                // but as long as spawning is handled via status effects, I don't know if there is any better way.
-                                // In practice there shouldn't be terminal cells from different thalamus organisms at the same time.
-                                // And if there was, the distance check should prevent killing the agents of a different organism.
-                                if (character.SpeciesName == Config.OffensiveAgent)
+                                // Sonar distance is used also for wreck positioning. No wreck should be closer to each other than this.
+                                float maxDistance = Sonar.DefaultSonarRange;
+                                if (Vector2.DistanceSquared(character.WorldPosition, Submarine.WorldPosition) < maxDistance * maxDistance)
                                 {
-                                    // Sonar distance is used also for wreck positioning. No wreck should be closer to each other than this.
-                                    float maxDistance = Sonar.DefaultSonarRange;
-                                    if (Vector2.DistanceSquared(character.WorldPosition, Submarine.WorldPosition) < maxDistance * maxDistance)
-                                    {
-                                        character.Kill(CauseOfDeathType.Unknown, null);
-                                    }
+                                    character.Kill(CauseOfDeathType.Unknown, null);
                                 }
                             }
                         }
@@ -515,5 +473,62 @@ namespace Barotrauma
             msg.WriteBoolean(IsAlive);
         }
 #endif
+        
+        public static List<(Hull hull, float weight)> GetPotentialBrainRooms(Submarine wreck, WreckAIConfig wreckAI, Point minSize, IEnumerable<Item> thalamusItems = null)
+        {
+            var potentialBrainHulls = new List<(Hull hull, float weight)>();
+            // Bigger hulls are allowed, but not preferred more than what's sufficient.
+            Vector2 sufficientSize = new Vector2(minSize.X * 2, minSize.Y * 1.1f);
+            Rectangle worldBounds = ToolBox.GetWorldBounds(wreck.WorldPosition.ToPoint(), new Point(wreck.Borders.Width, wreck.Borders.Height));
+            thalamusItems ??= GetThalamusEntities<Item>(wreck, wreckAI.Entity);
+            foreach (Hull hull in wreck.GetHulls(alsoFromConnectedSubs: false))
+            {
+                if (hull.GetLinkedEntities<Hull>().Any())
+                {
+                    // Ignore hulls that have any linked hulls to keep the calculations simple.
+                    continue;
+                }
+                else if (hull.ConnectedGaps.Any(g => (g.Open > 0 || g.ConnectedDoor?.Item.Condition <= 0) && (!g.IsRoomToRoom || g.Position.Y < hull.Position.Y)))
+                {
+                    // Ignore hulls that have open gaps to outside or below the center point, because we'll want the room to be full of water and not be accessible without breaking the wall.
+                    // Gaps in the broken doors are not yet open at this stage. Also Door.IsBroken is not yet up-to-date, so we'll have to check the item condition.
+                    continue;
+                }
+                else if (thalamusItems.Any(i => i.CurrentHull == hull && !i.HasTag(Tags.WireItem)))
+                {
+                    // Don't create the brain in a room that already has thalamus items inside it.
+                    continue;
+                }
+                else if (hull.Rect.Width < minSize.X || hull.Rect.Height < minSize.Y)
+                {
+                    // Don't select too small rooms.
+                    continue;
+                }
+                float weight = 0;
+                if (hull.IsAirlock)
+                {
+                    // Prefer something else than airlocks
+                    weight = 0;
+                }
+                else
+                {
+                    float distanceFromCenter = Vector2.Distance(wreck.WorldPosition, hull.WorldPosition);
+                    float distanceFactor = MathHelper.Lerp(1.0f, 0.5f, MathUtils.InverseLerp(0, Math.Max(worldBounds.Width, worldBounds.Height) / 2f, distanceFromCenter));
+                    float horizontalSizeFactor = MathHelper.Lerp(0.5f, 1.0f, MathUtils.InverseLerp(minSize.X, sufficientSize.X, hull.Rect.Width));
+                    float verticalSizeFactor = MathHelper.Lerp(0.5f, 1.0f, MathUtils.InverseLerp(minSize.Y, sufficientSize.Y, hull.Rect.Height));
+                    weight = verticalSizeFactor * horizontalSizeFactor * distanceFactor;
+                }
+                if (weight > 0 || potentialBrainHulls.None())
+                {
+                    potentialBrainHulls.Add((hull, weight));
+                }
+            }
+            Debug.WriteLine($"Wreck AI {wreck.Info.Name}: Potential brain rooms: {potentialBrainHulls.Count}");
+            foreach ((Hull hull, float weight) in potentialBrainHulls)
+            {
+                Debug.WriteLine($"Wreck AI: Potential brain room: {hull.DisplayName}, {weight.FormatSingleDecimal()}");
+            }
+            return potentialBrainHulls;
+        }
     }
 }

Barotrauma/BarotraumaShared/SharedSource/Characters/Animation/AnimController.cs

@@ -921,20 +921,16 @@ namespace Barotrauma
             {
                 isRemote = character.IsRemotelyControlled;
             }
-            if (isRemote)
+            //if the character is remotely controlled,
+            //let the server decide when to deselect the ladder and stop climbing
+            if (!isRemote)
             {
-                if (Math.Abs(targetMovement.X) > 0.05f ||
-                    (TargetMovement.Y < 0.0f && ConvertUnits.ToSimUnits(trigger.Height) + handPos.Y < HeadPosition) || 
-                    (TargetMovement.Y > 0.0f && handPos.Y > 0.1f))
+                if ((character.IsKeyDown(InputType.Left) || character.IsKeyDown(InputType.Right)) &&
+                    (!character.IsKeyDown(InputType.Up) && !character.IsKeyDown(InputType.Down)))
                 {
                     isClimbing = false;
                 }
             }
-            else if ((character.IsKeyDown(InputType.Left) || character.IsKeyDown(InputType.Right)) &&
-                    (!character.IsKeyDown(InputType.Up) && !character.IsKeyDown(InputType.Down)))
-            {
-                isClimbing = false;
-            }
 
             if (!isClimbing)
             {

Barotrauma/BarotraumaShared/SharedSource/Characters/Animation/FishAnimController.cs

@@ -147,20 +147,7 @@ namespace Barotrauma
 
             if (!character.CanMove)
             {
-                levitatingCollider = false;
-                Collider.FarseerBody.FixedRotation = false;
-                if (GameMain.NetworkMember == null || !GameMain.NetworkMember.IsClient)
-                {
-                    Collider.Enabled = false;
-                    Collider.LinearVelocity = mainLimb.LinearVelocity;
-                    Collider.SetTransformIgnoreContacts(mainLimb.SimPosition, mainLimb.Rotation);
-                    //reset pull joints to prevent the character from "hanging" mid-air if pull joints had been active when the character was still moving
-                    //(except when dragging, then we need the pull joints)
-                    if (!Draggable || character.SelectedBy == null)
-                    {
-                        ResetPullJoints();
-                    }
-                }
+                UpdateRagdollControlsMovement();
                 if (character.IsDead && deathAnimTimer < deathAnimDuration)
                 {
                     deathAnimTimer += deltaTime;
@@ -186,11 +173,11 @@ namespace Barotrauma
 
                 if (InWater)
                 {
-                    Collider.SetTransform(new Vector2(Collider.SimPosition.X, MainLimb.SimPosition.Y), 0.0f);
+                    Collider.SetTransformIgnoreContacts(new Vector2(Collider.SimPosition.X, MainLimb.SimPosition.Y), 0.0f);
                 }
                 else
                 {
-                    Collider.SetTransform(new Vector2(
+                    Collider.SetTransformIgnoreContacts(new Vector2(
                         Collider.SimPosition.X,
                         Math.Max(lowestLimb.SimPosition.Y + (Collider.Radius + Collider.Height / 2), Collider.SimPosition.Y)),
                         0.0f);
@@ -995,7 +982,7 @@ namespace Barotrauma
                 if (RagdollParams.IsSpritesheetOrientationHorizontal)
                 {
                     //horizontally aligned limbs need to be flipped 180 degrees
-                    l.body.SetTransform(l.SimPosition, l.body.Rotation + MathHelper.Pi * Dir);
+                    l.body.SetTransformIgnoreContacts(l.SimPosition, l.body.Rotation + MathHelper.Pi * Dir);
 				}
                 //no need to do anything when flipping vertically oriented limbs
                 //the sprite gets flipped horizontally, which does the job

Barotrauma/BarotraumaShared/SharedSource/Characters/Animation/HumanoidAnimController.cs

@@ -296,25 +296,7 @@ namespace Barotrauma
                     fallingProneAnimTimer += deltaTime;
                     UpdateFallingProne(1.0f);
                 }
-                levitatingCollider = false;
-                Collider.FarseerBody.FixedRotation = false;
-                if (GameMain.NetworkMember == null || !GameMain.NetworkMember.IsClient)
-                {
-                    if (Collider.Enabled)
-                    {
-                        //deactivating the collider -> make the main limb inherit the collider's velocity because it'll control the movement now
-                        MainLimb.body.LinearVelocity = Collider.LinearVelocity;
-                        Collider.Enabled = false;
-                    }
-                    Collider.LinearVelocity = MainLimb.LinearVelocity;
-                    Collider.SetTransformIgnoreContacts(MainLimb.SimPosition, MainLimb.Rotation);
-                    //reset pull joints to prevent the character from "hanging" mid-air if pull joints had been active when the character was still moving
-                    //(except when dragging, then we need the pull joints)
-                    if (!Draggable || character.SelectedBy == null)
-                    {
-                        ResetPullJoints();
-                    }
-                }
+                UpdateRagdollControlsMovement();
                 return;
             }
             fallingProneAnimTimer = 0.0f;
@@ -324,7 +306,7 @@ namespace Barotrauma
             {
                 var lowestLimb = FindLowestLimb();
 
-                Collider.SetTransform(new Vector2(
+                Collider.SetTransformIgnoreContacts(new Vector2(
                     Collider.SimPosition.X,
                     Math.Max(lowestLimb.SimPosition.Y + (Collider.Radius + Collider.Height / 2), Collider.SimPosition.Y)),
                     Collider.Rotation);
@@ -356,7 +338,7 @@ namespace Barotrauma
                 float angleDiff = MathUtils.GetShortestAngle(Collider.Rotation, 0.0f);
                 if (Math.Abs(angleDiff) > 0.001f)
                 {
-                    Collider.SetTransform(Collider.SimPosition, Collider.Rotation + angleDiff);
+                    Collider.SetTransformIgnoreContacts(Collider.SimPosition, Collider.Rotation + angleDiff);
                 }
             }
              
@@ -581,9 +563,7 @@ namespace Barotrauma
                 footMid += (Math.Max(Math.Abs(walkPosX) * limpAmount, 0.0f) * Math.Min(Math.Abs(TargetMovement.X), 0.3f)) * Dir;
             }
 
-            movement = overrideTargetMovement == Vector2.Zero ?
-                MathUtils.SmoothStep(movement, TargetMovement, movementLerp) :
-                overrideTargetMovement;
+            movement = overrideTargetMovement ?? MathUtils.SmoothStep(movement, TargetMovement, movementLerp);
 
             if (Math.Abs(movement.X) < 0.005f)
             {

Barotrauma/BarotraumaShared/SharedSource/Characters/Animation/Ragdoll.cs

@@ -112,7 +112,7 @@ namespace Barotrauma
 
         //a movement vector that overrides targetmovement if trying to steer
         //a Character to the position sent by server in multiplayer mode
-        protected Vector2 overrideTargetMovement;
+        protected Vector2? overrideTargetMovement;
 
         protected float floorY, standOnFloorY;
         protected Fixture floorFixture;
@@ -142,6 +142,12 @@ namespace Barotrauma
 
         private Category prevCollisionCategory = Category.None;
 
+        /// <summary>
+        /// When the character is alive/conscious, the collider drives the character's movement and is used to sync the character's position in MP.
+        /// When unconscious, the ragdoll controls the movement and the collider just sticks to the main limb.
+        /// </summary>
+        public bool ColliderControlsMovement => character.CanMove;
+
         public bool IsStuck => Limbs.Any(l => l.IsStuck);
 
         public PhysicsBody Collider
@@ -189,7 +195,7 @@ namespace Barotrauma
                 Vector2 pos = collider[colliderIndex].SimPosition;
                 pos.Y -= collider[colliderIndex].Height * 0.5f;
                 pos.Y += collider[value].Height * 0.5f;
-                collider[value].SetTransform(pos, collider[colliderIndex].Rotation);
+                collider[value].SetTransformIgnoreContacts(pos, collider[colliderIndex].Rotation);
 
                 collider[value].LinearVelocity  = collider[colliderIndex].LinearVelocity;
                 collider[value].AngularVelocity = collider[colliderIndex].AngularVelocity;
@@ -286,7 +292,7 @@ namespace Barotrauma
                     foreach (Limb limb in Limbs)
                     {
                         if (limb.IsSevered || !limb.body.PhysEnabled) { continue; }
-                        limb.body.SetTransform(Collider.SimPosition, Collider.Rotation);
+                        limb.body.SetTransformIgnoreContacts(Collider.SimPosition, Collider.Rotation);
                         //reset pull joints (they may be somewhere far away if the character has moved from the position where animations were last updated)
                         limb.PullJointEnabled = false;
                         limb.PullJointWorldAnchorB = limb.SimPosition;
@@ -301,11 +307,11 @@ namespace Barotrauma
         {
             get 
             { 
-                return (overrideTargetMovement == Vector2.Zero) ? targetMovement : overrideTargetMovement; 
+                return overrideTargetMovement ?? targetMovement; 
             }
             set 
             {
-                if (!MathUtils.IsValid(value)) return;
+                if (!MathUtils.IsValid(value)) { return; }
                 targetMovement.X = MathHelper.Clamp(value.X, -MAX_SPEED, MAX_SPEED);
                 targetMovement.Y = MathHelper.Clamp(value.Y, -MAX_SPEED, MAX_SPEED);
             }
@@ -1307,6 +1313,11 @@ namespace Barotrauma
                 }
             }
 
+            float MaxVel = NetConfig.MaxPhysicsBodyVelocity;
+            Collider.LinearVelocity = new Vector2(
+                NetConfig.Quantize(Collider.LinearVelocity.X, -MaxVel, MaxVel, 12),
+                NetConfig.Quantize(Collider.LinearVelocity.Y, -MaxVel, MaxVel, 12));
+
             if (forceStanding)
             {
                 inWater = false;
@@ -1451,7 +1462,7 @@ namespace Barotrauma
                 else
                 {
                     // Falling -> ragdoll briefly if we are not moving at all, because we are probably stuck.
-                    if (Collider.LinearVelocity == Vector2.Zero)
+                    if (Collider.LinearVelocity == Vector2.Zero && !character.IsRemotePlayer)
                     {
                         character.IsRagdolled = true;
                         if (character.IsBot)
@@ -1466,6 +1477,30 @@ namespace Barotrauma
             forceNotStanding = false;
         }
 
+        /// <summary>
+        /// Update the logic that needs to run when the ragdoll is what controls the character's movement instead of the collider <see cref="ColliderControlsMovement"/>
+        /// (making the collider stick to the ragdoll's main limb).
+        /// </summary>
+        protected void UpdateRagdollControlsMovement()
+        {
+            levitatingCollider = false;
+            Collider.FarseerBody.FixedRotation = false;
+            if (Collider.Enabled)
+            {
+                //deactivating the collider -> make the main limb inherit the collider's velocity because it'll control the movement now
+                MainLimb.body.LinearVelocity = Collider.LinearVelocity;
+                Collider.Enabled = false;
+            }
+            Collider.LinearVelocity = MainLimb.LinearVelocity;
+            Collider.SetTransformIgnoreContacts(MainLimb.SimPosition, MainLimb.Rotation);
+            //reset pull joints to prevent the character from "hanging" mid-air if pull joints had been active when the character was still moving
+            //(except when dragging, then we need the pull joints)
+            if (!Draggable || character.SelectedBy == null)
+            {
+                ResetPullJoints();
+            }            
+        }
+
         private void CheckBodyInRest(float deltaTime)
         {
             if (SimplePhysicsEnabled) { return; }
@@ -2102,7 +2137,7 @@ namespace Barotrauma
         partial void UpdateNetPlayerPositionProjSpecific(float deltaTime, float lowestSubPos);
         private void UpdateNetPlayerPosition(float deltaTime)
         {
-            if (GameMain.NetworkMember == null) return;
+            if (GameMain.NetworkMember == null) { return; }
 
             float lowestSubPos = float.MaxValue;
             if (Submarine.Loaded.Any())

Barotrauma/BarotraumaShared/SharedSource/Characters/Attack.cs

@@ -197,7 +197,22 @@ namespace Barotrauma
         /// <summary>
         /// Used for multiplying all the damage.
         /// </summary>
-        public float DamageMultiplier { get; set; } = 1;
+        public float DamageMultiplier
+        {
+            get => _damageMultiplier ?? initialDamageMultiplier;
+            set
+            {
+                if (!_damageMultiplier.HasValue)
+                {
+                    SetInitialDamageMultiplier(value);
+                }
+                _damageMultiplier = value;
+            }
+        }
+        private float? _damageMultiplier;
+        private float initialDamageMultiplier = 1.0f;
+        public void ResetDamageMultiplier() => _damageMultiplier = initialDamageMultiplier;
+        public void SetInitialDamageMultiplier(float value) => initialDamageMultiplier = value;
 
         /// <summary>
         /// Used for multiplying all the ranges.
@@ -275,6 +290,8 @@ namespace Barotrauma
         [Serialize("0.0, 0.0", IsPropertySaveable.Yes, description: "Applied to the main limb. In world space coordinates(i.e. 0, 1 pushes the character upwards a bit). The attacker's facing direction is taken into account."), Editable]
         public Vector2 RootForceWorldEnd { get; private set; }
 
+        public bool HasRootForce => RootForceWorldStart != Vector2.Zero || RootForceWorldMiddle != Vector2.Zero || RootForceWorldEnd != Vector2.Zero;
+
         [Serialize(TransitionMode.Linear, IsPropertySaveable.Yes, description:"Applied to the main limb. The transition smoothing of the applied force."), Editable]
         public TransitionMode RootTransitionEasing { get; private set; }
 

Barotrauma/BarotraumaShared/SharedSource/Characters/Character.cs

@@ -38,6 +38,8 @@ namespace Barotrauma
         public const float MaxHighlightDistance = 150.0f;
         public const float MaxDragDistance = 200.0f;
 
+        public override ContentPackage ContentPackage => Prefab?.ContentPackage;
+
         partial void UpdateLimbLightSource(Limb limb);
 
         private bool enabled = true;
@@ -666,9 +668,23 @@ namespace Barotrauma
         public bool RequireConsciousnessForCustomInteract = true;
         public bool AllowCustomInteract
         {
-            get { return (!RequireConsciousnessForCustomInteract || (!IsIncapacitated && Stun <= 0.0f)) && !Removed; }
+            get 
+            {
+                if (CampaignMode.HostileFactionDisablesInteraction(CampaignInteractionType) &&
+                    AIController is HumanAIController humanAi && humanAi.IsInHostileFaction())
+                {
+                    return false;
+                }
+
+                return (!RequireConsciousnessForCustomInteract || (!IsIncapacitated && Stun <= 0.0f)) && !Removed;
+            }
         }
 
+        public bool ShouldShowCustomInteractText =>
+            !CustomInteractHUDText.IsNullOrEmpty() &&
+            AllowCustomInteract &&
+            (AIController is not HumanAIController humanAi || humanAi.AllowCampaignInteraction());
+
         private float lockHandsTimer;
         public bool LockHands
         {
@@ -1212,6 +1228,7 @@ namespace Barotrauma
         }
 
         public CampaignMode.InteractionType CampaignInteractionType;
+
         public Identifier MerchantIdentifier;
 
         private bool accessRemovedCharacterErrorShown;
@@ -1265,6 +1282,10 @@ namespace Barotrauma
 
         public bool IsInFriendlySub => Submarine != null && Submarine.TeamID == TeamID;
         public bool IsInPlayerSub => Submarine != null && Submarine.Info.IsPlayer;
+        /// <summary>
+        /// Alias for <see cref="IsInPlayerSub"/>, so the same property name works on both items and characters.
+        /// </summary>
+        public bool InPlayerSubmarine => IsInPlayerSub;
 
         public float AITurretPriority
         {
@@ -1412,7 +1433,7 @@ namespace Barotrauma
             if (characterInfo?.HumanPrefabIds is { } prefabIds &&
                 prefabIds.NpcSetIdentifier != default && prefabIds.NpcIdentifier != default)
             {
-                humanPrefab = NPCSet.Get(
+                HumanPrefab = NPCSet.Get(
                     characterInfo.HumanPrefabIds.NpcSetIdentifier,
                     characterInfo.HumanPrefabIds.NpcIdentifier);
             }
@@ -1765,6 +1786,11 @@ namespace Barotrauma
                 }
             }
 
+            if (this == Controlled && inputType == InputType.Run && ToggleRun)
+            {
+                return true;
+            }
+
             return keys[(int)inputType].Held;
         }
 
@@ -1964,6 +1990,8 @@ namespace Barotrauma
             }
         }
 
+        public bool ToggleRun;
+
         public bool CanRunWhileDragging()
         {
             if (selectedCharacter is not { IsDraggable: true }) { return true; }
@@ -2169,8 +2197,9 @@ namespace Barotrauma
                 SmoothedCursorPosition = cursorPosition - smoothedCursorDiff;
             }
 
-            bool aiControlled = this is AICharacter && Controlled != this && !IsRemotelyControlled;
-            if (!aiControlled)
+            bool aiControlled = this is AICharacter && Controlled != this && !IsRemotePlayer;
+            bool controlledByServer = GameMain.NetworkMember is { IsClient: true } && IsRemotelyControlled;
+            if (!aiControlled && !controlledByServer)
             {
                 Vector2 targetMovement = GetTargetMovement();
                 AnimController.TargetMovement = targetMovement;
@@ -2199,7 +2228,8 @@ namespace Barotrauma
                 {
                     AnimController.TargetDir = Direction.Right;
                 }
-                else
+                //only humanoids' flipping is controlled by the cursor, monster flipping is driven by their movement in FishAnimController
+                else if (AnimController is HumanoidAnimController)
                 {
                     if (CursorPosition.X < AnimController.Collider.Position.X - cursorFollowMargin)
                     {
@@ -2262,15 +2292,9 @@ namespace Barotrauma
             }
             else if (IsKeyDown(InputType.Attack))
             {
-                if (GameMain.NetworkMember != null && GameMain.NetworkMember.IsClient && Controlled != this)
-                {
-                    if ((currentAttackTarget.DamageTarget as Entity)?.Removed ?? false)
-                    {
-                        currentAttackTarget = default;
-                    }
-                    currentAttackTarget.AttackLimb?.UpdateAttack(deltaTime, currentAttackTarget.AttackPos, currentAttackTarget.DamageTarget, out _);
-                }
-                else if (IsPlayer)
+                //normally the attack target, where to aim the attack and such is handled by EnemyAIController,
+                //but in the case of player-controlled monsters, we handle it here
+                if (IsPlayer)
                 {
                     float dist = -1;
                     Vector2 attackPos = SimPosition + ConvertUnits.ToSimUnits(cursorPosition - Position);
@@ -2315,13 +2339,16 @@ namespace Barotrauma
                         }
                     }
                     var currentContexts = GetAttackContexts();
-                    var validLimbs = AnimController.Limbs.Where(l =>
+                    var attackLimbs = AnimController.Limbs.Where(static l => l.attack != null);
+                    bool hasAttacksWithoutRootForce = attackLimbs.Any(static l=> !l.attack.HasRootForce);
+                    var validLimbs = attackLimbs.Where(l =>
                     {
                         if (l.IsSevered || l.IsStuck) { return false; }
                         if (l.Disabled) { return false; }
                         var attack = l.attack;
-                        if (attack == null) { return false; }
                         if (attack.CoolDownTimer > 0) { return false; }
+                        //disallow attacks with root force if there's any other attacks available
+                        if (hasAttacksWithoutRootForce && attack.HasRootForce) { return false; }
                         if (!attack.IsValidContext(currentContexts)) { return false; }
                         if (attackTarget != null)
                         {
@@ -2359,6 +2386,14 @@ namespace Barotrauma
                         }
                     }
                 }
+                else if (GameMain.NetworkMember is { IsClient: true } && Controlled != this)
+                {
+                    if (currentAttackTarget.DamageTarget is Entity { Removed: true })
+                    {
+                        currentAttackTarget = default;
+                    }
+                    currentAttackTarget.AttackLimb?.UpdateAttack(deltaTime, currentAttackTarget.AttackPos, currentAttackTarget.DamageTarget, out _);
+                }
             }
 
             if (Inventory != null)
@@ -2479,119 +2514,11 @@ namespace Barotrauma
             seeingEntity ??= AnimController.SimplePhysicsEnabled ? this : GetSeeingLimb();
             if (target is Character targetCharacter)
             {
-                return IsCharacterVisible(targetCharacter, seeingEntity, seeThroughWindows, checkFacing);
+                return ISpatialEntity.IsCharacterVisible(targetCharacter, seeingEntity, seeThroughWindows, checkFacing);
             }
             else
             {
-                return CheckVisibility(target, seeingEntity, seeThroughWindows, checkFacing);
-            }
-        }
-
-        public static bool IsTargetVisible(ISpatialEntity target, ISpatialEntity seeingEntity, bool seeThroughWindows = false, bool checkFacing = false)
-        {
-            if (seeingEntity is Character seeingCharacter)
-            {
-                return seeingCharacter.CanSeeTarget(target, seeThroughWindows: seeThroughWindows, checkFacing: checkFacing);
-            }
-            if (target is Character targetCharacter)
-            {
-                return IsCharacterVisible(targetCharacter, seeingEntity, seeThroughWindows, checkFacing);
-            }
-            else
-            {
-                return CheckVisibility(target, seeingEntity, seeThroughWindows, checkFacing);
-            }
-        }
-
-        private static bool IsCharacterVisible(Character target, ISpatialEntity seeingEntity, bool seeThroughWindows = false, bool checkFacing = false)
-        {
-            System.Diagnostics.Debug.Assert(target != null);
-            if (target == null || target.Removed) { return false; }
-            if (seeingEntity == null) { return false; }
-            if (CheckVisibility(target, seeingEntity, seeThroughWindows, checkFacing)) { return true; }
-            if (!target.AnimController.SimplePhysicsEnabled)
-            {
-                //find the limbs that are furthest from the target's position (from the viewer's point of view)
-                Limb leftExtremity = null, rightExtremity = null;
-                float leftMostDot = 0.0f, rightMostDot = 0.0f;
-                Vector2 dir = target.WorldPosition - seeingEntity.WorldPosition;
-                Vector2 leftDir = new Vector2(dir.Y, -dir.X);
-                Vector2 rightDir = new Vector2(-dir.Y, dir.X);
-                foreach (Limb limb in target.AnimController.Limbs)
-                {
-                    if (limb.IsSevered || limb == target.AnimController.MainLimb) { continue; }
-                    if (limb.Hidden) { continue; }
-                    Vector2 limbDir = limb.WorldPosition - seeingEntity.WorldPosition;
-                    float leftDot = Vector2.Dot(limbDir, leftDir);
-                    if (leftDot > leftMostDot)
-                    {
-                        leftMostDot = leftDot;
-                        leftExtremity = limb;
-                        continue;
-                    }
-                    float rightDot = Vector2.Dot(limbDir, rightDir);
-                    if (rightDot > rightMostDot)
-                    {
-                        rightMostDot = rightDot;
-                        rightExtremity = limb;
-                        continue;
-                    }
-                }
-                if (leftExtremity != null && CheckVisibility(leftExtremity, seeingEntity, seeThroughWindows, checkFacing)) { return true; }
-                if (rightExtremity != null && CheckVisibility(rightExtremity, seeingEntity, seeThroughWindows, checkFacing)) { return true; }
-            }
-            return false;
-        }
-
-        private static bool CheckVisibility(ISpatialEntity target, ISpatialEntity seeingEntity, bool seeThroughWindows = true, bool checkFacing = false)
-        {
-            System.Diagnostics.Debug.Assert(target != null);
-            if (target == null) { return false; }
-            if (seeingEntity == null) { return false; }
-            // TODO: Could we just use the method below? If not, let's refactor it so that we can.
-            Vector2 diff = ConvertUnits.ToSimUnits(target.WorldPosition - seeingEntity.WorldPosition);
-            if (checkFacing && seeingEntity is Character seeingCharacter)
-            {
-                if (Math.Sign(diff.X) != seeingCharacter.AnimController.Dir) { return false; }
-            }
-            //both inside the same sub (or both outside)
-            //OR the we're inside, the other character outside
-            if (target.Submarine == seeingEntity.Submarine || target.Submarine == null)
-            {
-                return Submarine.CheckVisibility(seeingEntity.SimPosition, seeingEntity.SimPosition + diff, blocksVisibilityPredicate: IsBlocking) == null;
-            }
-            //we're outside, the other character inside
-            else if (seeingEntity.Submarine == null)
-            {
-                return Submarine.CheckVisibility(target.SimPosition, target.SimPosition - diff, blocksVisibilityPredicate: IsBlocking) == null;
-            }
-            //both inside different subs
-            else
-            {
-                return 
-                    Submarine.CheckVisibility(seeingEntity.SimPosition, seeingEntity.SimPosition + diff, blocksVisibilityPredicate: IsBlocking) == null &&
-                    Submarine.CheckVisibility(target.SimPosition, target.SimPosition - diff, blocksVisibilityPredicate: IsBlocking) == null;                
-            }
-
-            bool IsBlocking(Fixture f)
-            {
-                var body = f.Body;
-                if (body == null) { return false; }
-                if (body.UserData is Structure wall)
-                {
-                    if (!wall.CastShadow && seeThroughWindows) { return false; }
-                    return wall != target;
-                }
-                else if (body.UserData is Item item)
-                {
-                    if (item.GetComponent<Door>() is { HasWindow: true } door && seeThroughWindows)
-                    {
-                        if (door.IsPositionOnWindow(ConvertUnits.ToDisplayUnits(Submarine.LastPickedPosition))) { return false; }
-                    }
-
-                    return item != target;
-                }
-                return true;
+                return ISpatialEntity.CheckVisibility(target, seeingEntity, seeThroughWindows, checkFacing);
             }
         }
 
@@ -2740,7 +2667,7 @@ namespace Barotrauma
         public bool CanBeDraggedBy(Character character)
         {
             if (!IsDraggable) { return false; }
-            return IsKnockedDown || LockHands || IsPet || (IsBot && character.TeamID == TeamID);
+            return IsKnockedDown || LockHands || (IsPet && character.IsFriendly(this)) || (IsBot && character.TeamID == TeamID);
         }
         
         /// <summary>
@@ -3669,7 +3596,12 @@ namespace Barotrauma
                 { 
                     humanAnimController.Crouching = false; 
                 }
-                if (IsRagdolled) { AnimController.IgnorePlatforms = true; }
+                //ragdolling manually makes the character go through platforms
+                //EXCEPT for clients, they rely on the server telling whether platforms should be ignored or not
+                if (IsRagdolled && GameMain.NetworkMember is not { IsClient: true }) 
+                { 
+                    AnimController.IgnorePlatforms = true; 
+                }
                 AnimController.ResetPullJoints();
                 SelectedItem = SelectedSecondaryItem = null;
                 return;
@@ -4121,6 +4053,7 @@ namespace Barotrauma
                                 if (character.TeamID != TeamID) { continue; }
                                 if (character.AIController is not HumanAIController) { continue; }
                                 if (!HumanAIController.IsActive(character)) { continue; }
+                                if (character.Info == null) { continue; }
                                 foreach (var currentOrder in character.CurrentOrders)
                                 {
                                     if (currentOrder == null) { continue; }
@@ -4136,12 +4069,15 @@ namespace Barotrauma
                         case OrderCategory.Movement:
                             // If there character has another movement order, dismiss that order
                             Order orderToReplace = null;
-                            foreach (var currentOrder in CurrentOrders)
+                            if (CurrentOrders != null)
                             {
-                                if (currentOrder == null) { continue; }
-                                if (currentOrder.Category != OrderCategory.Movement) { continue; }
-                                orderToReplace = currentOrder;
-                                break;
+                                foreach (var currentOrder in CurrentOrders)
+                                {
+                                    if (currentOrder == null) { continue; }
+                                    if (currentOrder.Category != OrderCategory.Movement) { continue; }
+                                    orderToReplace = currentOrder;
+                                    break;
+                                }
                             }
                             if (orderToReplace is { AutoDismiss: true })
                             {
@@ -4177,6 +4113,7 @@ namespace Barotrauma
 
         private void AddCurrentOrder(Order newOrder)
         {
+            if (CurrentOrders == null) { return; }
             if (newOrder == null || newOrder.Identifier == "dismissed")
             {
                 if (newOrder.Option != Identifier.Empty)
@@ -4218,9 +4155,9 @@ namespace Barotrauma
             }
         }
 
-        private bool RemoveDuplicateOrders(Order order)
+        private void RemoveDuplicateOrders(Order order)
         {
-            bool removed = false;
+            if (CurrentOrders == null) { return; }
             int? priorityOfRemoved = null;
             for (int i = CurrentOrders.Count - 1; i >= 0; i--)
             {
@@ -4229,12 +4166,11 @@ namespace Barotrauma
                 {
                     priorityOfRemoved = orderInfo.ManualPriority;
                     CurrentOrders.RemoveAt(i);
-                    removed = true;
                     break;
                 }
             }
 
-            if (!priorityOfRemoved.HasValue) { return removed; }
+            if (!priorityOfRemoved.HasValue) { return; }
 
             for (int i = 0; i < CurrentOrders.Count; i++)
             {
@@ -4245,11 +4181,9 @@ namespace Barotrauma
                 }
             }
 
-            CurrentOrders.RemoveAll(order => order.ManualPriority <= 0);
+            CurrentOrders.RemoveAll(o => o.ManualPriority <= 0);
             // Sort the current orders so the one with the highest priority comes first
             CurrentOrders.Sort((x, y) => y.ManualPriority.CompareTo(x.ManualPriority));
-
-            return removed;
         }
 
         public Order GetCurrentOrderWithTopPriority()
@@ -4334,6 +4268,30 @@ namespace Barotrauma
             aiChatMessageQueue.Add(new AIChatMessage(message, messageType, identifier, delay));
         }
 
+#if CLIENT
+        public void SendSinglePlayerMessage(AIChatMessage message, bool canUseRadio, WifiComponent radio)
+        {
+            if (message.MessageType == null)
+            {
+                message.MessageType = canUseRadio ? ChatMessageType.Radio : ChatMessageType.Default;
+            }
+            if (GameMain.GameSession?.CrewManager is { IsSinglePlayer: true } crewManager)
+            {
+                string modifiedMessage = ChatMessage.ApplyDistanceEffect(message.Message, message.MessageType.Value, this, Controlled);
+                if (!string.IsNullOrEmpty(modifiedMessage))
+                {
+                    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);
+                }
+            }
+            ShowSpeechBubble(ChatMessage.MessageColor[(int)message.MessageType.Value], message.Message);
+        }
+#endif
+
         private void UpdateAIChatMessages(float deltaTime)
         {
             if (GameMain.NetworkMember != null && GameMain.NetworkMember.IsClient) { return; }
@@ -4350,28 +4308,13 @@ namespace Barotrauma
                     message.MessageType = canUseRadio ? ChatMessageType.Radio : ChatMessageType.Default;
                 }
 #if CLIENT
-                if (GameMain.GameSession?.CrewManager != null && GameMain.GameSession.CrewManager.IsSinglePlayer)
-                {
-                    string modifiedMessage = ChatMessage.ApplyDistanceEffect(message.Message, message.MessageType.Value, this, Controlled);
-                    if (!string.IsNullOrEmpty(modifiedMessage))
-                    {
-                        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);
-                    }
-                }
+                SendSinglePlayerMessage(message, canUseRadio, radio);
 #endif
 #if SERVER
                 if (GameMain.Server != null && message.MessageType != ChatMessageType.Order)
                 {
                     GameMain.Server.SendChatMessage(message.Message, message.MessageType.Value, null, this);
                 }
-#endif
-#if CLIENT
-                ShowSpeechBubble(ChatMessage.MessageColor[(int)message.MessageType.Value], message.Message);
 #endif
                 sentMessages.Add(message);
             }
@@ -4451,10 +4394,12 @@ namespace Barotrauma
             {
                 attackAfflictions = attack.Afflictions.Keys;
             }
-
+            
+            float damageMultiplier = attack.DamageMultiplier * attackData.DamageMultiplier;
+            
             var attackResult = targetLimb == null ?
-                AddDamage(worldPosition, attackAfflictions, attack.Stun, playSound, attackImpulse, out limbHit, attacker, attack.DamageMultiplier * attackData.DamageMultiplier) :
-                DamageLimb(worldPosition, targetLimb, attackAfflictions, attack.Stun, playSound, attackImpulse, attacker, attack.DamageMultiplier * attackData.DamageMultiplier, penetration: penetration + attackData.AddedPenetration, shouldImplode: attackData.ShouldImplode);
+                AddDamage(worldPosition, attackAfflictions, attack.Stun, playSound, attackImpulse, out limbHit, attacker, damageMultiplier) :
+                DamageLimb(worldPosition, targetLimb, attackAfflictions, attack.Stun, playSound, attackImpulse, attacker, damageMultiplier, penetration: penetration + attackData.AddedPenetration, shouldImplode: attackData.ShouldImplode);
 
             if (attacker != null)
             {
@@ -5337,7 +5282,7 @@ namespace Barotrauma
         {
             SpawnInventoryItemsRecursive(inventory, itemData, new List<Item>());
         }
-
+        
         private void SpawnInventoryItemsRecursive(Inventory inventory, ContentXElement element, List<Item> extraDuffelBags)
         {
             foreach (var itemElement in element.Elements())
@@ -5352,8 +5297,8 @@ namespace Barotrauma
                 }
 #if SERVER
                 newItem.GetComponent<Terminal>()?.SyncHistory();
-                if (newItem.GetComponent<WifiComponent>() is WifiComponent wifiComponent) { newItem.CreateServerEvent(wifiComponent); }
                 if (newItem.GetComponent<GeneticMaterial>() is GeneticMaterial geneticMaterial) { newItem.CreateServerEvent(geneticMaterial); }
+                SyncInGameEditables(newItem);
 #endif
                 int[] slotIndices = itemElement.GetAttributeIntArray("i", new int[] { 0 });
                 if (!slotIndices.Any())
@@ -5576,7 +5521,7 @@ namespace Barotrauma
         /// <summary>
         /// Removes the talents the character has unlocked in their talent tree.
         /// </summary>
-        public void ResetTalents(bool applyXpPenalty)
+        public void ResetTalents(int talentPointReduction)
         {
             characterTalents.Clear();
             abilityResistances.Clear();
@@ -5584,13 +5529,17 @@ namespace Barotrauma
             CharacterHealth.RemoveAfflictions(affliction => affliction.Prefab.AfflictionType == Tags.AfflictionTypeTalentBuff);
             statValues.Clear();
 
-            if (applyXpPenalty)
+            for (int i = 0; i < talentPointReduction; i++)
             {
                 int currentLevel = info.GetCurrentLevel();
                 if (currentLevel > 0)
                 {
                     info.SetExperience(info.ExperiencePoints - CharacterInfo.ExperienceRequiredPerLevel(currentLevel));
                 }
+                else
+                {
+                    break;
+                }
             }
         }
 
@@ -5945,7 +5894,7 @@ namespace Barotrauma
             }
 
             // NOTE: Resistance is handled as a multiplier here, so 1.0 == 0% resistance
-            return hadResistance ? resistance : 1f;
+            return hadResistance ? Math.Max(0, resistance) : 1f;
         }
 
         public float GetAbilityResistance(AfflictionPrefab affliction)
@@ -5964,7 +5913,7 @@ namespace Barotrauma
             }
 
             // NOTE: Resistance is handled as a multiplier here, so 1.0 == 0% resistance
-            return hadResistance ? resistance : 1f;
+            return hadResistance ? Math.Max(0, resistance) : 1f;
         }
 
         public void ChangeAbilityResistance(TalentResistanceIdentifier identifier, float value)
@@ -6001,7 +5950,7 @@ namespace Barotrauma
                 // NPCs are friendly to the same team and the friendly NPCs
                 CharacterTeamType.Team1 or CharacterTeamType.Team2 => otherTeam == CharacterTeamType.FriendlyNPC,
                 // Friendly NPCs are friendly to both player teams
-                CharacterTeamType.FriendlyNPC => otherTeam == CharacterTeamType.Team1 || otherTeam == CharacterTeamType.Team2,
+                CharacterTeamType.FriendlyNPC => otherTeam is CharacterTeamType.Team1 or CharacterTeamType.Team2,
                 // None (bandits and such) consider friendly NPCs friendly, not attacking them unless they attack first
                 // Otherwise bandits would for example attach the hostages.
                 CharacterTeamType.None => otherTeam == CharacterTeamType.FriendlyNPC,

Barotrauma/BarotraumaShared/SharedSource/Characters/CharacterInfo.cs

@@ -1282,7 +1282,7 @@ namespace Barotrauma
 
         partial void LoadAttachmentSprites();
         
-        public int CalculateSalary()
+        public int CalculateSalary(int baseSalary = 0, float salaryMultiplier = 1.0f)
         {
             if (Name == null || Job == null) { return 0; }
 
@@ -1292,7 +1292,7 @@ namespace Barotrauma
                 salary += (int)(skill.Level * skill.PriceMultiplier);
             }
 
-            return (int)(salary * Job.Prefab.PriceMultiplier);
+            return (int)(baseSalary + (salary * Job.Prefab.PriceMultiplier * salaryMultiplier));
         }
 
         /// <summary>
@@ -1485,11 +1485,9 @@ namespace Barotrauma
             //e.g. talents from endocrine booster or extra talents some special NPC has
             var talentsFromOutsideTree = GetUnlockedTalentsOutsideTree().ToList();
 
-            bool applyXpPenalty = talentResetCount > 0;
-
             UnlockedTalents.Clear();
             SavedStatValues.Clear();
-            Character?.ResetTalents(applyXpPenalty);
+            Character?.ResetTalents(talentPointReduction: talentResetCount);
             TalentRefundPoints--;
             talentResetCount++;
 

Barotrauma/BarotraumaShared/SharedSource/Characters/CharacterNetworking.cs

@@ -14,24 +14,29 @@ namespace Barotrauma
 
         public readonly AnimController.Animation Animation;
 
-        public CharacterStateInfo(Vector2 pos, float? rotation, Vector2 velocity, float? angularVelocity, float time, Direction dir, Character selectedCharacter, Item selectedItem, Item selectedSecondaryItem, AnimController.Animation animation = AnimController.Animation.None)
-            : this(pos, rotation, velocity, angularVelocity, 0, time, dir, selectedCharacter, selectedItem, selectedSecondaryItem, animation)
+        public bool IgnorePlatforms;
+
+        public readonly Vector2 TargetMovement;
+
+        public CharacterStateInfo(Vector2 pos, float? rotation, Vector2 velocity, float? angularVelocity, float time, Direction dir, Character selectedCharacter, Item selectedItem, Item selectedSecondaryItem, Vector2 targetMovement, AnimController.Animation animation = AnimController.Animation.None, bool ignorePlatforms = false)
+            : this(pos, rotation, velocity, angularVelocity, 0, time, dir, selectedCharacter, selectedItem, selectedSecondaryItem, targetMovement, animation, ignorePlatforms)
         {
         }
 
-        public CharacterStateInfo(Vector2 pos, float? rotation, UInt16 ID, Direction dir, Character selectedCharacter, Item selectedItem, Item selectedSecondaryItem, AnimController.Animation animation = AnimController.Animation.None)
-            : this(pos, rotation, Vector2.Zero, 0.0f, ID, 0.0f, dir, selectedCharacter, selectedItem, selectedSecondaryItem, animation)
+        public CharacterStateInfo(Vector2 pos, float? rotation, UInt16 ID, Direction dir, Character selectedCharacter, Item selectedItem, Item selectedSecondaryItem, Vector2 targetMovement, AnimController.Animation animation = AnimController.Animation.None, bool ignorePlatforms = false)
+            : this(pos, rotation, Vector2.Zero, 0.0f, ID, 0.0f, dir, selectedCharacter, selectedItem, selectedSecondaryItem, targetMovement, animation, ignorePlatforms)
         {
         }
 
-        protected CharacterStateInfo(Vector2 pos, float? rotation, Vector2 velocity, float? angularVelocity, UInt16 ID, float time, Direction dir, Character selectedCharacter, Item selectedItem, Item selectedSecondaryItem, AnimController.Animation animation = AnimController.Animation.None)
+        protected CharacterStateInfo(Vector2 pos, float? rotation, Vector2 velocity, float? angularVelocity, UInt16 ID, float time, Direction dir, Character selectedCharacter, Item selectedItem, Item selectedSecondaryItem, Vector2 targetMovement, AnimController.Animation animation = AnimController.Animation.None, bool ignorePlatforms = false)
             : base(pos, rotation, velocity, angularVelocity, ID, time)
         {
             Direction = dir;
             SelectedCharacter = selectedCharacter;
             SelectedItem = selectedItem;
             SelectedSecondaryItem = selectedSecondaryItem;
-
+            IgnorePlatforms = ignorePlatforms;
+            TargetMovement = targetMovement;
             Animation = animation;
         }
     }

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

@@ -398,7 +398,7 @@ namespace Barotrauma
                 public readonly float MinValue;
 
                 /// <summary>
-                /// Minimum value to apply
+                /// Maximum value to apply
                 /// </summary>
                 public readonly float MaxValue;
 
@@ -764,6 +764,12 @@ namespace Barotrauma
         /// </summary>
         public readonly float TreatmentThreshold;
 
+        /// <summary>
+        /// How strong the affliction needs to be for treatment suggestions to be shown in the health interface.
+        /// Defaults to <see cref="TreatmentThreshold"/>.
+        /// </summary>
+        public readonly float TreatmentSuggestionThreshold;
+
         /// <summary>
         /// Bots will not try to treat the affliction if the character has any of these afflictions
         /// </summary>
@@ -941,6 +947,7 @@ namespace Barotrauma
             ShowInHealthScannerThreshold = element.GetAttributeFloat(nameof(ShowInHealthScannerThreshold), 
                 Math.Max(ActivationThreshold, AfflictionType == "talentbuff" ? float.MaxValue : ShowIconToOthersThreshold));
             TreatmentThreshold = element.GetAttributeFloat(nameof(TreatmentThreshold), Math.Max(ActivationThreshold, 10.0f));
+            TreatmentSuggestionThreshold = element.GetAttributeFloat(nameof(TreatmentSuggestionThreshold), TreatmentThreshold);
 
             DamageOverlayAlpha  = element.GetAttributeFloat(nameof(DamageOverlayAlpha), 0.0f);
             BurnOverlayAlpha    = element.GetAttributeFloat(nameof(BurnOverlayAlpha), 0.0f);

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

@@ -1198,7 +1198,11 @@ namespace Barotrauma
         /// </summary>
         /// <param name="treatmentSuitability">A dictionary where the key is the identifier of the item and the value the suitability</param>
         /// <param name="predictFutureDuration">If above 0, the method will take into account how much currently active status effects while affect the afflictions in the next x seconds.</param>   
-        public void GetSuitableTreatments(Dictionary<Identifier, float> treatmentSuitability, Character user, Limb limb = null, bool ignoreHiddenAfflictions = false, float predictFutureDuration = 0.0f)
+        /// <param name="checkTreatmentThreshold">Should the method check whether the afflictions are above <see cref="AfflictionPrefab.TreatmentThreshold"/> (whether they're severe enough for AI to treat)?</param>
+        /// <param name="checkTreatmentSuggestionThreshold">Should the method check whether the afflictions are above <see cref="AfflictionPrefab.TreatmentSuggestionThreshold"/> (whether treatment suggestions are shown in the health interface)?</param>
+        public void GetSuitableTreatments(Dictionary<Identifier, float> treatmentSuitability, Character user, Limb limb = null, bool ignoreHiddenAfflictions = false,
+            bool checkTreatmentThreshold = true, bool checkTreatmentSuggestionThreshold = true, 
+            float predictFutureDuration = 0.0f)
         {
             //key = item identifier
             //float = suitability
@@ -1249,7 +1253,14 @@ namespace Barotrauma
                         //if this a suitable treatment, ignore it if the affliction isn't severe enough to treat
                         //if the suitability is negative though, we need to take it into account!
                         //otherwise we may end up e.g. giving too much opiates to someone already close to overdosing
-                        if (totalAfflictionStrength < affliction.Prefab.TreatmentThreshold) { continue; }
+                        if (checkTreatmentThreshold)
+                        {
+                            if (totalAfflictionStrength < affliction.Prefab.TreatmentThreshold) { continue; }
+                        }
+                        if (checkTreatmentSuggestionThreshold)
+                        {
+                            if (totalAfflictionStrength < affliction.Prefab.TreatmentSuggestionThreshold) { continue; }
+                        }
                     }
                     if (treatment.Value > strength)
                     {

Barotrauma/BarotraumaShared/SharedSource/Characters/HumanPrefab.cs

@@ -33,6 +33,12 @@ namespace Barotrauma
         [Serialize(0, IsPropertySaveable.No)]
         public int ExperiencePoints { get; private set; }
 
+        [Serialize(0, IsPropertySaveable.No)]
+        public int BaseSalary { get; private set; }
+
+        [Serialize(1f, IsPropertySaveable.No)]
+        public float SalaryMultiplier { get; private set; }
+
         private readonly HashSet<Identifier> tags = new HashSet<Identifier>();
 
         [Serialize("", IsPropertySaveable.Yes)]
@@ -247,8 +253,8 @@ namespace Barotrauma
                     float newSkill = skill.Level * SkillMultiplier;
                     skill.IncreaseSkill(newSkill - skill.Level, increasePastMax: false);
                 }
-                characterInfo.Salary = characterInfo.CalculateSalary();
             }
+            characterInfo.Salary = characterInfo.CalculateSalary(BaseSalary, SalaryMultiplier);
             characterInfo.HumanPrefabIds = (NpcSetIdentifier, Identifier);
             characterInfo.GiveExperience(ExperiencePoints);
             return characterInfo;

Barotrauma/BarotraumaShared/SharedSource/Characters/Jobs/SkillPrefab.cs

@@ -19,7 +19,7 @@ namespace Barotrauma
         public SkillPrefab(ContentXElement element) 
         {
             Identifier = element.GetAttributeIdentifier("identifier", "");
-            PriceMultiplier = element.GetAttributeFloat("pricemultiplier", 25.0f);
+            PriceMultiplier = element.GetAttributeFloat("pricemultiplier", 15.0f);
             levelRange = GetSkillRange("level", element, defaultValue: new Range<float>(0, 0));
             levelRangePvP = GetSkillRange("pvplevel", element, defaultValue: levelRange);
             IsPrimarySkill = element.GetAttributeBool("primary", false);

Barotrauma/BarotraumaShared/SharedSource/Characters/Limb.cs

@@ -213,7 +213,9 @@ namespace Barotrauma
         public readonly Ragdoll ragdoll;
         public readonly LimbParams Params;
 
-        //the physics body of the limb
+        /// <summary>
+        /// The physics body of the limb
+        /// </summary>
         public PhysicsBody body;
 
         public Vector2 StepOffset => ConvertUnits.ToSimUnits(Params.StepOffset) * ragdoll.RagdollParams.JointScale;
@@ -528,6 +530,9 @@ namespace Barotrauma
 
         public readonly List<WearableSprite> WearingItems = new List<WearableSprite>();
 
+        /// <summary>
+        /// Other wearables attached to the head. I.e. husk sprite, hair, beard, moustache, and face attachments.
+        /// </summary>
         public readonly List<WearableSprite> OtherWearables = new List<WearableSprite>();
 
         public bool PullJointEnabled
@@ -721,7 +726,7 @@ namespace Barotrauma
                             var attackElement = character.Params.VariantFile.GetRootExcludingOverride().GetChildElement("attack");
                             if (attackElement != null)
                             {
-                                attack.DamageMultiplier = attackElement.GetAttributeFloat("damagemultiplier", 1f);
+                                attack.SetInitialDamageMultiplier(attackElement.GetAttributeFloat("damagemultiplier", 1f));
                                 attack.RangeMultiplier = attackElement.GetAttributeFloat("rangemultiplier", 1f);
                                 attack.ImpactMultiplier = attackElement.GetAttributeFloat("impactmultiplier", 1f);
                             }
@@ -1014,7 +1019,6 @@ namespace Barotrauma
             float dist = distance > -1 ? distance : ConvertUnits.ToDisplayUnits(Vector2.Distance(simPos, attackSimPos));
             bool wasRunning = attack.IsRunning;
             attack.UpdateAttackTimer(deltaTime, character);
-            attack.DamageMultiplier = 1.0f + character.GetStatValue(attack.Ranged ? StatTypes.NaturalRangedAttackMultiplier : StatTypes.NaturalMeleeAttackMultiplier);
             
             if (attack.Blink)
             {
@@ -1164,7 +1168,7 @@ namespace Barotrauma
                 // Set the main collider where the body lands after the attack
                 if (Vector2.DistanceSquared(character.AnimController.Collider.SimPosition, character.AnimController.MainLimb.body.SimPosition) > 0.1f * 0.1f)
                 {
-                    character.AnimController.Collider.SetTransform(character.AnimController.MainLimb.body.SimPosition, rotation: character.AnimController.Collider.Rotation);
+                    character.AnimController.Collider.SetTransformIgnoreContacts(character.AnimController.MainLimb.body.SimPosition, rotation: character.AnimController.Collider.Rotation);
                 }
             }
             return wasHit;
@@ -1180,9 +1184,11 @@ namespace Barotrauma
                 LastAttackSoundTime = SoundInterval;
             }
 #endif
-            if (damageTarget is Character targetCharacter && targetLimb != null)
-            {
-                attackResult = attack.DoDamageToLimb(character, targetLimb, WorldPosition, 1.0f, playSound, body, this);
+            attack.ResetDamageMultiplier();
+            attack.DamageMultiplier *= 1.0f + character.GetStatValue(attack.Ranged ? StatTypes.NaturalRangedAttackMultiplier : StatTypes.NaturalMeleeAttackMultiplier);
+            if (damageTarget is Character && targetLimb != null)
+            { 
+                attackResult = attack.DoDamageToLimb(character, targetLimb, WorldPosition, deltaTime: 1.0f, playSound, body, sourceLimb: this);
             }
             else
             {
@@ -1192,7 +1198,7 @@ namespace Barotrauma
                 }
                 else
                 {
-                    attackResult = attack.DoDamage(character, damageTarget, WorldPosition, 1.0f, playSound, body, this);
+                    attackResult = attack.DoDamage(character, damageTarget, WorldPosition, deltaTime: 1.0f, playSound, body, sourceLimb: this);
                 }
             }
             /*if (structureBody != null && attack.StickChance > Rand.Range(0.0f, 1.0f, Rand.RandSync.ServerAndClient))

Barotrauma/BarotraumaShared/SharedSource/Characters/Params/Animation/AnimationParams.cs

@@ -189,7 +189,7 @@ namespace Barotrauma
             CharacterPrefab prefab = CharacterPrefab.FindBySpeciesName(speciesName);
             if (prefab?.ConfigElement == null)
             {
-                DebugConsole.ThrowError($"Failed to find config file for '{speciesName}'");
+                DebugConsole.ThrowError($"Failed to find config file for '{speciesName}'", contentPackage: prefab?.ContentPackage);
                 return string.Empty;
             }
             return GetFolder(prefab.ConfigElement, prefab.FilePath.Value);
@@ -414,7 +414,7 @@ namespace Barotrauma
         {
             if (animationType == AnimationType.NotDefined)
             {
-                throw new Exception("Cannot create an animation file of type " + animationType.ToString());
+                throw new Exception("Cannot create an animation file of type " + animationType);
             }
             if (!allAnimations.TryGetValue(speciesName, out Dictionary<string, AnimationParams> anims))
             {
@@ -543,7 +543,7 @@ namespace Barotrauma
         {
             if (doc == null)
             {
-                DebugConsole.ThrowError("[AnimationParams] The source XML Document is null!");
+                DebugConsole.ThrowError("[AnimationParams] The source XML Document is null!", contentPackage: Path.ContentPackage);
                 return;
             }
             Serialize();

Barotrauma/BarotraumaShared/SharedSource/Characters/Params/CharacterParams.cs

@@ -193,25 +193,32 @@ namespace Barotrauma
             {
                 return newXml;
             }
-            // CreateVariantXML seems to merge the ai targets so that in the new xml we have both the old and the new target definitions.
+
+            // CreateVariantXML does not understand anything about targeting tags, it just replaces the <target> elements in the order they're defined in.
+            // We can do better here by replacing the target with a matching tag, so let's clear the element and do that.
             var finalAiElement = newXml.GetChildElement("ai");
-            var processedTags = new HashSet<string>();
-            foreach (var aiTarget in finalAiElement.Elements().ToArray())
+            finalAiElement.Elements().Remove();
+
+            //add all the targets from the base character
+            baseAi.Elements().ForEach(e => finalAiElement.Add(e));
+
+            var processedTags = new List<Identifier>();
+            foreach (var variantTargetElement in variantAi.Elements())
             {
-                string tag = aiTarget.GetAttributeString("tag", null);
-                if (tag == null) { continue; }
-                if (processedTags.Contains(tag))
+                Identifier tag = variantTargetElement.GetAttributeIdentifier("tag", Identifier.Empty);
+                var matchingElements = finalAiElement.Elements().Where(e => e.GetAttributeIdentifier("tag", Identifier.Empty) == tag);
+                int alreadyProcessed = processedTags.Count(t => t == tag);
+                if (matchingElements.Count() > alreadyProcessed)
                 {
-                    aiTarget.Remove();
-                    continue;
+                    //more matching elements found, replace the first one that hasn't been processed yet
+                    matchingElements.Skip(alreadyProcessed).First().ReplaceWith(variantTargetElement);
+                }
+                else
+                {
+                    //no more matching elements in the base XML, this must be a new target
+                    finalAiElement.Add(variantTargetElement);
                 }
                 processedTags.Add(tag);
-                var matchInSelf = variantAi.Elements().FirstOrDefault(e => e.GetAttributeString("tag", null) == tag);
-                var matchInParent = baseAi.Elements().FirstOrDefault(e => e.GetAttributeString("tag", null) == tag);
-                if (matchInSelf != null && matchInParent != null)
-                {
-                    aiTarget.ReplaceWith(new XElement(matchInSelf));
-                }
             }
             return newXml;
         }

Barotrauma/BarotraumaShared/SharedSource/Characters/Params/Ragdoll/RagdollParams.cs

@@ -137,15 +137,14 @@ namespace Barotrauma
                 .Concat(Joints);
 
         public static string GetDefaultFileName(Identifier speciesName) => $"{speciesName.Value.CapitaliseFirstInvariant()}DefaultRagdoll";
-        public static string GetDefaultFile(Identifier speciesName, ContentPackage contentPackage = null)
-            => IO.Path.Combine(GetFolder(speciesName, contentPackage), $"{GetDefaultFileName(speciesName)}.xml");
-
-        public static string GetFolder(Identifier speciesName, ContentPackage contentPackage = null)
+        public static string GetDefaultFile(Identifier speciesName) => IO.Path.Combine(GetFolder(speciesName), $"{GetDefaultFileName(speciesName)}.xml");
+        
+        public static string GetFolder(Identifier speciesName)
         {
-            CharacterPrefab prefab = CharacterPrefab.Find(p => p.Identifier == speciesName && (contentPackage == null || p.ContentFile.ContentPackage == contentPackage));
+            CharacterPrefab prefab = CharacterPrefab.FindBySpeciesName(speciesName);
             if (prefab?.ConfigElement == null)
             {
-                DebugConsole.ThrowError($"Failed to find config file for '{speciesName}'", contentPackage: contentPackage);
+                DebugConsole.ThrowError($"Failed to find config file for '{speciesName}'");
                 return string.Empty;
             }
             return GetFolder(prefab.ConfigElement, prefab.ContentFile.Path.Value);
@@ -199,10 +198,10 @@ namespace Barotrauma
                     }
                 }
             }
-            else if (!variantOf.IsEmpty && CharacterPrefab.FindBySpeciesName(variantOf) is CharacterPrefab prefab)
+            else if (!variantOf.IsEmpty && CharacterPrefab.FindBySpeciesName(variantOf) is CharacterPrefab parentPrefab)
             {
-                // Ragdoll element not defined -> use the ragdoll defined in the base definition file.
-                ragdollSpecies = prefab.GetBaseCharacterSpeciesName(variantOf);
+                //get the params from the parent prefab if this one doesn't re-define them
+                return GetDefaultRagdollParams<T>(variantOf, parentPrefab.ConfigElement, parentPrefab.ContentPackage);
             }
             // Using a null file definition means we use the default animations found in the Ragdolls folder.
             return GetRagdollParams<T>(speciesName, ragdollSpecies, file: null, contentPackage);
@@ -245,7 +244,7 @@ namespace Barotrauma
                 }
                 else
                 {
-                    DebugConsole.ThrowError($"[AnimationParams] Failed to load an animation {ragdollInstance} from {contentPath.Value} for the character {speciesName}. Using the default ragdoll.", contentPackage: contentPackage);
+                    DebugConsole.ThrowError($"[RagdollParams] Failed to load a ragdoll {ragdollInstance} from {contentPath.Value} for the character {speciesName}. Using the default ragdoll.", contentPackage: contentPackage);
                 }
             }
             // Seek the default ragdoll from the character's ragdoll folder.
@@ -294,8 +293,30 @@ namespace Barotrauma
             }
             else
             {
-                // Failing to create a ragdoll causes so many issues that cannot be handled. Dummy ragdoll just seems to make things harder to debug. It's better to fail early.
-                throw new Exception($"[RagdollParams] Failed to load ragdoll {r.Name} from {selectedFile} for the character {speciesName}.");
+                string error = $"[RagdollParams] Failed to load ragdoll {r.Name} from {selectedFile} for the character {speciesName}.";
+                if (contentPackage == GameMain.VanillaContent)
+                {
+                    // Check if the base character content package is vanilla too.
+                    CharacterPrefab characterPrefab = CharacterPrefab.FindBySpeciesName(speciesName);
+                    if (characterPrefab?.ParentPrefab == null || characterPrefab.ParentPrefab.ContentPackage == GameMain.VanillaContent)
+                    {
+                        // If the error is in the vanilla content, it's just better to crash early.
+                        // If dodging with the solution below fails, we'll also get here.
+                        throw new Exception(error);
+                    }
+                }
+                // Try to dodge crashing on modded content.
+                DebugConsole.ThrowError(error, contentPackage: contentPackage);
+                if (typeof(T) == typeof(HumanRagdollParams))
+                {
+                    Identifier fallbackSpecies = CharacterPrefab.HumanSpeciesName;
+                    r = GetRagdollParams<T>(fallbackSpecies, fallbackSpecies, file: ContentPath.FromRaw(contentPackage, "Content/Characters/Human/Ragdolls/HumanDefaultRagdoll.xml"), contentPackage: GameMain.VanillaContent);
+                }
+                else
+                {
+                    Identifier fallbackSpecies = "crawler".ToIdentifier();
+                    r = GetRagdollParams<T>(fallbackSpecies, fallbackSpecies, file: ContentPath.FromRaw(contentPackage, "Content/Characters/Crawler/Ragdolls/CrawlerDefaultRagdoll.xml"), contentPackage: GameMain.VanillaContent);
+                } 
             }
             return r;
         }
@@ -869,6 +890,9 @@ namespace Barotrauma
             [Serialize(true, IsPropertySaveable.Yes, description: "Can the limb enter submarines? Only valid if the ragdoll's CanEnterSubmarine is set to Partial, otherwise the limb can enter if the ragdoll can."), Editable]
             public bool CanEnterSubmarine { get; private set; }
 
+            [Serialize(LimbType.None, IsPropertySaveable.Yes, description: "When set to something else than None, this limb will be hidden if the limb of the specified type is hidden."), Editable]
+            public LimbType InheritHiding { get; set; }
+
             public LimbParams(ContentXElement element, RagdollParams ragdoll) : base(element, ragdoll)
             {
                 var spriteElement = element.GetChildElement("sprite");

Barotrauma/BarotraumaShared/SharedSource/Characters/Talents/Abilities/CharacterAbility.cs

@@ -100,7 +100,7 @@ namespace Barotrauma.Abilities
             string type = abilityElement.Name.ToString().ToLowerInvariant();
             try
             {
-                abilityType = ReflectionUtils.GetTypeWithBackwardsCompatibility("Barotrauma.Abilities", type, false, true);
+                abilityType = ReflectionUtils.GetTypeWithBackwardsCompatibility(ToolBox.BarotraumaAssembly, "Barotrauma.Abilities", type, false, true);
                 if (abilityType == null)
                 {
                     if (errorMessages) DebugConsole.ThrowError("Could not find the CharacterAbility \"" + type + "\" (" + characterAbilityGroup.CharacterTalent.DebugIdentifier + ")",

Barotrauma/BarotraumaShared/SharedSource/Characters/Talents/Abilities/CharacterAbilityApplyStatusEffects.cs

@@ -19,6 +19,13 @@ namespace Barotrauma.Abilities
 
         private bool effectBeingApplied;
 
+        /// <summary>
+        /// Should the character who has the ability be marked as the "user" of the status effect? 
+        /// Means that e.g. enemies will consider damage from the effect to be coming from the character with the ability, and that the character will gain skills if the effect e.g. heals someone.
+        /// </summary>
+
+        private readonly bool setUser;
+
         public CharacterAbilityApplyStatusEffects(CharacterAbilityGroup characterAbilityGroup, ContentXElement abilityElement) : base(characterAbilityGroup, abilityElement)
         {
             statusEffects = CharacterAbilityGroup.ParseStatusEffects(CharacterTalent, abilityElement.GetChildElement("statuseffects"));
@@ -27,6 +34,7 @@ namespace Barotrauma.Abilities
             nearbyCharactersAppliesToSelf = abilityElement.GetAttributeBool("nearbycharactersappliestoself", true);
             nearbyCharactersAppliesToAllies = abilityElement.GetAttributeBool("nearbycharactersappliestoallies", true);
             nearbyCharactersAppliesToEnemies = abilityElement.GetAttributeBool("nearbycharactersappliestoenemies", true);
+            setUser = abilityElement.GetAttributeBool("setuser", true);
         }
 
         protected void ApplyEffectSpecific(Character targetCharacter, Limb targetLimb = null)
@@ -44,7 +52,7 @@ namespace Barotrauma.Abilities
                     if (statusEffect.HasTargetType(StatusEffect.TargetType.UseTarget))
                     {
                         // currently used to spawn items on the targeted character
-                        statusEffect.SetUser(targetCharacter);
+                        if (setUser) { statusEffect.SetUser(targetCharacter); }
                         statusEffect.Apply(ActionType.OnAbility, EffectDeltaTime, targetCharacter, targetCharacter);
                     }
                     else if (statusEffect.HasTargetType(StatusEffect.TargetType.NearbyCharacters))
@@ -63,22 +71,22 @@ namespace Barotrauma.Abilities
                         {
                             targets.RemoveAll(c => c is Character otherCharacter && !HumanAIController.IsFriendly(otherCharacter, Character));
                         }
-                        statusEffect.SetUser(Character);
+                        if (setUser) { statusEffect.SetUser(Character); }
                         statusEffect.Apply(ActionType.OnAbility, EffectDeltaTime, targetCharacter, targets);
                     }
                     else if (statusEffect.HasTargetType(StatusEffect.TargetType.Limb) && targetLimb != null)
                     {
-                        statusEffect.SetUser(Character);
+                        if (setUser) { statusEffect.SetUser(Character); }
                         statusEffect.Apply(ActionType.OnAbility, EffectDeltaTime, Character, targetLimb);
                     }
                     else if (statusEffect.HasTargetType(StatusEffect.TargetType.Character))
                     {
-                        statusEffect.SetUser(Character);
+                        if (setUser) { statusEffect.SetUser(Character); }
                         statusEffect.Apply(ActionType.OnAbility, EffectDeltaTime, Character, targetCharacter);
                     }
                     else
                     {
-                        statusEffect.SetUser(Character);
+                        if (setUser) { statusEffect.SetUser(Character); }
                         statusEffect.Apply(ActionType.OnAbility, EffectDeltaTime, Character, Character);
                     }
                 }

Barotrauma/BarotraumaShared/SharedSource/Characters/Talents/Abilities/CharacterAbilityReduceAffliction.cs

@@ -1,4 +1,4 @@
-#nullable enable
+#nullable enable
 
 namespace Barotrauma.Abilities
 {
@@ -19,10 +19,30 @@ namespace Barotrauma.Abilities
             }
         }
 
+        protected override void ApplyEffect()
+        {
+            ApplyEffectToCharacter(Character);
+        }
+
         protected override void ApplyEffect(AbilityObject abilityObject)
         {
-            if (abilityObject is not IAbilityCharacter character) { return; }
-            character.Character.CharacterHealth.ReduceAfflictionOnAllLimbs(afflictionId, amount, attacker: Character);
+            if (abilityObject is IAbilityCharacter characterData) 
+            { 
+                ApplyEffectToCharacter(characterData.Character); 
+            }
+        }
+
+        private void ApplyEffectToCharacter(Character character)
+        {
+            character?.CharacterHealth.ReduceAfflictionOnAllLimbs(afflictionId, amount, attacker: Character);
+        }
+
+        protected override void VerifyState(bool conditionsMatched, float timeSinceLastUpdate)
+        {
+            if (conditionsMatched)
+            {
+                ApplyEffect();
+            }
         }
     }
 }

Barotrauma/BarotraumaShared/SharedSource/Characters/Talents/AbilityGroups/CharacterAbilityGroup.cs

@@ -140,7 +140,7 @@ namespace Barotrauma.Abilities
             string type = conditionElement.Name.ToString().ToLowerInvariant();
             try
             {
-                conditionType = ReflectionUtils.GetTypeWithBackwardsCompatibility("Barotrauma.Abilities", type, false, true);
+                conditionType = ReflectionUtils.GetTypeWithBackwardsCompatibility(ToolBox.BarotraumaAssembly, "Barotrauma.Abilities", type, false, true);
                 if (conditionType == null)
                 {
                     if (errorMessages)

Barotrauma/BarotraumaShared/SharedSource/Characters/Talents/TalentPrefab.cs

@@ -22,6 +22,11 @@ namespace Barotrauma
 
         public readonly Sprite Icon;
 
+        /// <summary>
+        /// When set to true, this talent will not be visible in the "Extra Talents" panel if it is not part of the character's job talent tree.
+        /// </summary>
+        public readonly bool IsHiddenExtraTalent;
+
         /// <summary>
         /// When set to a value the talent tooltip will display a text showing the current value of the stat and the max value.
         /// For example "Progress: 37/100".
@@ -62,6 +67,8 @@ namespace Barotrauma
                 DisplayName = TextManager.Get(nameIdentifier).Fallback(Identifier.Value);
             }
 
+            IsHiddenExtraTalent = element.GetAttributeBool("ishiddenextratalent", false);
+
             Description = string.Empty;
 
 #if CLIENT