Merge branch 'master' of https://github.com/Regalis11/Barotrauma.git into Regalis11-master

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

@@ -1,5 +1,4 @@
-using Barotrauma.Extensions;
-using Barotrauma.Items.Components;
+using Barotrauma.Items.Components;
 using Barotrauma.Networking;
 using FarseerPhysics;
 using Microsoft.Xna.Framework;
@@ -125,6 +124,8 @@ namespace Barotrauma
             minGapSize = ConvertUnits.ToDisplayUnits(Math.Min(colliderWidth, colliderLength));
         }
 
+        public virtual void OnHealed(Character healer, float healAmount) { }
+
         public virtual void OnAttacked(Character attacker, AttackResult attackResult) { }
 
         public virtual void SelectTarget(AITarget target) { }
@@ -306,14 +307,15 @@ namespace Barotrauma
 
         public void UnequipEmptyItems(Item parentItem, bool avoidDroppingInSea = true) => UnequipEmptyItems(Character, parentItem, avoidDroppingInSea);
 
-        public void UnequipContainedItems(Item parentItem, Func<Item, bool> predicate = null, bool avoidDroppingInSea = true) => UnequipContainedItems(Character, parentItem, predicate, avoidDroppingInSea);
+        public void UnequipContainedItems(Item parentItem, Func<Item, bool> predicate = null, bool avoidDroppingInSea = true, int? unequipMax = null) => UnequipContainedItems(Character, parentItem, predicate, avoidDroppingInSea, unequipMax);
 
         public static void UnequipEmptyItems(Character character, Item parentItem, bool avoidDroppingInSea = true) => UnequipContainedItems(character, parentItem, it => it.Condition <= 0, avoidDroppingInSea);
 
-        public static void UnequipContainedItems(Character character, Item parentItem, Func<Item, bool> predicate, bool avoidDroppingInSea = true)
+        public static void UnequipContainedItems(Character character, Item parentItem, Func<Item, bool> predicate, bool avoidDroppingInSea = true, int? unequipMax = null)
         {
             var inventory = parentItem.OwnInventory;
             if (inventory == null) { return; }
+            int removed = 0;
             if (predicate == null || inventory.AllItems.Any(predicate))
             {
                 foreach (Item containedItem in inventory.AllItemsMod)
@@ -326,10 +328,12 @@ namespace Barotrauma
                             // If we are not inside a friendly sub (= same team), try to put the item in the inventory instead dropping it.
                             if (character.Inventory.TryPutItem(containedItem, character, CharacterInventory.anySlot))
                             {
+                                if (unequipMax.HasValue && ++removed >= unequipMax) { return; }
                                 continue;
                             }
                         }
                         containedItem.Drop(character);
+                        if (unequipMax.HasValue && ++removed >= unequipMax) { return; }
                     }
                 }
             }

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

@@ -76,7 +76,7 @@ namespace Barotrauma
                 {
                     string errorMsg = "Invalid AITarget sector direction (" + value + ")\n" + Environment.StackTrace.CleanupStackTrace();
                     DebugConsole.ThrowError(errorMsg);
-                    GameAnalyticsManager.AddErrorEventOnce("AITarget.SectorDir:" + entity?.ToString(), GameAnalyticsSDK.Net.EGAErrorSeverity.Error, errorMsg);
+                    GameAnalyticsManager.AddErrorEventOnce("AITarget.SectorDir:" + entity?.ToString(), GameAnalyticsManager.ErrorSeverity.Error, errorMsg);
                     return;
                 }
                 sectorDir = value;
@@ -125,7 +125,7 @@ namespace Barotrauma
                     DebugConsole.ThrowError("Attempted to access a removed AITarget\n" + Environment.StackTrace.CleanupStackTrace());
 #endif
                     GameAnalyticsManager.AddErrorEventOnce("AITarget.WorldPosition:EntityRemoved",
-                        GameAnalyticsSDK.Net.EGAErrorSeverity.Error,
+                        GameAnalyticsManager.ErrorSeverity.Error,
                         "Attempted to access a removed AITarget\n" + Environment.StackTrace.CleanupStackTrace());
                     return Vector2.Zero;
                 }
@@ -144,7 +144,7 @@ namespace Barotrauma
                     DebugConsole.ThrowError("Attempted to access a removed AITarget\n" + Environment.StackTrace.CleanupStackTrace());
 #endif
                     GameAnalyticsManager.AddErrorEventOnce("AITarget.WorldPosition:EntityRemoved",
-                        GameAnalyticsSDK.Net.EGAErrorSeverity.Error,
+                        GameAnalyticsManager.ErrorSeverity.Error,
                         "Attempted to access a removed AITarget\n" + Environment.StackTrace.CleanupStackTrace());
                     return Vector2.Zero;
                 }
@@ -229,7 +229,7 @@ namespace Barotrauma
         {
             if (sectorRad >= MathHelper.TwoPi) { return true; }
             Vector2 diff = worldPosition - WorldPosition;
-            return MathUtils.GetShortestAngle(MathUtils.VectorToAngle(diff), MathUtils.VectorToAngle(sectorDir)) <= sectorRad * 0.5f;
+            return Math.Abs(MathUtils.GetShortestAngle(MathUtils.VectorToAngle(diff), MathUtils.VectorToAngle(sectorDir))) <= sectorRad * 0.5f;
         }
 
         public void Remove()

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

@@ -339,11 +339,15 @@ namespace Barotrauma
                 {
                     targetingTag = "dead";
                 }
+                else if (AIParams.TryGetTarget(targetCharacter.CharacterHealth.GetActiveAfflictionTags(), out CharacterParams.TargetParams tp) && tp.Threshold > Character.GetDamageDoneByAttacker(targetCharacter))
+                {
+                    targetingTag = tp.Tag;
+                }
                 else if (PetBehavior != null && aiTarget.Entity == PetBehavior.Owner) 
                 { 
-                    targetingTag = "owner"; 
+                    targetingTag = "owner";
                 }
-                else if (AIParams.TryGetTarget(targetCharacter.SpeciesName, out CharacterParams.TargetParams tP))
+                else if (AIParams.TryGetTarget(targetCharacter, out CharacterParams.TargetParams tP))
                 {
                     targetingTag = tP.Tag;
                 }
@@ -353,7 +357,7 @@ namespace Barotrauma
                     {
                         targetingTag = "husk";
                     }
-                    else
+                    else if (!Character.IsFriendly(targetCharacter))
                     {
                         if (enemy.CombatStrength > CombatStrength)
                         {
@@ -386,6 +390,10 @@ namespace Barotrauma
                     {
                         targetingTag = "sonar";
                     }
+                    if (targetItem.GetComponent<Door>() != null)
+                    {
+                        targetingTag = "door";
+                    }
                 }
             }
             else if (aiTarget.Entity is Structure)
@@ -511,8 +519,7 @@ namespace Barotrauma
                 }
                 else if (avoidTimer <= 0 || activeTriggers.Any() && returnTimer <= 0)
                 {
-                    CharacterParams.TargetParams targetingParams = null;
-                    UpdateTargets(Character, out targetingParams);
+                    UpdateTargets(out CharacterParams.TargetParams targetingParams);
                     updateTargetsTimer = updateTargetsInterval * Rand.Range(0.75f, 1.25f);
                     if (SelectedAiTarget == null)
                     {
@@ -1973,7 +1980,7 @@ namespace Barotrauma
                         ChangeTargetState(attacker, canAttack ? AIState.Attack : AIState.Escape, 100);
                     }
                 }
-                else if (canAttack && attacker.IsHuman && AIParams.TryGetTarget(attacker.SpeciesName, out CharacterParams.TargetParams targetingParams))
+                else if (canAttack && attacker.IsHuman && AIParams.TryGetTarget(attacker, out CharacterParams.TargetParams targetingParams))
                 {
                     if (targetingParams.State == AIState.Aggressive || targetingParams.State == AIState.PassiveAggressive)
                     {
@@ -2362,7 +2369,7 @@ namespace Barotrauma
         //goes through all the AItargets, evaluates how preferable it is to attack the target,
         //whether the Character can see/hear the target and chooses the most preferable target within
         //sight/hearing range
-        public AITarget UpdateTargets(Character character, out CharacterParams.TargetParams targetingParams)
+        public AITarget UpdateTargets(out CharacterParams.TargetParams targetingParams)
         {
             AITarget newTarget = null;
             targetValue = 0;
@@ -2386,70 +2393,35 @@ namespace Barotrauma
                 }
                 Character targetCharacter = aiTarget.Entity as Character;
                 //ignore the aitarget if it is the Character itself
-                if (targetCharacter == character) { continue; }
+                if (targetCharacter == Character) { continue; }
 
                 float valueModifier = 1;
-                string targetingTag = null;
+                string targetingTag = GetTargetingTag(aiTarget);
                 if (targetCharacter != null)
                 {
                     // ignore if target is tagged to be explicitly ignored (Feign Death)
                     if (targetCharacter.HasAbilityFlag(AbilityFlags.IgnoredByEnemyAI)) { continue; }
-
-                    if (targetCharacter.IsDead)
+                    if (AIParams.Targets.None() && Character.IsFriendly(targetCharacter))
                     {
-                        targetingTag = "dead";
+                        continue;
                     }
-                    else if (PetBehavior != null && aiTarget.Entity == PetBehavior.Owner)
+                    if (targetCharacter.AIController is EnemyAIController enemy)
                     {
-                        targetingTag = "owner";
-                    }
-                    else if (AIParams.TryGetTarget(targetCharacter.SpeciesName, out CharacterParams.TargetParams tP))
-                    {
-                        targetingTag = tP.Tag;
-                    }
-                    else
-                    {
-                        if (Character.IsFriendly(targetCharacter))
+                        if (targetingTag == "stronger" && (State == AIState.Avoid || State == AIState.Escape || State == AIState.Flee))
                         {
-                            continue;
-                        }
-                        if (targetCharacter.AIController is EnemyAIController enemy)
-                        {
-                            if (targetCharacter.IsHusk && AIParams.HasTag("husk"))
+                            if (SelectedAiTarget == aiTarget)
                             {
-                                targetingTag = "husk";
+                                // Freightened -> hold on to the target
+                                valueModifier *= 2;
                             }
-                            else
+                            if (IsBeingChasedBy(targetCharacter))
                             {
-                                if (enemy.CombatStrength > CombatStrength)
-                                {
-                                    targetingTag = "stronger";
-                                }
-                                else if (enemy.CombatStrength < CombatStrength)
-                                {
-                                    targetingTag = "weaker";
-                                }
-                                else
-                                {
-                                    targetingTag = "equal";
-                                }
-                                if (targetingTag == "stronger" && (State == AIState.Avoid || State == AIState.Escape || State == AIState.Flee))
-                                {
-                                    if (SelectedAiTarget == aiTarget)
-                                    {
-                                        // Freightened -> hold on to the target
-                                        valueModifier *= 2;
-                                    }
-                                    if (IsBeingChasedBy(targetCharacter))
-                                    {
-                                        valueModifier *= 2;
-                                    }
-                                    if (Character.CurrentHull != null && !VisibleHulls.Contains(targetCharacter.CurrentHull))
-                                    {
-                                        // Inside but in a different room
-                                        valueModifier /= 2;
-                                    }
-                                }
+                                valueModifier *= 2;
+                            }
+                            if (Character.CurrentHull != null && !VisibleHulls.Contains(targetCharacter.CurrentHull))
+                            {
+                                // Inside but in a different room
+                                valueModifier /= 2;
                             }
                         }
                     }
@@ -2469,7 +2441,7 @@ namespace Barotrauma
                     if (aiTarget.Entity is Hull hull)
                     {
                         // Ignore the target if it's a room and the character is already inside a sub
-                        if (character.CurrentHull != null) { continue; }
+                        if (Character.CurrentHull != null) { continue; }
                         // Ignore ruins
                         if (hull.Submarine == null) { continue; }
                         if (hull.Submarine.Info.IsRuin) { continue; }
@@ -2479,7 +2451,7 @@ namespace Barotrauma
                     if (aiTarget.Entity is Item item)
                     {
                         door = item.GetComponent<Door>();
-                        bool targetingFromOutsideToInside = item.CurrentHull != null && character.CurrentHull == null;
+                        bool targetingFromOutsideToInside = item.CurrentHull != null && Character.CurrentHull == null;
                         if (targetingFromOutsideToInside)
                         {
                             if (door != null && (!canAttackDoors && !AIParams.CanOpenDoors) || !canAttackWalls)
@@ -2488,28 +2460,12 @@ namespace Barotrauma
                                 continue;
                             }
                         }
-                        foreach (var prio in AIParams.Targets)
+                        if (door == null && targetingFromOutsideToInside)
                         {
-                            if (item.HasTag(prio.Tag))
+                            if (item.Submarine?.Info is { IsRuin: true })
                             {
-                                targetingTag = prio.Tag;
-                                break;
-                            }
-                        }
-                        if (door == null && targetingTag == null)
-                        {
-                            if (item.GetComponent<Sonar>() != null)
-                            {
-                                targetingTag = "sonar";
-                            }
-                            else if (targetingFromOutsideToInside)
-                            {
-                                targetingTag = "room";
-                                if (item.Submarine?.Info.IsRuin != null)
-                                {
-                                    // Ignore ruin items when the creature is outside.
-                                    continue;
-                                }
+                                // Ignore ruin items when the creature is outside.
+                                continue;
                             }
                         }
                         else if (targetingTag == "nasonov")
@@ -2521,14 +2477,13 @@ namespace Barotrauma
                             }
                         }
                         // Ignore the target if it's a decoy and the character is already inside a sub
-                        if (character.CurrentHull != null && targetingTag == "decoy")
+                        if (Character.CurrentHull != null && targetingTag == "decoy")
                         {
                             continue;
                         }
                     }
                     else if (aiTarget.Entity is Structure s)
                     {
-                        targetingTag = "wall";
                         if (!s.HasBody)
                         {
                             // Ignore structures that doesn't have a body (not walls)
@@ -2537,7 +2492,7 @@ namespace Barotrauma
                         if (s.IsPlatform) { continue; }
                         if (s.Submarine == null) { continue; }
                         if (s.Submarine.Info.IsRuin) { continue; }
-                        bool isCharacterInside = character.CurrentHull != null;
+                        bool isCharacterInside = Character.CurrentHull != null;
                         bool isInnerWall = s.prefab.Tags.Contains("inner");
                         if (isInnerWall && !isCharacterInside)
                         {
@@ -2624,21 +2579,12 @@ namespace Barotrauma
                             }
                         }
                     }
-                    else
-                    {
-                        targetingTag = "room";
-                    }
                     if (door != null)
                     {
-                        // If there's not a more specific tag for the door
-                        if (string.IsNullOrEmpty(targetingTag) || targetingTag == "room")
-                        {
-                            targetingTag = "door";
-                        }
                         if (door.Item.Submarine == null) { continue; }
                         bool isOutdoor = door.LinkedGap?.FlowTargetHull != null && !door.LinkedGap.IsRoomToRoom;
                         // Ignore inner doors when outside
-                        if (character.CurrentHull == null && !isOutdoor) { continue; }
+                        if (Character.CurrentHull == null && !isOutdoor) { continue; }
                         bool isOpen = door.CanBeTraversed;
                         if (!isOpen)
                         {
@@ -2651,7 +2597,7 @@ namespace Barotrauma
                         }
                         if (IsAggressiveBoarder)
                         {
-                            if (character.CurrentHull == null)
+                            if (Character.CurrentHull == null)
                             {
                                 // Increase the priority if the character is outside and the door is from outside to inside
                                 if (door.CanBeTraversed)
@@ -2679,14 +2625,14 @@ namespace Barotrauma
                 if (targetingTag == null) { continue; }
                 var targetParams = GetTargetParams(targetingTag);
                 if (targetParams == null) { continue; }
-                if (targetParams.IgnoreInside && character.CurrentHull != null) { continue; }
-                if (targetParams.IgnoreOutside && character.CurrentHull == null) { continue; }
+                if (targetParams.IgnoreInside && Character.CurrentHull != null) { continue; }
+                if (targetParams.IgnoreOutside && Character.CurrentHull == null) { continue; }
                 if (targetParams.IgnoreIncapacitated && targetCharacter != null && targetCharacter.IsIncapacitated) { continue; }
                 if (targetParams.IgnoreIfNotInSameSub)
                 {
                     if (aiTarget.Entity.Submarine != Character.Submarine) { continue; }
                     var targetHull = targetCharacter != null ? targetCharacter.CurrentHull : aiTarget.Entity is Item it ? it.CurrentHull : null;
-                    if ((targetHull == null) != (character.CurrentHull == null)) { continue; }
+                    if ((targetHull == null) != (Character.CurrentHull == null)) { continue; }
                 }
                 if (targetParams.State == AIState.Observe || targetParams.State == AIState.Eat)
                 {
@@ -2706,7 +2652,7 @@ namespace Barotrauma
                         {
                             target = selectedTargetingParams == targetParams ? targetParams.ThresholdMax : targetParams.ThresholdMin;
                         }
-                        if (character.HealthPercentage > target)
+                        if (Character.HealthPercentage > target)
                         {
                              continue;
                         }
@@ -2721,7 +2667,7 @@ namespace Barotrauma
                         // Halve the priority for each swarm mate targeting the same target -> reduces stacking
                         foreach (Character otherCharacter in SwarmBehavior.Members)
                         {
-                            if (otherCharacter == character) { continue; }
+                            if (otherCharacter == Character) { continue; }
                             if (otherCharacter.AIController?.SelectedAiTarget != aiTarget) { continue; }
                             valueModifier /= 2;
                         }
@@ -2731,15 +2677,15 @@ namespace Barotrauma
                         // The same as above, but using all the friendly characters in the level.
                         foreach (Character otherCharacter in Character.CharacterList)
                         {
-                            if (otherCharacter == character) { continue; }
+                            if (otherCharacter == Character) { continue; }
                             if (otherCharacter.AIController?.SelectedAiTarget != aiTarget) { continue; }
-                            if (!character.IsFriendly(otherCharacter)) { continue; }
+                            if (!Character.IsFriendly(otherCharacter)) { continue; }
                             valueModifier /= 2;
                         }
                     }
                 }
                 if (!aiTarget.IsWithinSector(WorldPosition)) { continue; }
-                Vector2 toTarget = aiTarget.WorldPosition - character.WorldPosition;
+                Vector2 toTarget = aiTarget.WorldPosition - Character.WorldPosition;
                 float dist = toTarget.Length();
                 float nonModifiedDist = dist;
                 //if the target has been within range earlier, the character will notice it more easily
@@ -2829,7 +2775,7 @@ namespace Barotrauma
                         Character owner = GetOwner(i);
                         // Don't target items that we own. 
                         // This is a rare case, and almost entirely related to Humanhusks, so let's check it last to reduce unnecessary checks (although the check shouldn't be expensive)
-                        if (owner == character) { continue; }
+                        if (owner == Character) { continue; }
                         if (owner != null && (Character.IsFriendly(owner) || owner.AiTarget != null && ignoredTargets.Contains(owner.AiTarget)))
                         {
                             continue;

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

@@ -85,6 +85,7 @@ namespace Barotrauma
         /// List of previous attacks done to this character
         /// </summary>
         private readonly Dictionary<Character, AttackResult> previousAttackResults = new Dictionary<Character, AttackResult>();
+        private readonly Dictionary<Character, float> previousHealAmounts = new Dictionary<Character, float>();
 
         private readonly SteeringManager outsideSteering, insideSteering;
 
@@ -187,6 +188,15 @@ namespace Barotrauma
                 foreach (var previousAttackResult in previousAttackResults)
                 {
                     RespondToAttack(previousAttackResult.Key, previousAttackResult.Value);
+                    if (previousHealAmounts.ContainsKey(previousAttackResult.Key))
+                    {
+                        //gradually forget past heals
+                        previousHealAmounts[previousAttackResult.Key] = Math.Min(previousHealAmounts[previousAttackResult.Key] - 5.0f, 100.0f);
+                        if (previousHealAmounts[previousAttackResult.Key] <= 0.0f)
+                        {
+                            previousHealAmounts.Remove(previousAttackResult.Key);
+                        }
+                    }
                 }
                 previousAttackResults.Clear();
                 respondToAttackTimer = RespondToAttackInterval;
@@ -237,39 +247,41 @@ namespace Barotrauma
 
             if (Character.Submarine == null)
             {
-                // When the character is outside, far enough from the target, and the direct route is blocked,
-                // use the indoor steering with the main and side path waypoints to help avoid getting stuck in level walls
-                if (SelectedAiTarget?.Entity != null && !IsCloseEnoughToTarget(2000, useTargetSub: false))
+                obstacleRaycastTimer -= deltaTime;
+                if (obstacleRaycastTimer <= 0)
                 {
-                    obstacleRaycastTimer -= deltaTime;
-                    if (obstacleRaycastTimer <= 0)
+                    obstacleRaycastTimer = obstacleRaycastIntervalLong;
+                    if (SelectedAiTarget?.Entity == null || SelectedAiTarget.Entity is ISpatialEntity target && target.Submarine == null || !IsCloseEnoughToTarget(2000, useTargetSub: false))
                     {
-                        obstacleRaycastTimer = obstacleRaycastIntervalLong;
-                        Vector2 rayEnd = SelectedAiTarget.Entity.SimPosition;
-                        if (SelectedAiTarget.Entity.Submarine != null)
+                        // If the target is behind a level wall, switch to the pathing to get around the obstacles.
+                        ISpatialEntity spatialTarget = SelectedAiTarget?.Entity;
+                        if (spatialTarget == null)
                         {
-                            rayEnd += SelectedAiTarget.Entity.Submarine.SimPosition;
+                            var gotoObjective = ObjectiveManager.GetActiveObjective<AIObjectiveGoTo>();
+                            spatialTarget = gotoObjective?.Target;
                         }
-                        IEnumerable<FarseerPhysics.Dynamics.Body> ignoredBodies = null;
-                        if (SelectedAiTarget.Entity is ISpatialEntity spatialTarget)
+                        if (spatialTarget == null)
                         {
+                            UseIndoorSteeringOutside = false;
+                        }
+                        else
+                        {
+                            IEnumerable<FarseerPhysics.Dynamics.Body> ignoredBodies = null;
+                            Vector2 rayEnd = spatialTarget.SimPosition;
                             Submarine targetSub = spatialTarget.Submarine;
                             if (targetSub != null)
                             {
+                                rayEnd += targetSub.SimPosition;
                                 ignoredBodies = targetSub.PhysicsBody.FarseerBody.ToEnumerable();
                             }
+                            var obstacle = Submarine.PickBody(SimPosition, rayEnd, ignoredBodies, collisionCategory: Physics.CollisionLevel | Physics.CollisionWall);
+                            UseIndoorSteeringOutside = obstacle != null;
                         }
-                        var obstacle = Submarine.PickBody(SimPosition, rayEnd, ignoredBodies, collisionCategory: Physics.CollisionLevel | Physics.CollisionWall);
-                        UseIndoorSteeringOutside = obstacle != null;
                     }
-                }
-                else
-                {
-                    UseIndoorSteeringOutside = false;
-                    if (hasValidPath)
+                    else
                     {
-                        obstacleRaycastTimer -= deltaTime;
-                        if (obstacleRaycastTimer <= 0)
+                        UseIndoorSteeringOutside = false;
+                        if (hasValidPath)
                         {
                             obstacleRaycastTimer = obstacleRaycastIntervalShort;
                             // Swimming outside and using the path finder -> check that the path is not blocked with anything (the path finder doesn't know about other subs).
@@ -332,25 +344,10 @@ namespace Barotrauma
                     }
                 }
             }
+            
+            IsInsideCave = Character.CurrentHull == null && Level.Loaded?.Caves.FirstOrDefault(c => c.Area.Contains(Character.WorldPosition)) is Level.Cave;
 
-            // Check whether the character is inside a cave
-            if (IsInsideCave)
-            {
-                // If the character was inside a cave, require them to move a bit further from the area to set the field back to false
-                // This is to avoid any twitchy behavior with the steering managers
-                IsInsideCave = Character.CurrentHull == null && Level.Loaded?.Caves.FirstOrDefault(c =>
-                {
-                    var area = c.Area;
-                    area.Inflate(new Vector2(100));
-                    return area.Contains(Character.WorldPosition);
-                }) is Level.Cave;
-            }
-            else
-            {
-                IsInsideCave = Character.CurrentHull == null && Level.Loaded?.Caves.FirstOrDefault(c => c.Area.Contains(Character.WorldPosition)) is Level.Cave;
-            }
-
-            if (UseIndoorSteeringOutside || IsInsideCave || Character.CurrentHull?.Submarine != null || hasValidPath || IsCloseEnoughToTarget(steeringBuffer))
+            if (UseIndoorSteeringOutside || Character.CurrentHull?.Submarine != null || hasValidPath || IsCloseEnoughToTarget(steeringBuffer))
             {
                 if (steeringManager != insideSteering)
                 {
@@ -524,11 +521,12 @@ namespace Barotrauma
             if (Character.LockHands) { return; }
             if (ObjectiveManager.CurrentObjective == null) { return; }
             if (Character.CurrentHull == null) { return; }
-            bool oxygenLow = !Character.AnimController.HeadInWater && Character.OxygenAvailable < CharacterHealth.LowOxygenThreshold;
+            bool oxygenLow = !Character.AnimController.HeadInWater && Character.OxygenAvailable < CharacterHealth.LowOxygenThreshold && Character.NeedsOxygen;
             bool isCarrying = ObjectiveManager.HasActiveObjective<AIObjectiveContainItem>() || ObjectiveManager.HasActiveObjective<AIObjectiveDecontainItem>();
 
             bool NeedsDivingGearOnPath(AIObjectiveGoTo gotoObjective)
             {
+                if (!Character.NeedsAir) { return false; }
                 bool insideSteering = SteeringManager == PathSteering && PathSteering.CurrentPath != null && !PathSteering.IsPathDirty;
                 Hull targetHull = gotoObjective.GetTargetHull();
                 return gotoObjective.Target != null && targetHull == null ||
@@ -567,6 +565,7 @@ namespace Barotrauma
                         Character.AnimController.HeadInWater ||
                         Character.Submarine == null ||
                         (Character.Submarine.TeamID != Character.TeamID && !Character.IsEscorted) ||
+                        ObjectiveManager.CurrentOrders.Any(o => o.Objective.KeepDivingGearOn) ||
                         ObjectiveManager.CurrentObjective.GetSubObjectivesRecursive(true).Any(o => o.KeepDivingGearOn) ||
                         Character.CurrentHull.OxygenPercentage < HULL_LOW_OXYGEN_PERCENTAGE + 10;
                     bool IsOrderedToWait() => Character.IsOnPlayerTeam && ObjectiveManager.CurrentOrder is AIObjectiveGoTo goTo && goTo.Target == Character;
@@ -599,7 +598,7 @@ namespace Barotrauma
                                         takeMaskOff = false;
                                         break;
                                     }
-                                    else if (gotoObjective.mimic)
+                                    else if (gotoObjective.Mimic)
                                     {
                                         if (!removeSuit)
                                         {
@@ -625,7 +624,7 @@ namespace Barotrauma
                     if (removeDivingSuit)
                     {
                         var divingSuit = Character.Inventory.FindItemByTag(AIObjectiveFindDivingGear.HEAVY_DIVING_GEAR);
-                        if (divingSuit != null)
+                        if (divingSuit != null && !divingSuit.HasTag(AIObjectiveFindDivingGear.DIVING_GEAR_WEARABLE_INDOORS))
                         {
                             if (oxygenLow || Character.Submarine?.TeamID != Character.TeamID || ObjectiveManager.GetCurrentPriority() >= AIObjectiveManager.RunPriority)
                             {
@@ -727,6 +726,7 @@ namespace Barotrauma
 
                     if (!item.AllowedSlots.Contains(InvSlotType.Any) || !Character.Inventory.TryPutItem(item, Character, new List<InvSlotType>() { InvSlotType.Any }) && Character.Submarine?.TeamID == Character.TeamID )
                     {
+                        if (item.AllowedSlots.Contains(InvSlotType.Bag) && Character.Inventory.TryPutItem(item, Character, new List<InvSlotType>() { InvSlotType.Bag })) { continue; }
                         findItemState = FindItemState.OtherItem;
                         if (FindSuitableContainer(item, out Item targetContainer))
                         {
@@ -878,7 +878,7 @@ namespace Barotrauma
                         if (target.CurrentHull != hull || !target.Enabled) { continue; }
                         if (AIObjectiveFightIntruders.IsValidTarget(target, Character))
                         {
-                            if (AddTargets<AIObjectiveFightIntruders, Character>(Character, target) && newOrder == null)
+                            if (!target.IsArrested && AddTargets<AIObjectiveFightIntruders, Character>(Character, target) && newOrder == null)
                             {
                                 var orderPrefab = Order.GetPrefab("reportintruders");
                                 newOrder = new Order(orderPrefab, hull, null, orderGiver: Character);
@@ -950,7 +950,7 @@ namespace Barotrauma
                                 if (item.CurrentHull != hull) { continue; }
                                 if (AIObjectiveRepairItems.IsValidTarget(item, Character))
                                 {
-                                    if (item.Repairables.All(r => item.ConditionPercentage > r.RepairIconThreshold)) { continue; }
+                                    if (!item.Repairables.Any(r => r.IsBelowRepairIconThreshold)) { continue; }
                                     if (AddTargets<AIObjectiveRepairItems, Item>(Character, item) && newOrder == null && !ObjectiveManager.HasActiveObjective<AIObjectiveRepairItem>())
                                     {
                                         var orderPrefab = Order.GetPrefab("reportbrokendevices");
@@ -1031,6 +1031,19 @@ namespace Barotrauma
             }
         }
 
+        public override void OnHealed(Character healer, float healAmount)
+        {
+            if (healer == null || healAmount <= 0.0f) { return; }
+            if (previousHealAmounts.ContainsKey(healer))
+            {
+                previousHealAmounts[healer] += healAmount;
+            }
+            else
+            {
+                previousHealAmounts.Add(healer, healAmount);
+            }
+        }
+
         public override void OnAttacked(Character attacker, AttackResult attackResult)
         {
             // The attack incapacitated/killed the character: respond immediately to trigger nearby characters because the update loop no longer runs
@@ -1074,11 +1087,16 @@ namespace Barotrauma
         }
 
         private void RespondToAttack(Character attacker, AttackResult attackResult)
-        { 
+        {
+            float healAmount = 0.0f;
+            if (attacker != null)
+            {
+                previousHealAmounts.TryGetValue(attacker, out healAmount);
+            }
             // excluding poisons etc
-            float realDamage = attackResult.Damage;
+            float realDamage = attackResult.Damage - healAmount;
             // including poisons etc
-            float totalDamage = realDamage;
+            float totalDamage = realDamage - healAmount;
             if (attackResult.Afflictions != null)
             {
                 foreach (Affliction affliction in attackResult.Afflictions)
@@ -1117,6 +1135,7 @@ namespace Barotrauma
                 // Don't react to attackers that are outside of the sub (e.g. AoE attacks)
                 return;
             }
+            bool isAttackerFightingEnemy = false;
             if (IsFriendly(attacker))
             {
                 if (attacker.AnimController.Anim == Barotrauma.AnimController.Animation.CPR && attacker.SelectedCharacter == Character)
@@ -1125,7 +1144,7 @@ namespace Barotrauma
                     // Should not cancel any existing ai objectives (so that if the character attacked you and then helped, we still would want to retaliate).
                     return;
                 }
-                float cumulativeDamage = GetDamageDoneByAttacker(attacker);
+                float cumulativeDamage = Character.GetDamageDoneByAttacker(attacker);
                 bool isAccidental = attacker.IsBot && !IsMentallyUnstable && !attacker.AIController.IsMentallyUnstable && Character.CombatAction == null;
                 if (isAccidental)
                 {
@@ -1136,7 +1155,6 @@ namespace Barotrauma
                 }
                 else
                 {
-                    (GameMain.GameSession?.GameMode as CampaignMode)?.OutpostNPCAttacked(Character, attacker, attackResult);
                     // Inform other NPCs
                     if (cumulativeDamage > 1 || totalDamage >= 10)
                     {
@@ -1184,6 +1202,10 @@ namespace Barotrauma
                             }
                         }
                     }
+                    if (!isAttackerFightingEnemy)
+                    {
+                        (GameMain.GameSession?.GameMode as CampaignMode)?.OutpostNPCAttacked(Character, attacker, attackResult);
+                    }
                 }
             }
             else
@@ -1191,7 +1213,7 @@ namespace Barotrauma
                 if (Character.Submarine != null && Character.Submarine.GetConnectedSubs().Contains(attacker.Submarine))
                 {
                     // Non-friendly
-                    InformOtherNPCs(GetDamageDoneByAttacker(attacker));
+                    InformOtherNPCs(Character.GetDamageDoneByAttacker(attacker));
                 }
                 if (Character.IsBot)
                 {
@@ -1211,7 +1233,15 @@ namespace Barotrauma
                     if (!(otherCharacter.AIController is HumanAIController otherHumanAI)) { continue; }
                     if (!otherHumanAI.IsFriendly(Character)) { continue; }
                     bool isWitnessing = otherHumanAI.VisibleHulls.Contains(Character.CurrentHull) || otherHumanAI.VisibleHulls.Contains(attacker.CurrentHull);
-                    if (!isWitnessing && !CheckReportRange(Character, otherCharacter, ReportRange)) { continue; }
+                    if (!isWitnessing) 
+                    { 
+                        //if the other character did not witness the attack, and the character is not within report range (or capable of reporting)
+                        //don't react to the attack
+                        if (Character.IsDead || Character.IsUnconscious || !CheckReportRange(Character, otherCharacter, ReportRange))
+                        {
+                            continue;
+                        } 
+                    }
                     var combatMode = DetermineCombatMode(otherCharacter, cumulativeDamage, isWitnessing, dmgThreshold: attacker.TeamID == Character.TeamID ? 50 : 10);
                     float delay = isWitnessing ? GetReactionTime() : Rand.Range(2.0f, 5.0f, Rand.RandSync.Unsynced);
                     otherHumanAI.AddCombatObjective(combatMode, attacker, delay);
@@ -1244,18 +1274,20 @@ namespace Barotrauma
                         return AIObjectiveCombat.CombatMode.None;
                     }
                     // If there are any enemies around, just ignore the friendly fire
-                    if (Character.CharacterList.Any(ch => ch.Submarine == Character.Submarine && !ch.Removed && !ch.IsDead && !ch.IsIncapacitated && !IsFriendly(ch) && VisibleHulls.Contains(ch.CurrentHull)))
+                    if (Character.CharacterList.Any(ch => ch.Submarine == Character.Submarine && !ch.Removed && !ch.IsIncapacitated && !IsFriendly(ch) && VisibleHulls.Contains(ch.CurrentHull)))
                     {
+                        isAttackerFightingEnemy = true;
                         return AIObjectiveCombat.CombatMode.None;
                     }
                     else if (isWitnessing && Character.CombatAction != null && !c.IsSecurity)
                     {
                         return Character.CombatAction.WitnessReaction;
                     }
-                    else if (Character.IsInstigator && attacker.IsPlayer)
+                    else if (attacker.IsPlayer && FindInstigator() is Character instigator)
                     {
-                        // The guards don't react when the player attacks instigators.
-                        return c.IsSecurity ? AIObjectiveCombat.CombatMode.None : (Character.CombatAction != null ? Character.CombatAction.WitnessReaction : AIObjectiveCombat.CombatMode.Retreat);
+                        // The guards don't react when the player there's an instigator around
+                        isAttackerFightingEnemy = true;
+                        return c.IsSecurity ? AIObjectiveCombat.CombatMode.None : (instigator.CombatAction != null ? instigator.CombatAction.WitnessReaction : AIObjectiveCombat.CombatMode.Retreat);
                     }
                     else if (attacker.TeamID == CharacterTeamType.FriendlyNPC && attacker.AIController != null && !(attacker.AIController.IsMentallyUnstable || attacker.AIController.IsMentallyUnstable))
                     {
@@ -1295,6 +1327,22 @@ namespace Barotrauma
                             return c.IsSecurity ? AIObjectiveCombat.CombatMode.Arrest : AIObjectiveCombat.CombatMode.Retreat;
                         }
                     }
+
+                    Character FindInstigator()
+                    {
+                        if (Character.IsInstigator)
+                        {
+                            return Character;
+                        }
+                        else if (c.AIController is HumanAIController humanAi)
+                        {
+                            return Character.CharacterList.FirstOrDefault(ch => ch.Submarine == c.Submarine && !ch.Removed && !ch.IsIncapacitated && ch.IsInstigator && humanAi.VisibleHulls.Contains(ch.CurrentHull));
+                        }
+                        else
+                        {
+                            return null;
+                        }
+                    }
                 }
             }
         }
@@ -1416,15 +1464,20 @@ namespace Barotrauma
             return true;
         }
 
-        public static bool NeedsDivingGear(Hull hull, out bool needsSuit)
+        public bool NeedsDivingGear(Hull hull, out bool needsSuit)
         {
+            if (!Character.NeedsAir) 
+            {
+                needsSuit = false;
+                return false; 
+            }
             needsSuit = false;
             if (hull == null || 
                 hull.WaterPercentage > 90 || 
                 hull.LethalPressure > 0 || 
                 hull.ConnectedGaps.Any(gap => !gap.IsRoomToRoom && gap.Open > 0.5f))
             {
-                needsSuit = true;
+                needsSuit = !Character.HasAbilityFlag(AbilityFlags.ImmuneToPressure);
                 return true;
             }
             if (hull.WaterPercentage > 60 || hull.OxygenPercentage < HULL_LOW_OXYGEN_PERCENTAGE + 1)
@@ -1564,21 +1617,19 @@ namespace Barotrauma
             }
         }
 
-        public static void ItemTaken(Item item, Character character)
+        public static void ItemTaken(Item item, Character thief)
         {
-            if (item == null || character == null || item.GetComponent<LevelResource>() != null) { return; }
-            Character thief = character;
+            if (item == null || thief == null || item.GetComponent<LevelResource>() != null) { return; }
+
             bool someoneSpoke = false;
+            bool stolenItemsInside = item.OwnInventory?.FindAllItems(it => it.SpawnedInCurrentOutpost && !it.AllowStealing, recursive: true).Any() ?? false;
 
-            bool stolenItemsInside = item.OwnInventory?.FindAllItems(it => it.SpawnedInOutpost && !it.AllowStealing, recursive: true).Any() ?? false;
-
-            if ((item.SpawnedInOutpost && !item.AllowStealing || stolenItemsInside) && thief.TeamID != CharacterTeamType.FriendlyNPC && !item.HasTag("handlocker"))
+            if ((item.SpawnedInCurrentOutpost && !item.AllowStealing || stolenItemsInside) && thief.TeamID != CharacterTeamType.FriendlyNPC && !item.HasTag("handlocker"))
             {
                 foreach (Character otherCharacter in Character.CharacterList)
                 {
-                    if (otherCharacter == thief || otherCharacter.TeamID == thief.TeamID || otherCharacter.IsDead ||
-                        otherCharacter.Info?.Job == null ||
-                        !(otherCharacter.AIController is HumanAIController otherHumanAI) ||
+                    if (otherCharacter == thief || otherCharacter.TeamID == thief.TeamID || otherCharacter.IsIncapacitated || otherCharacter.Stun > 0.0f ||
+                        otherCharacter.Info?.Job == null || !(otherCharacter.AIController is HumanAIController otherHumanAI) ||
                         !otherHumanAI.VisibleHulls.Contains(thief.CurrentHull))
                     {
                         continue;
@@ -1587,13 +1638,13 @@ namespace Barotrauma
                     if (!otherCharacter.CanSeeCharacter(thief)) { continue; }
                     // Don't react if the player is taking an extinguisher and there's any fires on the sub, or diving gear when the sub is flooding
                     // -> allow them to use the emergency items
-                    if (character.Submarine != null)
+                    if (thief.Submarine != null)
                     {
-                        var connectedHulls = character.Submarine.GetHulls(alsoFromConnectedSubs: true);
+                        var connectedHulls = thief.Submarine.GetHulls(alsoFromConnectedSubs: true);
                         if (item.HasTag("fireextinguisher") && connectedHulls.Any(h => h.FireSources.Any())) { continue; }
                         if (item.HasTag("diving") && connectedHulls.Any(h => h.ConnectedGaps.Any(g => AIObjectiveFixLeaks.IsValidTarget(g, thief)))) { continue; }
                     }
-                    if (!someoneSpoke && !character.IsIncapacitated && character.Stun <= 0.0f)
+                    if (!someoneSpoke)
                     {
                         if (!item.StolenDuringRound && GameMain.GameSession?.Campaign?.Map?.CurrentLocation != null)
                         {
@@ -1624,9 +1675,9 @@ namespace Barotrauma
                     }
                 }
             }
-            else if (item.OwnInventory?.FindItem(it => it.SpawnedInOutpost && !item.AllowStealing, true) is { } foundItem)
+            else if (item.OwnInventory?.FindItem(it => it.SpawnedInCurrentOutpost && !item.AllowStealing, true) is { } foundItem)
             {
-                ItemTaken(foundItem, character);
+                ItemTaken(foundItem, thief);
             }
 
             bool TriggerSecurity(HumanAIController humanAI)
@@ -1698,7 +1749,7 @@ namespace Barotrauma
                         if (item.CurrentHull != hull) { continue; }
                         if (AIObjectiveRepairItems.IsValidTarget(item, character))
                         {
-                            if (item.Repairables.All(r => item.ConditionPercentage >= r.RepairThreshold)) { continue; }
+                            if (item.Repairables.All(r => r.IsBelowRepairThreshold)) { continue; }
                             AddTargets<AIObjectiveRepairItems, Item>(character, item);
                         }
                     }
@@ -1754,17 +1805,6 @@ namespace Barotrauma
                 humanAI.ObjectiveManager.GetObjective<T1>()?.ReportedTargets.Remove(target));
         }
 
-        public float GetDamageDoneByAttacker(Character otherCharacter)
-        {
-            float dmg = 0;
-            Character.Attacker attacker = Character.LastAttackers.LastOrDefault(a => a.Character == otherCharacter);
-            if (attacker != null)
-            {
-                dmg = attacker.Damage;
-            }
-            return dmg;
-        }
-
         private void StoreHullSafety(Hull hull, HullSafety safety)
         {
             if (knownHulls.ContainsKey(hull))
@@ -1786,7 +1826,7 @@ namespace Barotrauma
             {
                 if (isCurrentHull)
                 {
-                    CurrentHullSafety = 0;
+                    CurrentHullSafety = character.NeedsAir ? 0 : 100;
                 }
                 return CurrentHullSafety;
             }
@@ -1809,8 +1849,8 @@ namespace Barotrauma
 
         private static float CalculateHullSafety(Hull hull, IEnumerable<Hull> visibleHulls, Character character, bool ignoreWater = false, bool ignoreOxygen = false, bool ignoreFire = false, bool ignoreEnemies = false)
         {
-            if (hull == null) { return 0; }
-            if (hull.LethalPressure > 0 && character.PressureProtection <= 0) { return 0; }
+            if (hull == null) { return character.NeedsAir ? 0 : 100; }
+            if (hull.LethalPressure > 0 && character.PressureProtection <= 0 && !character.HasAbilityFlag(AbilityFlags.ImmuneToPressure)) { return 0; }
             // Oxygen factor should be 1 with 70% oxygen or more and 0.1 when the oxygen level is 30% or lower.
             // With insufficient oxygen, the safety of the hull should be 39, all the other factors aside. So, just below the HULL_SAFETY_THRESHOLD.
             float oxygenFactor = ignoreOxygen ? 1 : MathHelper.Lerp((HULL_SAFETY_THRESHOLD - 1) / 100, 1, MathUtils.InverseLerp(HULL_LOW_OXYGEN_PERCENTAGE, 100 - HULL_LOW_OXYGEN_PERCENTAGE, hull.OxygenPercentage));
@@ -1831,7 +1871,7 @@ namespace Barotrauma
             float enemyFactor = 1;
             if (!ignoreEnemies)
             {
-                bool isValidTarget(Character e) => IsActive(e) && !IsFriendly(character, e);
+                bool isValidTarget(Character e) => IsActive(e) && !IsFriendly(character, e) && !e.IsArrested;
                 int enemyCount = visibleHulls == null ?
                     Character.CharacterList.Count(e => isValidTarget(e) && e.CurrentHull == hull) :
                     Character.CharacterList.Count(e => isValidTarget(e) && visibleHulls.Contains(e.CurrentHull));

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

@@ -26,9 +26,9 @@ namespace Barotrauma
 
         private float findPathTimer;
 
-        private float buttonPressCooldown;
-
-        const float ButtonPressInterval = 0.25f;
+        private const float buttonPressCooldown = 3;
+        private float checkDoorsTimer;
+        private float buttonPressTimer;
 
         public SteeringPath CurrentPath
         {
@@ -97,9 +97,10 @@ namespace Barotrauma
         public override void Update(float speed)
         {
             base.Update(speed);
-
-            buttonPressCooldown -= 1.0f / 60.0f;
-            findPathTimer -= 1.0f / 60.0f;
+            float step = 1.0f / 60.0f;
+            checkDoorsTimer -= step;
+            buttonPressTimer -= step;
+            findPathTimer -= step;
         }
 
         public void SetPath(SteeringPath path)
@@ -120,10 +121,18 @@ namespace Barotrauma
         {
             steering += base.DoSteeringSeek(targetSimPos, weight);
         }
-
+        
         public void SteeringSeek(Vector2 target, float weight, float minGapWidth = 0, Func<PathNode, bool> startNodeFilter = null, Func<PathNode, bool> endNodeFilter = null, Func<PathNode, bool> nodeFilter = null, bool checkVisiblity = true)
         {
-            steering += CalculateSteeringSeek(target, weight, minGapWidth, startNodeFilter, endNodeFilter, nodeFilter, checkVisiblity);
+            if (buttonPressTimer > 0 && lastDoor.door != null && lastDoor.state && !lastDoor.door.IsOpen)
+            {
+                // We have pressed the button and are waiting for the door to open -> Hold still until we can press the button again.
+                Reset();
+            }
+            else
+            {
+                steering += CalculateSteeringSeek(target, weight, minGapWidth, startNodeFilter, endNodeFilter, nodeFilter, checkVisiblity);
+            }
         }
 
         /// <summary>
@@ -204,28 +213,23 @@ namespace Barotrauma
                     pathFinder.ApplyPenaltyToOutsideNodes = character.Submarine != null && character.PressureProtection <= 0;
                     var newPath = pathFinder.FindPath(currentPos, target, character.Submarine, "(Character: " + character.Name + ")", minGapSize, startNodeFilter, endNodeFilter, nodeFilter, checkVisibility: checkVisibility);
                     bool useNewPath = needsNewPath || currentPath == null || currentPath.CurrentNode == null || character.Submarine != null && findPathTimer < -1 && Math.Abs(character.AnimController.TargetMovement.Combine()) <= 0;
-                    if (newPath.Unreachable || newPath.Nodes.None())
-                    {
-                        useNewPath = false;
-                    }
-                    else if (!useNewPath && currentPath != null && currentPath.CurrentNode != null)
+                    if (!useNewPath && currentPath?.CurrentNode != null && newPath.Nodes.Any() && !newPath.Unreachable)
                     {
                         // Check if the new path is the same as the old, in which case we just ignore it and continue using the old path (or the progress would reset).
                         if (IsIdenticalPath())
                         {
                             useNewPath = false;
                         }
-                        else
+                        else if (!character.IsClimbing)
                         {
                             // Use the new path if it has significantly lower cost (don't change the path if it has marginally smaller cost. This reduces navigating backwards due to new path that is calculated from the node just behind us).
                             float t = (float)currentPath.CurrentIndex / (currentPath.Nodes.Count - 1);
                             useNewPath = newPath.Cost < currentPath.Cost * MathHelper.Lerp(0.95f, 0, t);
-                            if (!useNewPath && character.Submarine != null && !character.IsClimbing)
+                            if (!useNewPath && character.Submarine != null)
                             {
                                 // It's possible that the current path was calculated from a start point that is no longer valid.
                                 // Therefore, let's accept also paths with a greater cost than the current, if the current node is much farther than the new start node.
                                 // This is a special case for cases e.g. where the character falls and thus needs a new path.
-                                // Don't do this outside or when climbing ladders, because both cause issues.
                                 useNewPath = Vector2.DistanceSquared(character.WorldPosition, currentPath.CurrentNode.WorldPosition) > Math.Pow(Vector2.Distance(character.WorldPosition, newPath.Nodes.First().WorldPosition) * 3, 2);
                             }
                         }
@@ -319,7 +323,8 @@ namespace Barotrauma
                 return currentTarget - pos2;
             }
             bool doorsChecked = false;
-            if (!character.LockHands && buttonPressCooldown <= 0.0f)
+            checkDoorsTimer = Math.Min(checkDoorsTimer, GetDoorCheckTime());
+            if (!character.LockHands && checkDoorsTimer <= 0.0f)
             {
                 CheckDoorsInPath();
                 doorsChecked = true;
@@ -340,7 +345,7 @@ namespace Barotrauma
             {
                 if (character.CanInteractWith(ladders.Item))
                 {
-                    ladders.Item.TryInteract(character, false, true);
+                    ladders.Item.TryInteract(character, forceSelectKey: true);
                 }
                 else
                 {
@@ -351,7 +356,7 @@ namespace Barotrauma
                     if (previousLadders != null && previousLadders != ladders && character.SelectedConstruction != previousLadders.Item &&
                         character.CanInteractWith(previousLadders.Item) && Math.Abs(previousLadders.Item.WorldPosition.X - ladders.Item.WorldPosition.X) < 5)
                     {
-                        previousLadders.Item.TryInteract(character, false, true);
+                        previousLadders.Item.TryInteract(character, forceSelectKey: true);
                     }
                 }
             }
@@ -391,7 +396,7 @@ namespace Barotrauma
                         // Try to change the ladder (hatches between two submarines)
                         if (character.SelectedConstruction != nextLadder.Item && nextLadder.Item.IsInsideTrigger(character.WorldPosition))
                         {
-                            nextLadder.Item.TryInteract(character, false, true);
+                            nextLadder.Item.TryInteract(character, forceSelectKey: true);
                         }
                     }
                     if (isAboveFloor || nextLadderSameAsCurrent)
@@ -491,7 +496,14 @@ namespace Barotrauma
             else
             {
                 // We'll want this to run each time, because the delegate is used to find a valid button component.
-                bool canAccessButtons = door.Item.GetConnectedComponents<Controller>(true).Any(b => b.HasAccess(character) && (buttonFilter == null || buttonFilter(b)));
+                bool canAccessButtons = false;
+                foreach (var button in door.Item.GetConnectedComponents<Controller>(true))
+                {
+                    if (button.HasAccess(character) && (buttonFilter == null || buttonFilter(button)))
+                    {
+                        canAccessButtons = true;
+                    }
+                }
                 return canAccessButtons || door.IsOpen || ShouldBreakDoor(door);
             }
         }
@@ -504,8 +516,22 @@ namespace Barotrauma
             return ConvertUnits.ToDisplayUnits(Math.Max(colliderSize.X, colliderSize.Y));
         }
 
+        private (Door door, bool state) lastDoor;
+        private float GetDoorCheckTime()
+        {
+            if (steering.LengthSquared() > 0)
+            {
+                return character.AnimController.IsMovingFast ? 0.1f : 0.3f;
+            }
+            else
+            {
+                return float.PositiveInfinity;
+            }
+        }
+
         private void CheckDoorsInPath()
         {
+            checkDoorsTimer = GetDoorCheckTime();
             if (!canOpenDoors) { return; }
             for (int i = 0; i < 5; i++)
             {
@@ -522,8 +548,7 @@ namespace Barotrauma
                 }
                 else
                 {
-                    bool closeDoors = character.IsBot && character.IsInFriendlySub || character.Params.AI != null && character.Params.AI.KeepDoorsClosed;
-                    if (i == 0 || !closeDoors)
+                    if (i == 0)
                     {
                         currentWaypoint = currentPath.CurrentNode;
                         nextWaypoint = currentPath.NextNode;
@@ -544,7 +569,7 @@ namespace Barotrauma
                         if (currentWaypoint.ConnectedDoor.LinkedGap != null)
                         {
                             // Keep the airlock doors closed, but not in ruins/wrecks
-                            if (currentWaypoint.ConnectedDoor.LinkedGap.IsRoomToRoom || currentWaypoint.Submarine?.Info.IsRuin != null || currentWaypoint.Submarine?.Info.IsWreck != null)
+                            if (currentWaypoint.ConnectedDoor.LinkedGap.IsRoomToRoom && currentWaypoint.CurrentHull is { IsWetRoom: false } || currentWaypoint.Submarine == null || currentWaypoint.Submarine.Info.IsRuin || currentWaypoint.Submarine.Info.IsWreck)
                             {
                                 shouldBeOpen = true;
                                 door = currentWaypoint.ConnectedDoor;
@@ -570,28 +595,48 @@ namespace Barotrauma
                 }
 
                 if (door == null) { return; }
+
+                if (door.BotsShouldKeepOpen) { shouldBeOpen = true; }    
                 
-                //toggle the door if it's the previous node and open, or if it's current node and closed
                 if ((door.IsOpen || door.IsBroken) != shouldBeOpen)
                 {
+                    if (!shouldBeOpen)
+                    {
+                        if (character.AIController is HumanAIController humanAI)
+                        {
+                            bool keepDoorsClosed = character.IsBot && door.Item.Submarine?.TeamID == character.TeamID || character.Params.AI != null && character.Params.AI.KeepDoorsClosed;
+                            if (!keepDoorsClosed) { return; }
+                            bool isInAirlock = door.Item.CurrentHull is { IsWetRoom: true } || character.CurrentHull is { IsWetRoom: true };
+                            if (!isInAirlock)
+                            {
+                                // Don't slam the door at anyones face
+                                if (Character.CharacterList.Any(c => c != character && humanAI.IsFriendly(c) && humanAI.VisibleHulls.Contains(c.CurrentHull) && !c.IsUnconscious))
+                                {
+                                    return;
+                                }
+                            }
+                        }
+                    }
                     Controller closestButton = null;
                     float closestDist = 0;
                     bool canAccess = CanAccessDoor(door, button =>
                     {
-                        if (currentWaypoint == null) { return true; }
                         // Check that the button is on the right side of the door.
-                        if (door.LinkedGap.IsHorizontal)
+                        if (nextWaypoint != null)
                         {
-                            int dir = Math.Sign((nextWaypoint ?? currentWaypoint).WorldPosition.X - door.Item.WorldPosition.X);
-                            if (button.Item.WorldPosition.X * dir > door.Item.WorldPosition.X * dir) { return false; }
-                        }
-                        else
-                        {
-                            int dir = Math.Sign((nextWaypoint ?? currentWaypoint).WorldPosition.Y - door.Item.WorldPosition.Y);
-                            if (button.Item.WorldPosition.Y * dir > door.Item.WorldPosition.Y * dir) { return false; }
+                            if (door.LinkedGap.IsHorizontal)
+                            {
+                                int dir = Math.Sign((nextWaypoint).WorldPosition.X - door.Item.WorldPosition.X);
+                                if (button.Item.WorldPosition.X * dir > door.Item.WorldPosition.X * dir) { return false; }
+                            }
+                            else
+                            {
+                                int dir = Math.Sign((nextWaypoint).WorldPosition.Y - door.Item.WorldPosition.Y);
+                                if (button.Item.WorldPosition.Y * dir > door.Item.WorldPosition.Y * dir) { return false; }
+                            }
                         }
                         float distance = Vector2.DistanceSquared(button.Item.WorldPosition, character.WorldPosition);
-                        if (closestButton == null || distance < closestDist)
+                        if (closestButton == null || distance < closestDist && character.CanSeeTarget(button.Item))
                         {
                             closestButton = button;
                             closestDist = distance;
@@ -600,18 +645,39 @@ namespace Barotrauma
                     });
                     if (canAccess)
                     {
+                        bool pressButton = buttonPressTimer <= 0 || lastDoor.door != door || lastDoor.state != shouldBeOpen;
                         if (door.HasIntegratedButtons)
                         {
-                            door.Item.TryInteract(character, false, true);
-                            buttonPressCooldown = ButtonPressInterval;
+                            if (pressButton && character.CanSeeTarget(door.Item))
+                            {
+                                if (door.Item.TryInteract(character, forceSelectKey: true))
+                                {
+                                    lastDoor = (door, shouldBeOpen);
+                                    buttonPressTimer = buttonPressCooldown;
+                                }
+                                else
+                                {
+                                    buttonPressTimer = 0;
+                                }
+                            }
                             break;
                         }
                         else if (closestButton != null)
                         {
-                            if (Vector2.DistanceSquared(closestButton.Item.WorldPosition, character.WorldPosition) < MathUtils.Pow(closestButton.Item.InteractDistance + GetColliderLength(), 2))
+                            if (closestDist < MathUtils.Pow2(closestButton.Item.InteractDistance + GetColliderLength()))
                             {
-                                closestButton.Item.TryInteract(character, false, true);
-                                buttonPressCooldown = ButtonPressInterval;
+                                if (pressButton)
+                                {
+                                    if (closestButton.Item.TryInteract(character, forceSelectKey: true))
+                                    {
+                                        lastDoor = (door, shouldBeOpen);
+                                        buttonPressTimer = buttonPressCooldown;
+                                    }
+                                    else
+                                    {
+                                        buttonPressTimer = 0;
+                                    }
+                                }
                                 break;
                             }
                             else
@@ -631,6 +697,7 @@ namespace Barotrauma
                                     // The button is on the wrong side of the door or a wall
                                     currentPath.Unreachable = true;
                                 }
+                                lastDoor = (null, false);
                                 return;
                             }
                         }

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

@@ -12,20 +12,19 @@ namespace Barotrauma
     class LatchOntoAI
     {
         const float RaycastInterval = 5.0f;
-
         private float raycastTimer;
-
-        private Structure targetWall;
         private Body targetBody;
         private Vector2 attachSurfaceNormal;
-        private Submarine targetSubmarine;
-        private Character targetCharacter;
         private readonly Character character;
 
         public bool AttachToSub { get; private set; }
         public bool AttachToWalls { get; private set; }
         public bool AttachToCharacters { get; private set; }
 
+        public Submarine TargetSubmarine { get; private set; }
+        public Structure TargetWall { get; private set; }
+        public Character TargetCharacter { get; private set; }
+
         private readonly float minDeattachSpeed, maxDeattachSpeed, maxAttachDuration, coolDown;
         private readonly float damageOnDetach, detachStun;
         private readonly bool weld;
@@ -51,7 +50,7 @@ namespace Barotrauma
 
         public bool IsAttached => AttachJoints.Count > 0;
 
-        public bool IsAttachedToSub => IsAttached && targetSubmarine != null && targetCharacter == null;
+        public bool IsAttachedToSub => IsAttached && TargetSubmarine != null && TargetCharacter == null;
 
         public LatchOntoAI(XElement element, EnemyAIController enemyAI)
         {
@@ -93,9 +92,9 @@ namespace Barotrauma
             var sub = wall.Submarine;
             if (sub == null) { return; }
             Reset();
-            targetWall = wall;
-            targetSubmarine = sub;
-            targetBody = targetSubmarine.PhysicsBody.FarseerBody;
+            TargetWall = wall;
+            TargetSubmarine = sub;
+            targetBody = TargetSubmarine.PhysicsBody.FarseerBody;
             this.attachSurfaceNormal = attachSurfaceNormal;
             _attachPos = attachPos;
         }
@@ -103,23 +102,20 @@ namespace Barotrauma
         public void SetAttachTarget(Character target)
         {
             if (!AttachToCharacters) { return; }
+            if (target.Submarine != character.Submarine) { return; }
             Reset();
-            targetCharacter = target;
-            targetSubmarine = target.Submarine;
+            TargetCharacter = target;
             targetBody = target.AnimController.Collider.FarseerBody;
             attachSurfaceNormal = Vector2.Normalize(character.WorldPosition - target.WorldPosition);
         }
         
         public void Update(EnemyAIController enemyAI, float deltaTime)
         {
-            if (character.Submarine != null)
+            if (TargetCharacter != null && character.Submarine != TargetCharacter.Submarine ||
+                character.Submarine != null && TargetSubmarine != null && TargetCharacter == null)
             {
-                if (targetCharacter != null && targetCharacter.Submarine != targetSubmarine ||
-                    character.Submarine != null && targetSubmarine != null && targetCharacter == null)
-                {
-                    DeattachFromBody(reset: true);
-                    return;
-                }
+                DeattachFromBody(reset: true);
+                return;
             }
             if (IsAttached)
             {
@@ -150,7 +146,7 @@ namespace Barotrauma
                         return;
                     }
                 }
-                if (targetCharacter != null)
+                if (TargetCharacter != null)
                 {
                     if (enemyAI.AttackingLimb?.attack == null)
                     {
@@ -159,10 +155,14 @@ namespace Barotrauma
                     else
                     {
                         float range = enemyAI.AttackingLimb.attack.DamageRange * 2f;
-                        if (Vector2.DistanceSquared(targetCharacter.WorldPosition, enemyAI.AttackingLimb.WorldPosition) > range * range)
+                        if (Vector2.DistanceSquared(TargetCharacter.WorldPosition, enemyAI.AttackingLimb.WorldPosition) > range * range)
                         {
                             DeattachFromBody(reset: true, cooldown: 1);
                         }
+                        else
+                        {
+                            TargetCharacter.Latchers.Add(this);
+                        }
                     }
                 }
             }
@@ -176,15 +176,15 @@ namespace Barotrauma
                 deattachCheckTimer -= deltaTime;
             }
 
-            if (targetCharacter != null)
+            if (TargetCharacter != null)
             {
                 // Own sim pos -> target where we are
                 _attachPos = character.SimPosition;
             }
             Vector2 transformedAttachPos = _attachPos;
-            if (character.Submarine == null && targetSubmarine != null)
+            if (character.Submarine == null && TargetSubmarine != null)
             {
-                transformedAttachPos += ConvertUnits.ToSimUnits(targetSubmarine.Position);
+                transformedAttachPos += ConvertUnits.ToSimUnits(TargetSubmarine.Position);
             }
             if (transformedAttachPos != Vector2.Zero)
             {
@@ -207,7 +207,8 @@ namespace Barotrauma
                                 var cells = Level.Loaded.GetCells(character.WorldPosition, 1);
                                 if (cells.Count > 0)
                                 {
-                                    float closestDist = float.PositiveInfinity;
+                                    //ignore walls more than 200 meters away
+                                    float closestDist = 200.0f * 200.0f;
                                     foreach (Voronoi2.VoronoiCell cell in cells)
                                     {
                                         foreach (Voronoi2.GraphEdge edge in cell.Edges)
@@ -267,7 +268,7 @@ namespace Barotrauma
                     if (enemyAI.AttackingLimb == null) { break; }
                     if (targetBody == null) { break; }
                     if (IsAttached && AttachJoints[0].BodyB == targetBody) { break; }
-                    Vector2 referencePos = targetCharacter != null ? targetCharacter.WorldPosition : ConvertUnits.ToDisplayUnits(transformedAttachPos);
+                    Vector2 referencePos = TargetCharacter != null ? TargetCharacter.WorldPosition : ConvertUnits.ToDisplayUnits(transformedAttachPos);
                     if (Vector2.DistanceSquared(referencePos, enemyAI.AttackingLimb.WorldPosition) < enemyAI.AttackingLimb.attack.DamageRange * enemyAI.AttackingLimb.attack.DamageRange)
                     {
                         AttachToBody(transformedAttachPos);
@@ -286,11 +287,11 @@ namespace Barotrauma
                     deattach = true;
                     attachCooldown = coolDown;
                 }
-                if (!deattach && targetWall != null && targetSubmarine != null)
+                if (!deattach && TargetWall != null && TargetSubmarine != null)
                 {
                     // Deattach if the wall is broken enough where we are attached to
-                    int targetSection = targetWall.FindSectionIndex(attachLimb.WorldPosition, world: true, clamp: true);
-                    if (enemyAI.CanPassThroughHole(targetWall, targetSection))
+                    int targetSection = TargetWall.FindSectionIndex(attachLimb.WorldPosition, world: true, clamp: true);
+                    if (enemyAI.CanPassThroughHole(TargetWall, targetSection))
                     {
                         deattach = true;
                         attachCooldown = coolDown;
@@ -298,7 +299,7 @@ namespace Barotrauma
                     if (!deattach)
                     {
                         // Deattach if the velocity is high
-                        float velocity = targetSubmarine.Velocity == Vector2.Zero ? 0.0f : targetSubmarine.Velocity.Length();
+                        float velocity = TargetSubmarine.Velocity == Vector2.Zero ? 0.0f : TargetSubmarine.Velocity.Length();
                         deattach = velocity > maxDeattachSpeed;
                         if (!deattach)
                         {
@@ -385,11 +386,8 @@ namespace Barotrauma
                 } as Joint;
 
             GameMain.World.Add(colliderJoint);
-            AttachJoints.Add(colliderJoint); 
-            if (targetCharacter != null)
-            {
-                targetCharacter.Latchers.Add(this);
-            }
+            AttachJoints.Add(colliderJoint);
+            TargetCharacter?.Latchers.Add(this);
             if (maxAttachDuration > 0)
             {
                 deattachCheckTimer = maxAttachDuration;
@@ -407,25 +405,19 @@ namespace Barotrauma
             {
                 attachCooldown = cooldown;
             }
+            TargetCharacter?.Latchers.Remove(this);
             if (reset)
             {
                 Reset();
             }
-            if (targetCharacter != null)
-            {
-                targetCharacter.Latchers.Remove(this);
-            }
         }
 
         private void Reset()
         {
-            if (targetCharacter != null)
-            {
-                targetCharacter.Latchers.Remove(this);
-            }
-            targetCharacter = null;
-            targetWall = null;
-            targetSubmarine = null;
+            TargetCharacter?.Latchers.Remove(this);
+            TargetCharacter = null;
+            TargetWall = null;
+            TargetSubmarine = null;
             targetBody = null;
             AttachPos = null;
         }

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

@@ -93,13 +93,6 @@ namespace Barotrauma
                 _abandon = value;
                 if (_abandon)
                 {
-#if DEBUG
-                    if (HumanAIController.debugai && objectiveManager.IsOrder(this) && !objectiveManager.IsCurrentOrder<AIObjectiveGoTo>() && !objectiveManager.IsCurrentOrder<AIObjectiveReturn>())
-                    {
-                        // TODO: dismiss
-                        throw new Exception("Order abandoned!");
-                    }
-#endif
                     OnAbandon();
                 }
             }
@@ -247,7 +240,7 @@ namespace Barotrauma
             }
         }
 
-        protected bool IsAllowed
+        public bool IsAllowed
         {
             get 
             {
@@ -271,7 +264,7 @@ namespace Barotrauma
             if (!IsAllowed)
             {
                 Priority = 0;
-                Abandon = !isOrder;
+                Abandon = true;
                 return Priority;
             }
             if (isOrder)
@@ -290,9 +283,9 @@ namespace Barotrauma
         /// </summary>
         public float CalculatePriority()
         {
+            ForceWalk = false;
             Priority = GetPriority();
             ForceHighestPriority = false;
-            ForceWalk = false;
             return Priority;
         }
 
@@ -508,5 +501,34 @@ namespace Barotrauma
                 }
             }
         }
+
+        protected static bool CanEquip(Character character, Item item)
+        {
+            bool canEquip = item != null;
+            if (canEquip && !item.AllowedSlots.Contains(InvSlotType.Any))
+            {
+                canEquip = false;
+                var inv = character.Inventory;
+                foreach (var allowedSlot in item.AllowedSlots)
+                {
+                    foreach (var slotType in inv.SlotTypes)
+                    {
+                        if (!allowedSlot.HasFlag(slotType)) { continue; }
+                        for (int i = 0; i < inv.Capacity; i++)
+                        {
+                            canEquip = true;
+                            if (allowedSlot.HasFlag(inv.SlotTypes[i]) && inv.GetItemAt(i) != null)
+                            {
+                                canEquip = false;
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+            return canEquip;
+        }
+
+        protected bool CanEquip(Item item) => CanEquip(character, item);
     }
 }

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

@@ -68,15 +68,12 @@ namespace Barotrauma
         protected override void OnObjectiveCompleted(AIObjective objective, Item target)
             => HumanAIController.RemoveTargets<AIObjectiveCleanupItems, Item>(character, target);
 
-        private static bool IsItemInsideValidSubmarine(Item item, Character character)
+        public static bool IsItemInsideValidSubmarine(Item item, Character character)
         {
             if (item.CurrentHull == null) { return false; }
             if (item.Submarine == null) { return false; }
             if (item.Submarine.TeamID != character.TeamID) { return false; }
-            if (character.Submarine != null)
-            {
-                if (!character.Submarine.IsConnectedTo(item.Submarine)) { return false; }
-            }
+            if (character.Submarine != null && !character.Submarine.IsConnectedTo(item.Submarine)) { return false; }
             return true;
         }
 
@@ -94,7 +91,7 @@ namespace Barotrauma
             if (item == null) { return false; }
             if (item.IgnoreByAI(character)) { return false; }
             if (!item.IsInteractable(character)) { return false; }
-            if (item.SpawnedInOutpost) { return false; }
+            if ((item.SpawnedInCurrentOutpost && !item.AllowStealing) == character.IsOnPlayerTeam) { return false; }
             if (item.ParentInventory != null)
             {
                 if (item.Container == null)
@@ -129,29 +126,7 @@ namespace Barotrauma
             {
                 return true;
             }
-            bool canEquip = true;
-            if (!item.AllowedSlots.Contains(InvSlotType.Any))
-            {
-                canEquip = false;
-                var inv = character.Inventory;
-                foreach (var allowedSlot in item.AllowedSlots)
-                {
-                    foreach (var slotType in inv.SlotTypes)
-                    {
-                        if (!allowedSlot.HasFlag(slotType)) { continue; }                        
-                        for (int i = 0; i < inv.Capacity; i++)
-                        {
-                            canEquip = true;
-                            if (allowedSlot.HasFlag(inv.SlotTypes[i]) && inv.GetItemAt(i) != null)
-                            {
-                                canEquip = false;
-                                break;
-                            }
-                        }                        
-                    }
-                }
-            }
-            return canEquip;
+            return CanEquip(character, item);
         }
 
         public override void OnDeselected()

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

@@ -111,7 +111,7 @@ namespace Barotrauma
         public CombatMode Mode { get; private set; }
 
         private bool IsOffensiveOrArrest => initialMode == CombatMode.Offensive || initialMode == CombatMode.Arrest;
-        private bool TargetEliminated => IsEnemyDisabled || (Enemy.IsUnconscious && Enemy.Params.Health.ConstantHealthRegeneration <= 0.0f);
+        private bool TargetEliminated => IsEnemyDisabled || Enemy.IsUnconscious && Enemy.Params.Health.ConstantHealthRegeneration <= 0.0f || Enemy.IsArrested && !character.IsInstigator;
         private bool IsEnemyDisabled => Enemy == null || Enemy.Removed || Enemy.IsDead;
 
         private float AimSpeed => HumanAIController.AimSpeed;
@@ -158,7 +158,7 @@ namespace Barotrauma
                     return Priority;
                 }
             }
-            float damageFactor = MathUtils.InverseLerp(0.0f, 5.0f, HumanAIController.GetDamageDoneByAttacker(Enemy) / 100.0f);
+            float damageFactor = MathUtils.InverseLerp(0.0f, 5.0f, character.GetDamageDoneByAttacker(Enemy) / 100.0f);
             Priority = TargetEliminated ? 0 : Math.Min((95 + damageFactor) * PriorityModifier, 100);
             return Priority;
         }
@@ -177,11 +177,12 @@ namespace Barotrauma
                 ignoredWeapons.Clear();
                 ignoreWeaponTimer = ignoredWeaponsClearTime;
             }
-            if (findSafety != null)
+            bool isCurrentObjective = objectiveManager.IsCurrentObjective<AIObjectiveFightIntruders>();
+            if (findSafety != null && isCurrentObjective)
             {
                 findSafety.Priority = 0;
             }
-            if (!AllowCoolDown && !character.IsOnPlayerTeam && !objectiveManager.IsCurrentObjective<AIObjectiveFightIntruders>())
+            if (!AllowCoolDown && !character.IsOnPlayerTeam && !isCurrentObjective)
             {
                 distanceTimer -= deltaTime;
                 if (distanceTimer < 0)
@@ -204,13 +205,18 @@ namespace Barotrauma
 
         protected override void Act(float deltaTime)
         {
+            if (IsEnemyDisabled)
+            {
+                IsCompleted = true;
+                return;
+            }
             if (AllowCoolDown)
             {
                 coolDownTimer -= deltaTime;
             }
             if (seekAmmunitionObjective == null && seekWeaponObjective == null)
             {
-                if (Mode != CombatMode.Retreat && TryArm() && !IsEnemyDisabled)
+                if (Mode != CombatMode.Retreat && TryArm())
                 {
                     OperateWeapon(deltaTime);
                 }
@@ -283,10 +289,12 @@ namespace Barotrauma
                     }
                     else
                     {
+                        AskHelp();
                         Retreat(deltaTime);
                     }
                     break;
                 case CombatMode.Retreat:
+                    AskHelp();
                     Retreat(deltaTime);
                     break;
                 default:
@@ -294,10 +302,6 @@ namespace Barotrauma
             }
         }
 
-        private bool IsLoaded(ItemComponent weapon, bool checkContainedItems = true) => 
-            weapon.HasRequiredContainedItems(character, addMessage: false) &&
-            (!checkContainedItems || weapon.Item.OwnInventory == null || weapon.Item.OwnInventory.AllItems.Any(i => i.Condition > 0));
-
         private bool TryArm()
         {
             if (character.LockHands || Enemy == null)
@@ -325,7 +329,7 @@ namespace Barotrauma
                         Weapon = null;
                         continue;
                     }
-                    if (IsLoaded(WeaponComponent, checkContainedItems: true))
+                    if (WeaponComponent.IsLoaded(character))
                     {
                         // All good, the weapon is loaded
                         break;
@@ -367,6 +371,7 @@ namespace Barotrauma
                 {
                     if (WeaponComponent == null)
                     {
+                        SpeakNoWeapons();
                         Mode = CombatMode.Retreat;
                     }
                 }
@@ -380,6 +385,7 @@ namespace Barotrauma
                         constructor: () => new AIObjectiveGetItem(character, "weapon", objectiveManager, equip: true, checkInventory: false)
                         {
                             AllowStealing = HumanAIController.IsMentallyUnstable,
+                            EvaluateCombatPriority = false,  // Use a custom formula instead
                             GetItemPriority = i =>
                             {
                                 if (Weapon != null && (i == Weapon || i.Prefab.Identifier == Weapon.Prefab.Identifier)) { return 0; }
@@ -412,6 +418,7 @@ namespace Barotrauma
                         onCompleted: () => RemoveSubObjective(ref seekWeaponObjective),
                         onAbandon: () =>
                         {
+                            SpeakNoWeapons();
                             RemoveSubObjective(ref seekWeaponObjective);
                             Mode = CombatMode.Retreat;
                         });
@@ -433,7 +440,7 @@ namespace Barotrauma
                     // Not in the inventory anymore or cannot find the weapon component
                     return false;
                 }
-                if (!IsLoaded(WeaponComponent))
+                if (!WeaponComponent.IsLoaded(character))
                 {
                     // Try reloading (and seek ammo)
                     if (!Reload(seekAmmo))
@@ -475,7 +482,7 @@ namespace Barotrauma
             foreach (var weapon in weaponList)
             {
                 float priority = weapon.CombatPriority;
-                if (!IsLoaded(weapon))
+                if (!weapon.IsLoaded(character))
                 {
                     if (weapon is RangedWeapon && enemyIsClose)
                     {
@@ -564,31 +571,6 @@ namespace Barotrauma
             }
             return weaponComponent.Item;
 
-            static Attack GetAttackDefinition(ItemComponent weapon)
-            {
-                Attack attack = null;
-                if (weapon is MeleeWeapon meleeWeapon)
-                {
-                    attack = meleeWeapon.Attack;
-                }
-                else if (weapon is RangedWeapon rangedWeapon)
-                {
-                    attack = rangedWeapon.FindProjectile(triggerOnUseOnContainers: false)?.Attack;
-                }
-                return attack;
-            }
-
-            static float GetLethalDamage(ItemComponent weapon)
-            {
-                float lethalDmg = 0;
-                Attack attack = GetAttackDefinition(weapon);
-                if (attack != null)
-                {
-                    lethalDmg = attack.GetTotalDamage();
-                }
-                return lethalDmg;
-            }
-
             float ApproximateStunDamage(ItemComponent weapon, Attack attack)
             {
                 // Try to reduce the priority using the actual damage values and status effects.
@@ -628,6 +610,31 @@ namespace Barotrauma
             }
         }
 
+        public static float GetLethalDamage(ItemComponent weapon)
+        {
+            float lethalDmg = 0;
+            Attack attack = GetAttackDefinition(weapon);
+            if (attack != null)
+            {
+                lethalDmg = attack.GetTotalDamage();
+            }
+            return lethalDmg;
+        }
+
+        private static Attack GetAttackDefinition(ItemComponent weapon)
+        {
+            Attack attack = null;
+            if (weapon is MeleeWeapon meleeWeapon)
+            {
+                attack = meleeWeapon.Attack;
+            }
+            else if (weapon is RangedWeapon rangedWeapon)
+            {
+                attack = rangedWeapon.FindProjectile(triggerOnUseOnContainers: false)?.Attack;
+            }
+            return attack;
+        }
+
         private HashSet<ItemComponent> FindWeaponsFromInventory()
         {
             weapons.Clear();
@@ -661,6 +668,13 @@ namespace Barotrauma
             {
                 if (!Weapon.AllowedSlots.Contains(InvSlotType.Any) || !character.Inventory.TryPutItem(Weapon, character, new List<InvSlotType>() { InvSlotType.Any }))
                 {
+                    if (Weapon.AllowedSlots.Contains(InvSlotType.Bag))
+                    {
+                        if (character.Inventory.TryPutItem(Weapon, character, new List<InvSlotType>() { InvSlotType.Bag }))
+                        {
+                            return;
+                        }
+                    }
                     Weapon.Drop(character);
                 }
             }
@@ -673,22 +687,25 @@ namespace Barotrauma
             {
                 return false;
             }
-            if (!character.HasEquippedItem(Weapon))
+            if (!character.HasEquippedItem(Weapon, predicate: IsHandSlotType))
             {
                 Weapon.TryInteract(character, forceSelectKey: true);
-                var slots = Weapon.AllowedSlots.Where(s => s == InvSlotType.LeftHand || s == InvSlotType.RightHand || s == (InvSlotType.LeftHand | InvSlotType.RightHand));
+                var slots = Weapon.AllowedSlots.Where(s => IsHandSlotType(s));
                 if (character.Inventory.TryPutItem(Weapon, character, slots))
                 {
                     aimTimer = Rand.Range(0.2f, 0.4f) / AimSpeed;
                 }
                 else
                 {
+                    SpeakNoWeapons();
                     Weapon = null;
                     Mode = CombatMode.Retreat;
                     return false;
                 }
             }
             return true;
+
+            bool IsHandSlotType(InvSlotType s) => s == InvSlotType.LeftHand || s == InvSlotType.RightHand || s == (InvSlotType.LeftHand | InvSlotType.RightHand);
         }
 
         private float findHullTimer;
@@ -788,7 +805,6 @@ namespace Barotrauma
                 {
                     UsePathingOutside = false,
                     IgnoreIfTargetDead = true,
-                    DialogueIdentifier = "dialogcannotreachtarget",
                     TargetName = Enemy.DisplayName,
                     AlwaysUseEuclideanDistance = false
                 },
@@ -812,7 +828,7 @@ namespace Barotrauma
                         ItemPrefab prefab = ItemPrefab.Find(null, "handcuffs");
                         if (prefab != null)
                         {
-                            Entity.Spawner.AddToSpawnQueue(prefab, character.Inventory, onSpawned: (Item i) => i.SpawnedInOutpost = true);
+                            Entity.Spawner.AddToSpawnQueue(prefab, character.Inventory, onSpawned: (Item i) => i.SpawnedInCurrentOutpost = true);
                         }
                     }
                     RemoveFollowTarget();
@@ -896,8 +912,9 @@ namespace Barotrauma
             TryAddSubObjective(ref seekAmmunitionObjective,
                 constructor: () => new AIObjectiveContainItem(character, ammunitionIdentifiers, Weapon.GetComponent<ItemContainer>(), objectiveManager)
                 {
-                    targetItemCount = Weapon.GetComponent<ItemContainer>().Capacity,
-                    checkInventory = false
+                    ItemCount = Weapon.GetComponent<ItemContainer>().Capacity * Weapon.GetComponent<ItemContainer>().MaxStackSize,
+                    checkInventory = false,
+                    MoveWholeStack = true
                 },
                 onCompleted: () => RemoveSubObjective(ref seekAmmunitionObjective),
                 onAbandon: () =>
@@ -1103,7 +1120,7 @@ namespace Barotrauma
             if (WeaponComponent is RangedWeapon rangedWeapon)
             {
                 // If the weapon is just equipped, we can't shoot just yet.
-                if (rangedWeapon.ReloadTimer <= 0)
+                if (rangedWeapon.ReloadTimer <= 0 && !rangedWeapon.HoldTrigger)
                 {
                     reloadTime = rangedWeapon.Reload;
                 }
@@ -1159,6 +1176,21 @@ namespace Barotrauma
             retreatTarget = null;
         }
 
+        private void SpeakNoWeapons() => Speak("dialogcombatnoweapons", delay: 0, minDuration: 30);
+        private void AskHelp() => Speak("dialogcombatretreating", delay: Rand.Range(0, 1), minDuration: 20);
+
+        private void Speak(string textIdentifier, float delay, float minDuration)
+        {
+            if (character.IsOnPlayerTeam && !character.IsInFriendlySub)
+            {
+                string msg = TextManager.Get(textIdentifier, true);
+                if (msg != null)
+                {
+                    character.Speak(msg, identifier: textIdentifier, delay: delay, minDurationBetweenSimilar: minDuration);
+                }
+            }
+        }
+
         //private float CalculateEnemyStrength()
         //{
         //    float enemyStrength = 0;

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

@@ -11,12 +11,11 @@ namespace Barotrauma
 
         public Func<Item, float> GetItemPriority;
 
-        public int targetItemCount = 1;
         public string[] ignoredContainerIdentifiers;
         public bool checkInventory = true;
 
-        //if the item can't be found, spawn it in the character's inventory (used by outpost NPCs)
-        private bool spawnItemIfNotFound = false;
+        //if the item can't be found, spawn it in the character's inventory (used by outpost NPCs and in some cases also enemy NPCs, like pirates)
+        private readonly bool spawnItemIfNotFound;
 
         //can either be a tag or an identifier
         public readonly string[] itemIdentifiers;
@@ -35,9 +34,24 @@ namespace Barotrauma
         public bool Equip { get; set; }
         public bool RemoveEmpty { get; set; } = true;
         public bool RemoveExisting { get; set; }
+        /// <summary>
+        /// Only remove existing items when the contain target can't be put in the inventory
+        /// </summary>
+        public bool RemoveExistingWhenNecessary { get; set; }
+        public Func<Item, bool> RemoveExistingPredicate { get; set; }
+        public int? RemoveMax { get; set; }
 
         public bool MoveWholeStack { get; set; }
 
+        private int _itemCount = 1;
+        public int ItemCount
+        {
+            get { return _itemCount; }
+            set
+            {
+                _itemCount = Math.Max(value, 1);
+            }
+        }
 
         public AIObjectiveContainItem(Character character, Item item, ItemContainer container, AIObjectiveManager objectiveManager, float priorityModifier = 1)
             : base(character, objectiveManager, priorityModifier)
@@ -83,7 +97,7 @@ namespace Barotrauma
                         containedItemCount++;
                     }
                 }
-                return containedItemCount >= targetItemCount;
+                return containedItemCount >= ItemCount;
             }
         }
 
@@ -106,9 +120,9 @@ namespace Barotrauma
                 }
                 if (character.CanInteractWith(container.Item, checkLinked: false))
                 {
-                    if (RemoveExisting)
+                    if (RemoveExisting || (RemoveExistingWhenNecessary && !container.Inventory.CanBePut(item)))
                     {
-                        HumanAIController.UnequipContainedItems(container.Item);
+                        HumanAIController.UnequipContainedItems(container.Item, predicate: RemoveExistingPredicate, unequipMax: RemoveMax);
                     }
                     else if (RemoveEmpty)
                     {
@@ -127,7 +141,6 @@ namespace Barotrauma
                                     container.Inventory.TryPutItem(item, null);
                                 }
                             }
-
                             IsCompleted = true;
                         }
                     }
@@ -144,7 +157,6 @@ namespace Barotrauma
                 {
                     TryAddSubObjective(ref goToObjective, () => new AIObjectiveGoTo(container.Item, character, objectiveManager, getDivingGearIfNeeded: AllowToFindDivingGear)
                     {
-                        DialogueIdentifier = "dialogcannotreachtarget",
                         TargetName = container.Item.Name,
                         AbortCondition = obj =>
                             container?.Item == null || container.Item.Removed || container.Item.IsThisOrAnyContainerIgnoredByAI(character) ||
@@ -174,7 +186,9 @@ namespace Barotrauma
                             AllowToFindDivingGear = AllowToFindDivingGear,
                             AllowDangerousPressure = AllowDangerousPressure,
                             TargetCondition = ConditionLevel,
-                            ItemFilter = (Item potentialItem) => RemoveEmpty ? container.CanBeContained(potentialItem) : container.Inventory.CanBePut(potentialItem)
+                            ItemFilter = (Item potentialItem) => RemoveEmpty ? container.CanBeContained(potentialItem) : container.Inventory.CanBePut(potentialItem),
+                            ItemCount = ItemCount,
+                            TakeWholeStack = MoveWholeStack
                         }, onAbandon: () =>
                         {
                             Abandon = true;

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

@@ -36,6 +36,11 @@ namespace Barotrauma
         /// </summary>
         public bool DropIfFails { get; set; } = true;
 
+        public bool RemoveExistingWhenNecessary { get; set; }
+        public Func<Item, bool> RemoveExistingPredicate { get; set; }
+        public int? RemoveExistingMax { get; set; }
+        public string AbandonGetItemDialogueIdentifier { get; set; }
+
         public AIObjectiveDecontainItem(Character character, Item targetItem, AIObjectiveManager objectiveManager, ItemContainer sourceContainer = null, ItemContainer targetContainer = null, float priorityModifier = 1) 
             : base(character, objectiveManager, priorityModifier)
         {
@@ -86,6 +91,7 @@ namespace Barotrauma
                 }
                 if (itemToDecontain.Container != sourceContainer.Item)
                 {
+                    itemToDecontain.Drop(character);
                     IsCompleted = true;
                     return;
                 }
@@ -98,7 +104,12 @@ namespace Barotrauma
             if (getItemObjective == null && !itemToDecontain.IsOwnedBy(character))
             {
                 TryAddSubObjective(ref getItemObjective,
-                    constructor: () => new AIObjectiveGetItem(character, targetItem, objectiveManager, Equip) { TakeWholeStack = this.TakeWholeStack },
+                    constructor: () => new AIObjectiveGetItem(character, targetItem, objectiveManager, Equip)
+                    {
+                        CannotFindDialogueIdentifierOverride = AbandonGetItemDialogueIdentifier,
+                        SpeakIfFails = AbandonGetItemDialogueIdentifier != null,
+                        TakeWholeStack = this.TakeWholeStack
+                    },
                     onAbandon: () => Abandon = true);
                 return;
             }
@@ -110,6 +121,9 @@ namespace Barotrauma
                         MoveWholeStack = TakeWholeStack,
                         Equip = Equip,
                         RemoveEmpty = false,
+                        RemoveExistingWhenNecessary = RemoveExistingWhenNecessary,
+                        RemoveExistingPredicate = RemoveExistingPredicate,
+                        RemoveMax = RemoveExistingMax,
                         GetItemPriority = GetItemPriority,
                         ignoredContainerIdentifiers = sourceContainer != null ? new string[] { sourceContainer.Item.Prefab.Identifier } : null
                     },

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

@@ -31,7 +31,7 @@ namespace Barotrauma
 
         protected override AIObjective ObjectiveConstructor(Character target)
         {
-            AIObjectiveCombat.CombatMode combatMode = target.IsEscorted && character.TeamID == CharacterTeamType.Team1 ? AIObjectiveCombat.CombatMode.Arrest : AIObjectiveCombat.CombatMode.Offensive;
+            AIObjectiveCombat.CombatMode combatMode = ShouldArrest(target, character) ? AIObjectiveCombat.CombatMode.Arrest : AIObjectiveCombat.CombatMode.Offensive;
             var combatObjective = new AIObjectiveCombat(character, target, combatMode, objectiveManager, PriorityModifier);
             if (character.TeamID == CharacterTeamType.FriendlyNPC && target.TeamID == CharacterTeamType.Team1 && GameMain.GameSession?.GameMode is CampaignMode campaign)
             {
@@ -41,7 +41,7 @@ namespace Barotrauma
                     combatObjective.holdFireCondition = () =>
                     {
                         //hold fire while the enemy is in the airlock (except if they've attacked us)
-                        if (HumanAIController.GetDamageDoneByAttacker(target) > 0.0f) { return false; }
+                        if (character.GetDamageDoneByAttacker(target) > 0.0f) { return false; }
                         return target.CurrentHull == null || target.CurrentHull.OutpostModuleTags.Any(t => t.Equals("airlock", System.StringComparison.OrdinalIgnoreCase));
                     };
                     character.Speak(TextManager.Get("dialogenteroutpostwarning"), null, Rand.Range(0.5f, 1.0f), "leaveoutpostwarning", 30.0f);
@@ -65,7 +65,13 @@ namespace Barotrauma
             if (HumanAIController.IsFriendly(character, target)) { return false; }
             if (!character.Submarine.IsConnectedTo(target.Submarine)) { return false; }
             if (target.HasAbilityFlag(AbilityFlags.IgnoredByEnemyAI)) { return false; }
+            if (target.IsArrested) { return false; }
             return true;
         }
+
+        public static bool ShouldArrest(Character target, Character character)
+        {
+            return target != null && target.IsEscorted && character.TeamID == CharacterTeamType.Team1;
+        }
     }
 }

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

@@ -19,10 +19,15 @@ namespace Barotrauma
         private AIObjectiveContainItem getOxygen;
         private Item targetItem;
 
-        public static float MIN_OXYGEN = 10;
-        public static string HEAVY_DIVING_GEAR = "deepdiving";
-        public static string LIGHT_DIVING_GEAR = "lightdiving";
-        public static string OXYGEN_SOURCE = "oxygensource";
+        public const float MIN_OXYGEN = 10;
+
+        public const string HEAVY_DIVING_GEAR = "deepdiving";
+        public const string LIGHT_DIVING_GEAR = "lightdiving";
+        /// <summary>
+        /// Diving gear that's suitable for wearing indoors (-> the bots don't try to unequip it when they don't need diving gear)
+        /// </summary>
+        public const string DIVING_GEAR_WEARABLE_INDOORS = "divinggear_wearableindoors";
+        public const string OXYGEN_SOURCE = "oxygensource";
 
         protected override bool CheckObjectiveSpecific() => targetItem != null && character.HasEquippedItem(targetItem, slotType: InvSlotType.OuterClothes | InvSlotType.Head);
 

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

@@ -46,10 +46,19 @@ namespace Barotrauma
             }
             if (character.CurrentHull == null)
             {
-                Priority = (objectiveManager.IsCurrentOrder<AIObjectiveGoTo>() ||
-                    objectiveManager.IsCurrentOrder<AIObjectiveReturn>() ||
-                    objectiveManager.Objectives.Any(o => o.Priority > 0 && o is AIObjectiveCombat))
-                    && HumanAIController.HasDivingSuit(character) ? 0 : 100;
+                if (!character.NeedsAir)
+                {
+                    Priority = 0;
+                }
+                else
+                {
+                    Priority = (
+                        objectiveManager.HasOrder<AIObjectiveGoTo>(o => o.Priority > 0) ||
+                        objectiveManager.HasOrder<AIObjectiveReturn>(o => o.Priority > 0) ||
+                        objectiveManager.HasActiveObjective<AIObjectiveRescue>() ||
+                        objectiveManager.Objectives.Any(o => o is AIObjectiveCombat && o.Priority > 0))
+                        && HumanAIController.HasDivingSuit(character) ? 0 : 100;
+                }
             }
             else
             {
@@ -253,7 +262,7 @@ namespace Barotrauma
                     }
                     foreach (Character enemy in Character.CharacterList)
                     {
-                        if (!HumanAIController.IsActive(enemy) || HumanAIController.IsFriendly(enemy)) { continue; }
+                        if (!HumanAIController.IsActive(enemy) || HumanAIController.IsFriendly(enemy) || enemy.IsArrested) { continue; }
                         if (HumanAIController.VisibleHulls.Contains(enemy.CurrentHull))
                         {
                             Vector2 dir = character.Position - enemy.Position;

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

@@ -1,6 +1,7 @@
 using Barotrauma.Items.Components;
 using Microsoft.Xna.Framework;
 using System;
+using System.Collections.Immutable;
 using System.Collections.Generic;
 using System.Linq;
 
@@ -11,6 +12,7 @@ namespace Barotrauma
         public override string Identifier { get; set; } = "get item";
 
         public override bool AbandonWhenCannotCompleteSubjectives => false;
+        public override bool AllowMultipleInstances => true;
 
         public HashSet<Item> ignoredItems = new HashSet<Item>();
 
@@ -19,7 +21,7 @@ namespace Barotrauma
         public float TargetCondition { get; set; } = 1;
         public bool AllowDangerousPressure { get; set; }
 
-        private readonly string[] identifiersOrTags;
+        public readonly ImmutableArray<string> IdentifiersOrTags;
 
         //if the item can't be found, spawn it in the character's inventory (used by outpost NPCs)
         private bool spawnItemIfNotFound = false;
@@ -31,6 +33,7 @@ namespace Barotrauma
         public Item TargetItem => targetItem;
         private int currSearchIndex;
         public string[] ignoredContainerIdentifiers;
+        public string[] ignoredIdentifiersOrTags;
         private AIObjectiveGoTo goToObjective;
         private float currItemPriority;
         private readonly bool checkInventory;
@@ -51,6 +54,21 @@ namespace Barotrauma
         public bool AllowVariants { get; set; }
         public bool Equip { get; set; }
         public bool Wear { get; set; }
+        public bool RequireLoaded { get; set; }
+        public bool EvaluateCombatPriority { get; set; }
+        public bool CheckPathForEachItem { get; set; }
+        public bool SpeakIfFails { get; set; }
+        public string CannotFindDialogueIdentifierOverride { get; set; }
+
+        private int _itemCount = 1;
+        public int ItemCount
+        {
+            get { return _itemCount; }
+            set
+            {
+                _itemCount = Math.Max(value, 1);
+            }
+        }
 
         public InvSlotType? EquipSlotType { get; set; }
 
@@ -67,23 +85,46 @@ namespace Barotrauma
         public AIObjectiveGetItem(Character character, string identifierOrTag, AIObjectiveManager objectiveManager, bool equip = true, bool checkInventory = true, float priorityModifier = 1, bool spawnItemIfNotFound = false) 
             : this(character, new string[] { identifierOrTag }, objectiveManager, equip, checkInventory, priorityModifier, spawnItemIfNotFound) { }
 
-        public AIObjectiveGetItem(Character character, string[] identifiersOrTags, AIObjectiveManager objectiveManager, bool equip = true, bool checkInventory = true, float priorityModifier = 1, bool spawnItemIfNotFound = false) 
+        public AIObjectiveGetItem(Character character, IEnumerable<string> identifiersOrTags, AIObjectiveManager objectiveManager, bool equip = true, bool checkInventory = true, float priorityModifier = 1, bool spawnItemIfNotFound = false) 
             : base(character, objectiveManager, priorityModifier)
         {
             currSearchIndex = -1;
             Equip = equip;
-            this.identifiersOrTags = identifiersOrTags;
             this.spawnItemIfNotFound = spawnItemIfNotFound;
-            for (int i = 0; i < identifiersOrTags.Length; i++)
-            {
-                identifiersOrTags[i] = identifiersOrTags[i].ToLowerInvariant();
-            }
             this.checkInventory = checkInventory;
+            IdentifiersOrTags = ParseGearTags(identifiersOrTags).ToImmutableArray();
+            ignoredIdentifiersOrTags = ParseIgnoredTags(identifiersOrTags).ToArray();
+        }
+
+        public static IEnumerable<string> ParseGearTags(IEnumerable<string> identifiersOrTags)
+        {
+            var tags = new List<string>();
+            foreach (string tag in identifiersOrTags)
+            {
+                if (!tag.Contains('!'))
+                {
+                    tags.Add(tag.ToLowerInvariant());
+                }
+            }
+            return tags;
+        }
+
+        public static IEnumerable<string> ParseIgnoredTags(IEnumerable<string> identifiersOrTags)
+        {
+            var ignoredTags = new List<string>();
+            foreach (string tag in identifiersOrTags)
+            {
+                if (tag.Contains('!'))
+                {
+                    ignoredTags.Add(tag.Remove("!").ToLowerInvariant());
+                }
+            }
+            return ignoredTags;
         }
 
         private bool CheckInventory()
         {
-            if (identifiersOrTags == null) { return false; }
+            if (IdentifiersOrTags == null) { return false; }
             var item = character.Inventory.FindItem(i => CheckItem(i), recursive: true);
             if (item != null)
             {
@@ -93,6 +134,19 @@ namespace Barotrauma
             return item != null;
         }
 
+        private bool CountItems()
+        {
+            int itemCount = 0;
+            foreach (Item it in character.Inventory.AllItems)
+            {
+                if (CheckItem(it))
+                {
+                    itemCount++;
+                }
+            }
+            return itemCount >= ItemCount;
+        }
+
         protected override void Act(float deltaTime)
         {
             if (character.LockHands)
@@ -105,7 +159,7 @@ namespace Barotrauma
                 Abandon = true;
                 return;
             }
-            if (identifiersOrTags != null && !isDoneSeeking)
+            if (IdentifiersOrTags != null && !isDoneSeeking)
             {
                 if (checkInventory)
                 {
@@ -122,7 +176,7 @@ namespace Barotrauma
                         if (dangerousPressure)
                         {
 #if DEBUG
-                            string itemName = targetItem != null ? targetItem.Name : identifiersOrTags.FirstOrDefault();
+                            string itemName = targetItem != null ? targetItem.Name : IdentifiersOrTags.FirstOrDefault();
                             DebugConsole.NewMessage($"{character.Name}: Seeking item ({itemName}) aborted, because the pressure is dangerous.", Color.Yellow);
 #endif
                             Abandon = true;
@@ -215,10 +269,28 @@ namespace Barotrauma
                             }
                         }
                     }
-                    IsCompleted = true;
+                    if (IdentifiersOrTags == null)
+                    {
+                        IsCompleted = true;
+                    }
+                    else
+                    {
+                        IsCompleted = CountItems();
+                        if (!IsCompleted)
+                        {
+                            ResetInternal();
+                        }
+                    }
                 }
                 else
                 {
+                    if (!Equip)
+                    {
+                        // Try equipping and wearing the item
+                        Wear = true;
+                        Equip = true;
+                        return;
+                    }
 #if DEBUG
                     DebugConsole.NewMessage($"{character.Name}: Failed to equip/move the item '{targetItem.Name}' into the character inventory. Aborting.", Color.Red);
 #endif
@@ -243,6 +315,10 @@ namespace Barotrauma
                         {
                             // Try again
                             ignoredItems.Add(targetItem);
+                            if (targetItem != moveToTarget && moveToTarget is Item item)
+                            {
+                                ignoredItems.Add(item);
+                            }
                             ResetInternal();
                         }
                         else
@@ -256,7 +332,7 @@ namespace Barotrauma
 
         private void FindTargetItem()
         {
-            if (identifiersOrTags == null)
+            if (IdentifiersOrTags == null)
             {
                 if (targetItem == null)
                 {
@@ -269,7 +345,15 @@ namespace Barotrauma
             }
 
             float priority = Math.Clamp(objectiveManager.GetCurrentPriority(), 10, 100);
-            bool checkPath = priority >= AIObjectiveManager.LowestOrderPriority && (objectiveManager.IsCurrentOrder<AIObjectiveFixLeaks>() || objectiveManager.CurrentOrder is AIObjectiveGoTo gotoOrder && gotoOrder.isFollowOrderObjective);
+            if (!CheckPathForEachItem)
+            {
+                // While following the player, let's ensure that there's a valid path to the target before accepting it.
+                // Otherwise it will take some time for us to find a valid item when there are multiple items that we can't reach and some that we can.
+                // This is relatively expensive, so let's do this only when it significantly improves the behavior.
+                // Only allow one path find call per frame.
+                CheckPathForEachItem = priority >= AIObjectiveManager.LowestOrderPriority && (objectiveManager.IsCurrentOrder<AIObjectiveFixLeaks>() || objectiveManager.CurrentOrder is AIObjectiveGoTo gotoOrder && gotoOrder.IsFollowOrderObjective);
+            }
+            bool checkPath = CheckPathForEachItem;
             bool hasCalledPathFinder = false;
             int itemsPerFrame = (int)priority;
             for (int i = 0; i < itemsPerFrame && currSearchIndex < Item.ItemList.Count - 1; i++)
@@ -280,14 +364,20 @@ namespace Barotrauma
                 if (itemSub == null) { continue; }
                 Submarine mySub = character.Submarine;
                 if (mySub == null) { continue; }
+                if (!checkInventory)
+                {
+                    // Ignore items in the inventory when defined not to check it.
+                    if (item.IsOwnedBy(character)) { continue; }
+                }
                 if (!AllowStealing)
                 {
-                    if (character.TeamID == CharacterTeamType.FriendlyNPC != item.SpawnedInOutpost) { continue; }
+                    if (character.TeamID == CharacterTeamType.FriendlyNPC != item.SpawnedInCurrentOutpost) { continue; }
                 }
                 if (!CheckItem(item)) { continue; }
                 if (item.Container != null)
                 {
                     if (item.Container.HasTag("donttakeitems")) { continue; }
+                    if (ignoredItems.Contains(item.Container)) { continue; }
                     if (ignoredContainerIdentifiers != null)
                     {
                         if (ignoredContainerIdentifiers.Contains(item.ContainerIdentifier)) { continue; }
@@ -315,17 +405,51 @@ namespace Barotrauma
                 float yDist = Math.Abs(character.WorldPosition.Y - itemPos.Y);
                 yDist = yDist > 100 ? yDist * 5 : 0;
                 float dist = Math.Abs(character.WorldPosition.X - itemPos.X) + yDist;
-                float distanceFactor = MathHelper.Lerp(1, 0, MathUtils.InverseLerp(0, 10000, dist));
+                float minDistFactor = EvaluateCombatPriority ? 0.1f : 0;
+                float distanceFactor = MathHelper.Lerp(1, minDistFactor, MathUtils.InverseLerp(100, 10000, dist));
                 itemPriority *= distanceFactor;
-                itemPriority *= item.Condition / item.MaxCondition;
+                if (EvaluateCombatPriority)
+                {
+                    var mw = item.GetComponent<MeleeWeapon>();
+                    var rw = item.GetComponent<RangedWeapon>();
+                    float combatFactor = 0;
+                    if (mw != null)
+                    {
+                        if (mw.CombatPriority > 0)
+                        {
+                            combatFactor = mw.CombatPriority / 100;
+                        }
+                        else
+                        {
+                            // The combat factor of items with zero combat priority is not allowed to be greater than 0.1f
+                            combatFactor = Math.Min(AIObjectiveCombat.GetLethalDamage(mw) / 1000, 0.1f);
+                        }
+                    }
+                    else if (rw != null)
+                    {
+                        if (rw.CombatPriority > 0)
+                        {
+                            combatFactor = rw.CombatPriority / 100;
+                        }
+                        else
+                        {
+                            combatFactor = Math.Min(AIObjectiveCombat.GetLethalDamage(rw) / 1000, 0.1f);
+                        }
+                    }
+                    else
+                    {
+                        combatFactor = Math.Min(item.Components.Sum(ic => AIObjectiveCombat.GetLethalDamage(ic)) / 1000, 0.1f);
+                    }
+                    itemPriority *= combatFactor;
+                }
+                else
+                {
+                    itemPriority *= item.Condition / item.MaxCondition;
+                }
                 // Ignore if the item has a lower priority than the currently selected one
                 if (itemPriority < currItemPriority) { continue; }
                 if (!hasCalledPathFinder && PathSteering != null && checkPath)
                 {
-                    // While following the player, let's ensure that there's a valid path to the target before accepting it.
-                    // Otherwise it will take some time for us to find a valid item when there are multiple items that we can't reach and some that we can.
-                    // This is relatively expensive, so let's do this only when it significantly improves the behavior.
-                    // Only allow one path find call per frame.
                     hasCalledPathFinder = true;
                     var path = PathSteering.PathFinder.FindPath(character.SimPosition, item.SimPosition, character.Submarine, errorMsgStr: $"AIObjectiveGetItem {character.DisplayName}", nodeFilter: node => node.Waypoint.CurrentHull != null);
                     if (path.Unreachable) { continue; }
@@ -341,10 +465,10 @@ namespace Barotrauma
                 {
                     if (spawnItemIfNotFound)
                     {
-                        if (!(MapEntityPrefab.List.FirstOrDefault(me => me is ItemPrefab ip && identifiersOrTags.Any(id => id == ip.Identifier || ip.Tags.Contains(id))) is ItemPrefab prefab))
+                        if (!(MapEntityPrefab.List.FirstOrDefault(me => me is ItemPrefab ip && IdentifiersOrTags.Any(id => id == ip.Identifier || ip.Tags.Contains(id))) is ItemPrefab prefab))
                         {
 #if DEBUG
-                            DebugConsole.NewMessage($"{character.Name}: Cannot find an item with the following identifier(s) or tag(s): {string.Join(", ", identifiersOrTags)}, tried to spawn the item but no matching item prefabs were found.", Color.Yellow);
+                            DebugConsole.NewMessage($"{character.Name}: Cannot find an item with the following identifier(s) or tag(s): {string.Join(", ", IdentifiersOrTags)}, tried to spawn the item but no matching item prefabs were found.", Color.Yellow);
 #endif
                             Abandon = true;
                         }
@@ -355,7 +479,7 @@ namespace Barotrauma
                                 targetItem = spawnedItem; 
                                 if (character.TeamID == CharacterTeamType.FriendlyNPC && (character.Submarine?.Info.IsOutpost ?? false))
                                 {
-                                    spawnedItem.SpawnedInOutpost = true;
+                                    spawnedItem.SpawnedInCurrentOutpost = true;
                                 }
                             });
                         }
@@ -363,9 +487,8 @@ namespace Barotrauma
                     else
                     {
 #if DEBUG
-                        DebugConsole.NewMessage($"{character.Name}: Cannot find an item with the following identifier(s) or tag(s): {string.Join(", ", identifiersOrTags)}", Color.Yellow);
+                        DebugConsole.NewMessage($"{character.Name}: Cannot find an item with the following identifier(s) or tag(s): {string.Join(", ", IdentifiersOrTags)}", Color.Yellow);
 #endif
-                        SpeakCannotFind();
                         Abandon = true;
                     }
                 }
@@ -375,7 +498,16 @@ namespace Barotrauma
         protected override bool CheckObjectiveSpecific()
         {
             if (IsCompleted) { return true; }
-            if (targetItem != null)
+            if (targetItem == null)
+            {
+                // Not yet ready
+                return false;
+            }
+            if (IdentifiersOrTags != null && ItemCount > 1)
+            {
+                return CountItems();
+            }
+            else
             {
                 if (Equip && EquipSlotType.HasValue)
                 {
@@ -386,23 +518,6 @@ namespace Barotrauma
                     return character.HasItem(targetItem, Equip);
                 }
             }
-            else if (identifiersOrTags != null)
-            {
-                var matchingItem = character.Inventory.FindItem(i => CheckItem(i), recursive: true);
-                if (matchingItem != null)
-                {
-                    if (Equip && EquipSlotType.HasValue)
-                    {
-                        return character.HasEquippedItem(matchingItem, EquipSlotType.Value);
-                    }
-                    else
-                    {
-                        return !Equip || character.HasEquippedItem(matchingItem);
-                    }
-                }
-                return false;
-            }
-            return false;
         }
 
         private bool CheckItem(Item item)
@@ -410,9 +525,11 @@ namespace Barotrauma
             if (!item.IsInteractable(character)) { return false; }
             if (item.IsThisOrAnyContainerIgnoredByAI(character)) { return false; }
             if (ignoredItems.Contains(item)) { return false; };
+            if (ignoredIdentifiersOrTags != null && ignoredIdentifiersOrTags.Any(id => item.prefab.Identifier == id || item.HasTag(id))) { return false; }
             if (item.Condition < TargetCondition) { return false; }
             if (ItemFilter != null && !ItemFilter(item)) { return false; }
-            return identifiersOrTags.Any(id => id == item.Prefab.Identifier || item.HasTag(id) || (AllowVariants && item.Prefab.VariantOf?.Identifier == id));
+            if (RequireLoaded && item.Components.Any(i => !i.IsLoaded(character))) { return false; }
+            return IdentifiersOrTags.Any(id => id == item.Prefab.Identifier || item.HasTag(id) || (AllowVariants && item.Prefab.VariantOf?.Identifier == id));
         }
 
         public override void Reset()
@@ -437,37 +554,28 @@ namespace Barotrauma
         protected override void OnAbandon()
         {
             base.OnAbandon();
-            if (moveToTarget == null) { return; }
+            if (moveToTarget != null)
+            {
 #if DEBUG
-            DebugConsole.NewMessage($"{character.Name}: Get item failed to reach {moveToTarget}", Color.Yellow);
+                DebugConsole.NewMessage($"{character.Name}: Get item failed to reach {moveToTarget}", Color.Yellow);
 #endif
+            }
+            if (SpeakIfFails)
+            {
+                SpeakCannotFind();
+            }
         }
 
         private void SpeakCannotFind()
         {
-            // TODO: Use the item name as the variable here.
             if (character.IsOnPlayerTeam && objectiveManager.CurrentOrder == objectiveManager.CurrentObjective)
             {
-                string msg = TextManager.Get("dialogcannotfinditem", true);
+                string msg = TextManager.Get(CannotFindDialogueIdentifierOverride, returnNull: true) ?? TextManager.Get("dialogcannotfinditem", returnNull: true);
                 if (msg != null)
                 {
                     character.Speak(msg, identifier: "dialogcannotfinditem", minDurationBetweenSimilar: 20.0f);
                 }
             }
         }
-
-        // TODO: remove?
-        private void SpeakCannotReach()
-        {
-            if (character.IsOnPlayerTeam && objectiveManager.CurrentOrder == objectiveManager.CurrentObjective)
-            {
-                string TargetName = (moveToTarget as MapEntity)?.Name ?? (moveToTarget as Character)?.Name ?? moveToTarget.ToString();
-                string msg = TargetName == null ? TextManager.Get("dialogcannotreachtarget", true) : TextManager.GetWithVariable("dialogcannotreachtarget", "[name]", TargetName, formatCapitals: !(moveToTarget is Character));
-                if (msg != null)
-                {
-                    character.Speak(msg, identifier: "dialogcannotreachtarget", minDurationBetweenSimilar: 20.0f);
-                }
-            }
-        }
     }
 }

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

@@ -0,0 +1,101 @@
+#nullable enable
+using Barotrauma.Extensions;
+using System.Linq;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+
+namespace Barotrauma
+{
+    class AIObjectiveGetItems : AIObjective
+    {
+        public override string Identifier { get; set; } = "get items";
+        public override string DebugTag => $"{Identifier}";
+        public override bool KeepDivingGearOn => true;
+        public override bool AllowMultipleInstances => true;
+
+        public bool AllowStealing { get; set; }
+        public bool TakeWholeStack { get; set; }
+        public bool AllowVariants { get; set; }
+        public bool Equip { get; set; }
+        public bool Wear { get; set; }
+        public bool CheckInventory { get; set; }
+        public bool EvaluateCombatPriority { get; set; }
+        public bool CheckPathForEachItem { get; set; }
+        public bool RequireLoaded { get; set; }
+        public bool RequireAllItems { get; set; }
+
+        private readonly ImmutableArray<string> gearTags;
+        private readonly string[] ignoredTags;
+        private bool subObjectivesCreated;
+
+        public readonly HashSet<Item> achievedItems = new HashSet<Item>();
+
+        public AIObjectiveGetItems(Character character, AIObjectiveManager objectiveManager, IEnumerable<string> identifiersOrTags, float priorityModifier = 1) : base(character, objectiveManager, priorityModifier)
+        {
+            gearTags = AIObjectiveGetItem.ParseGearTags(identifiersOrTags).ToImmutableArray();
+            ignoredTags = AIObjectiveGetItem.ParseIgnoredTags(identifiersOrTags).ToArray();
+        }
+
+        protected override bool CheckObjectiveSpecific() => subObjectivesCreated && subObjectives.None();
+
+        protected override void Act(float deltaTime)
+        {
+            if (character.LockHands)
+            {
+                Abandon = true;
+                return;
+            }
+            if (!subObjectivesCreated)
+            {
+                foreach (string tag in gearTags)
+                {
+                    if (subObjectives.Any(so => so is AIObjectiveGetItem getItem && getItem.IdentifiersOrTags.Contains(tag))) { continue; }
+                    int count = gearTags.Count(t => t == tag);
+                    AIObjectiveGetItem? getItem = null;
+                    TryAddSubObjective(ref getItem, () =>
+                        new AIObjectiveGetItem(character, tag, objectiveManager, Equip, CheckInventory && count <= 1)
+                        {
+                            AllowVariants = AllowVariants,
+                            Wear = Wear,
+                            TakeWholeStack = TakeWholeStack,
+                            AllowStealing = AllowStealing,
+                            ignoredIdentifiersOrTags = ignoredTags,
+                            CheckPathForEachItem = CheckPathForEachItem,
+                            RequireLoaded = RequireLoaded,
+                            ItemCount = count,
+                            SpeakIfFails = RequireAllItems
+                        },
+                        onCompleted: () =>
+                        {
+                            var item = getItem?.TargetItem;
+                            if (item?.IsOwnedBy(character) != null)
+                            {
+                                achievedItems.Add(item);
+                            }
+                        },
+                        onAbandon: () =>
+                        {
+                            var item = getItem?.TargetItem;
+                            if (item != null)
+                            {
+                                achievedItems.Remove(item);
+                            }
+                            RemoveSubObjective(ref getItem);
+                            if (RequireAllItems)
+                            {
+                                Abandon = true;
+                            }
+                        });
+                }
+                subObjectivesCreated = true;
+            }
+        }
+
+        public override void Reset()
+        {
+            base.Reset();
+            subObjectivesCreated = false;
+            achievedItems.Clear();
+        }
+    }
+}

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

@@ -22,15 +22,23 @@ namespace Barotrauma
         public Func<bool> requiredCondition;
         public Func<PathNode, bool> endNodeFilter;
 
-        public Func<float> priorityGetter;
+        public Func<float> PriorityGetter;
+
+        public bool IsFollowOrderObjective;
+        public bool Mimic;
 
-        public bool isFollowOrderObjective;
-        public bool mimic;
         public bool SpeakIfFails { get; set; } = true;
+        public bool DebugLogWhenFails { get; set; } = true;
         public bool UsePathingOutside { get; set; } = true;
 
-        public float extraDistanceWhileSwimming;
-        public float extraDistanceOutsideSub;
+        public float ExtraDistanceWhileSwimming;
+        public float ExtraDistanceOutsideSub;
+        private float _closeEnoughMultiplier = 1;
+        public float CloseEnoughMultiplier
+        {
+            get { return _closeEnoughMultiplier; }
+            set { _closeEnoughMultiplier = Math.Max(value, 1); }
+        }
         private float _closeEnough = 50;
         private readonly float minDistance = 50;
         private readonly float seekGapsInterval = 1;
@@ -44,14 +52,15 @@ namespace Barotrauma
         {
             get
             {
-                float dist = _closeEnough;
+                float dist = _closeEnough * CloseEnoughMultiplier;
+                float extraMultiplier = Math.Clamp(CloseEnoughMultiplier * 0.6f, 1, 3);
                 if (character.AnimController.InWater)
                 {
-                    dist += extraDistanceWhileSwimming;
+                    dist += ExtraDistanceWhileSwimming * extraMultiplier;
                 }
                 if (character.CurrentHull == null)
                 {
-                    dist += extraDistanceOutsideSub;
+                    dist += ExtraDistanceOutsideSub * extraMultiplier;
                 }
                 return dist;
             }
@@ -61,6 +70,9 @@ namespace Barotrauma
             }
         }
 
+        // TODO: Currently we never check the visibility (to the end node), which is actually unintentional.
+        // I don't think it has caused any issues so far, so let's keep defaulting to false for now, because the less we do raycasts the better.
+        // However, if there are cases where the bots attempt to go through walls (select the end node that is behind an obstacle), we should set this true.
         public bool CheckVisibility { get; set; }
         public bool IgnoreIfTargetDead { get; set; }
         public bool AllowGoingOutside { get; set; }
@@ -77,7 +89,7 @@ namespace Barotrauma
         public override bool AllowOutsideSubmarine => AllowGoingOutside;
         public override bool AllowInAnySub => true;
 
-        public string DialogueIdentifier { get; set; }
+        public string DialogueIdentifier { get; set; } = "dialogcannotreachtarget";
         public string TargetName { get; set; }
 
         public ISpatialEntity Target { get; private set; }
@@ -105,9 +117,9 @@ namespace Barotrauma
             }
             else
             {
-                if (priorityGetter != null)
+                if (PriorityGetter != null)
                 {
-                    Priority = priorityGetter();
+                    Priority = PriorityGetter();
                 }
                 else if (OverridePriority.HasValue)
                 {
@@ -149,7 +161,10 @@ namespace Barotrauma
         private void SpeakCannotReach()
         {
 #if DEBUG
-            DebugConsole.NewMessage($"{character.Name}: Cannot reach the target: {Target}", Color.Yellow);
+            if (DebugLogWhenFails)
+            {
+                DebugConsole.NewMessage($"{character.Name}: Cannot reach the target: {Target}", Color.Yellow);
+            }
 #endif
             if (character.IsOnPlayerTeam && objectiveManager.CurrentOrder == objectiveManager.CurrentObjective && DialogueIdentifier != null && SpeakIfFails)
             {
@@ -176,11 +191,6 @@ namespace Barotrauma
                 character.AIController.SteeringManager.Reset();
                 return;
             }
-            if (cannotFollow)
-            {
-                // Wait
-                character.AIController.SteeringManager.Reset();
-            }
             if (!character.IsClimbing)
             {
                 character.SelectedConstruction = null;
@@ -198,7 +208,7 @@ namespace Barotrauma
                 }
             }
             Hull targetHull = GetTargetHull();
-            if (!isFollowOrderObjective)
+            if (!IsFollowOrderObjective)
             {
                 // Abandon if going through unsafe paths. Note ignores unsafe nodes when following an order or when the objective is set to ignore unsafe hulls.
                 bool containsUnsafeNodes = character.IsDismissed && !HumanAIController.ObjectiveManager.CurrentObjective.IgnoreUnsafeHulls
@@ -211,26 +221,33 @@ namespace Barotrauma
             }
             bool insideSteering = SteeringManager == PathSteering && PathSteering.CurrentPath != null && !PathSteering.IsPathDirty;
             bool isInside = character.CurrentHull != null;
-            bool targetIsOutside = (Target != null && targetHull == null) || (insideSteering && PathSteering.CurrentPath.HasOutdoorsNodes);
-            if (isInside && targetIsOutside && !AllowGoingOutside)
+            bool hasOutdoorNodes = insideSteering && PathSteering.CurrentPath.HasOutdoorsNodes;
+            if (isInside && hasOutdoorNodes && !AllowGoingOutside)
             {
                 Abandon = true;
             }
-            else if (HumanAIController.IsCurrentPathNullOrUnreachable)
+            else if (HumanAIController.SteeringManager == PathSteering)
             {
                 waitUntilPathUnreachable -= deltaTime;
-                SteeringManager.Reset();
-                if (waitUntilPathUnreachable < 0)
+                if (HumanAIController.IsCurrentPathNullOrUnreachable)
+                {
+                    SteeringManager.Reset();
+                    if (waitUntilPathUnreachable < 0)
+                    {
+                        waitUntilPathUnreachable = pathWaitingTime;
+                        if (repeat)
+                        {
+                            SpeakCannotReach();
+                        }
+                        else
+                        {
+                            Abandon = true;
+                        }
+                    }
+                }
+                else if (HumanAIController.HasValidPath(requireNonDirty: true, requireUnfinished: false))
                 {
                     waitUntilPathUnreachable = pathWaitingTime;
-                    if (repeat)
-                    {
-                        SpeakCannotReach();
-                    }
-                    else
-                    {
-                        Abandon = true;
-                    }
                 }
             }
             if (!Abandon)
@@ -238,16 +255,16 @@ namespace Barotrauma
                 if (getDivingGearIfNeeded && !character.LockHands)
                 {
                     Character followTarget = Target as Character;
-                    bool needsDivingSuit = !isInside || targetIsOutside;
-                    bool needsDivingGear = needsDivingSuit || HumanAIController.NeedsDivingGear(targetHull, out needsDivingSuit);
-                    if (mimic)
+                    bool needsDivingSuit = (!isInside || hasOutdoorNodes) && character.NeedsAir && !character.HasAbilityFlag(AbilityFlags.ImmuneToPressure);
+                    bool needsDivingGear = (needsDivingSuit || HumanAIController.NeedsDivingGear(targetHull, out needsDivingSuit)) && character.NeedsAir;
+                    if (Mimic)
                     {
-                        if (HumanAIController.HasDivingSuit(followTarget))
+                        if (HumanAIController.HasDivingSuit(followTarget) && character.NeedsAir)
                         {
                             needsDivingGear = true;
                             needsDivingSuit = true;
                         }
-                        else if (HumanAIController.HasDivingMask(followTarget))
+                        else if (HumanAIController.HasDivingMask(followTarget) && character.NeedsAir)
                         {
                             needsDivingGear = true;
                         }
@@ -268,7 +285,7 @@ namespace Barotrauma
                         if (findDivingGear != null && !findDivingGear.CanBeCompleted)
                         {
                             TryAddSubObjective(ref findDivingGear, () => new AIObjectiveFindDivingGear(character, needsDivingSuit: false, objectiveManager),
-                                onAbandon: () => Abort(),
+                                onAbandon: () => Abandon = true,
                                 onCompleted: () =>
                                 {
                                     cannotFollow = false;
@@ -278,7 +295,7 @@ namespace Barotrauma
                         else
                         {
                             TryAddSubObjective(ref findDivingGear, () => new AIObjectiveFindDivingGear(character, needsDivingSuit, objectiveManager),
-                                onAbandon: () => Abort(),
+                                onAbandon: () => Abandon = true,
                                 onCompleted: () =>
                                 {
                                     cannotFollow = false;
@@ -311,7 +328,7 @@ namespace Barotrauma
                 if (character.AnimController.InWater)
                 {
                     if (character.CurrentHull == null ||
-                        isFollowOrderObjective && 
+                        IsFollowOrderObjective && 
                         targetCharacter != null && (targetCharacter.CurrentHull == null) != (character.CurrentHull == null) &&
                         Vector2.DistanceSquared(character.WorldPosition, Target.WorldPosition) < maxGapDistance * maxGapDistance)
                     {
@@ -354,7 +371,7 @@ namespace Barotrauma
                     }
                     if (TargetGap != null)
                     {
-                        if (TargetGap.FlowTargetHull != null && HumanAIController.SteerThroughGap(TargetGap, isFollowOrderObjective ? Target.WorldPosition : TargetGap.FlowTargetHull.WorldPosition, deltaTime))
+                        if (TargetGap.FlowTargetHull != null && HumanAIController.SteerThroughGap(TargetGap, IsFollowOrderObjective ? Target.WorldPosition : TargetGap.FlowTargetHull.WorldPosition, deltaTime))
                         {
                             SteeringManager.SteeringAvoid(deltaTime, avoidLookAheadDistance, weight: 1);
                             return;
@@ -373,7 +390,7 @@ namespace Barotrauma
                         Item scooter = null;
                         float closeEnough = 250;
                         float squaredDistance = Vector2.DistanceSquared(character.WorldPosition, Target.WorldPosition);
-                        bool shouldUseScooter = squaredDistance > closeEnough * closeEnough && (!mimic ||
+                        bool shouldUseScooter = squaredDistance > closeEnough * closeEnough && (!Mimic ||
                             (targetCharacter != null && targetCharacter.HasEquippedItem(scooterTag, allowBroken: false)) || squaredDistance > Math.Pow(closeEnough * 2, 2));
                         if (HumanAIController.HasItem(character, scooterTag, out IEnumerable<Item> equippedScooters, recursive: false, requireEquipped: true))
                         {
@@ -382,24 +399,32 @@ namespace Barotrauma
                         }
                         else if (shouldUseScooter)
                         {
-                            bool hasBattery = false;
-                            if (HumanAIController.HasItem(character, scooterTag, out IEnumerable<Item> nonEquippedScooters, containedTag: batteryTag, conditionPercentage: 1, requireEquipped: false))
+                            var leftHandItem = character.GetEquippedItem(slotType: InvSlotType.LeftHand);
+                            var rightHandItem = character.GetEquippedItem(slotType: InvSlotType.RightHand);
+                            bool handsFull =
+                                (leftHandItem != null && character.Inventory.CheckIfAnySlotAvailable(leftHandItem, inWrongSlot: false) == -1) ||
+                                (rightHandItem != null && character.Inventory.CheckIfAnySlotAvailable(rightHandItem, inWrongSlot: false) == -1);
+                            if (!handsFull)
                             {
-                                // Non-equipped scooter with a battery
-                                scooter = nonEquippedScooters.FirstOrDefault();
-                                hasBattery = true;
-                            }
-                            else if (HumanAIController.HasItem(character, scooterTag, out IEnumerable<Item> _nonEquippedScooters, requireEquipped: false))
-                            {
-                                // Non-equipped scooter without a battery
-                                scooter = _nonEquippedScooters.FirstOrDefault();
-                                // Non-recursive so that the bots won't take batteries from other items. Also means that they can't find batteries inside containers. Not sure how to solve this.
-                                hasBattery = HumanAIController.HasItem(character, batteryTag, out _, requireEquipped: false, conditionPercentage: 1, recursive: false);
-                            }
-                            if (scooter != null && hasBattery)
-                            {
-                                // Equip only if we have a battery available
-                                HumanAIController.TakeItem(scooter, character.Inventory, equip: true, dropOtherIfCannotMove: false, allowSwapping: true, storeUnequipped: false);
+                                bool hasBattery = false;
+                                if (HumanAIController.HasItem(character, scooterTag, out IEnumerable<Item> nonEquippedScooters, containedTag: batteryTag, conditionPercentage: 1, requireEquipped: false))
+                                {
+                                    // Non-equipped scooter with a battery
+                                    scooter = nonEquippedScooters.FirstOrDefault();
+                                    hasBattery = true;
+                                }
+                                else if (HumanAIController.HasItem(character, scooterTag, out IEnumerable<Item> _nonEquippedScooters, requireEquipped: false))
+                                {
+                                    // Non-equipped scooter without a battery
+                                    scooter = _nonEquippedScooters.FirstOrDefault();
+                                    // Non-recursive so that the bots won't take batteries from other items. Also means that they can't find batteries inside containers. Not sure how to solve this.
+                                    hasBattery = HumanAIController.HasItem(character, batteryTag, out _, requireEquipped: false, conditionPercentage: 1, recursive: false);
+                                }
+                                if (scooter != null && hasBattery)
+                                {
+                                    // Equip only if we have a battery available
+                                    HumanAIController.TakeItem(scooter, character.Inventory, equip: true, dropOtherIfCannotMove: false, allowSwapping: true, storeUnequipped: false);
+                                }
                             }
                         }
                         bool isScooterEquipped = scooter != null && character.HasEquippedItem(scooter);
@@ -588,7 +613,7 @@ namespace Barotrauma
             {
                 if (gap.Open < 1) { continue; }
                 if (gap.Submarine == null) { continue; }
-                if (!isFollowOrderObjective)
+                if (!IsFollowOrderObjective)
                 {
                     if (gap.FlowTargetHull == null) { continue; }
                     if (gap.Submarine != Target.Submarine) { continue; }
@@ -669,18 +694,6 @@ namespace Barotrauma
             return IsCompleted;
         }
 
-        private void Abort()
-        {
-            if (!objectiveManager.IsOrder(this))
-            {
-                Abandon = true;
-            }
-            else
-            {
-                cannotFollow = true;
-            }
-        }
-
         protected override void OnAbandon()
         {
             StopMovement();

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

@@ -0,0 +1,235 @@
+using Barotrauma.Extensions;
+using Barotrauma.Items.Components;
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+
+namespace Barotrauma
+{
+    class AIObjectiveLoadItem : AIObjective
+    {
+        public override string Identifier { get; set; } = "load item";
+        public override bool IsLoop
+        {
+            get => true;
+            set => throw new Exception("Trying to set the value for AIObjectiveLoadItem.IsLoop from: " + Environment.StackTrace.CleanupStackTrace());
+        }
+
+        private AIObjectiveLoadItems.ItemCondition TargetItemCondition { get; }
+        private Item Container { get; }
+        private ItemContainer ItemContainer { get; }
+        private ImmutableArray<string> TargetContainerTags { get; }
+
+        private int itemIndex = 0;
+        private AIObjectiveDecontainItem decontainObjective;
+        private readonly HashSet<Item> ignoredItems = new HashSet<Item>();
+        private Item targetItem;
+        private readonly string abandonGetItemDialogueIdentifier = "dialogcannotfindloadable";
+
+        public AIObjectiveLoadItem(Item container, ImmutableArray<string> targetTags, AIObjectiveLoadItems.ItemCondition targetCondition, string option, Character character, AIObjectiveManager objectiveManager, float priorityModifier)
+            : base(character, objectiveManager, priorityModifier)
+        {
+            Container = container;
+            ItemContainer = container?.GetComponent<ItemContainer>();
+            if (ItemContainer?.Inventory == null)
+            {
+                Abandon = true;
+                return;
+            }
+            TargetContainerTags = targetTags;
+            TargetItemCondition = targetCondition;
+            if (!string.IsNullOrEmpty(option))
+            {
+                string optionSpecificDialogueIdentifier = $"{abandonGetItemDialogueIdentifier}.{option}";
+                if (TextManager.ContainsTag(optionSpecificDialogueIdentifier))
+                {
+                    abandonGetItemDialogueIdentifier = optionSpecificDialogueIdentifier;
+                }
+            }
+        }
+
+        protected override float GetPriority()
+        {
+            if (!IsAllowed)
+            {
+                Priority = 0;
+                Abandon = true;
+                return Priority;
+            }
+            else if (!AIObjectiveLoadItems.IsValidTarget(Container, character, targetCondition: TargetItemCondition))
+            {
+                // Reduce priority to 0 if the this isn't a valid container right now
+                Priority = 0;
+            }
+            else if (targetItem == null)
+            {
+                Priority = 0;
+            }
+            else
+            {
+                float dist = 0.0f;
+                if (character.CurrentHull != targetItem.CurrentHull)
+                {
+                    AddDistance(character.WorldPosition, targetItem.WorldPosition);
+                }
+                if (targetItem.CurrentHull != Container.CurrentHull)
+                {
+                    AddDistance(targetItem.WorldPosition, Container.WorldPosition);
+                }
+                void AddDistance(Vector2 startPos, Vector2 targetPos)
+                {
+                    float yDist = Math.Abs(startPos.Y - targetPos.Y);
+                    // If we're on the same level with the target, we'll disregard the vertical distance
+                    if (yDist > 100) { dist += yDist * 5; }
+                    dist += Math.Abs(character.WorldPosition.X - targetPos.X);
+                }
+                float distanceFactor = dist > 0.0f ? MathHelper.Lerp(0.9f, 0, MathUtils.InverseLerp(0, 5000, dist)) : 0.9f;
+                bool hasContainable = character.HasItem(targetItem);
+                float devotion = (CumulatedDevotion + (hasContainable ? 100 - MaxDevotion : 0)) / 100;
+                float max = AIObjectiveManager.LowestOrderPriority - (hasContainable ? 1 : 2);
+                Priority = MathHelper.Lerp(0, max, MathHelper.Clamp(devotion + (distanceFactor * PriorityModifier), 0, 1));
+                if (decontainObjective != null && targetItem.Container != Container)
+                {
+                    if (!IsValidContainable(targetItem))
+                    {
+                        // Target is not valid anymore, abandon the objective
+                        decontainObjective.Abandon = true;
+                    }
+                    else if (!ItemContainer.Inventory.CanBePut(targetItem) && ItemContainer.Inventory.AllItems.None(i => AIObjectiveLoadItems.ItemMatchesTargetCondition(i, TargetItemCondition)))
+                    {
+                        // The container is full and there's no item that should be removed, abandon the objective
+                        decontainObjective.Abandon = true;
+                    }
+                }
+                if (ItemContainer.Inventory.IsFull())
+                {
+                    // Prioritize containers that still have empty space by lowering the priority of objectives with a full target container
+                    Priority /= 4;
+                }
+            }
+            return Priority;
+        }
+
+        public override void Update(float deltaTime)
+        {
+            base.Update(deltaTime);
+            if (targetItem == null)
+            {
+                if (character.FindItem(ref itemIndex, out Item item, identifiers: ItemContainer.ContainableItemIdentifiers, ignoreBroken: false, customPredicate: IsValidContainable, customPriorityFunction: GetConditionBasedPriority))
+                {
+                    if (item == null)
+                    {
+                        // No possible containables found, abandon the objective
+                        Abandon = true;
+                    }
+                    targetItem = item;
+                }
+                // Prefer items closer to full condition when target condition is Empty, and vice versa
+                float GetConditionBasedPriority(Item item)
+                {
+                    try
+                    {
+                        return TargetItemCondition switch
+                        {
+                            AIObjectiveLoadItems.ItemCondition.Full => MathUtils.InverseLerp(100.0f, 0.0f, item.ConditionPercentage),
+                            AIObjectiveLoadItems.ItemCondition.Empty => MathUtils.InverseLerp(0.0f, 100.0f, item.ConditionPercentage),
+                            _ => throw new NotImplementedException()
+                        };
+                    }
+                    catch (NotImplementedException)
+                    {
+#if DEBUG
+                        DebugConsole.ShowError($"Unexpected target condition \"{TargetItemCondition}\" in local function GetConditionBasedProperty");
+#endif
+                        return 0.0f;
+                    }
+                }
+            }
+        }
+
+        protected override void Act(float deltaTime)
+        {
+            if (targetItem != null)
+            {
+                if(decontainObjective == null && !IsValidContainable(targetItem))
+                {
+                    IgnoreTargetItem();
+                    Reset();
+                    return;
+                }
+                TryAddSubObjective(ref decontainObjective,
+                    constructor: () => new AIObjectiveDecontainItem(character, targetItem, objectiveManager, targetContainer: ItemContainer, priorityModifier: PriorityModifier)
+                    {
+                        AbandonGetItemDialogueIdentifier = abandonGetItemDialogueIdentifier,
+                        Equip = true,
+                        RemoveExistingWhenNecessary = true,
+                        RemoveExistingPredicate = (i) => AIObjectiveLoadItems.ItemMatchesTargetCondition(i, TargetItemCondition),
+                        RemoveExistingMax = 1
+                    },
+                    onCompleted: () =>
+                    {
+                        IsCompleted = true;
+                        RemoveSubObjective(ref decontainObjective);
+                    },
+                    onAbandon: () =>
+                    {
+                        // Try again
+                        IgnoreTargetItem();
+                        Reset();
+                    });
+            }
+            else
+            {
+                objectiveManager.GetObjective<AIObjectiveIdle>().Wander(deltaTime);
+            }
+        }
+
+        private bool IsValidContainable(Item item)
+        {
+            if (item == null) { return false; }
+            if (item.Removed) { return false; }
+            if (ignoredItems.Contains(item)) { return false; }
+            if ((item.SpawnedInCurrentOutpost && !item.AllowStealing) == character.IsOnPlayerTeam) { return false; }
+            var rootInventoryOwner = item.GetRootInventoryOwner();
+            if (rootInventoryOwner is Character owner && owner != character) { return false; }
+            if (rootInventoryOwner is Item parentItem)
+            {
+                if (parentItem.HasTag("donttakeitems")) { return false; }
+                if (!(parentItem.GetComponent<ItemContainer>()?.HasAccess(character) ?? true)) { return false; }
+            }
+            if (item.IsThisOrAnyContainerIgnoredByAI(character)) { return false; }
+            if (!character.HasItem(item) && !CanEquip(item)) { return false; }
+            if (!ItemContainer.HasAccess(character)) { return false; }
+            if (!ItemContainer.CanBeContained(item)) { return false; }
+            if (AIObjectiveLoadItems.ItemMatchesTargetCondition(item, TargetItemCondition)) { return false; }
+            if (TargetItemCondition == AIObjectiveLoadItems.ItemCondition.Full)
+            {
+                // Ignore items that have had their condition increase recently
+                if (TargetItemCondition == AIObjectiveLoadItems.ItemCondition.Full && item.ConditionIncreasedRecently) { return false; }
+                // Ignore items inside their (condition-restricted) primary containers
+                if (item.ParentInventory is ItemInventory itemInventory && item.IsContainerPreferred(itemInventory.Container, out bool _, out bool isSecondary, requireConditionRestriction: true) && !isSecondary) { return false; }
+            }
+            // Ignore items inside another valid container
+            if (AIObjectiveLoadItems.IsValidTarget(item.Container, character, TargetContainerTags)) { return false; }
+            return true;
+        }
+
+        protected override bool CheckObjectiveSpecific() => IsCompleted;
+
+        public override void Reset()
+        {
+            base.Reset();
+            // Don't reset the target item when resetting the objective because it affects priority calculations
+            decontainObjective = null;
+            itemIndex = 0;
+        }
+
+        private void IgnoreTargetItem()
+        {
+            if(targetItem == null) { return; }
+            ignoredItems.Add(targetItem);
+            targetItem = null;
+        }
+    }
+}

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

@@ -0,0 +1,115 @@
+using Barotrauma.Extensions;
+using Barotrauma.Items.Components;
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+
+namespace Barotrauma
+{
+    class AIObjectiveLoadItems : AIObjectiveLoop<Item>
+    {
+        public override string Identifier { get; set; } = "load items";
+        protected override float IgnoreListClearInterval => 20.0f;
+        protected override bool ResetWhenClearingIgnoreList => false;
+
+        private ImmutableArray<string> TargetContainerTags { get; }
+        private List<Item> TargetContainers { get; } = new List<Item>();
+        private ItemCondition TargetCondition { get; }
+
+        public enum ItemCondition
+        {
+            Empty,
+            Full
+        }
+
+        public AIObjectiveLoadItems(Character character, AIObjectiveManager objectiveManager, string option, ImmutableArray<string> containerTags, Item targetContainer = null, float priorityModifier = 1)
+            : base(character, objectiveManager, priorityModifier, option)
+        {
+            if ((containerTags == null || containerTags.None()) && targetContainer == null)
+            {
+                Abandon = true;
+                return;
+            }
+            else
+            {
+                TargetContainerTags = containerTags.ToImmutableArray();
+            }
+            if (targetContainer != null)
+            {
+                TargetContainers.Add(targetContainer);
+            }
+            TargetCondition = option == "turretammo" ? ItemCondition.Empty : ItemCondition.Full;
+        }
+
+        protected override bool Filter(Item target)
+        {
+            if (!IsValidTarget(target, character, TargetContainerTags, TargetCondition)) { return false; }
+            if (target.CurrentHull == null || target.CurrentHull.FireSources.Count > 0) { return false; }
+            if (Character.CharacterList.Any(c => c.CurrentHull == target.CurrentHull && !HumanAIController.IsFriendly(c) && HumanAIController.IsActive(c))) { return false; }
+            return true;
+        }
+
+        public static bool IsValidTarget(Item item, Character character, ImmutableArray<string>? targetContainerTags = null, ItemCondition? targetCondition = null)
+        {
+            if (item == null) { return false; }
+            if (item.Removed) { return false; }
+            if (targetContainerTags.HasValue && !Order.TargetItemsMatchItem(targetContainerTags.Value, item)) { return false; }
+            if (!(item.GetComponent<ItemContainer>() is ItemContainer container)) { return false; }
+            if (container.Inventory == null) { return false; }
+            if (targetCondition.HasValue && container.Inventory.IsFull() && container.Inventory.AllItems.None(i => ItemMatchesTargetCondition(i, targetCondition.Value))) { return false; }
+            if (!AIObjectiveCleanupItems.IsItemInsideValidSubmarine(item, character)) { return false; }
+            if (item.GetRootInventoryOwner() is Character owner && owner != character) { return false; }
+            if (!item.IsInteractable(character)) { return false; }
+            if (item.IsThisOrAnyContainerIgnoredByAI(character)) { return false; }
+            if (!container.HasAccess(character)) { return false; }
+            // Ignore items that require power but don't have it
+            if (item.GetComponent<Powered>() is Powered powered && powered.PowerConsumption > 0 && powered.Voltage < powered.MinVoltage) { return false; }
+            return true;
+        }
+
+        public static bool ItemMatchesTargetCondition(Item item, ItemCondition targetCondition)
+        {
+            if(item == null) { return false; }
+            try
+            {
+                return targetCondition switch
+                {
+                    ItemCondition.Empty => item.Condition <= 0.1f,
+                    ItemCondition.Full => item.IsFullCondition,
+                    _ => throw new NotImplementedException(),
+                };
+            }
+            catch (NotImplementedException)
+            {
+#if DEBUG
+                DebugConsole.ShowError($"Unexpected target condition \"{targetCondition}\" in AIObjectiveLoadItems.ItemMatchesTargetCondition");
+#endif
+                return false;
+            }
+        }
+
+        protected override IEnumerable<Item> GetList() => TargetContainers.Any() ? TargetContainers : Item.ItemList;
+
+        protected override AIObjective ObjectiveConstructor(Item target)
+            => new AIObjectiveLoadItem(target, TargetContainerTags, TargetCondition, Option, character, objectiveManager, PriorityModifier);
+
+        protected override void OnObjectiveCompleted(AIObjective objective, Item target)
+            => HumanAIController.RemoveTargets<AIObjectiveLoadItems, Item>(character, target);
+
+        protected override float TargetEvaluation()
+        {
+            if (Targets.None()) { return 0; }
+            if (objectiveManager.IsOrder(this))
+            {
+                float prio = objectiveManager.GetOrderPriority(this);
+                if (subObjectives.All(so => so.SubObjectives.None() || so.Priority <= 0))
+                {
+                    ForceWalk = true;
+                }
+                return prio;
+            }
+            return AIObjectiveManager.RunPriority - 0.5f;
+        }
+    }
+}

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

@@ -45,6 +45,7 @@ namespace Barotrauma
         public override bool AbandonWhenCannotCompleteSubjectives => false;
         public override bool AllowSubObjectiveSorting => true;
         public virtual bool InverseTargetEvaluation => false;
+        protected virtual bool ResetWhenClearingIgnoreList => true;
 
         public override bool IsLoop { get => true; set => throw new Exception("Trying to set the value for IsLoop from: " + System.Environment.StackTrace.CleanupStackTrace()); }
 
@@ -55,7 +56,15 @@ namespace Barotrauma
             {
                 if (ignoreListTimer > IgnoreListClearInterval)
                 {
-                    Reset();
+                    if (ResetWhenClearingIgnoreList)
+                    {
+                        Reset();
+                    }
+                    else
+                    {
+                        ignoreList.Clear();
+                        ignoreListTimer = 0;
+                    }
                 }
                 else
                 {
@@ -113,7 +122,7 @@ namespace Barotrauma
                 Priority = 0;
                 return Priority;
             }
-            if (character.LockHands || character.Submarine == null)
+            if (character.LockHands)
             {
                 Priority = 0;
             }
@@ -131,7 +140,7 @@ namespace Barotrauma
                     // If the priority is higher than the target value, let's just use it.
                     // The priority calculation is more precise, but it takes into account things like distances,
                     // so it's better not to use it if it's lower than the rougher targetValue.
-                    targetValue = Priority;
+                    targetValue = currentSubObjective.Priority;
                 }
                 // If the target value is less than 1% of the max value, let's just treat it as zero.
                 if (targetValue < 1)

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

@@ -137,7 +137,7 @@ namespace Barotrauma
                 Item item = null;
                 if (orderPrefab.MustSetTarget)
                 {
-                    item = orderPrefab.GetMatchingItems(character.Submarine, mustBelongToPlayerSub: false, requiredTeam: character.Info.TeamID, interactableFor: character)?.GetRandom();
+                    item = orderPrefab.GetMatchingItems(character.Submarine, mustBelongToPlayerSub: false, requiredTeam: character.Info.TeamID, interactableFor: character, orderOption: autonomousObjective.option)?.GetRandom();
                 }
                 var order = new Order(orderPrefab, item ?? character.CurrentHull as Entity, orderPrefab.GetTargetItemComponent(item), orderGiver: character);
                 if (order == null) { continue; }
@@ -288,6 +288,7 @@ namespace Barotrauma
             float highestPriority = 0;
             for (int i = CurrentOrders.Count - 1; i >= 0; i--)
             {
+                if (CurrentOrders.Count <= i) { break; }
                 var orderObjective = CurrentOrders[i].Objective;
                 if (orderObjective == null) { continue; }
                 orderObjective.CalculatePriority();
@@ -332,7 +333,6 @@ namespace Barotrauma
             SortObjectives();
         }
 
-        private CoroutineHandle speakRoutine;
         public void SetOrder(Order order, string option, int priority, Character orderGiver, bool speak)
         {
             if (character.IsDead)
@@ -364,6 +364,7 @@ namespace Barotrauma
             // Make sure the order priorities reflect those set by the player
             for (int i = CurrentOrders.Count - 1; i >= 0; i--)
             {
+                if (CurrentOrders.Count <= i) { break; }
                 var currentOrder = CurrentOrders[i];
                 if (currentOrder.Objective == null || currentOrder.MatchesOrder(order, option))
                 {
@@ -388,6 +389,7 @@ namespace Barotrauma
             var newCurrentOrder = CreateObjective(order, option, orderGiver);
             if (newCurrentOrder != null)
             {
+                newCurrentOrder.Abandoned += () => DismissSelf(order, option);
                 CurrentOrders.Add(new OrderInfo(order, option, priority, newCurrentOrder));
             }
             if (!HasOrders())
@@ -395,53 +397,12 @@ namespace Barotrauma
                 // Recreate objectives, because some of them may be removed, if impossible to complete (e.g. due to path finding)
                 CreateAutonomousObjectives();
             }
-            else
+            else if (newCurrentOrder != null)
             {
-                // This should be redundant, because all the objectives are reset when they are selected as active.
-                newCurrentOrder?.Reset();
-
                 if (speak && character.IsOnPlayerTeam)
                 {
-                    character.Speak(TextManager.Get("DialogAffirmative"), null, 1.0f);
-                    //if (speakRoutine != null)
-                    //{
-                    //    CoroutineManager.StopCoroutines(speakRoutine);
-                    //}
-                    //speakRoutine = CoroutineManager.InvokeAfter(() =>
-                    //{
-                    //    if (GameMain.GameSession == null || Level.Loaded == null) { return; }
-                    //    if (newCurrentOrder != null && character.SpeechImpediment < 100.0f)
-                    //    {
-                    //        if (newCurrentOrder is AIObjectiveRepairItems repairItems && repairItems.Targets.None())
-                    //        {
-                    //            character.Speak(TextManager.Get("DialogNoRepairTargets"), null, 3.0f, "norepairtargets");
-                    //        }
-                    //        else if (newCurrentOrder is AIObjectiveChargeBatteries chargeBatteries && chargeBatteries.Targets.None())
-                    //        {
-                    //            character.Speak(TextManager.Get("DialogNoBatteries"), null, 3.0f, "nobatteries");
-                    //        }
-                    //        else if (newCurrentOrder is AIObjectiveExtinguishFires extinguishFires && extinguishFires.Targets.None())
-                    //        {
-                    //            character.Speak(TextManager.Get("DialogNoFire"), null, 3.0f, "nofire");
-                    //        }
-                    //        else if (newCurrentOrder is AIObjectiveFixLeaks fixLeaks && fixLeaks.Targets.None())
-                    //        {
-                    //            character.Speak(TextManager.Get("DialogNoLeaks"), null, 3.0f, "noleaks");
-                    //        }
-                    //        else if (newCurrentOrder is AIObjectiveFightIntruders fightIntruders && fightIntruders.Targets.None())
-                    //        {
-                    //            character.Speak(TextManager.Get("DialogNoEnemies"), null, 3.0f, "noenemies");
-                    //        }
-                    //        else if (newCurrentOrder is AIObjectiveRescueAll rescueAll && rescueAll.Targets.None())
-                    //        {
-                    //            character.Speak(TextManager.Get("DialogNoRescueTargets"), null, 3.0f, "norescuetargets");
-                    //        }
-                    //        else if (newCurrentOrder is AIObjectivePumpWater pumpWater && pumpWater.Targets.None())
-                    //        {
-                    //            character.Speak(TextManager.Get("DialogNoPumps"), null, 3.0f, "nopumps");
-                    //        }
-                    //    }
-                    //}, 3);
+                    string msg = newCurrentOrder.IsAllowed ? TextManager.Get("DialogAffirmative") : TextManager.Get("DialogNegative");
+                    character.Speak(msg, delay: 1.0f);
                 }
             }
         }
@@ -456,13 +417,14 @@ namespace Barotrauma
                     if (orderGiver == null) { return null; }
                     newObjective = new AIObjectiveGoTo(orderGiver, character, this, repeat: true, priorityModifier: priorityModifier)
                     {
-                        CloseEnough = Rand.Range(90, 100) + Rand.Range(50, 70) * Math.Min(HumanAIController.CountCrew(c => c.ObjectiveManager.CurrentOrder is AIObjectiveGoTo gotoOrder && gotoOrder.Target == orderGiver, onlyBots: true), 4),
-                        extraDistanceOutsideSub = 100,
-                        extraDistanceWhileSwimming = 100,
+                        CloseEnough = Rand.Range(80, 100),
+                        CloseEnoughMultiplier = Math.Min(1 + HumanAIController.CountCrew(c => c.ObjectiveManager.HasOrder<AIObjectiveGoTo>(o => o.Target == orderGiver), onlyBots: true) * Rand.Range(0.8f, 1f), 4),
+                        ExtraDistanceOutsideSub = 100,
+                        ExtraDistanceWhileSwimming = 100,
                         AllowGoingOutside = true,
                         IgnoreIfTargetDead = true,
-                        isFollowOrderObjective = true,
-                        mimic = true,
+                        IsFollowOrderObjective = true,
+                        Mimic = character.IsOnPlayerTeam,
                         DialogueIdentifier = "dialogcannotreachplace"
                     };
                     break;
@@ -474,7 +436,6 @@ namespace Barotrauma
                     break;
                 case "return":
                     newObjective = new AIObjectiveReturn(character, orderGiver, this, priorityModifier: priorityModifier);
-                    newObjective.Abandoned += () => DismissSelf(order, option);
                     newObjective.Completed += () => DismissSelf(order, option);
                     break;
                 case "fixleaks":
@@ -500,12 +461,10 @@ namespace Barotrauma
                         if (!order.TargetItemComponent.Item.IsInteractable(character)) { return null; }
                         newObjective = new AIObjectiveOperateItem(targetPump, character, this, option, false, priorityModifier: priorityModifier)
                         {
-                            IsLoop = true,
+                            IsLoop = false,
                             Override = orderGiver != null && orderGiver.IsCommanding
                         };
-                        // ItemComponent.AIOperate() returns false by default -> We'd have to set IsLoop = false and implement a custom override of AIOperate for the Pump.cs, 
-                        // if we want that the bot just switches the pump on/off and continues doing something else.
-                        // If we want that the bot does the objective and then forgets about it, I think we could do the same plus dismiss when the bot is done.
+                        newObjective.Completed += () => DismissSelf(order, option);
                     }
                     else
                     {
@@ -575,6 +534,39 @@ namespace Barotrauma
                 case "escapehandcuffs":
                     newObjective = new AIObjectiveEscapeHandcuffs(character, this, priorityModifier: priorityModifier);
                     break;
+                case "prepareforexpedition":
+                    newObjective = new AIObjectivePrepare(character, this, order.GetTargetItems(option), order.RequireItems)
+                    {
+                        KeepActiveWhenReady = true,
+                        CheckInventory = true,
+                        Equip = false,
+                        FindAllItems = true
+                    };
+                    break;
+                case "findweapon":
+                    AIObjectivePrepare prepareObjective;
+                    if (order.TargetEntity is Item tItem)
+                    {
+                        prepareObjective = new AIObjectivePrepare(character, this, targetItem: tItem);
+                    }
+                    else
+                    {
+                        prepareObjective = new AIObjectivePrepare(character, this, order.GetTargetItems(option), order.RequireItems)
+                        {
+                            KeepActiveWhenReady = false,
+                            CheckInventory = false,
+                            EvaluateCombatPriority = true,
+                            FindAllItems = false
+                        };
+                    }
+                    prepareObjective.KeepActiveWhenReady = false;
+                    prepareObjective.Equip = true;
+                    newObjective = prepareObjective;
+                    newObjective.Completed += () => DismissSelf(order, option);
+                    break;
+                case "loaditems":
+                    newObjective = new AIObjectiveLoadItems(character, this, option, order.GetTargetItems(option), order.TargetEntity as Item, priorityModifier);
+                    break;
                 default:
                     if (order.TargetItemComponent == null) { return null; }
                     if (!order.TargetItemComponent.Item.IsInteractable(character)) { return null; }
@@ -606,17 +598,20 @@ namespace Barotrauma
 #endif
                 return;
             }
+            Order dismissOrder = Order.GetPrefab("dismissed");
+            var orderOption = Order.GetDismissOrderOption(currentOrder);
+            int priority = currentOrder.ManualPriority;
 #if CLIENT
             if (GameMain.GameSession?.CrewManager != null && GameMain.GameSession.CrewManager.IsSinglePlayer)
             {
-                GameMain.GameSession?.CrewManager?.SetCharacterOrder(character, Order.GetPrefab("dismissed"), Order.GetDismissOrderOption(currentOrder), currentOrder.ManualPriority, character);
+                GameMain.GameSession.CrewManager.SetCharacterOrder(character, dismissOrder, orderOption, priority, character);
             }
 #else
-            GameMain.Server?.SendOrderChatMessage(new OrderChatMessage(Order.GetPrefab("dismissed"), Order.GetDismissOrderOption(currentOrder), currentOrder.ManualPriority, currentOrder.Order?.TargetSpatialEntity, character, character));
+            GameMain.Server?.SendOrderChatMessage(new OrderChatMessage(dismissOrder, orderOption, priority, currentOrder.Order.TargetSpatialEntity, character, character));
+            SetOrder(dismissOrder, orderOption, priority, character, speak: false);
 #endif
         }
 
-
         private bool IsAllowedToWait()
         {
             if (!character.IsOnPlayerTeam) { return false; }
@@ -665,10 +660,9 @@ namespace Barotrauma
             return ForcedOrder != null || CurrentOrders.Any();
         }
 
-        public bool HasOrder<T>() where T : AIObjective
-        {
-            return ForcedOrder is T || CurrentOrders.Any(o => o.Objective is T);
-        }
+        public bool HasOrder<T>(Func<T, bool> predicate = null) where T : AIObjective =>
+                ForcedOrder is T forcedOrder && (predicate == null || predicate(forcedOrder)) || 
+                CurrentOrders.Any(o => o.Objective is T order && (predicate == null || predicate(order)));
 
         public float GetOrderPriority(AIObjective objective)
         {

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

@@ -202,7 +202,7 @@ namespace Barotrauma
                     HumanAIController.FaceTarget(target.Item);
                     if (character.SelectedConstruction != target.Item)
                     {
-                        target.Item.TryInteract(character, false, true);
+                        target.Item.TryInteract(character, forceSelectKey: true);
                     }
                     if (component.AIOperate(deltaTime, character, this))
                     {
@@ -213,7 +213,6 @@ namespace Barotrauma
                 {
                     TryAddSubObjective(ref goToObjective, () => new AIObjectiveGoTo(target.Item, character, objectiveManager, closeEnough: 50)
                     {
-                        DialogueIdentifier = "dialogcannotreachtarget",
                         TargetName = target.Item.Name,
                         endNodeFilter = node => node.Waypoint.Ladders == null
                     },

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

@@ -0,0 +1,200 @@
+using Barotrauma.Extensions;
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+
+namespace Barotrauma
+{
+    class AIObjectivePrepare : AIObjective
+    {
+        public override string Identifier { get; set; } = "prepare";
+        public override string DebugTag => $"{Identifier}";
+        public override bool KeepDivingGearOn => true;
+        public override bool PrioritizeIfSubObjectivesActive => true;
+
+        private AIObjectiveGetItem getSingleItemObjective;
+        private AIObjectiveGetItems getAllItemsObjective;
+        private AIObjectiveGetItems getMultipleItemsObjective;
+        private bool subObjectivesCreated;
+        private readonly Item targetItem;
+        private readonly ImmutableArray<string> requiredItems;
+        private readonly ImmutableArray<string> optionalItems;
+        private readonly HashSet<Item> items = new HashSet<Item>();
+        public bool KeepActiveWhenReady { get; set; }
+        public bool CheckInventory { get; set; }
+        public bool FindAllItems { get; set; }
+        public bool Equip { get; set; }
+        public bool EvaluateCombatPriority { get; set; }
+
+        private AIObjective GetSubObjective()
+        {
+            if (getSingleItemObjective != null) { return getSingleItemObjective; }
+            if (getAllItemsObjective == null || getAllItemsObjective.IsCompleted)
+            {
+                return getMultipleItemsObjective;
+            }
+            return getAllItemsObjective;
+        }
+        public AIObjectivePrepare(Character character, AIObjectiveManager objectiveManager, Item targetItem, float priorityModifier = 1)
+            : base(character, objectiveManager, priorityModifier)
+        {
+            this.targetItem = targetItem;
+        }
+
+        public AIObjectivePrepare(Character character, AIObjectiveManager objectiveManager, IEnumerable<string> optionalItems, IEnumerable<string> requiredItems = null, float priorityModifier = 1)
+            : base(character, objectiveManager, priorityModifier)
+        {
+            this.optionalItems = optionalItems.ToImmutableArray();
+            if (requiredItems != null)
+            {
+                this.requiredItems = requiredItems.ToImmutableArray();
+            }
+        }
+
+        protected override bool CheckObjectiveSpecific() => IsCompleted;
+
+        protected override float GetPriority()
+        {
+            if (!IsAllowed)
+            {
+                Priority = 0;
+                Abandon = true;
+                return Priority;
+            }
+            Priority = objectiveManager.GetOrderPriority(this);
+            var subObjective = GetSubObjective();
+            if (subObjective != null && subObjective.IsCompleted)
+            {
+                Priority = 0;
+                items.RemoveWhere(i => i == null || i.Removed || !i.IsOwnedBy(character));
+                if (items.None())
+                {
+                    Abandon = true;
+
+                }
+                else if (items.Any(i => i.Components.Any(i => !i.IsLoaded(character))))
+                {
+                    Reset();
+                }
+            }
+            return Priority;
+        }
+
+        protected override void Act(float deltaTime)
+        {
+            if (character.LockHands)
+            {
+                Abandon = true;
+                return;
+            }
+            if (!subObjectivesCreated)
+            {
+                if (FindAllItems && targetItem == null)
+                {
+                    getMultipleItemsObjective = CreateObjectives(optionalItems, requireAll: false);
+                    if (requiredItems != null && requiredItems.Any())
+                    {
+                        getAllItemsObjective = CreateObjectives(requiredItems, requireAll: true);
+                    }
+                    AIObjectiveGetItems CreateObjectives(IEnumerable<string> itemTags, bool requireAll)
+                    {
+                        AIObjectiveGetItems objectiveReference = null;
+                        if (!TryAddSubObjective(ref objectiveReference, () => new AIObjectiveGetItems(character, objectiveManager, itemTags)
+                        {
+                            CheckInventory = CheckInventory,
+                            Equip = Equip,
+                            EvaluateCombatPriority = EvaluateCombatPriority,
+                            RequireLoaded = true,
+                            RequireAllItems = requireAll
+                        },
+                        onCompleted: () =>
+                        {
+                            if (KeepActiveWhenReady)
+                            {
+                                if (objectiveReference != null)
+                                {
+                                    foreach (var item in objectiveReference.achievedItems)
+                                    {
+                                        if (item?.IsOwnedBy(character) != null)
+                                        {
+                                            items.Add(item);
+                                        }
+                                    }
+                                }
+                            }
+                            else
+                            {
+                                IsCompleted = true;
+                            }
+                        },
+                        onAbandon: () => Abandon = true))
+                        {
+                            Abandon = true;
+                        }
+                        return objectiveReference;
+                    }
+                }
+                else
+                {
+                    Func<AIObjectiveGetItem> getItemConstructor;
+                    if (targetItem != null)
+                    {
+                        getItemConstructor = () => new AIObjectiveGetItem(character, targetItem, objectiveManager, equip: Equip)
+                        {
+                            SpeakIfFails = true
+                        };
+                    }
+                    else
+                    {
+                        IEnumerable<string> allItems = optionalItems;
+                        if (requiredItems != null && requiredItems.Any())
+                        {
+                            allItems = requiredItems;
+                        }
+                        getItemConstructor = () => new AIObjectiveGetItem(character, allItems, objectiveManager, equip: Equip, checkInventory: CheckInventory)
+                        {
+                            EvaluateCombatPriority = EvaluateCombatPriority,
+                            SpeakIfFails = true,
+                            RequireLoaded = true
+                        };
+                    }
+                    if (!TryAddSubObjective(ref getSingleItemObjective, getItemConstructor,
+                    onCompleted: () =>
+                    {
+                        if (KeepActiveWhenReady)
+                        {
+                            if (getSingleItemObjective != null)
+                            {
+                                var item = getSingleItemObjective?.TargetItem;
+                                if (item?.IsOwnedBy(character) != null)
+                                {
+                                    items.Add(item);
+                                }
+                            }
+                        }
+                        else
+                        {
+                            IsCompleted = true;
+                        }
+                    },
+                    onAbandon: () => Abandon = true))
+                    {
+                        Abandon = true;
+                    }
+                }
+                subObjectivesCreated = true;
+            }
+        }
+
+        public override void Reset()
+        {
+            base.Reset();
+            items.Clear();
+            subObjectivesCreated = false;
+            getMultipleItemsObjective = null;
+            getSingleItemObjective = null;
+            getAllItemsObjective = null;
+        }
+    }
+}

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

@@ -20,6 +20,9 @@ namespace Barotrauma
         private float previousCondition = -1;
         private RepairTool repairTool;
 
+        private const float WaitTimeBeforeRepair = 0.5f;
+        private float waitTimer;
+
         private bool IsRepairing() => IsRepairing(character, Item);
         private readonly bool isPriority;
 
@@ -107,7 +110,7 @@ namespace Barotrauma
                     {
                         foreach (RelatedItem requiredItem in kvp.Value)
                         {
-                            var getItemObjective = new AIObjectiveGetItem(character, requiredItem.Identifiers, objectiveManager, true)
+                            var getItemObjective = new AIObjectiveGetItem(character, requiredItem.Identifiers, objectiveManager, equip: true)
                             {
                                 AllowVariants = requiredItem.AllowVariants
                             };
@@ -160,6 +163,9 @@ namespace Barotrauma
             }
             if (!character.IsClimbing && character.CanInteractWith(Item, out _, checkLinked: false))
             {
+                waitTimer += deltaTime;
+                if (waitTimer < WaitTimeBeforeRepair) { return; }
+
                 HumanAIController.FaceTarget(Item);
                 if (repairTool != null)
                 {
@@ -176,8 +182,12 @@ namespace Barotrauma
                     {
                         if (character.SelectedConstruction != Item)
                         {
-                            if (!Item.TryInteract(character, ignoreRequiredItems: true, forceSelectKey: true) &&
-                                !Item.TryInteract(character, ignoreRequiredItems: true, forceActionKey: true))
+                            if (Item.TryInteract(character, ignoreRequiredItems: true, forceSelectKey: true) ||
+                                Item.TryInteract(character, ignoreRequiredItems: true, forceUseKey: true))
+                            {
+                                character.SelectedConstruction = Item;
+                            }
+                            else
                             {
                                 Abandon = true;
                             }
@@ -209,6 +219,7 @@ namespace Barotrauma
             }
             else
             {
+                waitTimer = 0.0f;
                 RemoveSubObjective(ref refuelObjective);
                 // If cannot reach the item, approach it.
                 TryAddSubObjective(ref goToObjective,
@@ -219,8 +230,7 @@ namespace Barotrauma
                         {
                             // Don't stop in ladders, because we can't interact with other items while holding the ladders.
                             endNodeFilter = node => node.Waypoint.Ladders == null,
-                            // Allow repairing hatches and airlock doors.
-                            AllowGoingOutside = HumanAIController.ObjectiveManager.IsCurrentOrder<AIObjectiveRepairItems>() && Item.GetComponent<Door>() != null
+                            TargetName = Item.Name
                         };
                         if (repairTool != null)
                         {

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

@@ -91,8 +91,7 @@ namespace Barotrauma
 
         public static bool NearlyFullCondition(Item item)
         {
-            float condition = item.ConditionPercentage;
-            return item.Repairables.All(r => condition >= r.RepairThreshold);
+            return item.Repairables.All(r => !r.IsBelowRepairThreshold);
         }
 
         protected override float TargetEvaluation()

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

@@ -36,9 +36,9 @@ namespace Barotrauma
         {
             if (targetCharacter == null)
             {
-                string errorMsg = $"{character.Name}: Attempted to create a Rescue objective with no target!\n" + Environment.StackTrace.CleanupStackTrace();
-                DebugConsole.ThrowError(errorMsg);
-                GameAnalyticsManager.AddErrorEventOnce("AIObjectiveRescue:ctor:targetnull", GameAnalyticsSDK.Net.EGAErrorSeverity.Error, errorMsg);
+                string errorMsg = $"Attempted to create a Rescue objective with no target!\n" + Environment.StackTrace.CleanupStackTrace();
+                DebugConsole.ThrowError(character.Name + ": " + errorMsg);
+                GameAnalyticsManager.AddErrorEventOnce("AIObjectiveRescue:ctor:targetnull", GameAnalyticsManager.ErrorSeverity.Error, errorMsg);
                 Abandon = true;
                 return;
             }
@@ -59,7 +59,7 @@ namespace Barotrauma
 
         protected override void Act(float deltaTime)
         {
-            if (character.LockHands || targetCharacter == null || targetCharacter.CurrentHull == null || targetCharacter.Removed || targetCharacter.IsDead)
+            if (character.LockHands || targetCharacter == null || targetCharacter.Removed || targetCharacter.IsDead)
             {
                 Abandon = true;
                 return;
@@ -137,66 +137,69 @@ namespace Barotrauma
                                 recursive: true);
                         }
                     }
-                    if (HumanAIController.GetHullSafety(targetCharacter.CurrentHull, targetCharacter) < HumanAIController.HULL_SAFETY_THRESHOLD)
+                    if (character.Submarine != null)
                     {
-                        // Incapacitated target is not in a safe place -> Move to a safe place first
-                        if (character.SelectedCharacter != targetCharacter)
+                        if (HumanAIController.GetHullSafety(targetCharacter.CurrentHull, targetCharacter) < HumanAIController.HULL_SAFETY_THRESHOLD)
                         {
-                            if (targetCharacter.CurrentHull != null && HumanAIController.VisibleHulls.Contains(targetCharacter.CurrentHull) && targetCharacter.CurrentHull.DisplayName != null)
+                            // Incapacitated target is not in a safe place -> Move to a safe place first
+                            if (character.SelectedCharacter != targetCharacter)
                             {
-                                character.Speak(TextManager.GetWithVariables("DialogFoundUnconsciousTarget", new string[2] { "[targetname]", "[roomname]" },
-                                    new string[2] { targetCharacter.Name, targetCharacter.CurrentHull.DisplayName }, new bool[2] { false, true }),
-                                    null, 1.0f, "foundunconscioustarget" + targetCharacter.Name, 60.0f);
-                            }
-                            // Go to the target and select it
-                            if (!character.CanInteractWith(targetCharacter))
-                            {
-                                RemoveSubObjective(ref replaceOxygenObjective);
-                                RemoveSubObjective(ref goToObjective);
-                                TryAddSubObjective(ref goToObjective, () => new AIObjectiveGoTo(targetCharacter, character, objectiveManager)
+                                if (targetCharacter.CurrentHull != null && HumanAIController.VisibleHulls.Contains(targetCharacter.CurrentHull) && targetCharacter.CurrentHull.DisplayName != null)
                                 {
-                                    CloseEnough = CloseEnoughToTreat,
-                                    DialogueIdentifier = "dialogcannotreachpatient",
-                                    TargetName = targetCharacter.DisplayName
-                                },
-                                onCompleted: () => RemoveSubObjective(ref goToObjective),
-                                onAbandon: () =>
+                                    character.Speak(TextManager.GetWithVariables("DialogFoundUnconsciousTarget", new string[2] { "[targetname]", "[roomname]" },
+                                        new string[2] { targetCharacter.Name, targetCharacter.CurrentHull.DisplayName }, new bool[2] { false, true }),
+                                        null, 1.0f, "foundunconscioustarget" + targetCharacter.Name, 60.0f);
+                                }
+                                // Go to the target and select it
+                                if (!character.CanInteractWith(targetCharacter))
                                 {
+                                    RemoveSubObjective(ref replaceOxygenObjective);
                                     RemoveSubObjective(ref goToObjective);
-                                    Abandon = true;
-                                });
-                            }
-                            else
-                            {
-                                character.SelectCharacter(targetCharacter);
-                            }
-                        }
-                        else
-                        {
-                            // Drag the character into safety
-                            if (safeHull == null)
-                            {
-                                if (findHullTimer > 0)
-                                {
-                                    findHullTimer -= deltaTime;
-                                }
-                                else
-                                {
-                                    safeHull = objectiveManager.GetObjective<AIObjectiveFindSafety>().FindBestHull(HumanAIController.VisibleHulls);
-                                    findHullTimer = findHullInterval * Rand.Range(0.9f, 1.1f);
-                                }
-                            }
-                            if (safeHull != null && character.CurrentHull != safeHull)
-                            {
-                                RemoveSubObjective(ref replaceOxygenObjective);
-                                RemoveSubObjective(ref goToObjective);
-                                TryAddSubObjective(ref goToObjective, () => new AIObjectiveGoTo(safeHull, character, objectiveManager),
+                                    TryAddSubObjective(ref goToObjective, () => new AIObjectiveGoTo(targetCharacter, character, objectiveManager)
+                                    {
+                                        CloseEnough = CloseEnoughToTreat,
+                                        DialogueIdentifier = "dialogcannotreachpatient",
+                                        TargetName = targetCharacter.DisplayName
+                                    },
                                     onCompleted: () => RemoveSubObjective(ref goToObjective),
                                     onAbandon: () =>
                                     {
                                         RemoveSubObjective(ref goToObjective);
-                                        safeHull = character.CurrentHull;
+                                        Abandon = true;
                                     });
+                                }
+                                else
+                                {
+                                    character.SelectCharacter(targetCharacter);
+                                }
+                            }
+                            else
+                            {
+                                // Drag the character into safety
+                                if (safeHull == null)
+                                {
+                                    if (findHullTimer > 0)
+                                    {
+                                        findHullTimer -= deltaTime;
+                                    }
+                                    else
+                                    {
+                                        safeHull = objectiveManager.GetObjective<AIObjectiveFindSafety>().FindBestHull(HumanAIController.VisibleHulls);
+                                        findHullTimer = findHullInterval * Rand.Range(0.9f, 1.1f);
+                                    }
+                                }
+                                if (safeHull != null && character.CurrentHull != safeHull)
+                                {
+                                    RemoveSubObjective(ref replaceOxygenObjective);
+                                    RemoveSubObjective(ref goToObjective);
+                                    TryAddSubObjective(ref goToObjective, () => new AIObjectiveGoTo(safeHull, character, objectiveManager),
+                                        onCompleted: () => RemoveSubObjective(ref goToObjective),
+                                        onAbandon: () =>
+                                        {
+                                            RemoveSubObjective(ref goToObjective);
+                                            safeHull = character.CurrentHull;
+                                        });
+                                }
                             }
                         }
                     }
@@ -228,7 +231,7 @@ namespace Barotrauma
                 // We can start applying treatment
                 if (character != targetCharacter && character.SelectedCharacter != targetCharacter)
                 {
-                    if (targetCharacter.CurrentHull.DisplayName != null)
+                    if (targetCharacter.CurrentHull?.DisplayName != null)
                     {
                         character.Speak(TextManager.GetWithVariables("DialogFoundWoundedTarget", new string[2] { "[targetname]", "[roomname]" },
                             new string[2] { targetCharacter.Name, targetCharacter.CurrentHull.DisplayName }, new bool[2] { false, true }),
@@ -252,7 +255,7 @@ namespace Barotrauma
                 return;
             }
 
-            SteeringManager?.Reset();
+            SteeringManager.Reset();
 
             if (!targetCharacter.IsPlayer)
             {
@@ -269,26 +272,36 @@ namespace Barotrauma
             float cprSuitability = targetCharacter.Oxygen < 0.0f ? -targetCharacter.Oxygen * 100.0f : 0.0f;
 
             //find which treatments are the most suitable to treat the character's current condition
-            targetCharacter.CharacterHealth.GetSuitableTreatments(currentTreatmentSuitabilities, normalize: false);
+            targetCharacter.CharacterHealth.GetSuitableTreatments(currentTreatmentSuitabilities, normalize: false, predictFutureDuration: 10.0f);
 
             //check if we already have a suitable treatment for any of the afflictions
             foreach (Affliction affliction in GetSortedAfflictions(targetCharacter))
             {
                 if (affliction == null) { throw new Exception("Affliction was null"); }
                 if (affliction.Prefab == null) { throw new Exception("Affliction prefab was null"); }
+                float bestSuitability = 0.0f;
+                Item bestItem = null;
                 foreach (KeyValuePair<string, float> treatmentSuitability in affliction.Prefab.TreatmentSuitability)
                 {
-                    if (currentTreatmentSuitabilities.ContainsKey(treatmentSuitability.Key) && currentTreatmentSuitabilities[treatmentSuitability.Key] > 0.0f)
+                    if (currentTreatmentSuitabilities.ContainsKey(treatmentSuitability.Key) && 
+                        currentTreatmentSuitabilities[treatmentSuitability.Key] > bestSuitability)
                     {
                         Item matchingItem = character.Inventory.FindItemByIdentifier(treatmentSuitability.Key, true);
-                        if (matchingItem == null) { continue; }
-                        if (targetCharacter != character) { character.SelectCharacter(targetCharacter); }
-                        ApplyTreatment(affliction, matchingItem);
-                        //wait a bit longer after applying a treatment to wait for potential side-effects to manifest
-                        treatmentTimer = TreatmentDelay * 4;
-                        return;
+                        if (matchingItem != null) 
+                        {
+                            bestItem = matchingItem;
+                            bestSuitability = currentTreatmentSuitabilities[treatmentSuitability.Key];
+                        }
                     }
                 }
+                if (bestItem != null)
+                {
+                    if (targetCharacter != character) { character.SelectCharacter(targetCharacter); }
+                    ApplyTreatment(affliction, bestItem);
+                    //wait a bit longer after applying a treatment to wait for potential side-effects to manifest
+                    treatmentTimer = TreatmentDelay * 4;
+                    return;
+                }
             }
             // Find treatments outside of own inventory only if inside the own sub.
             if (character.Submarine != null && character.Submarine.TeamID == character.TeamID)
@@ -319,9 +332,32 @@ namespace Barotrauma
                         {
                             itemListStr = itemNameList[0];
                         }
+                        else if (itemNameList.Count == 2)
+                        {
+                            //[treatment1] or [treatment2]
+                            itemListStr = TextManager.GetWithVariables(
+                                "DialogRequiredTreatmentOptionsLast",
+                                new string[] { "[treatment1]", "[treatment2]" },
+                                new string[] { itemNameList[0], itemNameList[1] });
+                        }
                         else
                         {
-                            itemListStr = string.Join(" or ", string.Join(", ", itemNameList.Take(itemNameList.Count - 1)), itemNameList.Last());
+                            //[treatment1], [treatment2], [treatment3] ... or [treatmentx]
+                            itemListStr = TextManager.GetWithVariables(
+                                "DialogRequiredTreatmentOptionsFirst",
+                                new string[] { "[treatment1]", "[treatment2]" },
+                                new string[] { itemNameList[0], itemNameList[1] });
+                            for (int i = 2; i < itemNameList.Count - 1; i++)
+                            {
+                                itemListStr = TextManager.GetWithVariables(
+                                  "DialogRequiredTreatmentOptionsFirst",
+                                  new string[] { "[treatment1]", "[treatment2]" },
+                                  new string[] { itemListStr, itemNameList[i] });
+                            }
+                            itemListStr = TextManager.GetWithVariables(
+                                "DialogRequiredTreatmentOptionsLast",
+                                new string[] { "[treatment1]", "[treatment2]" },
+                                new string[] { itemListStr, itemNameList.Last() });
                         }
                         if (targetCharacter != character && character.IsOnPlayerTeam)
                         {
@@ -395,21 +431,7 @@ namespace Barotrauma
 
         protected override bool CheckObjectiveSpecific()
         {
-            if (character.LockHands || targetCharacter == null || targetCharacter.CurrentHull == null || targetCharacter.Removed || targetCharacter.IsDead)
-            {
-                Abandon = true;
-                return false;
-            }
-            // Don't go into rooms that have enemies
-            if (Character.CharacterList.Any(c => c.CurrentHull == targetCharacter.CurrentHull && !HumanAIController.IsFriendly(character, c) && HumanAIController.IsActive(c)))
-            {
-                Abandon = true;
-                return false;
-            }
-            bool isCompleted = 
-                AIObjectiveRescueAll.GetVitalityFactor(targetCharacter) >= AIObjectiveRescueAll.GetVitalityThreshold(objectiveManager, character, targetCharacter) ||
-                targetCharacter.CharacterHealth.GetAllAfflictions().All(a => a.Prefab.IsBuff || a.Strength <= a.Prefab.TreatmentThreshold);
-
+            bool isCompleted = AIObjectiveRescueAll.GetVitalityFactor(targetCharacter) >= AIObjectiveRescueAll.GetVitalityThreshold(objectiveManager, character, targetCharacter);
             if (isCompleted && targetCharacter != character && character.IsOnPlayerTeam)
             {                
                 character.Speak(TextManager.GetWithVariable("DialogTargetHealed", "[targetname]", targetCharacter.Name),
@@ -426,16 +448,36 @@ namespace Barotrauma
                 Abandon = true;
                 return Priority;
             }
-            if (character.LockHands || targetCharacter == null || targetCharacter.CurrentHull == null || targetCharacter.Removed || targetCharacter.IsDead)
+            if (character.CurrentHull == null)
+            {
+                if (!objectiveManager.HasOrder<AIObjectiveRescueAll>())
+                {
+                    Priority = 0;
+                    Abandon = true;
+                    return Priority;
+                }
+            }
+            else if (Character.CharacterList.Any(c => c.CurrentHull == targetCharacter.CurrentHull && !HumanAIController.IsFriendly(character, c) && HumanAIController.IsActive(c)))
+            {
+                // Don't go into rooms that have enemies
+                Priority = 0;
+                Abandon = true;
+                return Priority;
+            }
+            if (targetCharacter == null)
             {
                 Priority = 0;
                 Abandon = true;
             }
             else
             {
-                // Vertical distance matters more than horizontal (climbing up/down is harder than moving horizontally)
-                float dist = Math.Abs(character.WorldPosition.X - targetCharacter.WorldPosition.X) + Math.Abs(character.WorldPosition.Y - targetCharacter.WorldPosition.Y) * 2.0f;
-                float distanceFactor = MathHelper.Lerp(1, 0.1f, MathUtils.InverseLerp(0, 5000, dist));
+                float horizontalDistance = Math.Abs(character.WorldPosition.X - targetCharacter.WorldPosition.X);
+                float verticalDistance = Math.Abs(character.WorldPosition.Y - targetCharacter.WorldPosition.Y);
+                if (character.Submarine?.Info is { IsRuin: false })
+                {
+                    verticalDistance *= 2;
+                }
+                float distanceFactor = MathHelper.Lerp(1, 0.1f, MathUtils.InverseLerp(0, 5000, horizontalDistance + verticalDistance));
                 if (targetCharacter.CurrentHull == character.CurrentHull)
                 {
                     distanceFactor = 1;
@@ -449,6 +491,16 @@ namespace Barotrauma
 
         public static IEnumerable<Affliction> GetSortedAfflictions(Character character) => CharacterHealth.SortAfflictionsBySeverity(character.CharacterHealth.GetAllAfflictions());
 
+        public static IEnumerable<Affliction> GetTreatableAfflictions(Character character)
+        {
+            foreach (Affliction affliction in character.CharacterHealth.GetAllAfflictions())
+            {
+                if (affliction.Prefab.IsBuff || affliction.Strength < affliction.Prefab.TreatmentThreshold) { continue; }
+                if (!affliction.Prefab.TreatmentSuitability.Any(kvp => kvp.Value > 0)) { continue; }
+                yield return affliction;
+            }
+        }
+
         public override void Reset()
         {
             base.Reset();

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

@@ -64,8 +64,15 @@ namespace Barotrauma
 
         public static float GetVitalityFactor(Character character)
         {
-            float vitality = character.HealthPercentage - (character.Bleeding * 2) - character.Bloodloss + Math.Min(character.Oxygen, 0);
+            float vitality = 100;
+            vitality -= character.Bleeding * 2;
+            vitality += Math.Min(character.Oxygen, 0);
             vitality -= character.CharacterHealth.GetAfflictionStrength("paralysis");
+            foreach (Affliction affliction in AIObjectiveRescue.GetTreatableAfflictions(character))
+            {
+                float strength = character.CharacterHealth.GetPredictedStrength(affliction, predictFutureDuration: 10.0f);
+                vitality -= affliction.GetVitalityDecrease(character.CharacterHealth, strength) / character.MaxVitality * 100;
+            }
             return Math.Clamp(vitality, 0, 100);
         }
 
@@ -79,11 +86,11 @@ namespace Barotrauma
         {
             if (target == null || target.IsDead || target.Removed) { return false; }
             if (target.IsInstigator) { return false; }
+            if (target.IsPet) { return false; }
             if (!HumanAIController.IsFriendly(character, target, onlySameTeam: true)) { return false; }
             if (character.AIController is HumanAIController humanAI)
             {
-                if (GetVitalityFactor(target) >= GetVitalityThreshold(humanAI.ObjectiveManager, character, target) ||
-                    target.CharacterHealth.GetAllAfflictions().All(a => a.Prefab.IsBuff || a.Strength <= a.Prefab.TreatmentThreshold)) 
+                if (GetVitalityFactor(target) >= GetVitalityThreshold(humanAI.ObjectiveManager, character, target)) 
                 {
                     return false; 
                 }
@@ -105,10 +112,13 @@ namespace Barotrauma
             {
                 if (GetVitalityFactor(target) >= vitalityThreshold) { return false; }
             }
-            if (target.Submarine == null || character.Submarine == null) { return false; }
-            // Don't allow going into another sub, unless it's connected and of the same team and type.
-            if (!character.Submarine.IsEntityFoundOnThisSub(target.CurrentHull, includingConnectedSubs: true)) { return false; }
-            if (target != character &&!target.IsPlayer && HumanAIController.IsActive(target) && target.AIController is HumanAIController targetAI)
+            if (target.Submarine != character.Submarine) { return false; }
+            if (character.Submarine != null)
+            {
+                // Don't allow going into another sub, unless it's connected and of the same team and type.
+                if (!character.Submarine.IsEntityFoundOnThisSub(target.CurrentHull, includingConnectedSubs: true)) { return false; }
+            }
+            if (target != character && target.IsBot && HumanAIController.IsActive(target) && target.AIController is HumanAIController targetAI)
             {
                 // Ignore all concious targets that are currently fighting, fleeing, fixing, or treating characters
                 if (targetAI.ObjectiveManager.HasActiveObjective<AIObjectiveCombat>() ||
@@ -119,9 +129,12 @@ namespace Barotrauma
                     return false;
                 }
             }
-            // Don't go into rooms that have enemies
-            if (Character.CharacterList.Any(c => c.CurrentHull == target.CurrentHull && !HumanAIController.IsFriendly(character, c) && HumanAIController.IsActive(c))) { return false; }
-            return true;
+            if (target.CurrentHull != null)
+            {
+                // Don't go into rooms that have enemies
+                if (Character.CharacterList.Any(c => c.CurrentHull == target.CurrentHull && !HumanAIController.IsFriendly(character, c) && HumanAIController.IsActive(c))) { return false; }
+            }
+            return character.GetDamageDoneByAttacker(target) <= 0;
         }
     }
 }

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

@@ -5,6 +5,7 @@ using System;
 using System.Collections.Generic;
 using System.Xml.Linq;
 using System.Linq;
+using System.Collections.Immutable;
 
 namespace Barotrauma
 {
@@ -19,11 +20,11 @@ namespace Barotrauma
 
     struct OrderInfo
     {
-        public Order Order { get; }
-        public string OrderOption { get; }
-        public int ManualPriority { get; }
-        public OrderType Type { get; }
-        public AIObjective Objective { get; }
+        public readonly Order Order;
+        public readonly string OrderOption;
+        public readonly int ManualPriority;
+        public readonly OrderType Type;
+        public readonly AIObjective Objective;
         public bool IsCurrentOrder => Type == OrderType.Current;
 
         public enum OrderType
@@ -41,6 +42,8 @@ namespace Barotrauma
             Objective = objective;
         }
 
+        public OrderInfo(Order order, string orderOption) : this(order, orderOption, CharacterInfo.HighestManualOrderPriority, null) { }
+
         public OrderInfo(Order order, string orderOption, int manualPriority) : this(order, orderOption, manualPriority, OrderType.Current, null) { }
 
         public OrderInfo(Order order, string orderOption, int manualPriority, AIObjective objective) : this(order, orderOption, manualPriority, OrderType.Current, objective) { }
@@ -103,7 +106,10 @@ namespace Barotrauma
 
         public readonly Type ItemComponentType;
         public readonly bool CanTypeBeSubclass;
-        public readonly string[] TargetItems;
+        public readonly ImmutableArray<string> TargetItems;
+        public readonly ImmutableArray<string> RequireItems;
+        private readonly Dictionary<string, ImmutableArray<string>> OptionTargetItems;
+        public bool HasOptionSpecificTargetItems => OptionTargetItems != null && OptionTargetItems.Any();
 
         public readonly string Identifier;
 
@@ -170,6 +176,7 @@ namespace Barotrauma
         public bool HasOptions => (IsPrefab ? Options : Prefab.Options).Length > 1;
         public bool IsPrefab { get; private set; }
         public readonly bool MustManuallyAssign;
+        public readonly bool AutoDismiss;
 
         public readonly OrderTarget TargetPosition;
 
@@ -208,6 +215,12 @@ namespace Barotrauma
         /// </summary>
         public bool DrawIconWhenContained { get; }
 
+        /// <summary>
+        /// Affects how high on the order list the order will be placed (i.e. the manual priority order when it's given) when it's first given.
+        /// Manually rearranging orders will override this priority.
+        /// </summary>
+        public int AssignmentPriority { get; }
+
         public static void Init()
         {
             Prefabs = new Dictionary<string, Order>();
@@ -305,8 +318,6 @@ namespace Barotrauma
                 }
             }
             CanTypeBeSubclass = orderElement.GetAttributeBool("cantypebesubclass", false);
-
-            TargetItems = orderElement.GetAttributeStringArray("targetitems", new string[0], trim: true, convertToLowerInvariant: true);
             color = orderElement.GetAttributeColor("color");
             FadeOutTime = orderElement.GetAttributeFloat("fadeouttime", 0.0f);
             UseController = orderElement.GetAttributeBool("usecontroller", false);
@@ -316,6 +327,36 @@ namespace Barotrauma
             Options = orderElement.GetAttributeStringArray("options", new string[0]);
             HiddenOptions = orderElement.GetAttributeStringArray("hiddenoptions", new string[0]);
             AllOptions = Options.Concat(HiddenOptions).ToArray();
+
+            OptionTargetItems = new Dictionary<string, ImmutableArray<string>>();
+            if (orderElement.GetAttributeString("targetitems", "") is string targetItems && targetItems.Contains(';'))
+            {
+                string[] splitTargetItems = targetItems.Split(';');
+#if DEBUG
+                if (splitTargetItems.Length != AllOptions.Length)
+                {
+                    DebugConsole.ThrowError($"Order \"{Identifier}\" has option-specific target items, but the option count doesn't match the target item count");
+                }
+#endif
+                var allTargetItems = new List<string>();
+                for (int i = 0; i < AllOptions.Length; i++)
+                {
+                    string[] optionTargetItems = i < splitTargetItems.Length ? splitTargetItems[i].Split(',', '，') : new string[0];
+                    for (int j = 0; j < optionTargetItems.Length; j++)
+                    {
+                        optionTargetItems[j] = optionTargetItems[j].ToLowerInvariant().Trim();
+                        allTargetItems.Add(optionTargetItems[j]);
+                    }
+                    OptionTargetItems.Add(AllOptions[i], optionTargetItems.ToImmutableArray());
+                }
+                TargetItems = allTargetItems.ToImmutableArray();
+            }
+            else
+            {
+                TargetItems = orderElement.GetAttributeStringArray("targetitems", new string[0], trim: true, convertToLowerInvariant: true).ToImmutableArray();
+            }
+            RequireItems = orderElement.GetAttributeStringArray("requireitems", new string[0], trim: true, convertToLowerInvariant: true).ToImmutableArray();
+
             var category = orderElement.GetAttributeString("category", null);
             if (!string.IsNullOrWhiteSpace(category)) { this.Category = (OrderCategory)Enum.Parse(typeof(OrderCategory), category, true); }
             MustSetTarget = orderElement.GetAttributeBool("mustsettarget", false);
@@ -363,6 +404,8 @@ namespace Barotrauma
             MustManuallyAssign = orderElement.GetAttributeBool("mustmanuallyassign", false);
             IsIgnoreOrder = Identifier == "ignorethis" || Identifier == "unignorethis";
             DrawIconWhenContained = orderElement.GetAttributeBool("displayiconwhencontained", false);
+            AutoDismiss = orderElement.GetAttributeBool("autodismiss", Category == OrderCategory.Movement);
+            AssignmentPriority = Math.Clamp(orderElement.GetAttributeInt("assignmentpriority", 100), 0, 100);
         }
 
         /// <summary>
@@ -378,6 +421,8 @@ namespace Barotrauma
             ItemComponentType     = prefab.ItemComponentType;
             CanTypeBeSubclass     = prefab.CanTypeBeSubclass;
             TargetItems           = prefab.TargetItems;
+            OptionTargetItems     = prefab.OptionTargetItems;
+            RequireItems          = prefab.RequireItems;
             Options               = prefab.Options;
             SymbolSprite          = prefab.SymbolSprite;
             Color                 = prefab.Color;
@@ -395,6 +440,7 @@ namespace Barotrauma
             DrawIconWhenContained = prefab.DrawIconWhenContained;
             Hidden                = prefab.Hidden;
             IgnoreAtOutpost       = prefab.IgnoreAtOutpost;
+            AssignmentPriority    = prefab.AssignmentPriority;
 
             OrderGiver = orderGiver;
             TargetEntity = targetEntity;
@@ -510,16 +556,17 @@ namespace Barotrauma
         }
 
         /// <param name="interactableFor">Only returns items which are interactable for this character</param>
-        public List<Item> GetMatchingItems(Submarine submarine, bool mustBelongToPlayerSub, CharacterTeamType? requiredTeam = null, Character interactableFor = null)
+        public List<Item> GetMatchingItems(Submarine submarine, bool mustBelongToPlayerSub, CharacterTeamType? requiredTeam = null, Character interactableFor = null, string orderOption = null)
         {
             List<Item> matchingItems = new List<Item>();
             if (submarine == null) { return matchingItems; }
-            if (ItemComponentType != null || TargetItems.Length > 0)
+            if (ItemComponentType != null || TargetItems.Any() || RequireItems.Any())
             {
                 foreach (var item in Item.ItemList)
                 {
-                    if (TargetItems.Length > 0 && !TargetItems.Contains(item.Prefab.Identifier) && !item.HasTag(TargetItems)) { continue; }
-                    if (TargetItems.Length == 0 && !TryGetTargetItemComponent(item, out _)) { continue; }
+                    if (RequireItems.Any() && !TargetItemsMatchItem(RequireItems, item)) { continue; }
+                    if (TargetItems.Any() && !TargetItemsMatchItem(item, orderOption)) { continue; }
+                    if (RequireItems.None() && TargetItems.None() && !TryGetTargetItemComponent(item, out _)) { continue; }
                     if (mustBelongToPlayerSub && item.Submarine?.Info != null && item.Submarine.Info.Type != SubmarineType.Player) { continue; }
                     if (item.Submarine != submarine && !submarine.DockedTo.Contains(item.Submarine)) { continue; }
                     if (requiredTeam.HasValue && (item.Submarine == null || item.Submarine.TeamID != requiredTeam.Value)) { continue; }
@@ -534,14 +581,13 @@ namespace Barotrauma
             return matchingItems;
         }
 
-
         /// <param name="interactableFor">Only returns items which are interactable for this character</param>
-        public List<Item> GetMatchingItems(bool mustBelongToPlayerSub, Character interactableFor = null)
+        public List<Item> GetMatchingItems(bool mustBelongToPlayerSub, Character interactableFor = null, string orderOption = null)
         {
             Submarine submarine = Character.Controlled != null && Character.Controlled.TeamID == CharacterTeamType.Team2 && Submarine.MainSubs.Length > 1 ?
                 Submarine.MainSubs[1] :
                 Submarine.MainSub;
-            return GetMatchingItems(submarine, mustBelongToPlayerSub, interactableFor: interactableFor);
+            return GetMatchingItems(submarine, mustBelongToPlayerSub, interactableFor: interactableFor, orderOption: orderOption);
         }
 
         public string GetOptionName(string id)
@@ -580,5 +626,34 @@ namespace Barotrauma
             }
             return "";
         }
+
+        public override string ToString()
+        {
+            return $"Order ({Name})";
+        }
+
+        public ImmutableArray<string> GetTargetItems(string option = null)
+        {
+            if (string.IsNullOrEmpty(option) || !OptionTargetItems.TryGetValue(option, out ImmutableArray<string> optionTargetItems))
+            {
+                return TargetItems;
+            }
+            else
+            {
+                return optionTargetItems;
+            }
+        }
+
+        public bool TargetItemsMatchItem(Item item, string option = null)
+        {
+            if (item == null) { return false; }
+            ImmutableArray<string> targetItems = GetTargetItems(option);
+            return TargetItemsMatchItem(targetItems, item);
+        }
+
+        public static bool TargetItemsMatchItem(ImmutableArray<string> targetItems, Item item)
+        {
+            return item != null && targetItems != null && targetItems.Length > 0 && (targetItems.Contains(item.Prefab.Identifier) || item.HasTag(targetItems));
+        }
     }
 }

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

@@ -84,18 +84,17 @@ namespace Barotrauma
         public bool IsBlocked()
         {
             if (blocked.HasValue) { return blocked.Value; }
-
             blocked = false;
-
             if (Waypoint.Submarine != null) { return blocked.Value; }
             if (Waypoint.Tunnel?.Type != Level.TunnelType.Cave) { return blocked.Value; }
             foreach (var w in Level.Loaded.ExtraWalls)
             {
-                if (!(w is DestructibleLevelWall d)) { return blocked.Value; }
-                if (d.Destroyed) { return blocked.Value; }
-                if (!d.IsPointInside(Waypoint.Position)) { return blocked.Value; }
-                blocked = true;
-                break;
+                if (!w.IsPointInside(Waypoint.Position)) { continue; }
+                if (w is DestructibleLevelWall d)
+                {
+                    blocked = !d.Destroyed;
+                }
+                if (blocked.Value) { break; }
             }
             return blocked.Value;
         }
@@ -125,6 +124,7 @@ namespace Barotrauma
             {
                 wp.OnLinksChanged += WaypointLinksChanged;
             }
+            sortedNodes = new List<PathNode>(nodes.Count);
             this.isCharacter = isCharacter;
         }
 
@@ -166,7 +166,7 @@ namespace Barotrauma
             }
         }
 
-        private readonly List<PathNode> sortedNodes = new List<PathNode>();
+        private readonly List<PathNode> sortedNodes;
 
         public SteeringPath FindPath(Vector2 start, Vector2 end, Submarine hostSub = null, string errorMsgStr = null, float minGapSize = 0, Func<PathNode, bool> startNodeFilter = null, Func<PathNode, bool> endNodeFilter = null, Func<PathNode, bool> nodeFilter = null, bool checkVisibility = true)
         {
@@ -175,8 +175,7 @@ namespace Barotrauma
                 node.ResetBlocked();
             }
 
-            //sort nodes roughly according to distance
-            sortedNodes.Clear();
+            // First calculate the temp positions for all nodes.
             foreach (PathNode node in nodes)
             {
                 node.TempPosition = node.Position;
@@ -194,8 +193,15 @@ namespace Barotrauma
                 else if (hostSub == null && wpSub != null)
                 {
                     // Outside and targeting inside 
-                    node.TempPosition += wpSub.SimPosition;       
+                    node.TempPosition += wpSub.SimPosition;
                 }
+            }
+
+            //sort nodes roughly according to distance
+            sortedNodes.Clear();
+            PathNode startNode = null;
+            foreach (PathNode node in nodes)
+            {
                 float xDiff = Math.Abs(start.X - node.TempPosition.X);
                 float yDiff = Math.Abs(start.Y - node.TempPosition.Y);
                 if (InsideSubmarine && !(node.Waypoint.Submarine?.Info?.IsRuin ?? false))
@@ -215,13 +221,20 @@ namespace Barotrauma
                 //much higher cost to waypoints that are outside
                 if (node.Waypoint.CurrentHull == null && ApplyPenaltyToOutsideNodes) { node.TempDistance *= 10.0f; }
 
-                //optimization:
-                //node extremely far, don't try to use it as a start node
-                if (node.TempDistance > 800.0f)
+                //optimization: node extremely far, don't try to use it as a start node
+                if (node.TempDistance > (InsideSubmarine ? 100.0f : 800.0f))
                 {
                     continue;
                 }
-
+                //optimization: node extremely close (< 1 m). If it's valid, choose it as the start node and skip the more exhaustive search for the closest one
+                if (node.TempDistance < 1.0f)
+                {
+                    if (IsValidStartNode(node))
+                    {
+                        startNode = node;
+                        break;
+                    }
+                }
                 //prefer nodes that are closer to the end position
                 node.TempDistance += (Math.Abs(end.X - node.TempPosition.X) + Math.Abs(end.Y - node.TempPosition.Y)) / 100.0f;
 
@@ -233,6 +246,88 @@ namespace Barotrauma
                 sortedNodes.Insert(i, node);
             }
 
+            //find the most suitable start node, starting from the ones that are the closest
+            if (startNode == null)
+            {
+                foreach (PathNode node in sortedNodes)
+                {
+                    if (IsValidStartNode(node))
+                    {
+                        startNode = node;
+                        break;
+                    }
+                }
+            }
+
+            if (startNode == null)
+            {
+#if DEBUG
+                DebugConsole.NewMessage("Pathfinding error, couldn't find a start node. "+ errorMsgStr, Color.DarkRed);
+#endif
+                return new SteeringPath(true);
+            }
+
+            //sort nodes again, now based on distance from the end position
+            sortedNodes.Clear();
+            PathNode endNode = null;
+            foreach (PathNode node in nodes)
+            {
+                node.TempDistance = Vector2.DistanceSquared(end, node.TempPosition);
+                if (InsideSubmarine)
+                {
+                    if (ApplyPenaltyToOutsideNodes)
+                    {
+                        //much higher cost to waypoints that are outside
+                        if (node.Waypoint.CurrentHull == null) { node.TempDistance *= 10.0f; }
+                    }
+                    //avoid stopping at a doorway
+                    if (node.Waypoint.ConnectedDoor != null) { node.TempDistance *= 10.0f; }
+                    //avoid stopping at a ladder
+                    if (node.Waypoint.Ladders != null) { node.TempDistance *= 10.0f; }
+                }
+                //optimization: node extremely far (> 100m / 800 m) from the end position, don't try to use it as an end node
+                if (node.TempDistance > (InsideSubmarine ? 100.0f * 100.0f : 800.0f * 800.0f))
+                {
+                    continue;
+                }
+                //optimization: node extremely close (< 1 m). If it's valid, choose it as the end node and skip the more exhaustive search for the closest one
+                if (node.TempDistance < 1.0f)
+                {
+                    if (IsValidEndNode(node))
+                    {
+                        endNode = node;
+                        break;
+                    }
+                }
+                int i = 0;
+                while (i < sortedNodes.Count && sortedNodes[i].TempDistance < node.TempDistance)
+                {
+                    i++;
+                }
+                sortedNodes.Insert(i, node);
+            }
+            if (endNode == null)
+            {
+                //find the most suitable end node, starting from the ones closest to the end position
+                foreach (PathNode node in sortedNodes)
+                {
+                    if (IsValidEndNode(node))
+                    {
+                        endNode = node;
+                        break;
+                    }
+                }
+            }
+            if (endNode == null)
+            {
+#if DEBUG
+                DebugConsole.NewMessage("Pathfinding error, couldn't find an end node. " + errorMsgStr, Color.DarkRed);
+#endif
+                return new SteeringPath(true);
+            }
+            var path = FindPath(startNode, endNode, nodeFilter, errorMsgStr, minGapSize);
+            return path;
+
             bool IsWaypointVisible(PathNode node, Vector2 rayStart, bool checkVisibility = true)
             {
                 //if searching for a path inside the sub, make sure the waypoint is visible
@@ -251,85 +346,33 @@ namespace Barotrauma
                 return true;
             }
 
-            //find the most suitable start node, starting from the ones that are the closest
-            PathNode startNode = null;
-            foreach (PathNode node in sortedNodes)
+            bool IsValidStartNode(PathNode node)
             {
-                if (nodeFilter != null && !nodeFilter(node)) { continue; }
-                if (startNodeFilter != null && !startNodeFilter(node)) { continue; }
+                if (nodeFilter != null && !nodeFilter(node)) { return false; }
+                if (startNodeFilter != null && !startNodeFilter(node)) { return false; }
                 // Always check the visibility for the start node
-                if (!IsWaypointVisible(node, start)) { continue; }
-                if (node.IsBlocked()) { continue; }
+                if (!IsWaypointVisible(node, start)) { return false; }
+                if (node.IsBlocked()) { return false; }
                 if (node.Waypoint.ConnectedGap != null)
                 {
-                    if (!CanFitThroughGap(node.Waypoint.ConnectedGap, minGapSize)) { continue; }
+                    if (!CanFitThroughGap(node.Waypoint.ConnectedGap, minGapSize)) { return false; }
                 }
-                startNode = node;
-                break;                
+                return true;
             }
 
-            if (startNode == null)
+            bool IsValidEndNode(PathNode node)
             {
-#if DEBUG
-                DebugConsole.NewMessage("Pathfinding error, couldn't find a start node. "+ errorMsgStr, Color.DarkRed);
-#endif
-                return new SteeringPath(true);
-            }
-
-            //sort nodes again, now based on distance from the end position
-            sortedNodes.Clear();
-            foreach (PathNode node in nodes)
-            {
-                node.TempDistance = Vector2.DistanceSquared(end, node.TempPosition);
-                if (InsideSubmarine)
-                {
-                    if (ApplyPenaltyToOutsideNodes)
-                    {
-                        //much higher cost to waypoints that are outside
-                        if (node.Waypoint.CurrentHull == null) { node.TempDistance *= 10.0f; }
-                    }
-                    //avoid stopping at a doorway
-                    if (node.Waypoint.ConnectedDoor != null) { node.TempDistance *= 10.0f; }
-                    //avoid stopping at a ladder
-                    if (node.Waypoint.Ladders != null) { node.TempDistance *= 10.0f; }
-                }
-
-                int i = 0;
-                while (i < sortedNodes.Count && sortedNodes[i].TempDistance < node.TempDistance)
-                {
-                    i++;
-                }
-                sortedNodes.Insert(i, node);
-            }
-
-            //find the most suitable end node, starting from the ones closest to the end position
-            PathNode endNode = null;
-            foreach (PathNode node in sortedNodes)
-            {
-                if (nodeFilter != null && !nodeFilter(node)) { continue; }
-                if (endNodeFilter != null && !endNodeFilter(node)) { continue; }
+                if (nodeFilter != null && !nodeFilter(node)) { return false; }
+                if (endNodeFilter != null && !endNodeFilter(node)) { return false; }
                 // Only check the visibility for the end node when allowed (fix leaks)
-                if (!IsWaypointVisible(node, end, checkVisibility: checkVisibility)) { continue; }
-                if (node.IsBlocked()) { continue; }
+                if (!IsWaypointVisible(node, end, checkVisibility: checkVisibility)) { return false; }
+                if (node.IsBlocked()) { return false; }
                 if (node.Waypoint.ConnectedGap != null)
                 {
-                    if (!CanFitThroughGap(node.Waypoint.ConnectedGap, minGapSize)) { continue; }
+                    if (!CanFitThroughGap(node.Waypoint.ConnectedGap, minGapSize)) { return false; }
                 }
-                endNode = node;
-                break;
+                return true;
             }
-
-            if (endNode == null)
-            {
-#if DEBUG
-                DebugConsole.NewMessage("Pathfinding error, couldn't find an end node. " + errorMsgStr, Color.DarkRed);
-#endif
-                return new SteeringPath(true);
-            }
-
-            var path = FindPath(startNode, endNode, nodeFilter, errorMsgStr, minGapSize);
-
-            return path;
         }
 
         private SteeringPath FindPath(PathNode start, PathNode end, Func<PathNode, bool> filter = null, string errorMsgStr = "", float minGapSize = 0)

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

@@ -1,4 +1,5 @@
 using Barotrauma.Items.Components;
+using Barotrauma.Extensions;
 using Microsoft.Xna.Framework;
 
 namespace Barotrauma
@@ -47,14 +48,16 @@ namespace Barotrauma
         public void SetOrder(Character orderedCharacter)
         {
             OrderedCharacter = orderedCharacter;
-            if (orderedCharacter != CommandingCharacter)
+            if (OrderedCharacter.AIController is HumanAIController humanAI && humanAI.ObjectiveManager.CurrentOrders.None(o => o.MatchesOrder(SuggestedOrderPrefab, Option)))
             {
-                CommandingCharacter.Speak(SuggestedOrderPrefab.GetChatMessage(OrderedCharacter.Name, "", false));
+                if (orderedCharacter != CommandingCharacter)
+                {
+                    CommandingCharacter.Speak(SuggestedOrderPrefab.GetChatMessage(OrderedCharacter.Name, "", false), minDurationBetweenSimilar: 5);
+                }
+                CurrentOrder = new Order(SuggestedOrderPrefab, TargetItem, TargetItemComponent, CommandingCharacter);
+                OrderedCharacter.SetOrder(CurrentOrder, Option, priority: 3, CommandingCharacter, CommandingCharacter != OrderedCharacter);
+                OrderedCharacter.Speak(TextManager.Get("DialogAffirmative"), delay: 1.0f, minDurationBetweenSimilar: 5);
             }
-
-            // not sure if new orders are supposed to be created each time. TODO m61: check later
-            CurrentOrder = new Order(SuggestedOrderPrefab, TargetItem, TargetItemComponent, CommandingCharacter); 
-            OrderedCharacter.SetOrder(CurrentOrder, Option, priority: 3, CommandingCharacter, CommandingCharacter != OrderedCharacter);
             TimeSinceLastAttempt = 0f;
         }
 

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

@@ -31,10 +31,10 @@ namespace Barotrauma
             } 
             // there should maybe be additional logic for targeting and destroying spires, because they currently cause some issues with pathing
 
-            if (targetingImportances.Any())
+            if (targetingImportances.Any(i => i > 0))
             {
                 targetingImportances.Sort();
-                Importance = targetingImportances.TakeLast(3).Average();
+                Importance = targetingImportances.TakeLast(3).Sum();
             }
         }
     }

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

@@ -199,7 +199,7 @@ namespace Barotrauma
 
             foreach (Character potentialCharacter in Character.CharacterList)
             {
-                if (!HumanAIController.IsActive(character)) { continue; }
+                if (!HumanAIController.IsActive(potentialCharacter)) { continue; }
 
                 if (HumanAIController.IsFriendly(character, potentialCharacter, true) && potentialCharacter.AIController is HumanAIController)
                 {
@@ -313,7 +313,7 @@ namespace Barotrauma
                         ShipCommandLog("Dismissing " + shipIssueWorker + " for character " + shipIssueWorker.OrderedCharacter);
 #endif
                         Order orderPrefab = Order.GetPrefab("dismissed");
-                        character.Speak(orderPrefab.GetChatMessage(shipIssueWorker.OrderedCharacter.Name, "", givingOrderToSelf: false));
+                        //character.Speak(orderPrefab.GetChatMessage(shipIssueWorker.OrderedCharacter.Name, "", givingOrderToSelf: false));
                         shipIssueWorker.OrderedCharacter.SetOrder(Order.GetPrefab("dismissed"), orderOption: null, priority: 3, character);
                         shipIssueWorker.RemoveOrder();
                         break;